Wie funktioniert der Request-Lebenszyklus in FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI läuft auf **ASGI**, daher durchläuft ein Request eine asynchrone Pipeline: Der ASGI-Server nimmt ihn an, Middleware umhüllt ihn, der Router matcht einen Pfad, **Dependencies werden aufgelöst**, deine Path Operation läuft, und der Rückgabewert wird in die Response serialisiert.

## Die Phasen

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── matche method + path → path operation
   ▼
Dependencies (Depends)  ── löse sub-deps, security, yield-setup auf
   ▼
Path operation function  ── dein handler läuft
   ▼
Response model  ── validieren + zu JSON serialisieren
   ▼
Background tasks  ── läuft nach dem Senden der Response
   ▼
Response ──▶ client
```

1. **ASGI-Server** (uvicorn/hypercorn) nimmt die Verbindung an und übergibt der App ein `scope` sowie die Callables `receive`/`send`.
2. **Middleware** läuft beim Hineingehen von außen nach innen und beim Herausgehen von innen nach außen (`BaseHTTPMiddleware` oder reine ASGI-Middleware). CORS, GZip und eigenes Timing leben hier.
3. **Routing** matcht die HTTP-Methode + den Pfad auf eine Path Operation; Path-/Query-/Body-Parameter werden von **Pydantic** extrahiert und validiert.
4. **Dependency Injection** — `Depends(...)` löst jede Dependency (DB-Session, aktueller Benutzer, Settings) auf und cacht sie innerhalb des Requests. Eine Dependency mit `yield` führt Setup vor und Teardown nach dem Handler aus.
5. **Path Operation** — deine `async def` (oder `def`, in einem Threadpool ausgeführt) führt die Geschäftslogik aus.
6. **Response** — der Rückgabewert wird auf das deklarierte `response_model` gebracht, validiert und zu JSON serialisiert; Statuscode und Header werden angewendet.
7. **Background Tasks**, die über `BackgroundTasks` registriert werden, laufen *nachdem* die Response gesendet wurde.

```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. serialisiert über response_model
```

Ausnahmen werden von **Exception Handlern** (`@app.exception_handler(...)` / `HTTPException`) abgefangen, die sie in Responses umwandeln, anstatt den Request abstürzen zu lassen.

## Warum es wichtig ist

Der Request-Lebenszyklus ist der Ort, an dem die Kernfeatures von FastAPI tatsächlich passieren: asynchrones I/O, Pydantic-Validierung und Dependency Injection klinken sich alle in bestimmte Phasen ein. Die Reihenfolge zu kennen — Middleware, dann Routing, dann Dependencies, dann Handler, dann Serialisierung — erlaubt dir, übergreifende Logik an der richtigen Stelle zu platzieren (Auth als Dependency, Timing als Middleware, Cleanup in einer `yield`-Dependency), zu debuggen, warum ein Validierungs- oder Auth-Fehler ausgelöst wird, bevor dein Code läuft, und zu vermeiden, den Event Loop innerhalb eines asynchronen Handlers zu blockieren.

Die Phasen

Warum es wichtig ist

Ähnliche Fragen