Middleware

🌐 Traduction par IA et humains

Cette traduction a été réalisée par une IA guidée par des humains. 🤝

Elle peut contenir des erreurs d'interprétation du sens original, ou paraître peu naturelle, etc. 🤖

Vous pouvez améliorer cette traduction en nous aidant à mieux guider le LLM d'IA.

Version anglaise

Vous pouvez ajouter des middlewares aux applications FastAPI.

Un « middleware » est une fonction qui agit sur chaque requête avant qu’elle ne soit traitée par un chemin d'accès spécifique. Et aussi sur chaque réponse avant son renvoi.

• Il intercepte chaque requête qui parvient à votre application.
• Il peut alors faire quelque chose avec cette requête ou exécuter tout code nécessaire.
• Ensuite, il transmet la requête pour qu’elle soit traitée par le reste de l’application (par un chemin d'accès).
• Puis il récupère la réponse générée par l’application (par un chemin d'accès).
• Il peut faire quelque chose avec cette réponse ou exécuter tout code nécessaire.
• Enfin, il renvoie la réponse.

Détails techniques

Si vous avez des dépendances avec yield, le code de sortie s’exécutera après le middleware.

S’il y avait des tâches d’arrière-plan (présentées dans la section Tâches d’arrière-plan, que vous verrez plus tard), elles s’exécuteront après tous les middlewares.

Créer un middleware

Pour créer un middleware, utilisez le décorateur @app.middleware("http") au-dessus d’une fonction.

La fonction de middleware reçoit :

• La request.
• Une fonction call_next qui recevra la request en paramètre.
  • Cette fonction transmettra la request au chemin d'accès correspondant.
  • Puis elle renverra la response générée par le chemin d'accès correspondant.
• Vous pouvez ensuite modifier la response avant de la renvoyer.

Python 3.10+

import time

from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Astuce

Gardez à l’esprit que des en-têtes propriétaires personnalisés peuvent être ajoutés en utilisant le préfixe X-.

Mais si vous avez des en-têtes personnalisés que vous voulez rendre visibles pour un client dans un navigateur, vous devez les ajouter à votre configuration CORS (CORS (Partage des ressources entre origines)) en utilisant le paramètre expose_headers documenté dans la documentation CORS de Starlette.

Détails techniques

Vous pourriez aussi utiliser from starlette.requests import Request.

FastAPI le fournit pour votre confort de développeur. Mais cela provient directement de Starlette.

Avant et après la response

Vous pouvez ajouter du code à exécuter avec la request, avant que tout chemin d'accès ne la reçoive.

Et aussi après que la response a été générée, avant de la renvoyer.

Par exemple, vous pourriez ajouter un en-tête personnalisé X-Process-Time contenant le temps en secondes nécessaire pour traiter la requête et générer une réponse :

Python 3.10+

import time

from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Astuce

Ici, nous utilisons time.perf_counter() au lieu de time.time() car cela peut être plus précis pour ces cas d’usage. 🤓

Ordre d’exécution de plusieurs middlewares

Quand vous ajoutez plusieurs middlewares en utilisant soit le décorateur @app.middleware(), soit la méthode app.add_middleware(), chaque nouveau middleware enveloppe l’application, formant une pile. Le dernier middleware ajouté est le plus externe, et le premier est le plus interne.

Sur le chemin de la requête, le plus externe s’exécute en premier.

Sur le chemin de la réponse, il s’exécute en dernier.

Par exemple :

app.add_middleware(MiddlewareA)
app.add_middleware(MiddlewareB)

Cela aboutit à l’ordre d’exécution suivant :

• Requête : MiddlewareB → MiddlewareA → route

• Réponse : route → MiddlewareA → MiddlewareB

Ce comportement d’empilement garantit que les middlewares s’exécutent dans un ordre prévisible et contrôlable.

Autres middlewares

Vous pouvez en lire davantage sur d’autres middlewares dans le Guide de l’utilisateur avancé : Middleware avancé.

Vous verrez comment gérer CORS avec un middleware dans la section suivante.