Comment intégrez-vous une base de données SQL avec FastAPI ?

Question

Accepted Answer

Contrairement à Django, FastAPI est **sans opinions préconçues** concernant les bases de données — vous choisissez la bibliothèque. Le choix courant est **SQLAlchemy** (souvent avec **SQLModel**, écrit par l'auteur de FastAPI, qui combine SQLAlchemy + Pydantic). Les sessions de base de données sont fournies via l'injection de dépendances.

## Configuration de SQLAlchemy

```python
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base

engine = create_engine("postgresql://user:pass@localhost/db")
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class User(Base):                        # an ORM model (maps to a table)
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String, unique=True)
```

## Fournir la session DB via une dépendance

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                 # provide the session
    finally:
        db.close()               # ALWAYS close after the request (cleanup)

@app.get("/users/{id}")
def get_user(id: int, db: Session = Depends(get_db)):   # inject a session per request
    user = db.query(User).filter(User.id == id).first()
    if not user:
        raise HTTPException(404, "Not found")
    return user
```

Le pattern de dépendance `yield` est la façon standard de gérer les sessions : en ouvrir une par requête, l'injecter, et la fermer automatiquement ensuite — chaque endpoint obtient une session propre et correctement fermée.

## SQLModel — SQLAlchemy + Pydantic en un

```python
from sqlmodel import SQLModel, Field, Session, select

class User(SQLModel, table=True):        # ONE class = ORM model AND Pydantic model
    id: int | None = Field(default=None, primary_key=True)
    name: str
    email: str

@app.get("/users")
def list_users(db: Session = Depends(get_session)):
    return db.exec(select(User)).all()    # query; results are also valid response models
```

SQLModel unifie le modèle ORM et le modèle Pydantic en une seule classe — réduisant la duplication entre le schéma de base de données et le schéma d'API.

## Migrations et options asynchrones

```text
✓ Migrations: use Alembic (SQLAlchemy's migration tool) for schema changes
✓ Async: use SQLAlchemy's async engine + async session for async endpoints
  (don't use a SYNC database driver inside async def — it blocks the event loop)
```

## Pourquoi c'est important

L'intégration de base de données est essentielle pour presque toute API réelle, et puisque FastAPI est délibérément **sans opinions préconçues** à ce sujet (contrairement à l'ORM intégré de Django), comprendre l'approche courante est une connaissance pratique importante.

Le pattern standard — **SQLAlchemy** (ou **SQLModel**, qui unifie élégamment l'ORM et les modèles Pydantic pour réduire la duplication) avec des **sessions injectées via les dépendances** grâce au pattern `yield` — est ce que presque toute application FastAPI utilise pour persister les données.

La dépendance session-par-requête (ouvrir avant, fermer après, automatiquement) est la façon idiomatique et correcte de gérer les connexions de base de données, et l'unification de SQLModel des schémas de base de données et d'API est une fonctionnalité de productivité notable de l'auteur de FastAPI lui-même.

Savoir comment configurer la base de données, fournir des sessions via l'injection de dépendances, effectuer des requêtes et gérer les migrations (Alembic) et la cavité asynchrone (utiliser des drivers asynchrones dans les endpoints async, ne jamais bloquer les synchrones) est nécessaire pour construire des applications FastAPI axées sur les données — puisque FastAPI vous donne la liberté de choisir, connaître le chemin conventionnel et bien balisé est précieux pour construire des applications réelles correctement.