Hvordan fungerer middleware i FastAPI?

Question

Accepted Answer

**Middleware** i FastAPI er kode, der kører for **hvert request og response** — den omslutter dine endpoints for at håndtere cross-cutting concerns som logging, timing, CORS og tilføjelse af headers. FastAPI bruger Starlettes middleware-system (det er ASGI-baseret).

## Skrivning af custom 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ønsteret: kode før `await call_next(request)` køres på vej **ind** (før endpointet), `call_next` udfører endpointet, og kode efter køres på vej **ud** (ændring af response). Dette omslutter hvert request — her tilføjes en timing header til alle responses.

## Request/response-flowet

```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.
```

## Indbygget / almindelig 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 tilføjes almindeligvis via `add_middleware` — CORS (tillad cross-origin requests), GZip (komprimér responses) og trusted-host-kontroller er typiske built-ins.

## Almindelig middleware-brug

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

## Middleware versus 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.
```

## Hvorfor det er vigtig

Middleware er den rigtige mekanisme for **globale, cross-cutting concerns** i FastAPI — logik, der skal gælde for hvert request og response, som logging, request-timing, CORS, komprimering og custom headers.

Forståelse heraf er vigtig for at strukturere applikationer korrekt: middleware omslutter alle endpoints (køres før og efter, med evnen til at ændre både request og response), hvilket gør det ideelt til app-bred opførsel, som ville være besværligt og fejlbetinget at gentage i hvert endpoint.

At kende skel mellem **middleware** (global, rå request/response-niveau) og **dependencies** (per-endpoint, med adgang til parserede/typede værdier og DI — bedre for auth og validering) er nøglen til at vælge det rigtige værktøj.

Almindelige behov som CORS og komprimering håndteres af indbygget middleware, mens custom middleware dækker logging og instrumentering — hvilket gør dette til praktisk, hyppigt brugt viden for opbygning af velstrukturerede, observerbare API'er.