Hogyan működik a kérés életciklusa a FastAPI-ban?

Question

IT Interview Practice · Accepted Answer

A FastAPI **ASGI**-ra épül, így egy kérés egy aszinkron pipeline-on halad végig: az ASGI szerver fogadja, a middleware körbeveszi, a router illeszti a path-t, **a függőségek feloldódnak**, lefut a path operation függvényed, és a visszatérési érték a response-ba szerializálódik.

## A szakaszok

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── illeszti method + path → path operation
   ▼
Dependencies (Depends)  ── sub-deps feloldása, security, yield-setup
   ▼
Path operation function  ── lefut a handlered
   ▼
Response model  ── validálás + szerializálás JSON-ba
   ▼
Background tasks  ── a response elküldése után fut
   ▼
Response ──▶ client
```

1. **ASGI szerver** (uvicorn/hypercorn) fogadja a kapcsolatot, és átad egy `scope`-ot, valamint `receive`/`send` callable-öket az appnak.
2. **Middleware** kívülről befelé fut bemenetkor és belülről kifelé kimenetkor (`BaseHTTPMiddleware` vagy tiszta ASGI middleware). A CORS, a GZip és az egyéni időmérés itt él.
3. **Routing** illeszti a HTTP method + path párost egy path operationhöz; a path/query/body paramétereket a **Pydantic** vonja ki és validálja.
4. **Dependency injection** — a `Depends(...)` feloldja az egyes függőségeket (DB session, aktuális felhasználó, beállítások), a kérésen belül cache-elve. Egy `yield`-et használó függőség a handler előtt lefuttatja a setupot, utána a teardownt.
5. **Path operation** — az `async def`-ed (vagy `def`, amely threadpoolban fut) végrehajtja az üzleti logikát.
6. **Response** — a visszatérési érték a deklarált `response_model`-re kényszerítődik, validálódik, és JSON-ba szerializálódik; a status code és a headerök alkalmazódnak.
7. **Background taskok**, amelyeket a `BackgroundTasks`-on át regisztráltál, a response elküldése *után* futnak.

```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. szerializálva a response_model-en át
```

A kivételeket az **exception handlerek** (`@app.exception_handler(...)` / `HTTPException`) kapják el, amelyek response-okká alakítják őket, ahelyett hogy összeomlana a kérés.

## Miért fontos

A kérés életciklusa az, ahol a FastAPI kiemelt funkciói valójában megtörténnek: az aszinkron I/O, a Pydantic-validálás és a dependency injection mind konkrét szakaszokba kapcsolódnak be. A sorrend ismerete — middleware, majd routing, majd függőségek, majd handler, majd szerializálás — lehetővé teszi, hogy a keresztmetsző logikát a megfelelő helyre tedd (auth mint függőség, időmérés mint middleware, takarítás egy `yield` függőségben), hogy hibakeresd, miért lő ki egy validálási vagy auth hiba a kódod lefutása előtt, és hogy elkerüld az event loop blokkolását egy async handleren belül.

A szakaszok

Miért fontos

Kapcsolódó kérdések