Como integrar um banco de dados SQL com FastAPI?

Question

IT Interview Practice · Accepted Answer

Diferente do Django, FastAPI é **agnóstico** em relação a bancos de dados — você escolhe a biblioteca. A escolha comum é **SQLAlchemy** (frequentemente com **SQLModel**, do autor do FastAPI, que combina SQLAlchemy + Pydantic). As sessões de banco de dados são fornecidas via injeção de dependência.

## Configuração do 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)
```

## Fornecendo a sessão do BD via uma dependência

```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
```

O padrão de dependência com `yield` é a forma padrão de gerenciar sessões: abre uma por requisição, injeta-a e fecha-a automaticamente depois — cada endpoint recebe uma sessão limpa e propriamente fechada.

## SQLModel — SQLAlchemy + Pydantic em um

```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 unifica o modelo ORM e o modelo Pydantic em uma única classe — reduzindo duplicação entre o banco de dados e os esquemas da API.

## Migrações e opções assíncronas

```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)
```

## Por que isso importa

A integração com banco de dados é essencial para praticamente qualquer API real, e como FastAPI é deliberadamente **agnóstico** (diferente do ORM integrado do Django), entender a abordagem comum é um conhecimento prático importante.

O padrão padrão — **SQLAlchemy** (ou **SQLModel**, que elegantemente unifica o ORM e os modelos Pydantic para reduzir duplicação) com **sessões injetadas por dependência** via o padrão `yield` — é o que praticamente todos os aplicativos FastAPI usam para persistir dados.

A dependência uma-sessão-por-requisição (abre antes, fecha depois, automaticamente) é a forma idiomática e correta de gerenciar conexões de banco de dados, e a unificação do SQLModel entre esquemas de banco de dados e API é um recurso de produtividade notável do próprio autor do FastAPI.

Saber como configurar o banco de dados, fornecer sessões por meio de DI, executar consultas, lidar com migrações (Alembic) e o aviso assincronismo (usar drivers assincronismo em endpoints assincronismo, nunca sincronismo bloqueante) é necessário para construir aplicativos FastAPI orientados a dados — como FastAPI oferece a liberdade de escolher, conhecer o caminho convencional e bem pavimentado é valioso para construir aplicativos reais corretamente.

Configuração do SQLAlchemy

Fornecendo a sessão do BD via uma dependência

SQLModel — SQLAlchemy + Pydantic em um

Migrações e opções assíncronas

Por que isso importa

Perguntas relacionadas