Bagaimana cara kerja request lifecycle di FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI berjalan di atas **ASGI**, jadi sebuah request melewati sebuah pipeline async: ASGI server menerimanya, middleware membungkusnya, router mencocokkan path, **dependency diselesaikan**, path operation Anda berjalan, dan nilai kembalian diserialisasi menjadi response.

## Tahapannya

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── cocokkan method + path → path operation
   ▼
Dependencies (Depends)  ── selesaikan sub-deps, security, yield-setup
   ▼
Path operation function  ── handler Anda berjalan
   ▼
Response model  ── validasi + serialisasi ke JSON
   ▼
Background tasks  ── berjalan setelah response terkirim
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) menerima koneksi dan meneruskan sebuah `scope` beserta callable `receive`/`send` ke app.
2. **Middleware** berjalan dari luar ke dalam saat masuk dan dari dalam ke luar saat keluar (`BaseHTTPMiddleware` atau ASGI middleware murni). CORS, GZip, dan timing kustom tinggal di sini.
3. **Routing** mencocokkan HTTP method + path ke sebuah path operation; parameter path/query/body diekstrak dan divalidasi oleh **Pydantic**.
4. **Dependency injection** — `Depends(...)` menyelesaikan setiap dependency (DB session, current user, settings), dengan caching dalam lingkup request. Sebuah dependency dengan `yield` menjalankan setup sebelum dan teardown sesudah handler.
5. **Path operation** — `async def` Anda (atau `def`, yang berjalan di threadpool) menjalankan logika bisnis.
6. **Response** — nilai kembalian dipaksa ke `response_model` yang dideklarasikan, divalidasi, dan diserialisasi ke JSON; status code dan header diterapkan.
7. **Background tasks** yang didaftarkan lewat `BackgroundTasks` berjalan *setelah* response terkirim.

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. diserialisasi via response_model
```

Exception ditangkap oleh **exception handler** (`@app.exception_handler(...)` / `HTTPException`), yang mengubahnya menjadi response alih-alih membuat request crash.

## Mengapa ini penting

Request lifecycle adalah tempat fitur-fitur andalan FastAPI benar-benar terjadi: async I/O, validasi Pydantic, dan dependency injection semuanya terhubung ke tahapan tertentu. Mengetahui urutannya — middleware, lalu routing, lalu dependency, lalu handler, lalu serialisasi — memungkinkan Anda menempatkan logika lintas-potong di tempat yang tepat (auth sebagai dependency, timing sebagai middleware, cleanup di dependency `yield`), men-debug kenapa sebuah error validasi atau auth terpicu sebelum kode Anda berjalan, dan menghindari pemblokiran event loop di dalam sebuah handler async.

Tahapannya

Mengapa ini penting

Pertanyaan terkait