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
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
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
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
✓ 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.