Kako funkcionira životni ciklus zahtjeva u FastAPI-ju?

Question

IT Interview Practice · Accepted Answer

FastAPI radi na **ASGI**, pa zahtjev putuje kroz asinkroni pipeline: ASGI server ga prihvaća, middleware ga omata, router pronalazi odgovarajući path, **dependencies se razrješavaju**, izvršava se tvoja path operation, a povratna vrijednost se serijalizira u response.

## Faze

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, prilagođeni)
   ▼
Routing  ── uskladi method + path → path operation
   ▼
Dependencies (Depends)  ── razriješi sub-deps, security, yield-setup
   ▼
Path operation funkcija  ── izvršava se tvoj handler
   ▼
Response model  ── validiraj + serijaliziraj u JSON
   ▼
Background tasks  ── izvršavaju se nakon slanja responsea
   ▼
Response ──▶ klijent
```

1. **ASGI server** (uvicorn/hypercorn) prihvaća konekciju i aplikaciji prosljeđuje `scope` te callableove `receive`/`send`.
2. **Middleware** se izvršava izvana-prema-unutra na ulazu i iznutra-prema-van na izlazu (`BaseHTTPMiddleware` ili čisti ASGI middleware). CORS, GZip i prilagođeno mjerenje vremena žive ovdje.
3. **Routing** uspoređuje HTTP method + path s path operationom; path/query/body parametri se izvlače i validiraju putem **Pydantica**.
4. **Dependency injection** — `Depends(...)` razrješava svaki dependency (DB session, trenutni korisnik, settings), uz cache unutar zahtjeva. Dependency s `yield` izvodi setup prije i teardown nakon handlera.
5. **Path operation** — tvoj `async def` (ili `def`, koji se izvodi u threadpoolu) izvršava poslovnu logiku.
6. **Response** — povratna vrijednost se svodi na deklarirani `response_model`, validira i serijalizira u JSON; primjenjuju se status code i headeri.
7. **Background tasks** registrirani preko `BackgroundTasks` izvršavaju se *nakon* što je response 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. serijalizirano preko response_model
```

Iznimke hvataju **exception handleri** (`@app.exception_handler(...)` / `HTTPException`), koji ih pretvaraju u responseove umjesto da sruše zahtjev.

## Zašto je to važno

Životni ciklus zahtjeva je mjesto gdje se glavne značajke FastAPI-ja stvarno odvijaju: asinkroni I/O, Pydantic validacija i dependency injection sve se ukapčaju u određene faze. Poznavanje redoslijeda — middleware, zatim routing, zatim dependencies, zatim handler, zatim serijalizacija — omogućuje ti da presijecajuću logiku staviš na pravo mjesto (auth kao dependency, mjerenje vremena kao middleware, čišćenje u `yield` dependencyju), da otkriješ zašto se validacijska ili auth greška aktivira prije nego što se tvoj kod pokrene te da izbjegneš blokiranje event loopa unutar asinkronog handlera.

Faze

Zašto je to važno

Povezana pitanja