Hoe werkt middleware in FastAPI?

Question

Accepted Answer

**Middleware** in FastAPI is code dat voor **elk request en response** wordt uitgevoerd — dit omhult uw endpoints om cross-cutting concerns zoals logging, timing, CORS en het toevoegen van headers af te handelen. FastAPI maakt gebruik van het middleware-systeem van Starlette (het is ASGI-gebaseerd).

## Aangepaste middleware schrijven

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

Het patroon: code vóór `await call_next(request)` wordt **naar binnen** uitgevoerd (vóór het endpoint), `call_next` roept het endpoint aan, en code erna wordt **naar buiten** uitgevoerd (de response modificerend). Dit omhult elk request — hier wordt een timing header aan alle responses toegevoegd.

## De request/response flow

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

## Ingebouwde / veelgebruikte 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 wordt meestal via `add_middleware` toegevoegd — CORS (cross-origin requests toestaan), GZip (responses comprimeren) en trusted-host controles zijn typische ingebouwde versies.

## Veelgebruikte middleware-toepassingen

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

## Waarom het belangrijk is

Middleware is het juiste mechanisme voor **globale, cross-cutting concerns** in FastAPI — logica die op elk request en response van toepassing moet zijn, zoals logging, request timing, CORS, compressie en aangepaste headers.

Begrijpen hiervan is belangrijk voor het correct structureren van applicaties: middleware omhult alle endpoints (loopt vóór en ná, met de mogelijkheid om zowel request als response te modificeren), waardoor het ideaal is voor app-brede gedragingen die in elk endpoint vervelend en foutgevoelig zouden zijn om herhalen.

Het onderscheid kennen tussen **middleware** (globaal, raw request/response niveau) en **dependencies** (per-endpoint, met toegang tot geverifieerde/getypeerde waarden en DI — beter voor authentificatie en validatie) is belangrijk voor het kiezen van het juiste hulpmiddel.

Veelgebruikte behoeften zoals CORS en compressie worden afgehandeld door ingebouwde middleware, terwijl aangepaste middleware logging en instrumentation omvat — waardoor dit praktische, veelgebruikte kennis is voor het bouwen van goed gestructureerde, waarneembare API's.