FastAPI: Framework Python Tercepat untuk Bikin REST API di 2026

FastAPI: REST API Python yang Cepat dan Modern

Kalau kamu masih pakai Flask untuk bikin API di 2026, sudah waktunya kenalan dengan FastAPI. Framework ini bukan cuma lebih cepat — tapi juga lebih menyenangkan untuk ditulis.

Kenapa FastAPI?

• Performa tinggi — setara Go dan Node.js berkat Starlette dan Uvicorn
• Auto dokumentasi — Swagger UI dan ReDoc langsung dari kode
• Type safety — pakai Python type hints, error ketangkap saat develop
• Async native — support async/await dari awal
• Validasi otomatis — terintegrasi dengan Pydantic v2

Setup Project

mkdir my-api && cd my-api
uv init
uv add fastapi uvicorn pydantic sqlalchemy

Struktur Project yang Direkomendasikan

my-api/
├── app/
│   ├── __init__.py
│   ├── main.py          # Entry point
│   ├── models/          # Database models
│   ├── schemas/         # Pydantic schemas
│   ├── routers/         # Route handlers
│   ├── services/        # Business logic
│   └── database.py      # DB connection
├── tests/
├── pyproject.toml
└── .env

Kode Dasar

# app/main.py
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from app.routers import products, orders, users

app = FastAPI(
    title="My Business API",
    description="API untuk manajemen bisnis",
    version="1.0.0"
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://yourdomain.com"],
    allow_methods=["*"],
    allow_headers=["*"],
)

app.include_router(users.router, prefix="/users", tags=["Users"])
app.include_router(products.router, prefix="/products", tags=["Products"])
app.include_router(orders.router, prefix="/orders", tags=["Orders"])

@app.get("/")
def root():
    return {"status": "ok", "version": "1.0.0"}

# app/schemas/product.py
from pydantic import BaseModel, Field
from typing import Optional
from uuid import UUID
from datetime import datetime

class ProductBase(BaseModel):
    name: str = Field(..., min_length=3, max_length=100)
    price: float = Field(..., gt=0)
    stock: int = Field(default=0, ge=0)
    category: Optional[str] = None

class ProductCreate(ProductBase):
    pass

class ProductResponse(ProductBase):
    id: UUID
    created_at: datetime
    
    model_config = {"from_attributes": True}

# app/routers/products.py
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from app.schemas.product import ProductCreate, ProductResponse
from app.services import product_service
from app.database import get_db

router = APIRouter()

@router.get("/", response_model=list[ProductResponse])
async def get_products(
    skip: int = 0,
    limit: int = 20,
    db: Session = Depends(get_db)
):
    return product_service.get_all(db, skip=skip, limit=limit)

@router.post("/", response_model=ProductResponse, status_code=status.HTTP_201_CREATED)
async def create_product(
    product: ProductCreate,
    db: Session = Depends(get_db)
):
    return product_service.create(db, product)

@router.delete("/{product_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_product(product_id: str, db: Session = Depends(get_db)):
    if not product_service.delete(db, product_id):
        raise HTTPException(status_code=404, detail="Product not found")

Authentication dengan JWT

from fastapi import Security
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt

security = HTTPBearer()

def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
    try:
        payload = jwt.decode(
            credentials.credentials,
            SECRET_KEY,
            algorithms=["HS256"]
        )
        return payload
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

# Pakai sebagai dependency
@router.get("/me")
async def get_profile(user = Depends(verify_token)):
    return user

Deploy ke Production

# Dockerfile
FROM python:3.12-slim
WORKDIR /app
COPY pyproject.toml .
RUN pip install uv && uv sync
COPY . .
EXPOSE 8000
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

FastAPI dengan 4 workers di server VPS 2GB RAM sudah cukup untuk handle ribuan request per menit. Untuk skala lebih besar, tambah horizontal scaling di belakang load balancer.

Butuh API custom untuk bisnis Anda? Hubungi kami — kami berpengalaman membangun REST API dan microservices dengan FastAPI.