Hvordan fungerer en requests livscyklus i FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI kører på **ASGI**, så en request bevæger sig gennem en asynkron pipeline: ASGI-serveren modtager den, middleware pakker den ind, routeren matcher en sti, **dependencies bliver løst**, din path operation kører, og returværdien serialiseres til svaret.

## Faserne

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── match method + path → path operation
   ▼
Dependencies (Depends)  ── løs sub-deps, security, yield-setup
   ▼
Path operation function  ── din handler kører
   ▼
Response model  ── validér + serialisér til JSON
   ▼
Background tasks  ── kører efter svaret er sendt
   ▼
Response ──▶ client
```

1. **ASGI-serveren** (uvicorn/hypercorn) accepterer forbindelsen og sender et `scope` samt `receive`/`send`-callables til appen.
2. **Middleware** kører udefra-og-ind på vej ind og indefra-og-ud på vej ud (`BaseHTTPMiddleware` eller ren ASGI-middleware). CORS, GZip og brugerdefineret timing bor her.
3. **Routing** matcher HTTP-metoden + stien til en path operation; path/query/body-parametre udtrækkes og valideres af **Pydantic**.
4. **Dependency injection** — `Depends(...)` løser hver dependency (DB-session, nuværende bruger, indstillinger) og cacher inden for requesten. En dependency med `yield` kører setup før og teardown efter handleren.
5. **Path operation** — din `async def` (eller `def`, der kører i en threadpool) udfører forretningslogikken.
6. **Svar** — returværdien konverteres til den deklarerede `response_model`, valideres og serialiseres til JSON; statuskode og headers påføres.
7. **Background tasks** registreret via `BackgroundTasks` kører *efter* svaret er sendt.

```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. serialiseret via response_model
```

Undtagelser fanges af **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), som konverterer dem til svar i stedet for at få requesten til at gå ned.

## Hvorfor det betyder noget

Requestens livscyklus er der, hvor FastAPIs vigtigste funktioner faktisk sker: asynkron I/O, Pydantic-validering og dependency injection hægter sig alle på bestemte faser. At kende rækkefølgen — middleware, så routing, så dependencies, så handler, så serialisering — lader dig placere tværgående logik det rigtige sted (auth som en dependency, timing som middleware, oprydning i en `yield`-dependency), fejlfinde hvorfor en validerings- eller auth-fejl udløses før din kode kører, og undgå at blokere event-loopet inde i en asynkron handler.

Faserne

Hvorfor det betyder noget

Relaterede spørgsmål