Gestion des données entrantes (Fast API)

Dans FastAPI, les données entrantes sont toutes les informations envoyées par le client via une requête HTTP.
FastAPI les reçoit et les convertit automatiquement en types Python, ce qui simplifie beaucoup la gestion des données.

Données = informations envoyées par le client
Endpoint = fonction Python qui reçoit et traite ces données

Comment ça fonctionne ?

FastAPI utilise la déclaration de types Python et les modèles Pydantic pour lire et valider les données.
Chaque paramètre d’une fonction endpoint correspond à une source de données :

Sources principales des données entrantes :

Paramètres d’URL
- Exemple : /users/{user_id} → user_id est un paramètre de chemin (Path)
Paramètres de requête (Query)
- Exemple : /users?active=true → active est un paramètre de requête (Query)
Corps de la requête (Request Body)
- Souvent utilisé pour POST ou PUT
- FastAPI utilise pydantic.BaseModel pour valider automatiquement les données JSON
Fichiers envoyés par le client
- Accès via File et UploadFile
Cookies et headers HTTP
- Accès via Cookie, Header ou Depends

Exemple conceptuel

URL : /users
Méthode HTTP : POST
Données envoyées : JSON { "name": "Alice", "email": "alice@example.com" }
Endpoint : reçoit les données via un modèle Pydantic, crée un nouvel utilisateur dans la base de données
Réponse : code HTTP 201 + JSON { "success": true, "id": 42 }

Ici, FastAPI valide automatiquement le JSON, renvoie une erreur si un champ est manquant ou de type incorrect.

Pourquoi c’est important :

Permet à l’application de recevoir et traiter les informations envoyées par le client
La validation automatique réduit les risques d’erreurs et d’attaques
Facilite la création de fonctionnalités dynamiques (création, modification, suppression de données)

Bonnes pratiques pour la gestion des données entrantes

Utiliser Pydantic pour la validation
- Définir les modèles pour chaque type de données attendu
Sanitisation des données
- Nettoyer les entrées pour éviter les injections ou attaques XSS
Gestion des erreurs
- FastAPI renvoie automatiquement 422 si les données ne sont pas valides
- On peut personnaliser les messages d’erreur si nécessaire
Limiter la taille des fichiers
- Pour éviter surcharge ou abus
Documentation automatique
- FastAPI génère automatiquement la documentation Swagger/OpenAPI pour chaque endpoint et chaque paramètre

En résumé, dans FastAPI :

Données entrantes = informations envoyées par le client via URL, query, JSON, fichiers…
Endpoint = fonction Python qui reçoit et traite les données
Pydantic = outil central pour validation et conversion automatique
Validation, sanitisation et gestion des erreurs = fondamentaux pour une API sécurisée et robuste
Documentation automatique = énorme avantage pour comprendre et tester les endpoints

Fonctions :

Gestion des données entrantes avec Fast API (exemple)

Exemple de code :

from fastapi import FastAPI, Query, Path
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

# 1️⃣ Paramètre dynamique dans l'URL
@app.get("/user/{username}")
def read_user(username: str = Path(..., title="Nom de l'utilisateur", min_length=1)):
    return {"username": username}

# 2️⃣ Paramètres de requête (query)
@app.get("/search/")
def search_items(q: Optional[str] = Query(None, max_length=50), limit: int = 10):
    return {"query": q, "limit": limit}

# 3️⃣ Données JSON avec POST
class Item(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

@app.post("/items/")
def create_item(item: Item):
    return {"message": "Article reçu", "item": item}

Explication du code :

from fastapi import FastAPI, Query, Path importe FastAPI pour créer l’application, et Query et Path pour gérer les paramètres de requête et les paramètres d’URL.
 from pydantic import BaseModel importe BaseModel pour créer des modèles de données et valider les entrées JSON.
 from typing import Optional permet de définir des paramètres optionnels dans les fonctions.
 app = FastAPI() crée une instance de l’application FastAPI.
Paramètre dynamique dans l'URL
 @app.get("/user/{username}") définit une route GET qui capture une valeur dans l’URL (exemple : /user/Alice).
 username: str = Path(..., title="Nom de l'utilisateur", min_length=1) indique que le paramètre username est obligatoire, a un titre descriptif et doit avoir au moins 1 caractère.
 return {"username": username} renvoie la valeur capturée sous forme de JSON.
Paramètres de requête (query)
 @app.get("/search/") définit une route GET avec des paramètres de requête.
 q: Optional[str] = Query(None, max_length=50) définit un paramètre optionnel q pour la recherche, avec une longueur maximale de 50 caractères.
 limit: int = 10 définit un paramètre entier limit avec une valeur par défaut de 10.
 return {"query": q, "limit": limit} renvoie les valeurs reçues sous forme de JSON.
Données JSON avec POST
 class Item(BaseModel): crée un modèle de données pour valider les entrées JSON.
 Les attributs name: str, price: float et description: Optional[str] = None définissent les champs attendus et leur type.
 @app.post("/items/") définit une route POST pour recevoir des données JSON.
 def create_item(item: Item): transforme automatiquement le JSON envoyé en objet Item.
 return {"message": "Article reçu", "item": item} renvoie une confirmation et les données reçues.