Middleware FastAPI

Un middleware est une fonction qui s'exécute avant et après que chaque requête atteint le gestionnaire de route.

Un middleware peut être utilisé pour la logique courante, comme l'ajout de journaux, la modification des requêtes/réponses, la gestion de CORS, etc.


Comment fonctionne un middleware

Flux d'exécution d'un middleware :

  • La requête atteint le middleware
  • Le middleware exécute la logique de prétraitement
  • Le middleware transmet la requête au middleware suivant ou à la fonction de route.
  • La fonction de route renvoie la réponse
  • Le middleware exécute la logique de post-traitement
  • Réponse renvoyée au client

Name Fonction
Client Les navigateurs, les applications frontend, Postman, etc. envoient des requêtes HTTP à FastAPI
Demande Objet de requête HTTP, contenant des données telles que l'URL, l'en-tête, le corps, le cookie
Middleware 1 La première couche de traitement après l'entrée d'une requête
Middleware 2 Logique de traitement de la deuxième couche
Middleware N Plusieurs middleware s'exécutent dans l'ordre
Fonction de gestion de route (Path Operation) L'endroit où le code métier est réellement exécuté
Phase de réponse Après que la route renvoie une Response, la réponse passe à nouveau par le middleware.
Le middleware revient dans l'ordre inverse Les réponses reviennent dans « l'ordre inverse »
Response response Les données finalement renvoyées au client

Créer un middleware

Utilisation@app.middleware("http")Création d'un middleware avec des décorateurs :

Exemple

import time
from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    # 1. Traitement avant requête : enregistrer l'heure de début
    start_time = time.time()

    # 2. Transmettre la requête au middleware suivant ou à la fonction de route suivante.
    response = await call_next(request)

    # 3. Traitement post-réponse : calculer le temps de traitement et ajouter les en-têtes de réponse.
    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"}

Explication du code :

PartieDescription
@app.middleware("http")Déclarez ceci comme un middleware HTTP.
request: RequestObjet de requête actuel
call_nextFonction de rappel pour invoquer le middleware suivant ou la fonction de route suivante.
await call_next(request)Transmettre la requête à la couche suivante et obtenir la réponse

call_nextRecevoirrequestParamètres et valeur de retourresponse. Vous pouvez appelercall_nextModifiez la requête avant l'appel, et modifiez la réponse après l'appel.


Middleware de journalisation des requêtes

Le middleware suivant journalise des informations de base sur chaque requête :

Exemple

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):
    # Enregistrer les informations de la requête
    logger.info(fRequête: {request.method} {request.url})

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

    # Enregistrer les informations de la réponse
    logger.info(
        f"Réponse: {request.method} {request.url} "
        fCode d'état={response.status_code} temps écoulé={process_time:.3f}s
    )

    return response

Ordre d'exécution des middlewares

Le middleware s'exécute dans l'ordre d'enregistrement ; les requêtes traversent les middlewares dans l'ordre direct, et les réponses les traversent dans l'ordre inverse :

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

L'ordre d'enregistrement des middlewares est important. Si vous avez deux middlewares A et B, et que vous enregistrez A en premier, la requête traverse A en premier, puis B, mais la réponse traverse B en premier, puis A.


Utilisation des middlewares intégrés de Starlette

FastAPI hérite de Starlette, donc les middlewares fournis par Starlette peuvent être utilisés directement :

Exemple

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

app = FastAPI()

# Forcer la redirection vers HTTPS
app.add_middleware(HTTPSRedirectMiddleware)


@app.get("/")
async def root():
    return {"message": Accès via HTTPS}

Middlewares intégrés courants :

middlewareDescription
HTTPSRedirectMiddlewareForcer la redirection des requêtes HTTP vers HTTPS
TrustedHostMiddlewareRestreindre les noms d’hôtes autorisés
GZipMiddlewareCompresser automatiquement le contenu de la réponse
CORSMiddlewareGérer les requêtes cross-origin (détaillées dans le chapitre suivant)

Middleware de compression GZip

Activer la compression GZip peut réduire la taille de la réponse et améliorer la vitesse de transfert :

Exemple

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

app = FastAPI()

# Compresser automatiquement lorsque la taille de la réponse dépasse 1000 octets
app.add_middleware(GZipMiddleware, minimum_size=1000)


@app.get("/")
async def root():
    return {"message": "This response may be GZip compressed"}

Résumé

  • Le middleware exécute une logique commune dans la chaîne de traitement des requêtes/réponses.
  • Utilisation@app.middleware("http")Créer un middleware personnalisé
  • call_next(request)Passer la requête à la couche suivante
  • Le middleware s'exécute dans l'ordre d'enregistrement (les requêtes dans le sens aller, les réponses dans le sens inverse)
  • FastAPI/Starlette fournit des intergiciels intégrés tels que CORS, GZip, la redirection HTTPS, etc.
autres extensions