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
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 :
| Partie | Description |
|---|---|
@app.middleware("http") | Déclarez ceci comme un middleware HTTP. |
request: Request | Objet de requête actuel |
call_next | Fonction 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 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 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 :
| middleware | Description |
|---|---|
HTTPSRedirectMiddleware | Forcer la redirection des requêtes HTTP vers HTTPS |
TrustedHostMiddleware | Restreindre les noms d’hôtes autorisés |
GZipMiddleware | Compresser automatiquement le contenu de la réponse |
CORSMiddleware | Gé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.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.