Si funksionon cikli i jetës së një kërkese në FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI funksionon mbi **ASGI**, ndaj një kërkesë kalon nëpër një pipeline asinkron: serveri ASGI e pranon, middleware e mbështjell, router-i përputh një path, **dependencies zgjidhen**, ekzekutohet path operation-i yt, dhe vlera e kthyer serializohet në përgjigje.

## Fazat

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── përputh metodën + path → path operation
   ▼
Dependencies (Depends)  ── zgjidh sub-deps, security, yield-setup
   ▼
Path operation function  ── ekzekutohet handler-i yt
   ▼
Response model  ── validon + serializon në JSON
   ▼
Background tasks  ── ekzekutohen pasi përgjigja është dërguar
   ▼
Response ──▶ client
```

1. **Serveri ASGI** (uvicorn/hypercorn) pranon lidhjen dhe i kalon aplikacionit një `scope` plus callable-t `receive`/`send`.
2. **Middleware** ekzekutohet nga jashtë-brenda gjatë hyrjes dhe nga brenda-jashtë gjatë daljes (`BaseHTTPMiddleware` ose middleware ASGI i pastër). CORS, GZip dhe matja e kohës e personalizuar ndodhen këtu.
3. **Routing** përputh metodën HTTP + path me një path operation; parametrat path/query/body nxirren dhe validohen nga **Pydantic**.
4. **Injektimi i varësive (dependency injection)** — `Depends(...)` zgjidh çdo varësi (sesion DB, përdoruesi aktual, settings), duke e ruajtur në cache brenda kërkesës. Një varësi me `yield` ekzekuton setup-in para dhe teardown-in pas handler-it.
5. **Path operation** — `async def`-i yt (ose `def`, i ekzekutuar në një threadpool) ekzekuton logjikën e biznesit.
6. **Response** — vlera e kthyer konvertohet në `response_model`-in e deklaruar, validohet dhe serializohet në JSON; zbatohen kodi i statusit dhe headers.
7. **Background tasks** të regjistruara përmes `BackgroundTasks` ekzekutohen *pasi* përgjigja është dërguar.

```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. serializuar përmes response_model
```

Përjashtimet kapen nga **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), të cilët i shndërrojnë ato në përgjigje në vend që të rrëzojnë kërkesën.

## Pse ka rëndësi

Cikli i jetës së kërkesës është vendi ku ndodhin realisht veçoritë kryesore të FastAPI: I/O asinkron, validimi me Pydantic dhe injektimi i varësive lidhen të gjitha me faza specifike. Njohja e rendit — middleware, pastaj routing, pastaj dependencies, pastaj handler, pastaj serializim — të lejon të vendosësh logjikën tërthore në vendin e duhur (auth si varësi, matja e kohës si middleware, pastrimi në një varësi me `yield`), të bësh debug pse një gabim validimi ose autentikimi ndodh para se të ekzekutohet kodi yt, dhe të shmangësh bllokimin e event loop-it brenda një handler-i asinkron.

Fazat

Pse ka rëndësi

Pyetje të ngjashme