backend / fastapi

Première API

Leçon 11 exercice

Explication

Un peu d'histoire

FastAPI est créé par Sebastián Ramírez (connu sous le pseudonyme "tiangolo") et publié fin 2018. Il s'appuie sur deux briques déjà existantes : Starlette (un framework web asynchrone bas niveau) pour la partie réseau, et Pydantic pour la validation des données. L'objectif affiché dès le départ est ambitieux : offrir à la fois une vitesse de développement très élevée, des performances comparables à des frameworks en Node.js ou en Go, et une documentation d'API générée automatiquement.

Pourquoi apprendre FastAPI aujourd'hui

FastAPI s'est imposé comme l'un des frameworks Python backend les plus utilisés pour créer des APIs modernes, en particulier dans l'écosystème de l'intelligence artificielle où il sert très souvent à exposer des modèles de machine learning. Il s'appuie sur le typage natif de Python : en déclarant simplement les types de vos données, vous obtenez à la fois validation automatique, autocomplétion dans l'éditeur et documentation Swagger générée sans effort supplémentaire — un gain de temps considérable par rapport à écrire tout ça à la main.

Ce que vous allez apprendre

Installer FastAPI et Uvicorn, puis démarrer un serveur de développement avec rechargement automatique
Créer une première route GET et comprendre ce que retourne réellement une fonction de vue
Explorer la documentation Swagger générée automatiquement à partir du code
Choisir entre def et async def pour une route selon la nature du traitement
Organiser un projet dès le départ avec APIRouter plutôt que tout empiler dans main.py

Dans quel contexte ?

Un développeur junior rejoint une équipe backend et doit exposer un premier endpoint /health pour que l'équipe infrastructure puisse vérifier que le service répond avant de le mettre en production. Plutôt que d'écrire un serveur HTTP à la main avec http.server, il installe FastAPI, écrit dix lignes de code, et obtient immédiatement une documentation interactive sur /docs que l'équipe frontend peut consulter sans lui poser de questions.

Pourquoi FastAPI et pas juste Python "brut"

Écrire un serveur web en Python pur demande de gérer soi-même énormément de détails techniques. Parser les requêtes HTTP, valider les données reçues, générer une documentation à jour.

FastAPI automatise tout ce travail répétitif en s'appuyant sur un seul ingrédient central : les type hints Python. En lisant simplement les types que tu déclares, comme item_id: int, FastAPI sait valider les données, les convertir, et documenter ton API.

Une fois ce mécanisme compris, un vrai changement de paradigme apparaît : la documentation automatique. Dans beaucoup de frameworks, la documentation d'API est un document séparé du code, qui devient vite obsolète.

Avec FastAPI, les pages /docs et /redoc sont générées EN DIRECT à partir du code lui-même. Elles ne peuvent jamais être "en retard" sur l'implémentation réelle, puisqu'elles EN DÉCOULENT.

Une fois cette base posée, un premier choix se présente à chaque route : def ou async def. FastAPI accepte les deux styles, mais la différence n'est pas cosmétique.

Style de route	Adapté à	Piège à éviter
`def` (synchrone)	Calcul CPU, code utilisant des libs bloquantes	Aucun particulier
`async def`	Appels réseau/DB attendus avec `await`	Y placer du code bloquant (ex: `requests.get`) ralentit tout le serveur

Une route async def doit éviter tout code bloquant en son sein. Retiens pour l'instant qu'elle est adaptée aux opérations d'entrée/sortie, comme le réseau ou la base de données, qui peuvent être attendues sans bloquer le reste du serveur — une notion approfondie plus loin dans ce cours.

Prérequis

Cette leçon suppose des bases de Python (fonctions, types simples) mais aucune connaissance préalable de FastAPI ni des APIs web.

Il reste un dernier réflexe à prendre dès le premier projet : organiser le code tôt. L'exemple avec APIRouter peut sembler une complexité inutile pour "juste deux routes".

Mais cette habitude prise dès le départ évite une refonte pénible plus tard. Séparer les routes par domaine plutôt que tout empiler dans main.py est un principe qui reviendra dans toutes les leçons suivantes sur l'organisation de projet.

Piège fréquent

Confondre uvicorn main:app — le nom du FICHIER (main.py), puis le nom de la VARIABLE app — est une source d'erreur classique chez qui démarre son premier serveur FastAPI. Une erreur ModuleNotFoundError ou AttributeError à ce stade vient presque toujours de là.

Commandes & code

Première API

pip install fastapi uvicorn[standard]

# main.py
from fastapi import FastAPI

app = FastAPI(title="Mon API", version="0.1.0")


@app.get("/")
def read_root():
    return {"message": "Bienvenue sur mon API"}


@app.get("/ping")
def ping():
    return {"status": "ok"}

# Lancer le serveur de développement avec rechargement automatique
uvicorn main:app --reload --port 8000

# Documentation interactive générée automatiquement :
# http://localhost:8000/docs      (Swagger UI)
# http://localhost:8000/redoc     (ReDoc)
# http://localhost:8000/openapi.json

# Fonctions async ou sync : FastAPI gère les deux de manière transparente
import asyncio

@app.get("/sync")
def sync_endpoint():
    return {"type": "synchrone"}


@app.get("/async")
async def async_endpoint():
    await asyncio.sleep(0.1)  # simule une opération I/O non bloquante
    return {"type": "asynchrone"}

# Structure de projet minimale mais déjà organisée
# app/
# ├── __init__.py
# ├── main.py          <- point d'entrée, crée l'app FastAPI
# ├── core/
# │   └── config.py     <- configuration
# └── routers/
#     └── health.py

# app/main.py
from fastapi import FastAPI
from app.routers import health

app = FastAPI(title="Mon API")
app.include_router(health.router)

# app/routers/health.py
from fastapi import APIRouter

router = APIRouter(prefix="/health", tags=["health"])


@router.get("")
def health_check():
    return {"status": "ok"}

Résumé

uvicorn main:app --reload lance un serveur ASGI avec rechargement à chaud en développement.
La documentation OpenAPI (/docs, /redoc) est générée automatiquement depuis le code, sans configuration.
Les endpoints peuvent être def (synchrones) ou async def : FastAPI adapte l'exécution.
Dès le départ, organiser le code en routers évite un fichier main.py monolithique.

Exercices pratiques

1 disponible

Mission : le endpoint /health qui ne démarre jamais

Objectif : Diagnostiquer et corriger un projet FastAPI minimal qui refuse de démarrer, puis exposer un endpoint /health organisé en router.

Contexte

Un développeur junior te transmet son tout premier projet FastAPI. Il a écrit un fichier app.py contenant api = FastAPI() et une route /health, mais lance la commande uvicorn main:app --reload et obtient une erreur. L'équipe infra attend ce endpoint pour brancher une sonde de disponibilité avant la mise en production.

Résoudre l’exercice →