Hur fungerar request-livscykeln i FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI körs på **ASGI**, så en request färdas genom en asynkron pipeline: ASGI-servern tar emot den, middleware omsluter den, routern matchar en path, **dependencies löses upp**, din path operation körs, och returvärdet serialiseras till responsen.

## Stegen

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── matcha method + path → path operation
   ▼
Dependencies (Depends)  ── lös upp sub-deps, security, yield-setup
   ▼
Path operation function  ── din handler körs
   ▼
Response model  ── validera + serialisera till JSON
   ▼
Background tasks  ── körs efter att responsen skickats
   ▼
Response ──▶ client
```

1. **ASGI-server** (uvicorn/hypercorn) tar emot anslutningen och skickar en `scope` plus `receive`/`send`-anropbara till appen.
2. **Middleware** körs utifrån-och-in på vägen in och inifrån-och-ut på vägen ut (`BaseHTTPMiddleware` eller ren ASGI-middleware). CORS, GZip och anpassad tidmätning ligger här.
3. **Routing** matchar HTTP-metoden + path till en path operation; path/query/body-parametrar extraheras och valideras av **Pydantic**.
4. **Dependency injection** — `Depends(...)` löser upp varje dependency (DB-session, aktuell användare, settings) och cachar inom requesten. En dependency med `yield` kör setup före och teardown efter handlern.
5. **Path operation** — din `async def` (eller `def`, körd i en threadpool) exekverar affärslogiken.
6. **Response** — returvärdet tvingas till den deklarerade `response_model`, valideras och serialiseras till JSON; statuskod och headers appliceras.
7. **Background tasks** registrerade via `BackgroundTasks` körs *efter* att responsen har skickats.

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

Undantag fångas av **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), som omvandlar dem till responser istället för att krascha requesten.

## Varför det är viktigt

Request-livscykeln är där FastAPI:s främsta funktioner faktiskt sker: async I/O, Pydantic-validering och dependency injection kopplar alla in i specifika steg. Att känna till ordningen — middleware, sedan routing, sedan dependencies, sedan handler, sedan serialisering — låter dig placera tvärgående logik på rätt ställe (auth som en dependency, tidmätning som middleware, städning i en `yield`-dependency), felsöka varför ett validerings- eller auth-fel utlöses innan din kod körs, och undvika att blockera event-loopen inuti en async-handler.

Stegen

Varför det är viktigt

Relaterade frågor