Cum funcționează ciclul de viață al unei cereri în FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI rulează pe **ASGI**, deci o cerere trece printr-un pipeline asincron: serverul ASGI o acceptă, middleware-ul o învelește, router-ul potrivește o cale, **dependențele sunt rezolvate**, se execută operația ta de cale (path operation), iar valoarea returnată este serializată în răspuns.

## Etapele

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── potrivește metoda + calea → path operation
   ▼
Dependencies (Depends)  ── rezolvă sub-deps, security, yield-setup
   ▼
Path operation function  ── rulează handler-ul tău
   ▼
Response model  ── validează + serializează în JSON
   ▼
Background tasks  ── rulează după ce răspunsul este trimis
   ▼
Response ──▶ client
```

1. **Serverul ASGI** (uvicorn/hypercorn) acceptă conexiunea și transmite aplicației un `scope` plus callable-urile `receive`/`send`.
2. **Middleware-ul** rulează din exterior spre interior la intrare și din interior spre exterior la ieșire (`BaseHTTPMiddleware` sau middleware ASGI pur). CORS, GZip și măsurarea timpului personalizată se află aici.
3. **Routing-ul** potrivește metoda HTTP + calea cu o path operation; parametrii path/query/body sunt extrași și validați de **Pydantic**.
4. **Injecția de dependențe** — `Depends(...)` rezolvă fiecare dependență (sesiune DB, utilizatorul curent, setări), memorând-o în cache în cadrul cererii. O dependență cu `yield` rulează setup-ul înainte și teardown-ul după handler.
5. **Path operation** — `async def` (sau `def`, rulat într-un threadpool) execută logica de business.
6. **Response** — valoarea returnată este convertită la `response_model`-ul declarat, validată și serializată în JSON; se aplică codul de status și antetele.
7. **Background tasks** înregistrate prin `BackgroundTasks` rulează *după* ce răspunsul este trimis.

```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. serializat prin response_model
```

Excepțiile sunt prinse de **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), care le transformă în răspunsuri în loc să prăbușească cererea.

## De ce contează

Ciclul de viață al cererii este locul unde se întâmplă efectiv funcțiile emblematice ale FastAPI: I/O asincron, validarea Pydantic și injecția de dependențe se conectează toate la etape specifice. Cunoașterea ordinii — middleware, apoi routing, apoi dependențe, apoi handler, apoi serializare — îți permite să pui logica transversală la locul potrivit (auth ca dependență, măsurarea timpului ca middleware, curățarea într-o dependență cu `yield`), să depanezi de ce o eroare de validare sau de autentificare apare înainte ca codul tău să ruleze și să eviți blocarea event loop-ului în interiorul unui handler asincron.

Etapele

De ce contează

Întrebări conexe