Jak funguje životní cyklus požadavku ve FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI běží na **ASGI**, takže požadavek prochází asynchronní rourou (pipeline): ASGI server jej přijme, middleware jej obalí, router porovná cestu, **závislosti se vyřeší**, spustí se vaše path operation a návratová hodnota se serializuje do odpovědi.

## Fáze

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── porovná method + path → path operation
   ▼
Dependencies (Depends)  ── vyřeší sub-deps, security, yield-setup
   ▼
Path operation function  ── spustí se váš handler
   ▼
Response model  ── validace + serializace do JSON
   ▼
Background tasks  ── spustí se po odeslání odpovědi
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) přijme spojení a předá aplikaci `scope` a volatelné objekty `receive`/`send`.
2. **Middleware** běží zvenčí dovnitř na cestě tam a zevnitř ven na cestě zpět (`BaseHTTPMiddleware` nebo čistý ASGI middleware). Zde žijí CORS, GZip a vlastní měření času.
3. **Routing** porovná HTTP method + cestu s path operation; parametry path/query/body extrahuje a validuje **Pydantic**.
4. **Dependency injection** — `Depends(...)` vyřeší každou závislost (DB session, aktuální uživatel, nastavení) a cachuje ji v rámci požadavku. Závislost s `yield` spustí setup před handlerem a teardown po něm.
5. **Path operation** — vaše `async def` (nebo `def`, spuštěná ve threadpoolu) vykoná byznys logiku.
6. **Odpověď** — návratová hodnota se převede na deklarovaný `response_model`, zvaliduje a serializuje do JSON; aplikují se status code a hlavičky.
7. **Background tasks** registrované přes `BackgroundTasks` běží *po* odeslání odpovědi.

```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. závislost (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. serializace přes response_model
```

Výjimky zachytávají **exception handlery** (`@app.exception_handler(...)` / `HTTPException`), které je převedou na odpovědi místo toho, aby požadavek spadl.

## Proč je to důležité

Životní cyklus požadavku je místo, kde se stěžejní funkce FastAPI skutečně odehrávají: asynchronní I/O, validace přes Pydantic i dependency injection se napojují do konkrétních fází. Znalost pořadí — middleware, pak routing, pak závislosti, pak handler, pak serializace — vám umožní umístit průřezovou logiku na správné místo (autentizace jako závislost, měření času jako middleware, úklid v závislosti s `yield`), ladit, proč se validační nebo autentizační chyba spustí ještě před vaším kódem, a vyhnout se blokování event loopu uvnitř asynchronního handleru.

Fáze

Proč je to důležité

Související otázky