FastAPI + Pydantic : créer une API robuste sans boilerplate

Introduction : pourquoi FastAPI change la donne

Tu connais déjà Flask ou Django, et tu veux aller plus vite sans sacrifier la qualité ? FastAPI est devenu le standard pour construire des APIs modernes en Python. Combiné à Pydantic, il élimine le boilerplate de validation et donne des erreurs claires dès le développement — pas au déploiement.

Dans cet article, tu vas voir comment structurer un projet Python professionnel avec FastAPI, gérer la validation des données avec Pydantic, et produire une documentation interactive automatiquement. Pas de théorie abstraite : des exemples concrets que tu peux copier dans ton propre projet.

Le problème : trop de boilerplate pour trop peu de résultat

Avec Flask et Django REST Framework, valider un JSON entrant demande du code répété : vérifier les types, les champs obligatoires, les contraintes. Si tu oublies un cas aux frontières, ton API renvoie une erreur 500 au lieu d’une réponse 422 propre.

FastAPI résout cela avec Pydantic : tu définis un modèle, et la validation — y compris la sérialisation — est automatique. Résultat : moins de code, moins de bugs, et une documentation interactive (Swagger / ReDoc) générée sans effort supplémentaire.

Structure du projet : un modèle réutilisable

Avant d’écrire la première route, structure ton dépôt. Voici un modèle minimal et professionnel :

mon_api/
  ├── app/
  │     ├── __init__.py
  │     ├── main.py
  │     ├── models.py
  │     └── routes/
  ├── tests/
  │     └── test_routes.py
  ├── requirements.txt
  └── pyproject.toml

Utilise pyproject.toml au lieu de setup.py : il est plus lisible, gère les dépendances via Poetry ou pip, et s’intègre avec les outils modernes (black, ruff, pytest). Pour un projet d’apprentissage, reste simple — mais habitude le bon format dès le début.

Le modèle Pydantic : validation en une ligne

Définis ton schéma d’entrée avec Pydantic. L’exemple ci-dessous valide un utilisateur avec un email correct, un âge entre 18 et 120, et un rôle autorisé :

from pydantic import BaseModel, EmailStr, Field
from typing import Literal

class UserCreate(BaseModel):
    email: EmailStr
    name: str = Field(min_length=2, max_length=100)
    age: int = Field(ge=18, le=120)
    role: Literal["admin", "editor", "viewer"] = "viewer"

Quand tu passes cet objet dans une route FastAPI, la validation est automatique. Si un utilisateur envoie un âge de 15, l’API répond avec un 422 et un message précis — pas un crash, pas une erreur 500 opaque.

La route : simple, typée, documentée

Voici la route qui crée un utilisateur. Note la syntaxe : pas de décorateur complexe, pas de sérialisation manuelle. Le type UserCreate est utilisé comme paramètre de la fonction, et FastAPI en déduit le schéma de la requête POST :

from fastapi import FastAPI
from .models import UserCreate

app = FastAPI()

@app.post("/users/", status_code=201)
def create_user(user: UserCreate):
    # logique métier ici (base, service, etc.)
    return {"id": 1, **user.dict()}

Le résultat : au lancement du serveur, tu as déjà /docs et /redoc accessibles. Pas de documentation séparée à maintenir. Quand ton modèle change, la doc change avec.

Tests : valider le comportement sans le serveur

FastAPI fournit un TestClient basé sur Starlette. Tu peux tester tes routes sans lancer le serveur réel — essentiel pour un projet dupliqué en CI/CD. Un exemple minimal :

from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_create_user():
    resp = client.post("/users/", json={"email":"a@b.fr","name":"Alex","age":30})
    assert resp.status_code == 201
    assert resp.json()["email"] == "a@b.fr"

Ce test s’exécute en moins d’une seconde. Si tu ajoutes une nouvelle contrainte dans le modèle Pydantic, ce test valide que la route répond correctement — pas seulement que la fonction ne plante pas.

Bonnes pratiques pour ne pas perdre le fil

• Sépare la logique métier : ne mets pas la base de données dans la route directement. Crée un module services/ ou repositories/.
• Utilise des variables d’environnement : python-dotenv ou pydantic-settings pour la config (DB, secrets, ports).
• Versionne ton API : /v1/users/ plutôt que /users/ tout de suite — cela évite les ruptures futures.
• Ajoute des limites de taux : slowapi ou un proxy Nginx pour protéger contre les abus.

Conclusion : un outil, pas une religion

FastAPI + Pydantic ne remplacent pas ta réflexion sur l’architecture. Ils réduisent le bruit pour te concentrer sur ce qui compte : la logique métier, la sécurité, l’expérience utilisateur. Pour un développeur en formation, c’est un excellent point d’entrée : tu comprends rapidement le cycle demande-réponse, tu vois immédiatement ce que fait ton code, et tu produis quelque chose de professionnel dès le premier jour.

Pour aller plus loin : si tu veux structurer un projet réel, consulte la page Apprendre Python : de zéro à projet concret et passe au cours sur les APIs REST avec FastAPI. Tu y trouveras un projet guidé, des exercices progressifs, et un accompagnement direct.

Article publié sur adamcours.fr — formation développement et IA.