Kepiye cara kerja request lifecycle ing FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI mlaku ing ndhuwur **ASGI**, dadi sawijining request ngliwati pipeline async: ASGI server nampa, middleware mbungkus, router nyocokake path, **dependency dirampungake**, path operation sampeyan mlaku, lan nilai bali diserialisasi dadi response.

## Tahap-tahape

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── cocogake method + path → path operation
   ▼
Dependencies (Depends)  ── rampungake sub-deps, security, yield-setup
   ▼
Path operation function  ── handler sampeyan mlaku
   ▼
Response model  ── validasi + serialisasi menyang JSON
   ▼
Background tasks  ── mlaku sawise response dikirim
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) nampa koneksi lan ngoperake `scope` plus callable `receive`/`send` menyang app.
2. **Middleware** mlaku saka njaba menyang njero nalika mlebu lan saka njero menyang njaba nalika metu (`BaseHTTPMiddleware` utawa ASGI middleware murni). CORS, GZip, lan timing kustom manggon ing kene.
3. **Routing** nyocokake HTTP method + path menyang sawijining path operation; parameter path/query/body dijupuk lan divalidasi dening **Pydantic**.
4. **Dependency injection** — `Depends(...)` ngrampungake saben dependency (DB session, current user, settings), kanthi caching ing sajrone request. Dependency kanthi `yield` nglakokake setup sadurunge lan teardown sawise handler.
5. **Path operation** — `async def` sampeyan (utawa `def`, sing mlaku ing threadpool) nglakokake logika bisnis.
6. **Response** — nilai bali dipeksa menyang `response_model` sing dideklarasi, divalidasi, lan diserialisasi menyang JSON; status code lan header diterapake.
7. **Background tasks** sing didaftar liwat `BackgroundTasks` mlaku *sawise* response dikirim.

```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 liwat response_model
```

Exception dicekel dening **exception handler** (`@app.exception_handler(...)` / `HTTPException`), sing ngowahi dadi response tinimbang nggawe request crash.

## Kenapa iki penting

Request lifecycle yaiku papan ing ngendi fitur-fitur unggulan FastAPI tenanan kedadeyan: async I/O, validasi Pydantic, lan dependency injection kabeh nyanthol menyang tahap tartamtu. Ngerti urutane — middleware, banjur routing, banjur dependency, banjur handler, banjur serialisasi — ngidini sampeyan nyelehake logika lintas-potong ing panggonan sing bener (auth minangka dependency, timing minangka middleware, cleanup ing dependency `yield`), ndebug kenapa sawijining error validasi utawa auth muncul sadurunge kode sampeyan mlaku, lan nyingkiri mblokir event loop ing sajrone handler async.

Tahap-tahape

Kenapa iki penting

Pitakon sing gegandhengan