Integrar bancos de dados ao FastAPI é um dos passos mais importantes para construir APIs modernas, robustas e que realmente entregam valor aos usuários. Seja para um projeto pequeno ou aplicações que demandam alta escalabilidade, armazenar e manipular dados de forma segura e eficiente é fundamental.
Neste artigo, você vai entender como conectar bancos relacionais (como PostgreSQL, MySQL e SQLite) e NoSQL (como MongoDB e Redis) ao FastAPI, quais ORMs utilizar, como implementar operações CRUD, e as melhores práticas de segurança e desempenho.
Por que Usar Bancos de Dados com FastAPI?
A integração com banco de dados permite que sua API guarde informações entre requisições, possibilitando operações como cadastro, consulta, atualização ou exclusão de dados de forma estruturada e segura.
Em aplicações reais, é praticamente obrigatório persistir dados — seja usuários, produtos, pedidos ou qualquer outro recurso. Utilizar um banco de dados facilita buscas, filtros e garante integridade, ampliando a escalabilidade da aplicação (veja mais sobre os conceitos básicos de bancos de dados).
Principais Opções de Bancos de Dados e ORMs Compatíveis com FastAPI
FastAPI foi pensado para versatilidade. Entre as opções mais populares, destacam-se:
Bancos Relacionais (SQL)
- PostgreSQL
- MySQL
- SQLite (ideal para testes/desenvolvimento)
O FastAPI tem excelente compatibilidade com drivers SQL e ORMs. SQLAlchemy é o mais documentado e recomendado oficialmente para bancos relacionais.
Bancos NoSQL
- MongoDB (via bibliotecas como PyMongo ou Motor)
- Redis (usado normalmente para cache ou sessões)
A integração com NoSQL costuma ser feita diretamente pelo driver, sem necessidade de ORMs.
ORMs Populares
- SQLAlchemy: suporte síncrono e assíncrono (1.4+)
- Tortoise ORM: focado em operações totalmente assíncronas, inspirado no Django ORM
- GINO: assíncrono, ideal para PostgreSQL
Instalação de Dependências
O primeiro passo no seu projeto FastAPI é instalar os pacotes necessários:
bash
pip install fastapi[all] sqlalchemy
O comando acima garante que FastAPI, Uvicorn (servidor ASGI), SQLAlchemy e outras dependências úteis sejam instaladas.
Para bancos NoSQL, utilize:
bash
pip install pymongo # Para MongoDB
pip install motor # MongoDB Async
pip install redis # Para Redis
Configurando a Conexão com o Banco de Dados
Sempre utilize variáveis de ambiente para armazenar URIs e senhas, evitando expor credenciais no código fonte — uma prática alinhada com o padrão Twelve-Factor App.
Exemplo usando dotenv:
- Instale a biblioteca:
bash pip install python-dotenv - No arquivo
.env, coloque:env DATABASE_URL=postgresql://usuario:senha@localhost:5432/banco - No seu código Python:
python import os from dotenv import load_dotenv load_dotenv() DATABASE_URL = os.getenv('DATABASE_URL')
Gerenciamento de Sessões e Conexões
No FastAPI, é recomendado abrir e fechar uma sessão de banco de dados a cada requisição. Use dependências (Depends) para garantir o gerenciamento correto e evitar vazamento de conexões:
python
from sqlalchemy.orm import sessionmaker
from fastapi import Depends
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
Utilize esse get_db() nos endpoints como uma dependência.
Criando e Manipulando Dados: Operações CRUD no FastAPI
As operações CRUD são o coração da API:
- Create (Criação): cadastrar novos registros (POST)
- Read (Leitura): buscar dados (GET)
- Update (Atualização): modificar registros existentes (PUT/PATCH)
- Delete (Exclusão): remover registros (DELETE)
FastAPI integra a validação de dados com Pydantic, tornando sua API mais segura e confiável.
Exemplo Prático de CRUD com SQLAlchemy
Modelo Pydantic:
python
from pydantic import BaseModel
class UserCreate(BaseModel):
nome: str
email: str
Modelo ORM:
python
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base
Base = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
nome = Column(String, index=True)
email = Column(String, unique=True, index=True)
Endpoint de criação:
python
from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
app = FastAPI()
@app.post("/users/")
def create_user(user: UserCreate, db: Session = Depends(get_db)):
db_user = User(nome=user.nome, email=user.email)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
Os endpoints de leitura, atualização e exclusão seguem padrão semelhante, usando métodos apropriados do SQLAlchemy (consulta, update, delete) e tratamento correto das respostas HTTP.
Integração com NoSQL: MongoDB e Redis
Para MongoDB, utilize drivers como PyMongo (síncrono) ou Motor (assíncrono). Exemplo simples:
python
from motor.motor_asyncio import AsyncIOMotorClient
client = AsyncIOMotorClient(DATABASE_URL)
db = client['meu_banco']
Para Redis, o uso é normalmente associado a cache e armazenamento temporário de sessões.
Boas Práticas e Dicas de Segurança
- Gerencie sessões de conexão por requisição para evitar vazamentos de memória.
- Utilize variáveis de ambiente e arquivos
.envpara credenciais. - Evite expor informações sensíveis em logs.
- Sempre valide dados de entrada com Pydantic.
- Use ORMs, pois ajudam a proteger sua aplicação contra SQL Injection.
- Criptografe senhas usando bibliotecas como
passlib.
Respostas para Dúvidas Frequentes
Como escolher entre bancos SQL e NoSQL para FastAPI?
- Use SQL (PostgreSQL, MySQL) se seus dados têm estrutura fixa e relacionamentos.
- Prefira NoSQL (MongoDB, Redis) para dados flexíveis, alta escalabilidade horizontal ou armazenamento de cache/sessões.
Qual ORM funciona melhor com FastAPI?
SQLAlchemy é o mais utilizado. Para projetos assíncronos, Tortoise ORM é boa alternativa.
Como proteger a string de conexão?
Utilize arquivos .env e variáveis de ambiente, nunca commitando credenciais em repositórios públicos.
É possível usar operações assíncronas com bancos de dados em FastAPI?
Sim, com ORMs como SQLAlchemy 1.4+, Tortoise ORM e drivers assíncronos.
Como evitar conexões abertas/vazamentos de memória?
Gerencie conexões por requisição, usando dependências (Depends) e garantindo fechamento após uso.
Conclusão
A integração de bancos de dados é parte crítica do desenvolvimento de APIs robustas e escaláveis com FastAPI. Aliar boas práticas de segurança, gerenciamento eficiente de conexões e uso de ORMs traz produtividade e tranquilidade para evoluir seu sistema.
Como próximos passos, sugerimos aprofundar-se em temas como autenticação, deploy e testes automatizados. Acesse nosso Guia Prático para Iniciantes em APIs Python com FastAPI e aprimore também seu conhecimento sobre autenticação e autorização segura no FastAPI.
Próximos Passos: Continue Aprendendo FastAPI e Bancos de Dados
- Explore autenticação em APIs e estratégias de segurança avançadas
- Conheça integração com bancos NoSQL mais a fundo
- Participe de comunidades e cursos sobre desenvolvimento Python e FastAPI
Quer criar ou evoluir sua API? Continue aprendendo com nossos conteúdos e domine de vez as habilidades mais procuradas do mercado!