FastAPI : Framework web Python moderne et performant

Construisez des API extrêmement rapides avec des documents automatiques et une sécurité des types

Sommaire

FastAPI est devenu l’un des cadres web les plus excitants pour construire des API en Python, combinant des fonctionnalités modernes de Python avec une performance exceptionnelle et une expérience utilisateur optimisée.

Quelle que soit la tâche : création de microservices, fonctions serverless ou applications web complexes, FastAPI fournit les outils nécessaires pour des API prêtes pour la production.

python et fastapi château

Qu’est-ce que FastAPI ?

FastAPI est un cadre web moderne et performant pour construire des API avec Python 3.8+ basé sur les indicateurs de type standard de Python. Créé par Sebastián Ramírez, il est conçu pour être facile à utiliser, rapide à coder et prêt pour la production dès le départ.

Le framework repose sur deux bibliothèques puissantes :

  • Starlette pour le routage web et les capacités asynchrones
  • Pydantic pour la validation des données à l’aide des indicateurs de type de Python

Cette combinaison offre une performance comparable à celle de Node.js et de Go tout en maintenant la simplicité et la lisibilité de Python. FastAPI a rapidement gagné en popularité, avec des milliers d’étoiles sur GitHub et une adoption par des entreprises majeures à travers le monde.

Fonctionnalités clés qui distinguent FastAPI

1. Documentation API automatique

L’une des fonctionnalités les plus appréciées de FastAPI est la documentation API interactive automatique. Basée sur la norme OpenAPI (anciennement Swagger), FastAPI génère deux interfaces de documentation :

  • Swagger UI à /docs - Documentation interactive où vous pouvez tester directement les points de terminaison API dans le navigateur
  • ReDoc à /redoc - Alternative de documentation avec un design propre à trois panneaux

La documentation est générée automatiquement à partir des indicateurs de type et des commentaires de votre code - aucun paramétrage supplémentaire n’est requis. Cela signifie que votre documentation est toujours à jour avec votre code.

2. Indicateurs de type et validation

FastAPI utilise les indicateurs de type de Python non seulement pour la documentation, mais aussi pour la validation et la sérialisation en temps de fonctionnement. Lorsque vous définissez un paramètre d’endpoint comme int, FastAPI effectue automatiquement :

  • La validation que la requête contient un entier
  • La conversion de la valeur à partir de la chaîne en entier
  • Des messages d’erreur clairs si la validation échoue
  • La documentation du type du paramètre dans les documents API
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    email: str
    age: int

@app.post("/users/")
async def create_user(user: User):
    return {"message": f"Utilisateur {user.username} créé avec succès"}

Cette approche détecte les bugs tôt, réduit le code redondant et rend votre API auto-documentée.

3. Prise en charge asynchrone

FastAPI est construit sur l’interface ASGI (Asynchronous Server Gateway Interface) plutôt que sur WSGI, lui donnant un support natif d’async/await. Cela est crucial pour les applications à haute performance qui effectuent de nombreuses appels d’E/S (requêtes de base de données, requêtes API, opérations de fichiers).

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    # Les opérations asynchrones ne bloquent pas les autres requêtes
    data = await fetch_from_database(item_id)
    return data

Le support asynchrone signifie que FastAPI peut gérer efficacement des milliers de connexions simultanées, ce qui en fait un choix idéal pour les applications cloud modernes et les architectures de microservices.

4. Performance

FastAPI est l’un des cadres Python les plus rapides disponibles, avec une performance comparable à celle des cadres Node.js et Go. Des benchmarks indépendants montrent régulièrement que FastAPI dépasse les cadres traditionnels comme Flask et Django de manière significative, surtout pour les charges de travail liées à l’E/S.

La vitesse provient de :

  • La validation C-level de Pydantic
  • L’implémentation efficace asynchrone de Starlette
  • Un faible surcoût du cadre lui-même

Démarrage avec FastAPI

L’installation de FastAPI est simple. Lorsque vous travaillez sur des projets Python, avoir un bon gestionnaire de paquets Python facilite beaucoup la gestion des dépendances. Vous aurez besoin de FastAPI et d’un serveur ASGI comme Uvicorn :

pip install fastapi uvicorn[standard]

Voici une application FastAPI minimale :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Bonjour le monde"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Exécutez-la avec :

uvicorn main:app --reload

Visitez http://localhost:8000/docs pour voir votre documentation API interactive.

Construction d’API prêtes pour la production

Modèles de requête et de réponse

Définir des modèles de données clairs est essentiel pour des API maintenables. Suivre les modèles de conception Python pour une architecture propre aide à créer des applications bien structurées :

from pydantic import BaseModel, EmailStr, Field
from typing import Optional
from datetime import datetime

class UserCreate(BaseModel):
    username: str = Field(..., min_length=3, max_length=50)
    email: EmailStr
    password: str = Field(..., min_length=8)

class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    created_at: datetime
    
    class Config:
        orm_mode = True  # Permet à Pydantic de fonctionner avec des objets ORM

@app.post("/users/", response_model=UserResponse)
async def create_user(user: UserCreate):
    # Votre logique métier ici
    new_user = save_user_to_database(user)
    return new_user

Le paramètre response_model garantit que FastAPI ne renvoie que les champs spécifiés, filtrant automatiquement les données sensibles comme les mots de passe.

Injection de dépendances

Le système d’injection de dépendances de FastAPI est puissant et élégant. Il permet de :

  • Partager du code entre les endpoints
  • Imposer l’authentification/autorisation
  • Gérer les connexions à la base de données
  • Gérer les dépendances complexes
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = verify_token(token)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Crédentiel d'authentification invalides"
        )
    return user

@app.get("/users/me")
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user

Gestion des erreurs

FastAPI fournit des gestionnaires d’exceptions intégrés et permet des réponses d’erreur personnalisées :

from fastapi import HTTPException

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id not in items_db:
        raise HTTPException(
            status_code=404,
            detail="Élément non trouvé",
            headers={"X-Error": "En-tête personnalisé"}
        )
    return items_db[item_id]

Tâches en arrière-plan

Pour les opérations qui n’ont pas besoin d’être terminées avant de renvoyer une réponse :

from fastapi import BackgroundTasks

def send_email_notification(email: str, message: str):
    # Logique d'envoi d'e-mail
    pass

@app.post("/send-notification/")
async def send_notification(
    email: str,
    background_tasks: BackgroundTasks
):
    background_tasks.add_task(send_email_notification, email, "Bienvenue !")
    return {"message": "Notification planifiée"}

Tests des applications FastAPI

Les tests unitaires en Python complets sont essentiels pour des API fiables. FastAPI fonctionne sans problème avec pytest et fournit un client de test :

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_main():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Bonjour le monde"}

def test_read_item():
    response = client.get("/items/42?q=test")
    assert response.status_code == 200
    assert response.json() == {"item_id": 42, "q": "test"}

Pour tester les endpoints asynchrones :

import pytest
from httpx import AsyncClient

@pytest.mark.asyncio
async def test_async_endpoint():
    async with AsyncClient(app=app, base_url="http://test") as ac:
        response = await ac.get("/")
    assert response.status_code == 200

Intégration de base de données

FastAPI s’intègre bien avec diverses bases de données et ORMs. Voici un exemple avec SQLAlchemy :

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from fastapi import Depends

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/{user_id}")
async def read_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="Utilisateur non trouvé")
    return user

Options de déploiement

Déploiement avec Docker

Les applications FastAPI s’emballent facilement. Voici un Dockerfile prêt pour la production :

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Déploiement sur AWS Lambda

FastAPI fonctionne excellente avec les plateformes serverless. Lorsque vous construisez un AWS Lambda dual-mode avec Python et Terraform, vous pouvez déployer des applications FastAPI à l’aide de Mangum, un adaptateur qui enveloppe FastAPI pour AWS Lambda :

from mangum import Mangum
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Bonjour depuis Lambda !"}

handler = Mangum(app)

Pour des déploiements plus complexes, AWS SAM avec Python PowerTools fournit d’excellents outils pour les applications FastAPI.

Déploiement sur serveur traditionnel

Pour le déploiement en production sur des serveurs traditionnels ou Kubernetes :

# Avec Gunicorn et Uvicorn workers
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000

Fonctionnalités avancées

CORS (Cross-Origin Resource Sharing)

Activez CORS pour les applications front-end :

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://example.com"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Prise en charge des WebSockets

FastAPI prend en charge les WebSockets pour la communication en temps réel :

from fastapi import WebSocket

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Message reçu : {data}")

Intégration GraphQL

FastAPI peut fonctionner avec GraphQL via Strawberry ou d’autres bibliothèques GraphQL :

import strawberry
from strawberry.fastapi import GraphQLRouter

@strawberry.type
class Query:
    @strawberry.field
    def hello(self) -> str:
        return "Bonjour le monde"

schema = strawberry.Schema(query=Query)
graphql_app = GraphQLRouter(schema)

app.include_router(graphql_app, prefix="/graphql")

Travail avec les LLM et l’IA

FastAPI est excellent pour construire des API alimentées par l’IA. Lorsque vous restreignez les LLM avec une sortie structurée à l’aide d’Ollama, les modèles Pydantic de FastAPI fournissent des définitions de schéma parfaites pour les réponses structurées :

from pydantic import BaseModel
from typing import List
import httpx

class SentimentResponse(BaseModel):
    sentiment: str
    confidence: float
    keywords: List[str]

@app.post("/analyze-sentiment/", response_model=SentimentResponse)
async def analyze_sentiment(text: str):
    # Appel du service LLM
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "qwen2.5",
                "prompt": f"Analyser le sentiment : {text}",
                "format": SentimentResponse.schema_json()
            }
        )
    return response.json()

Bonnes pratiques et conseils

1. Utilisez les décorateurs d’opération de chemin de manière cohérente

Organisez vos endpoints avec des méthodes HTTP claires :

@app.get("/items/")      # Liste des éléments
@app.post("/items/")     # Créer un élément
@app.get("/items/{id}")  # Obtenir un élément spécifique
@app.put("/items/{id}")  # Mettre à jour un élément
@app.delete("/items/{id}") # Supprimer un élément

2. Versionnez votre API

Incluez la version de l’API dès le départ :

from fastapi import APIRouter

api_v1 = APIRouter(prefix="/api/v1")
api_v2 = APIRouter(prefix="/api/v2")

@api_v1.get("/users/")
async def get_users_v1():
    return {"version": "1.0"}

app.include_router(api_v1)
app.include_router(api_v2)

3. Utilisez les variables d’environnement

Ne codez jamais de secrets. Utilisez des variables d’environnement :

from pydantic import BaseSettings

class Settings(BaseSettings):
    database_url: str
    secret_key: str
    api_key: str
    
    class Config:
        env_file = ".env"

settings = Settings()

4. Implémentez un bon journalisation

Utilisez le module de journalisation de Python :

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.get("/items/")
async def get_items():
    logger.info("Récupération de tous les éléments")
    return items

5. Surveillez les performances

Utilisez un middleware pour le timing des requêtes :

import time
from fastapi import Request

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

FastAPI vs autres cadres

FastAPI vs Flask

Flask est plus minimaliste et vous donne plus de contrôle, mais FastAPI propose plus de fonctionnalités par défaut :

  • FastAPI a une validation et une documentation automatique
  • Flask nécessite des extensions pour le support asynchrone
  • FastAPI est nettement plus rapide pour les opérations liées à l’E/S
  • Flask a un écosystème plus grand et plus de ressources d’apprentissage

FastAPI vs Django REST Framework

Le Django REST Framework (DRF) fait partie de l’écosystème plus large de Django :

  • DRF inclut un ORM complet et une interface d’administration
  • FastAPI est plus léger et plus rapide
  • DRF est mieux adapté aux applications complexes et lourdes en base de données
  • FastAPI excelle dans les microservices et les APIs autonomes

FastAPI vs Node.js/Express

FastAPI offre la simplicité de Python avec une performance comparable à celle de Node.js :

  • Des caractéristiques de performance asynchrone similaires
  • Le système de type de Python est plus robuste que JavaScript/TypeScript
  • Node.js a un écosystème de paquets plus grand
  • La documentation automatique de FastAPI est supérieure

Cas d’utilisation réels

Architecture de microservices

La nature légère de FastAPI et son temps de démarrage rapide le rendent idéal pour les microservices. Chaque service peut être déployé et échelonné indépendamment.

API de machine learning

Le déploiement de modèles de machine learning est un cas d’utilisation courant de FastAPI. Le support asynchrone du cadre gère efficacement de nombreuses requêtes de prédiction.

Backend pour les applications mobiles/web

FastAPI est un excellent backend pour les applications SPAs modernes (Single Page Applications) et mobiles grâce à sa gestion automatique du CORS et son support des WebSockets.

Collecte de données IoT

FastAPI peut gérer l’ingestion à grande échelle de données provenant d’appareils IoT, traitant et stockant efficacement les données des capteurs.

Chatbots et interfaces conversationnelles

La construction d’interfaces conversationnelles et de backends de chatbots bénéficie du support des WebSockets et des capacités asynchrones de FastAPI.

Pièges courants et solutions

1. Opérations bloquantes dans les fonctions asynchrones

Problème : Exécuter du code synchrone bloquant dans des fonctions asynchrones :

@app.get("/slow")
async def slow_endpoint():
    time.sleep(10)  # Bloque l'ensemble de la boucle d'événement !
    return {"status": "terminé"}

Solution : Utilisez run_in_executor pour les opérations bloquantes :

from fastapi import BackgroundTasks
import asyncio

@app.get("/fast")
async def fast_endpoint():
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, blocking_function)
    return {"result": result}

2. Non utilisation des modèles de réponse

Problème : Renvoyer directement des objets de base de données expose la structure interne.

Solution : Définissez toujours des modèles de réponse :

@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
    return db_user  # Filtré automatiquement via UserResponse

3. Gestion insuffisante des erreurs

Problème : Les exceptions non gérées provoquent le crash de l’application.

Solution : Utilisez des gestionnaires d’exceptions :

@app.exception_handler(ValueError)
async def value_error_handler(request, exc):
    return JSONResponse(
        status_code=400,
        content={"message": str(exc)}
    )

Ressources de l’écosystème Python

FastAPI s’intègre parfaitement avec l’écosystème Python plus large. Pour un aperçu complet des fondamentaux Python, consultez le cheat sheet Python qui couvre les syntaxes et modèles essentiels que vous utiliserez dans les applications FastAPI.

Conclusion

FastAPI représente une avancée majeure dans la conception des cadres web Python. En adoptant les fonctionnalités modernes de Python comme les indicateurs de type et async/await, il offre une performance exceptionnelle et une expérience utilisateur optimisée. Qu’il s’agisse de construire un simple API REST ou une architecture complexe de microservices, FastAPI fournit les outils et la performance nécessaires pour les applications de production.

Le framework de documentation automatique, de sécurité de type et de conception intuitive en font un excellent choix à la fois pour les débutants et les développeurs expérimentés. Alors que l’écosystème Python continue d’évoluer, FastAPI se positionne comme le cadre pour le développement d’API modernes.

Commencez petit avec un API simple, explorez la documentation, et adoptez progressivement des fonctionnalités plus avancées à mesure que votre application grandit. La communauté FastAPI est active et utile, avec une documentation et des exemples étendus pour vous guider.

Liens utiles

Ressources externes et références