FastAPI

À quoi ça sert

Une API, c'est ce qui permet à différentes applications de se parler par HTTP : ton front, ton appli mobile, un script automatisé, un autre service. Quand tu veux exposer une fonction Python (ou un modèle ML) au reste du monde, tu écris une API.

FastAPI brille par trois points :

• Rapide à coder — on déclare les routes avec des décorateurs et les types Python (annotations).
• Validation automatique — grâce à Pydantic, FastAPI vérifie les entrées et renvoie des erreurs claires.
• Documentation gratuite — une UI Swagger interactive est générée à l'adresse /docs, sans aucune ligne de code en plus.

Un exemple d'usage

Tu as un modèle de machine learning qui prédit le prix d'un appartement à partir de sa surface et de son nombre de chambres. Tu veux que d'autres applications puissent l'interroger. Avec FastAPI, voici l'API minimale :

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Appartement(BaseModel):
    surface: float
    chambres: int

@app.post("/predire")
def predire(appart: Appartement):
    prix = appart.surface * 4500 + appart.chambres * 10000
    return {"prix_estime": prix}

Ton client envoie {"surface": 50, "chambres": 2} à POST /predire, et il reçoit {"prix_estime": 245000}. Si on envoie une chaîne au lieu d'un nombre, FastAPI répond automatiquement par une erreur 422 explicite.

How-to : installer et utiliser FastAPI

1. Créer un projet et installer les dépendances

   Avec UV (voir la fiche UV) :

   bash Copier

   uv init mon-api
   cd mon-api
   uv add fastapi uvicorn

   FastAPI est le framework, Uvicorn est le serveur web qui exécute l'app.

2. Écrire une API simple

   Crée main.py :

   python Copier

   from fastapi import FastAPI, HTTPException
   from pydantic import BaseModel
   
   app = FastAPI(title="API démo")
   
   # Mini "base de données" en mémoire
   livres = {
       1: {"titre": "1984", "auteur": "Orwell"},
       2: {"titre": "Le Petit Prince", "auteur": "Saint-Exupéry"},
   }
   
   class Livre(BaseModel):
       titre: str
       auteur: str
   
   @app.get("/")
   def accueil():
       return {"message": "API livres en ligne"}
   
   @app.get("/livres")
   def lister():
       return livres
   
   @app.get("/livres/{livre_id}")
   def detail(livre_id: int):
       if livre_id not in livres:
           raise HTTPException(status_code=404, detail="Livre introuvable")
       return livres[livre_id]
   
   @app.post("/livres")
   def ajouter(livre: Livre):
       nouvel_id = max(livres) + 1
       livres[nouvel_id] = livre.model_dump()
       return {"id": nouvel_id, **livres[nouvel_id]}

3. Lancer le serveur

   bash Copier

   uv run uvicorn main:app --reload

   main:app = fichier main.py, variable app. --reload redémarre automatiquement à chaque modification.

   L'API est dispo sur http://localhost:8000.

4. Explorer la doc auto-générée

   Ouvre dans ton navigateur :

   • http://localhost:8000/docs — UI Swagger interactive (tu peux tester les routes en direct)
   • http://localhost:8000/redoc — version ReDoc (lecture seule, plus lisible)
   Astuce

   Cette doc est générée à partir de tes annotations de type et tes modèles Pydantic. Plus tu annotes, plus la doc est précise — sans effort supplémentaire.

5. Tester l'API depuis le terminal

   bash Copier

   # GET
   curl http://localhost:8000/livres
   
   # POST avec JSON
   curl -X POST http://localhost:8000/livres \
     -H "Content-Type: application/json" \
     -d '{"titre": "Dune", "auteur": "Herbert"}'

6. Configurer VS Code

   1. Installe l'extension Python de Microsoft.
   2. Sélectionne l'interpréteur du venv (./.venv/bin/python).
   3. Pour déboguer FastAPI avec breakpoints, crée .vscode/launch.json :
   json Copier

   {
       "version": "0.2.0",
       "configurations": [
           {
               "name": "FastAPI",
               "type": "python",
               "request": "launch",
               "module": "uvicorn",
               "args": ["main:app", "--reload"],
               "jinja": true
           }
       ]
   }

   Une extension utile en bonus : Thunder Client ou REST Client pour tester tes endpoints directement depuis VS Code, sans quitter l'éditeur.

7. Aller plus loin : validation et erreurs

   Pydantic permet de poser des contraintes fortes sur les entrées. Exemple :

   python Copier

   from pydantic import BaseModel, Field
   
   class Utilisateur(BaseModel):
       nom: str = Field(min_length=2, max_length=50)
       age: int = Field(ge=0, le=120)
       email: str = Field(pattern=r"^[\w.+-]+@[\w-]+\.[\w.-]+$")

   Si un client envoie un email invalide ou un âge négatif, FastAPI renvoie automatiquement une 422 avec le détail de l'erreur. Pas une seule ligne de validation à écrire toi-même.

Aide-mémoire

# Méthodes HTTP
@app.get("/path")        # lire
@app.post("/path")       # créer
@app.put("/path")        # remplacer
@app.patch("/path")      # modifier partiellement
@app.delete("/path")     # supprimer

# Paramètres
def f(id: int):              # /items/{id}  → path param
def f(q: str = None):       # /items?q=...  → query param
def f(corps: MonModele):     # body JSON

# Erreurs
raise HTTPException(status_code=404, detail="...")

# Lancement
uvicorn main:app --reload                # dev
uvicorn main:app --host 0.0.0.0 --port 80  # prod

Pour aller plus loin

• Documentation officielle : fastapi.tiangolo.com
• Tutoriel pas à pas : fastapi.tiangolo.com/tutorial
• Pydantic (la lib de validation) : docs.pydantic.dev