O FastAPI é uma das ferramentas mais populares para criar APIs em Python. Ele combina simplicidade, velocidade e recursos modernos que facilitam o desenvolvimento de aplicações web robustas.
Recomendo conferir o vídeo abaixo do canal Hashtag Programação que te ensina sobre como usar o FastAPI:
Se você já trabalha com Python e quer criar APIs de forma eficiente, este guia completo vai te ensinar tudo que precisa saber sobre FastAPI.
O Que É FastAPI e Por Que Escolhê-lo
FastAPI é um framework web moderno e de alto desempenho para construir APIs com Python. Criado por Sebastián Ramírez, ele se destaca por usar recursos modernos da linguagem, como as type hints do Python 3.6+, para oferecer validação automática de dados e documentação interativa.
O nome FastAPI não é por acaso. Ele é um dos frameworks mais rápidos disponíveis para Python, competindo diretamente com soluções em Node.js e Go. Isso acontece porque ele foi construído sobre Starlette para a parte web e Pydantic para validação de dados.
Principais características que tornam o FastAPI especial:
- Velocidade excepcional de execução, próxima a NodeJS e Go
- Desenvolvimento mais rápido, aumentando a produtividade em até 300%
- Menos bugs graças à validação automática de tipos
- Documentação automática com Swagger UI e ReDoc
- Baseado em padrões abertos como OpenAPI e JSON Schema
- Suporte nativo a operações assíncronas
Empresas como Microsoft, Uber e Netflix já utilizam FastAPI em produção. A popularidade do framework cresce exponencialmente, e ele já supera até mesmo o Django em algumas métricas de crescimento no GitHub.
Como Instalar e Configurar o FastAPI
Antes de começar, você precisa ter o Python 3.7 ou superior instalado no seu computador. A instalação do FastAPI é extremamente simples e pode ser feita em poucos minutos.
Primeiro, crie um ambiente virtual para manter suas dependências organizadas. Abra seu terminal e execute os seguintes comandos:
python -m venv venv
source venv/bin/activate # No Windows: venv\Scripts\activateAgora instale o FastAPI e o Uvicorn, que é o servidor ASGI usado para rodar a aplicação:
pip install fastapi uvicorn[standard]Pronto! Com apenas esses dois comandos, você já tem tudo necessário para começar a desenvolver. O Uvicorn é fundamental porque o FastAPI precisa de um servidor ASGI para funcionar, diferente do Flask que pode usar WSGI.
Para verificar se a instalação foi bem-sucedida, você pode usar o comando pip list e confirmar que tanto o fastapi quanto o uvicorn aparecem na lista de bibliotecas instaladas.
Criando Sua Primeira API com FastAPI
Vamos criar uma API simples para você entender como o FastAPI funciona na prática. Crie um arquivo chamado main.py e adicione o seguinte código:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"mensagem": "Olá, FastAPI!"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "query": q}Esse código cria duas rotas básicas. A primeira responde na raiz da aplicação e a segunda aceita um parâmetro de caminho. Repare como usamos type hints para indicar que item_id deve ser um número inteiro.
Para executar sua API, use o comando:
uvicorn main:app --reloadO parâmetro --reload faz com que o servidor reinicie automaticamente sempre que você modificar o código. Isso é extremamente útil durante o desenvolvimento, similar ao que você teria em um projeto Flask.
Acesse http://127.0.0.1:8000 no seu navegador e você verá a resposta JSON. Mas a mágica acontece quando você acessa http://127.0.0.1:8000/docs. Ali está a documentação automática da sua API, completamente interativa!
Entendendo os Métodos HTTP no FastAPI
APIs RESTful utilizam diferentes métodos HTTP para diferentes operações. O FastAPI facilita muito a implementação desses métodos através de decoradores intuitivos.
GET: Usado para buscar dados. É o método mais comum e não modifica informações no servidor.
@app.get("/usuarios")
def listar_usuarios():
return {"usuarios": ["João", "Maria", "Pedro"]}POST: Serve para criar novos recursos. Você envia dados no corpo da requisição.
from pydantic import BaseModel
class Usuario(BaseModel):
nome: str
email: str
idade: int
@app.post("/usuarios")
def criar_usuario(usuario: Usuario):
return {"mensagem": f"Usuário {usuario.nome} criado com sucesso"}PUT e PATCH: Atualizam recursos existentes. PUT substitui completamente, PATCH modifica parcialmente.
@app.put("/usuarios/{usuario_id}")
def atualizar_usuario(usuario_id: int, usuario: Usuario):
return {"mensagem": f"Usuário {usuario_id} atualizado"}DELETE: Remove recursos do sistema.
@app.delete("/usuarios/{usuario_id}")
def deletar_usuario(usuario_id: int):
return {"mensagem": f"Usuário {usuario_id} removido"}Validação Automática com Pydantic
Uma das características mais poderosas do FastAPI é a validação automática de dados usando Pydantic. Você define modelos de dados como classes Python, e o framework cuida do resto.
Quando você cria um modelo Pydantic, está definindo exatamente quais campos são obrigatórios, seus tipos e até regras de validação mais complexas:
from pydantic import BaseModel, EmailStr, validator
class Produto(BaseModel):
nome: str
preco: float
descricao: str = None
em_estoque: bool = True
@validator('preco')
def preco_positivo(cls, v):
if v <= 0:
raise ValueError('O preço deve ser positivo')
return vSe alguém enviar dados inválidos para sua API, o FastAPI automaticamente retorna uma mensagem de erro clara explicando o problema. Isso economiza muito tempo que você gastaria escrevendo código de validação manual.
O sistema de validação também funciona com tipos complexos. Você pode usar listas, dicionários, valores opcionais e até modelos aninhados. Tudo é validado automaticamente.
Trabalhando com Banco de Dados
Conectar sua API FastAPI a um banco de dados é essencial para aplicações reais. A integração mais comum é com SQLAlchemy, mas você também pode usar outros ORMs ou trabalhar diretamente com drivers de banco de dados.
Primeiro, instale as dependências necessárias:
pip install sqlalchemy databasesAqui está um exemplo básico de configuração com SQLite:
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
SQLALCHEMY_DATABASE_URL = "sqlite:///./app.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
class Usuario(Base):
__tablename__ = "usuarios"
id = Column(Integer, primary_key=True, index=True)
nome = Column(String)
email = Column(String, unique=True, index=True)Para usar o banco em suas rotas, crie uma dependência que gerencia a sessão:
from fastapi import Depends
from sqlalchemy.orm import Session
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get("/usuarios")
def listar_usuarios(db: Session = Depends(get_db)):
usuarios = db.query(Usuario).all()
return usuariosSe preferir trabalhar com MySQL, basta alterar a string de conexão. O FastAPI também suporta PostgreSQL, MongoDB e outros bancos de dados populares.
Autenticação e Segurança
Proteger sua API é fundamental. O FastAPI oferece diversos recursos de segurança integrados, incluindo suporte a OAuth2, JWT tokens e autenticação básica.
Um exemplo simples de autenticação com token Bearer:
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
security = HTTPBearer()
def verificar_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
token = credentials.credentials
if token != "meu-token-secreto":
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Token inválido"
)
return token
@app.get("/protegido")
def rota_protegida(token: str = Depends(verificar_token)):
return {"mensagem": "Acesso autorizado"}Para implementações mais robustas, você pode usar JWT (JSON Web Tokens):
from datetime import datetime, timedelta
from jose import JWTError, jwt
SECRET_KEY = "sua-chave-secreta-super-segura"
ALGORITHM = "HS256"
def criar_token(data: dict):
to_encode = data.copy()
expire = datetime.utcnow() + timedelta(hours=24)
to_encode.update({"exp": expire})
return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)Sempre use HTTPS em produção e nunca exponha suas chaves secretas no código. Use variáveis de ambiente para guardar informações sensíveis.
Operações Assíncronas e Performance
O FastAPI brilha quando falamos de operações assíncronas. Ele foi construído pensando em alto desempenho desde o início, e usar async/await é extremamente simples.
Você pode definir rotas assíncronas adicionando async antes da definição da função:
import asyncio
from fastapi import FastAPI
@app.get("/async")
async def rota_assincrona():
await asyncio.sleep(1)
return {"mensagem": "Operação assíncrona concluída"}Isso é especialmente útil quando você precisa fazer múltiplas requisições externas ou operações de I/O. Com asyncio, sua aplicação pode processar outras requisições enquanto aguarda respostas.
Um exemplo prático fazendo requisições HTTP assíncronas:
import httpx
@app.get("/dados-externos")
async def buscar_dados():
async with httpx.AsyncClient() as client:
response = await client.get("https://api.exemplo.com/dados")
return response.json()A diferença de performance entre rotas síncronas e assíncronas pode ser significativa em aplicações que fazem muitas chamadas externas ou acessam bancos de dados frequentemente.
Testando Sua API FastAPI
Testes são essenciais para garantir que sua API funcione corretamente. O FastAPI facilita muito a criação de testes automatizados usando pytest.
Instale as dependências de teste:
pip install pytest httpxCrie um arquivo test_main.py com seus testes:
from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_read_root():
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"mensagem": "Olá, FastAPI!"}
def test_criar_usuario():
response = client.post(
"/usuarios",
json={"nome": "João", "email": "joao@email.com", "idade": 25}
)
assert response.status_code == 200Execute os testes com o comando pytest. O TestClient simula requisições HTTP sem precisar rodar o servidor, tornando os testes muito mais rápidos.
Você também pode testar autenticação, validações e comportamentos de erro. Quanto mais testes você escrever, mais confiável sua API será.
Documentação Automática e Interativa
Uma das funcionalidades mais impressionantes do FastAPI é a geração automática de documentação. Sem escrever uma linha de código adicional, você tem acesso a duas interfaces de documentação completas.
O Swagger UI está disponível em /docs e oferece uma interface interativa onde você pode testar todos os endpoints diretamente no navegador. É perfeito para desenvolvimento e demonstrações.
O ReDoc está em /redoc e oferece uma apresentação mais limpa e focada em leitura. É ideal para compartilhar com outras equipes ou documentar APIs públicas.
Você pode personalizar a documentação adicionando descrições, exemplos e metadados:
@app.post("/usuarios",
summary="Criar novo usuário",
description="Cria um novo usuário no sistema com nome, email e idade",
response_description="Usuário criado com sucesso"
)
def criar_usuario(usuario: Usuario):
return {"mensagem": f"Usuário {usuario.nome} criado"}Todos os parâmetros, tipos de retorno e validações que você define aparecem automaticamente na documentação. Isso economiza horas de trabalho manual e garante que a documentação esteja sempre atualizada.
Deploy e Produção
Colocar sua API em produção exige alguns cuidados adicionais. O Uvicorn que usamos no desenvolvimento não é ideal para ambientes de produção com alto tráfego.
Para produção, é recomendado usar Gunicorn com workers Uvicorn:
pip install gunicorn
gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000Outras boas práticas para produção incluem:
- Usar variáveis de ambiente para configurações sensíveis
- Implementar logging adequado para rastrear erros
- Configurar CORS se sua API for acessada por frontends
- Adicionar rate limiting para prevenir abuso
- Usar HTTPS com certificados SSL/TLS válidos
- Implementar monitoramento e alertas
Você pode fazer deploy em diversas plataformas como Heroku, AWS, Google Cloud, Digital Ocean ou Vercel. O FastAPI funciona perfeitamente em containers Docker também:
FROM python:3.9
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]Diferenças Entre FastAPI e Outros Frameworks
Quando comparamos o FastAPI com outros frameworks Python como Flask e Django, as diferenças ficam claras. O Flask é mais simples e flexível, mas exige muitas bibliotecas adicionais para ter os recursos que o FastAPI oferece nativamente.
O Django é um framework completo com muitas funcionalidades, mas é mais pesado e focado em aplicações web tradicionais, não especificamente em APIs. O FastAPI foi pensado desde o início para construir APIs modernas.
Vantagens do FastAPI:
- Performance superior a Flask e Django
- Validação automática de dados com Pydantic
- Documentação gerada automaticamente
- Suporte nativo a operações assíncronas
- Menos código necessário para mesmas funcionalidades
- Type hints obrigatórios melhoram qualidade do código
Quando usar cada framework:
- FastAPI: APIs modernas, microsserviços, aplicações que exigem alta performance
- Flask: Projetos pequenos, APIs simples, quando você precisa de máxima flexibilidade
- Django: Aplicações web completas com admin, ORM robusto e muitas funcionalidades prontas
A escolha depende das necessidades do seu projeto. Para APIs puras, o FastAPI geralmente é a melhor opção atualmente disponível no ecossistema Python.
Recursos Avançados e Boas Práticas
Conforme sua aplicação cresce, você precisará conhecer recursos mais avançados do FastAPI. A organização do código em múltiplos arquivos é essencial para manter a manutenibilidade.
Use o sistema de APIRouter para modularizar suas rotas:
from fastapi import APIRouter
router = APIRouter(prefix="/usuarios", tags=["usuarios"])
@router.get("/")
def listar_usuarios():
return {"usuarios": []}
@router.post("/")
def criar_usuario():
return {"mensagem": "Usuário criado"}No arquivo principal, importe e inclua o router:
from routers import usuarios
app.include_router(usuarios.router)Outras boas práticas importantes:
- Use injeção de dependências para compartilhar lógica entre rotas
- Implemente tratamento de erros personalizado com exception handlers
- Configure CORS adequadamente para APIs públicas
- Use background tasks para operações demoradas
- Implemente paginação em endpoints que retornam listas
- Adicione rate limiting para proteger contra abuso
O FastAPI também suporta WebSockets, Server-Sent Events e GraphQL através de bibliotecas adicionais. A flexibilidade do framework permite adaptar sua API para praticamente qualquer necessidade.
Perguntas Frequentes (FAQ)
1. O que é FastAPI?
FastAPI é um framework moderno para criar APIs em Python com alta performance e validação automática de dados.
2. Como posso começar com FastAPI?
Instale com pip install fastapi uvicorn e crie um arquivo Python com suas rotas usando decoradores como @app.get().
3. FastAPI é mais rápido que Flask?
Sim, FastAPI é significativamente mais rápido que Flask, especialmente para operações assíncronas e validação de dados.
4. Preciso conhecer programação assíncrona para usar FastAPI?
Não é obrigatório. FastAPI funciona com funções síncronas normais, mas oferece suporte completo para async/await quando necessário.
5. Como o FastAPI gera documentação automática?
Usa os type hints do Python e modelos Pydantic para gerar automaticamente documentação OpenAPI, disponível em /docs e /redoc.
6. Posso usar FastAPI com bancos de dados?
Sim, FastAPI funciona com qualquer ORM ou biblioteca de banco de dados, incluindo SQLAlchemy, Tortoise ORM e MongoDB.
7. FastAPI é adequado para produção?
Absolutamente. É usado em produção por empresas como Netflix, Uber e Microsoft. Oferece alta performance e recursos empresariais.
8. Como implementar autenticação no FastAPI?
FastAPI oferece suporte nativo para JWT, OAuth2, cookies e outros métodos de autenticação através de dependências.
