Conheça o Rocketseat Para Empresas
Oferecemos soluções personalizadas para empresas de todos os portes.
Chega um momento no aprendizado de Python em que surge a pergunta natural: e se essa lógica que eu escrevi precisasse ser acessada por um app mobile, por um frontend em React ou por outro serviço? É nesse momento que entra a necessidade de expor código Python como uma API, e é aí que o FastAPI se tornou uma das primeiras escolhas de quem está começando.
A dúvida comum é por onde começar. Existem várias formas de criar uma API em Python, e é fácil se perder entre tutoriais que misturam conceitos de frameworks diferentes ou que pulam etapas importantes, como validação de dados e documentação automática.
Vem comigo entender o FastAPI, como criar uma API funcional desde o primeiro endpoint até rotas assíncronas e validação de dados, e como organizar esse projeto de um jeito que já nasce próximo do que se usa em produção.
O que é o FastAPI e por que ele ganhou espaço
FastAPI é um framework para construção de APIs em Python que se apoia em dois pilares: tipagem estática (via type hints do próprio Python) e suporte nativo a código assíncrono. Isso permite que ele valide dados automaticamente, gere documentação interativa sem esforço extra e tenha uma performance próxima de frameworks escritos em linguagens compiladas, quando usado com um servidor ASGI como o Uvicorn.
Diferente de frameworks mais antigos, o FastAPI foi desenhado depois que o ecossistema Python já tinha suporte maduro a
async/await, então ele aproveita isso desde a base, em vez de adicionar suporte assíncrono como uma camada extra.Criando sua primeira API com FastAPI
O primeiro passo é instalar o framework e um servidor ASGI para rodar a aplicação.
# Instala o FastAPI e o Uvicorn (servidor que executa a aplicação) pip install fastapi uvicorn
Com as dependências instaladas, o próximo passo é criar o primeiro endpoint.
# arquivo: main.py # Aplicação mínima com um único endpoint from fastapi import FastAPI app = FastAPI() @app.get("/") def ler_raiz(): """Endpoint inicial, só para confirmar que a API está no ar.""" return {"mensagem": "API rodando com FastAPI"}
Para rodar essa aplicação localmente:
# --reload reinicia o servidor automaticamente a cada alteração no código uvicorn main:app --reload
A partir daí, a aplicação já responde em
http://127.0.0.1:8000 e a documentação interativa fica disponível automaticamente em http://127.0.0.1:8000/docs, gerada a partir do próprio código, sem necessidade de escrever nada a mais.Validação de dados com Pydantic
Um dos motivos do FastAPI ser tão usado é a integração com o Pydantic para validar o formato dos dados recebidos e enviados pela API, evitando checagens manuais de tipo e formato.
# arquivo: main.py # Endpoint que recebe dados de um usuário e valida o formato automaticamente from fastapi import FastAPI from pydantic import BaseModel, EmailStr app = FastAPI() class UsuarioCriacao(BaseModel): """Define o formato esperado para criar um usuário.""" nome: str email: EmailStr idade: int @app.post("/usuarios") def criar_usuario(usuario: UsuarioCriacao): """Recebe os dados já validados pelo Pydantic e retorna uma confirmação.""" return { "mensagem": f"Usuário {usuario.nome} criado com sucesso", "email": usuario.email, }
Se o corpo da requisição não seguir o formato de
UsuarioCriacao, como um e-mail em formato inválido ou a idade enviada como texto, o FastAPI retorna automaticamente um erro 422 explicando qual campo está incorreto, sem precisar escrever essa validação manualmente.Rotas assíncronas e por que isso importa
Nem todo endpoint precisa ser assíncrono, mas quando a API depende de operações de entrada e saída, como chamadas a um banco de dados ou a outro serviço externo, declarar a rota como
async permite que o servidor atenda outras requisições enquanto aguarda essa resposta, em vez de ficar bloqueado.# arquivo: main.py # Exemplo de rota assíncrona simulando uma consulta externa import asyncio from fastapi import FastAPI app = FastAPI() async def buscar_dados_externos(): """Simula uma chamada a um serviço externo que leva um tempo para responder.""" await asyncio.sleep(1) return {"status": "dados recebidos"} @app.get("/dados") async def obter_dados(): """Rota assíncrona que aguarda o resultado sem bloquear o servidor.""" resultado = await buscar_dados_externos() return resultado
Vale destacar que declarar uma rota como
async def só traz ganho real se o código dentro dela também for assíncrono, usando bibliotecas compatíveis com await. Para entender melhor o funcionamento de corrotinas e do módulo asyncio, a documentação oficial do Python é a referência mais completa sobre o assunto.Documentação automática (Swagger e OpenAPI)
Um dos diferenciais do FastAPI é gerar, a partir do próprio código, uma documentação interativa seguindo o padrão OpenAPI. Isso significa que qualquer pessoa do time, incluindo quem não escreveu o backend, consegue testar os endpoints diretamente pelo navegador, em
/docs, sem precisar de ferramentas externas para simular requisições.Essa documentação é montada automaticamente com base nos type hints e nos modelos Pydantic definidos no código, então mantê-la atualizada é consequência de manter o código bem tipado, e não um trabalho manual separado.
FastAPI vs Flask: quando escolher cada um
É comum comparar FastAPI com Flask, já que os dois são frameworks leves e bastante usados no ecossistema Python.
O Flask tende a fazer mais sentido em projetos simples, onde não há necessidade de validação de dados complexa nem de operações assíncronas, e onde a flexibilidade de não impor uma estrutura é uma vantagem.
O FastAPI costuma se destacar quando a API vai crescer, quando existe integração com múltiplos serviços externos (bancos de dados, filas, outras APIs) que se beneficiam de chamadas assíncronas, ou quando a validação automática de dados e a documentação gerada sozinha economizam tempo real do time ao longo do projeto.
Boas práticas para organizar um projeto FastAPI
Conforme o projeto cresce além de um único arquivo
main.py, algumas práticas ajudam a manter o código organizado:- Separar rotas por domínio usando
APIRouter, em vez de deixar todos os endpoints no mesmo arquivo.
- Isolar os modelos Pydantic de entrada e saída dos modelos usados para persistência no banco de dados.
- Usar o sistema de injeção de dependências do próprio FastAPI para lidar com autenticação, conexão com banco de dados e outras dependências compartilhadas entre rotas.
- Escrever testes automatizados usando o
TestClient, que já vem integrado ao framework.
Essas práticas evitam que o projeto vire um único arquivo gigante conforme o número de endpoints aumenta, o que é um problema comum em quem está criando sua primeira API.
Próximos passos
Criar o primeiro endpoint é só o começo. Entender como estruturar rotas assíncronas, integrar autenticação JWT, conectar a bancos de dados relacionais e NoSQL, e organizar um projeto FastAPI pronto para produção exige uma base sólida em Python e em conceitos de arquitetura de software. A Formação Python da Rocketseat cobre esse caminho completo, da introdução à linguagem até um módulo dedicado a FastAPI, passando por design de código, autenticação e segurança, e integração com bancos como MongoDB e Redis.
Conheça o Rocketseat Para Empresas
Oferecemos soluções personalizadas para empresas de todos os portes.
NewsletterReceba conteúdos inéditos e novidades gratuitamente