Kako deluje življenjski cikel zahteve v FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI teče na **ASGI**, zato zahteva potuje skozi asinhroni cevovod: strežnik ASGI jo sprejme, middleware jo ovije, router ujame pot, **odvisnosti (dependencies) se razrešijo**, izvede se tvoja path operation, vrnjena vrednost pa se serializira v odgovor.

## Faze

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── ujemi metodo + pot → path operation
   ▼
Dependencies (Depends)  ── razreši sub-deps, security, yield-setup
   ▼
Path operation function  ── izvede se tvoj handler
   ▼
Response model  ── validiraj + serializiraj v JSON
   ▼
Background tasks  ── tečejo po tem, ko je odgovor poslan
   ▼
Response ──▶ client
```

1. **Strežnik ASGI** (uvicorn/hypercorn) sprejme povezavo in aplikaciji posreduje `scope` ter klicljiva objekta `receive`/`send`.
2. **Middleware** ob vstopu teče od zunaj navznoter, ob izstopu pa od znotraj navzven (`BaseHTTPMiddleware` ali čisti ASGI middleware). CORS, GZip in lastno merjenje časa so tukaj.
3. **Routing** ujame HTTP-metodo + pot s path operation; parametri path/query/body se izluščijo in validirajo s **Pydantic**.
4. **Vbrizgavanje odvisnosti (dependency injection)** — `Depends(...)` razreši vsako odvisnost (seja DB, trenutni uporabnik, nastavitve) in jo predpomni znotraj zahteve. Odvisnost z `yield` izvede setup pred in teardown po handlerju.
5. **Path operation** — tvoj `async def` (ali `def`, ki teče v threadpoolu) izvede poslovno logiko.
6. **Response** — vrnjena vrednost se pretvori v deklariran `response_model`, validira in serializira v JSON; uporabita se statusna koda in glave.
7. **Background tasks**, registrirane prek `BackgroundTasks`, tečejo *po* tem, ko je odgovor poslan.

```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. serializirano prek response_model
```

Izjeme ujamejo **exception handlerji** (`@app.exception_handler(...)` / `HTTPException`), ki jih pretvorijo v odgovore, namesto da bi zahteva sesula.

## Zakaj je to pomembno

Življenjski cikel zahteve je mesto, kjer se v resnici zgodijo glavne zmožnosti FastAPI: asinhroni I/O, validacija Pydantic in vbrizgavanje odvisnosti se vsi vpnejo v določene faze. Poznavanje vrstnega reda — middleware, nato routing, nato odvisnosti, nato handler, nato serializacija — ti omogoča, da prečno logiko postaviš na pravo mesto (avtentikacija kot odvisnost, merjenje časa kot middleware, čiščenje v odvisnosti z `yield`), razhroščuješ, zakaj se napaka validacije ali avtentikacije sproži pred tvojo kodo, in se izogneš blokiranju event loopa znotraj asinhronega handlerja.

Faze

Zakaj je to pomembno

Povezana vprašanja