Gestion des types de réponse personnalisés

FastAPI permet d'adapter les sorties HTTP selon divers formats, au-delà du JSON par défaut. Les développeurs peuvent renvoyer des contenus HTML, du texte brut ou du XML en spécifiant la classe de réponse appropriée.

Réponse HTML avec FastAPI

Pour retourner une page HTML, utilisez la classe HTMLResponse pour simplifier le processus.

from fastapi import FastAPI
from fastapi.responses import HTMLResponse

application = FastAPI()

@app.get("/bienvenue", response_class=HTMLResponse)
def afficher_page():
    structure_html = """
    
        <title>Accueil FastAPI</title>
        <h1>Salutations depuis FastAPI!</h1>
    
    """
    return structure_html

Cette approche convient aux pages statiques ou aux modèles légers. Le paramètre response_class force l'en-tête Content-Type à text/html.

Réponses en texte brut

Les interfaces nécessitant des messages simples ou des journaux utilisent PlainTextResponse.

from fastapi.responses import PlainTextResponse

@app.get("/message", response_class=PlainTextResponse)
def obtenir_texte():
    return "Contenu textuel brut pour le débogage."

Génération de contenu XML

Bien que JSON domine, XML reste utile pour certaines intégrations. La classe Response offre un contrôle total.

from fastapi.responses import Response

@app.get("/donnees-xml", response_class=Response)
def produire_xml():
    donnees_xml = """
    <catalogue>
        <article id="1">FastAPI Guide</article>
        <article id="2">Advanced Patterns</article>
    </catalogue>
    """
    return Response(content=donnees_xml, media_type="application/xml")

Le type MIME est explicitement défini via media_type pour garantir l'interprétation correcte.

Traitement des fichiers

FastAPI intègre des mécanismes robustes pour gérer les transferts de fichiers, avec des classes dédiées comme UploadFile.

Upload de fichiers

Recevez un ou plusieurs fichiers via des formulaires multipart.

from fastapi import File, UploadFile

@app.post("/envoyer/")
def recevoir_fichier(document: UploadFile = File(...)):
    return {"nom_du_fichier": document.filename, "taille": document.size}

@app.post("/envoyer/multiples/")
def recevoir_plusieurs(documents: list[UploadFile] = File(...)):
    noms = [doc.filename for doc in documents]
    return {"fichiers_recus": noms}

L'objet UploadFile encapsule les métadonnées et le contenu, permettant un traitement asynchrone.

Download de fichiers

Pour envoyer un fichier au client, utilisez FileResponse avec un chemin dynamique.

from fastapi.responses import FileResponse
import os

chemin_stockage = "./archives"

@app.get("/telecharger/{nom_fichier}")
def envoyer_fichier(nom_fichier: str):
    chemin_complet = os.path.join(chemin_stockage, nom_fichier)
    if os.path.isfile(chemin_complet):
        return FileResponse(path=chemin_complet, filename=nom_fichier, media_type="application/octet-stream")
    return {"erreur": "Fichier introuvable"}

La vérification d'existence évite les erreurs 500 et améliore la sécurité.

Configuraton des en-têtes et cookies

Les en-têtes HTTP personnalisés et les cookies sont essentiels pour le suivi, la sécurité et la personnalisation.

Ajout d'en-têtes personnalisés

Injectez des métadonnées dans la réponse via l'objet Response.

from fastapi import Response

@app.get("/donnees-avec-en-tetes")
def ajouter_entetes(reponse: Response):
    reponse.headers["X-Id-Requete"] = "abc123"
    reponse.headers["X-Priorite"] = "haute"
    return {"statut": "En-têtes définis"}

Cela permet d'intégrer des identifiants de corrélation ou des politiques de cache.

Impression de cookies

Les cookies gèrent l'état côté client, avec des options de sécurité.

@app.get("/initialiser-session")
def definir_cookie(reponse: Response):
    reponse.set_cookie(
        key="session_id",
        value="xyz789",
        max_age=3600,
        httponly=True,
        secure=True
    )
    return {"message": "Cookie de session créé"}

Les drapeaux httponly et secure protègent contre les attaques XSS et garantissent une transmission chiffrée.