Hoe werkt de request-lifecycle in FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI draait op **ASGI**, dus een request reist door een async pipeline: de ASGI-server accepteert hem, middleware omhult hem, de router matcht een pad, **dependencies worden opgelost**, jouw path operation draait, en de returnwaarde wordt geserialiseerd naar de response.

## De fasen

```
uvicorn (ASGI-server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── match method + pad → path operation
   ▼
Dependencies (Depends)  ── los sub-deps op, security, yield-setup
   ▼
Path operation function  ── jouw handler draait
   ▼
Response model  ── validate + serialize naar JSON
   ▼
Background tasks  ── draaien nadat de response is verstuurd
   ▼
Response ──▶ client
```

1. **ASGI-server** (uvicorn/hypercorn) accepteert de verbinding en geeft een `scope` plus `receive`/`send` callables door aan de app.
2. **Middleware** draait van buiten naar binnen op de weg naar binnen en van binnen naar buiten op de weg naar buiten (`BaseHTTPMiddleware` of pure ASGI-middleware). CORS, GZip en custom timing leven hier.
3. **Routing** matcht de HTTP-method + pad met een path operation; path-, query- en body-parameters worden geëxtraheerd en gevalideerd door **Pydantic**.
4. **Dependency injection** — `Depends(...)` lost elke dependency op (DB-sessie, huidige gebruiker, settings), met caching binnen de request. Een dependency met `yield` draait de setup ervoor en de teardown na de handler.
5. **Path operation** — jouw `async def` (of `def`, uitgevoerd in een threadpool) voert de businesslogica uit.
6. **Response** — de returnwaarde wordt omgezet naar het gedeclareerde `response_model`, gevalideerd en geserialiseerd naar JSON; statuscode en headers worden toegepast.
7. **Background tasks** geregistreerd via `BackgroundTasks` draaien *nadat* de response is verstuurd.

```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. geserialiseerd via response_model
```

Excepties worden opgevangen door **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), die ze omzetten naar responses in plaats van de request te laten crashen.

## Waarom het belangrijk is

De request-lifecycle is waar FastAPI's kernfuncties daadwerkelijk plaatsvinden: async I/O, Pydantic-validatie en dependency injection haken allemaal in op specifieke fasen. De volgorde kennen — middleware, dan routing, dan dependencies, dan handler, dan serialisatie — stelt je in staat om cross-cutting logica op de juiste plek te zetten (auth als een dependency, timing als middleware, cleanup in een `yield`-dependency), te debuggen waarom een validatie- of auth-fout afgaat voordat jouw code draait, en te voorkomen dat je de event loop blokkeert binnen een async handler.

De fasen

Waarom het belangrijk is

Gerelateerde vragen