Jak działa cykl życia żądania w FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI działa na **ASGI**, więc żądanie przechodzi przez asynchroniczny potok: serwer ASGI je przyjmuje, middleware je opakowuje, router dopasowuje ścieżkę, **zależności są rozwiązywane**, uruchamia się Twoja operacja ścieżki (path operation), a zwrócona wartość jest serializowana do odpowiedzi.

## Etapy

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── dopasuj metodę + ścieżkę → path operation
   ▼
Dependencies (Depends)  ── rozwiąż sub-deps, security, yield-setup
   ▼
Path operation function  ── uruchamia się Twój handler
   ▼
Response model  ── walidacja + serializacja do JSON
   ▼
Background tasks  ── uruchamiane po wysłaniu odpowiedzi
   ▼
Response ──▶ client
```

1. **Serwer ASGI** (uvicorn/hypercorn) przyjmuje połączenie i przekazuje aplikacji `scope` oraz obiekty wywoływalne `receive`/`send`.
2. **Middleware** działa z zewnątrz do wewnątrz w drodze do środka i od wewnątrz na zewnątrz w drodze powrotnej (`BaseHTTPMiddleware` lub czysty ASGI middleware). CORS, GZip i własne mierzenie czasu mieszczą się tutaj.
3. **Routing** dopasowuje metodę HTTP + ścieżkę do operacji ścieżki; parametry path/query/body są wyodrębniane i walidowane przez **Pydantic**.
4. **Wstrzykiwanie zależności (dependency injection)** — `Depends(...)` rozwiązuje każdą zależność (sesja DB, bieżący użytkownik, ustawienia), buforując ją w obrębie żądania. Zależność z `yield` uruchamia setup przed handlerem i teardown po nim.
5. **Path operation** — Twoje `async def` (lub `def`, uruchamiane w threadpool) wykonuje logikę biznesową.
6. **Response** — zwrócona wartość jest rzutowana na zadeklarowany `response_model`, walidowana i serializowana do JSON; stosowane są kod statusu i nagłówki.
7. **Background tasks** zarejestrowane przez `BackgroundTasks` uruchamiają się *po* wysłaniu odpowiedzi.

```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. serializacja przez response_model
```

Wyjątki są przechwytywane przez **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), które zamieniają je w odpowiedzi zamiast wywoływać awarię żądania.

## Dlaczego to ważne

Cykl życia żądania to miejsce, gdzie faktycznie dzieją się sztandarowe funkcje FastAPI: asynchroniczne I/O, walidacja Pydantic i wstrzykiwanie zależności — wszystkie podpinają się do konkretnych etapów. Znajomość kolejności — middleware, potem routing, potem zależności, potem handler, potem serializacja — pozwala umieścić logikę przekrojową we właściwym miejscu (auth jako zależność, mierzenie czasu jako middleware, sprzątanie w zależności z `yield`), zdebugować, dlaczego błąd walidacji lub uwierzytelnienia pojawia się przed uruchomieniem Twojego kodu, i uniknąć blokowania pętli zdarzeń wewnątrz asynchronicznego handlera.

Etapy

Dlaczego to ważne

Powiązane pytania