FastAPI-Middleware

Middleware ist eine Funktion, die ausgeführt wird, bevor jede Anfrage den Route-Handler erreicht, und danach.

Middleware kann für allgemeine Logik wie das Hinzufügen von Logs, das Ändern von Anfragen/Antworten, die Behandlung von CORS usw. verwendet werden.


Wie Middleware funktioniert

Ausführungsablauf der Middleware:

  • Anfrage erreicht Middleware
  • Middleware führt Vorverarbeitungslogik aus
  • Middleware übergibt die Anfrage an die nächste Middleware oder Route-Funktion.
  • Route-Funktion gibt Antwort zurück
  • Middleware führt Nachverarbeitungslogik aus
  • Antwort wird an den Client zurückgegeben

Name Funktion
Client Browser, Frontend-Apps, Postman usw. senden HTTP-Anfragen an FastAPI
Anfrage HTTP-Anfrageobjekt, das Daten wie URL, Header, Body, Cookie enthält
Middleware 1 Die erste Verarbeitungsebene, nachdem eine Anfrage eingeht
Middleware 2 Verarbeitungslogik der zweiten Ebene
Middleware N Mehrere Middlewares werden der Reihe nach ausgeführt
Route-Handler-Funktion (Pfadoperation) Der Ort, an dem der Business-Code tatsächlich ausgeführt wird
Response-Phase Nachdem die Route eine Response zurückgibt, durchläuft die Antwort erneut die Middleware.
Middleware gibt in umgekehrter Reihenfolge zurück Antworten erfolgen in "umgekehrter Reihenfolge"
Response response Die letztlich an den Client zurückgegebenen Daten

Middleware erstellen

Nutzung@app.middleware("http")Middleware mit Dekoratoren erstellen:

Beispiel

import time
from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    # 1. Vorverarbeitung der Anfrage: Startzeit aufzeichnen
    start_time = time.time()

    # 2. Anfrage an die nächste Middleware- oder Routenfunktion weiterleiten
    response = await call_next(request)

    # 3. Verarbeitung nach der Antwort: Verarbeitungszeit berechnen und Antwort-Header hinzufügen.
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response


@app.get("/")
async def root():
    return {"message": "Hello World"}

Code-Erklärung:

TeilBeschreibung
@app.middleware("http")Deklariere dies als HTTP-Middleware.
request: RequestAktuelles Anfrageobjekt
call_nextCallback zum Aufrufen der nächsten Middleware- oder Routenfunktion.
await call_next(request)Die Anfrage an die nächste Ebene weiterleiten und die Antwort erhalten

call_nextEmpfangenrequestParameter und Rückgaberesponse. Du kannst aufrufencall_nextÄndern Sie die Anfrage vor dem Aufruf und ändern Sie die Antwort nach dem Aufruf.


Middleware zur Anfrageprotokollierung

Die folgende Middleware protokolliert grundlegende Informationen zu jeder Anfrage:

Beispiel

import time
import logging
from fastapi import FastAPI, Request

app = FastAPI()

logger = logging.getLogger("uvicorn.access")


@app.middleware("http")
async def log_requests(request: Request, call_next):
    # Anfrageinformationen protokollieren
    logger.info(fAnfrage: {request.method} {request.url})

    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time

    # Antwortinformationen protokollieren
    logger.info(
        f"Antwort: {request.method} {request.url} "
        fStatuscode={response.status_code} verstrichene Zeit={process_time:.3f}s
    )

    return response

Middleware-Ausführungsreihenfolge

Middleware wird in der Reihenfolge ihrer Registrierung ausgeführt; Anfragen durchlaufen Middleware in Vorwärtsrichtung und Antworten in umgekehrter Reihenfolge:

请求 -> 中间件A(前) -> 中间件B(前) -> 路由函数
响应 <- 中间件A(后) <- 中间件B(后) <- 路由函数

Die Reihenfolge der Middleware-Registrierung ist wichtig. Wenn Sie zwei Middleware A und B haben und A zuerst registrieren, durchläuft die Anfrage zuerst A, dann B, aber die Antwort durchläuft zuerst B, dann A.


Verwendung der in Starlette integrierten Middleware

FastAPI erbt von Starlette, daher kann die von Starlette bereitgestellte Middleware direkt verwendet werden:

Beispiel

from fastapi import FastAPI
from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware

app = FastAPI()

# HTTPS-Weiterleitung erzwingen
app.add_middleware(HTTPSRedirectMiddleware)


@app.get("/")
async def root():
    return {"message": Zugriff über HTTPS}

Gängige integrierte Middleware:

MiddlewareBeschreibung
HTTPSRedirectMiddlewareHTTP-Anfragen zwangsweise auf HTTPS umleiten
TrustedHostMiddlewareErlaubte Hostnamen einschränken
GZipMiddlewareAntwortinhalte automatisch komprimieren
CORSMiddlewareCross-Origin-Anfragen behandeln (ausführlich im nächsten Kapitel)

GZip-Komprimierungs-Middleware

Das Aktivieren der GZip-Komprimierung kann die Antwortgröße reduzieren und die Übertragungsgeschwindigkeit verbessern:

Beispiel

from fastapi import FastAPI
from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# Automatisch komprimieren, wenn die Antwortgröße 1000 Bytes überschreitet
app.add_middleware(GZipMiddleware, minimum_size=1000)


@app.get("/")
async def root():
    return {"message": "Diese Antwort kann GZip-komprimiert sein"}

Zusammenfassung

  • Middleware führt gemeinsame Logik in der Request-/Response-Verarbeitungskette aus.
  • Nutzung@app.middleware("http")Benutzerdefinierte Middleware erstellen
  • call_next(request)Die Anfrage an die nächste Schicht weitergeben
  • Middleware wird in der Reihenfolge der Registrierung ausgeführt (Anfragen in Vorwärtsreihenfolge, Antworten in umgekehrter Reihenfolge)
  • FastAPI/Starlette bietet integrierte Middleware wie CORS, GZip, HTTPS-Umleitung usw.
Weitere Erweiterungen