Hur fungerar middleware i FastAPI?

Question

Accepted Answer

**Middleware** i FastAPI är kod som körs för **varje request och response** — och omsluter dina endpoints för att hantera tvärsnittande problem som loggning, tidtagning, CORS och att lägga till headers. FastAPI använder Starlettehs middleware-system (det är ASGI-baserat).

## Skriva anpassad middleware

```python
import time

@app.middleware("http")
async def add_timing(request: Request, call_next):
    start = time.time()
    response = await call_next(request)        # call the endpoint (and any inner middleware)
    response.headers["X-Process-Time"] = str(time.time() - start)   # modify the response
    return response
```

Mönstret: kod före `await call_next(request)` körs på vägen **in** (före endpoint), `call_next` anropar endpoint, och kod efter körs på vägen **ut** (modifierar response). Detta omsluter varje request — här läggs en timing-header till alla responses.

## Request/response-flödet

```text
Request  → MW1 → MW2 → endpoint
Response ← MW1 ← MW2 ← endpoint
Middleware wraps the endpoint; runs in order on the way in, reverse on the way out.
```

## Inbyggd / vanlig middleware

```python
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.gzip import GZipMiddleware

app.add_middleware(CORSMiddleware, allow_origins=["https://app.example.com"], ...)  # CORS
app.add_middleware(GZipMiddleware, minimum_size=1000)                               # compression
```

Middleware läggs vanligtvis till via `add_middleware` — CORS (tillåta cross-origin-requests), GZip (komprimera responses) och trusted-host-kontroller är typiska inbyggda.

## Vanlig användning av middleware

```text
✓ Logging / request timing / metrics
✓ CORS (cross-origin request handling)
✓ Adding security or custom headers
✓ Response compression (GZip)
✓ Request ID / correlation ID injection
```

## Middleware vs dependencies

```text
Middleware   → runs for ALL requests; works at the raw request/response level (headers,
               timing, the whole response). Best for truly global concerns.
Dependencies → per-endpoint (or grouped) logic with access to parsed params, DI, and
               typed values. Best for auth, validation, shared parameters.
→ Use middleware for global cross-cutting concerns; dependencies for endpoint logic.
```

## Varför det spelar roll

Middleware är rätt mekanismför **globala, tvärsnittande problem** i FastAPI — logik som ska gälla för varje request och response, som loggning, request-timing, CORS, komprimering och anpassade headers.

Det är viktigt att förstå för att strukturera applikationer korrekt: middleware omsluter alla endpoints (körs före och efter, med möjlighet att modifiera både request och response), vilket gör det idealiskt för app-omfattande beteende som skulle vara tråkigt och felbenäget att upprepa i varje endpoint.

Att känna till skillnaden mellan **middleware** (global, rå request/response-nivå) och **dependencies** (per-endpoint, med åtkomst till tolkade/typade värden och DI — bättre för auth och validering) är nyckeln till att välja rätt verktyg.

Vanliga behov som CORS och komprimering hanteras av inbyggd middleware, medan anpassad middleware täcker loggning och instrumentering — vilket gör detta till praktisk, ofta använd kunskap för att bygga väl-strukturerade, observerbara API:er.