Hvordan fungerer request-livssyklusen i FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI kjører på **ASGI**, så en request reiser gjennom en async pipeline: ASGI-serveren tar imot den, middleware pakker den inn, routeren matcher en path, **dependencies blir løst opp**, path operation-funksjonen din kjører, og returverdien serialiseres til responsen.

## Stegene

```
uvicorn (ASGI-server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, egendefinert)
   ▼
Routing  ── match method + path → path operation
   ▼
Dependencies (Depends)  ── løs sub-deps, security, yield-oppsett
   ▼
Path operation-funksjon  ── handleren din kjører
   ▼
Response model  ── valider + serialiser til JSON
   ▼
Background tasks  ── kjører etter at responsen er sendt
   ▼
Response ──▶ klient
```

1. **ASGI-server** (uvicorn/hypercorn) tar imot forbindelsen og sender en `scope` pluss `receive`/`send`-callables til appen.
2. **Middleware** kjører utenfra-inn på vei inn og innenfra-ut på vei ut (`BaseHTTPMiddleware` eller ren ASGI middleware). CORS, GZip og egendefinert tidtaking hører hjemme her.
3. **Routing** matcher HTTP-method + path til en path operation; path/query/body-parametere blir hentet ut og validert av **Pydantic**.
4. **Dependency injection** — `Depends(...)` løser opp hver dependency (DB-session, gjeldende bruker, settings), med caching innenfor requesten. En dependency med `yield` kjører oppsett før og opprydding etter handleren.
5. **Path operation** — din `async def` (eller `def`, kjørt i en threadpool) utfører forretningslogikken.
6. **Response** — returverdien tvinges til den deklarerte `response_model`, valideres og serialiseres til JSON; statuskode og headere blir satt.
7. **Background tasks** registrert via `BackgroundTasks` kjører *etter* at responsen 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. serialisert via response_model
```

Exceptions fanges av **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), som konverterer dem til responser i stedet for å krasje requesten.

## Hvorfor det er viktig

Request-livssyklusen er der FastAPIs sentrale funksjoner faktisk skjer: async I/O, Pydantic-validering og dependency injection kobler seg alle inn på bestemte steg. Å kjenne rekkefølgen — middleware, så routing, så dependencies, så handler, så serialisering — lar deg plassere tverrgående logikk på rett sted (auth som en dependency, tidtaking som middleware, opprydding i en `yield`-dependency), feilsøke hvorfor en validerings- eller auth-feil utløses før koden din kjører, og unngå å blokkere event-loopen inne i en async handler.

Stegene

Hvorfor det er viktig

Relaterte spørsmål