Wie funktioniert Middleware in FastAPI?

Question

Accepted Answer

**Middleware** in FastAPI ist Code, der für **jeden Request und Response** ausgeführt wird — es umhüllt deine Endpoints, um übergreifende Belange wie Logging, Timing, CORS und das Hinzufügen von Headern zu behandeln. FastAPI verwendet das Middleware-System von Starlette (es ist ASGI-basiert).

## Schreiben von benutzerdefinierter 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
```

Das Muster: Code vor `await call_next(request)` wird auf dem Weg **herein** ausgeführt (vor dem Endpoint), `call_next` ruft den Endpoint auf, und Code danach wird auf dem Weg **hinaus** ausgeführt (Änderung der Response). Dies umhüllt jeden Request — hier wird ein Timing-Header zu allen Responses hinzugefügt.

## Der Request/Response-Fluss

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

## Integrierte / häufige 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 wird üblicherweise über `add_middleware` hinzugefügt — CORS (Cross-Origin-Requests erlauben), GZip (Responses komprimieren) und Trusted-Host-Überprüfungen sind typische Built-ins.

## Häufige Middleware-Anwendungen

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

## Warum es wichtig ist

Middleware ist der richtige Mechanismus für **globale, übergreifende Belange** in FastAPI — Logik, die auf jeden Request und Response angewendet werden sollte, wie Logging, Request-Timing, CORS, Komprimierung und benutzerdefinierte Header.

Sein Verständnis ist wichtig für die richtige Strukturierung von Anwendungen: Middleware umhüllt alle Endpoints (wird vor und nach ausgeführt, mit der Möglichkeit, sowohl Request als auch Response zu ändern), was sie ideal für anwendungsweites Verhalten macht, das in jedem Endpoint mühsam und fehleranfällig zu wiederholen wäre.

Die Unterscheidung zwischen **Middleware** (global, auf Raw-Request/Response-Ebene) und **Dependencies** (pro-Endpoint, mit Zugriff auf geparste/typisierte Werte und DI — besser für Auth und Validierung) zu kennen, ist der Schlüssel zur Wahl des richtigen Werkzeugs.

Häufige Anforderungen wie CORS und Komprimierung werden durch integrierte Middleware behandelt, während benutzerdefinierte Middleware Logging und Instrumentation abdeckt — was dies zu praktischem, häufig genutztem Wissen für die Erstellung gut strukturierter, beobachtbarer APIs macht.