Como Construir REST APIs Usando Python e FastAPI
Construir APIs virou parte do dia a dia no desenvolvimento de software, e o ecossistema Python finalmente amadureceu a ponto de oferecer um framework elegante e rápido ao mesmo tempo. O FastAPI combina recursos modernos da linguagem, um design intuitivo e alta performance, tornando-se uma excelente escolha para desenvolvedores que querem entregar serviços confiáveis sem brigar com a ferramenta.
Neste guia, você vai criar uma API completa com operações CRUD para gerenciar um pequeno catálogo de livros. Ao final, terá um serviço totalmente funcional rodando localmente, com documentação automática, validação de tipos e um comportamento limpo e previsível.
Introdução ao FastAPI
FastAPI é um framework web de alta performance construído sobre o Starlette e impulsionado pelos type hints do Python. Ele oferece uma experiência API-first que gera automaticamente schemas OpenAPI, integra modelos Pydantic para validação e incentiva uma arquitetura limpa desde o início.
Por que os desenvolvedores escolhem FastAPI:
- Alta performance: Comparável a Node.js e Go graças ao uso de async I/O.
- Amigável para o desenvolvedor: Type hints impulsionam autocompletar no editor e documentação interativa da API.
- Menos bugs: A validação do Pydantic captura dados malformados antes de chegarem à sua lógica.
- Pouco boilerplate: Rotas claras e funções simples.
- Baseado em padrões: Suporte completo a OpenAPI e JSON Schema para clientes e testes.
Antes de construir algo mais complexo, você vai configurar um ambiente leve e garantir que o FastAPI está funcionando corretamente.
Configuração do Projeto: My Library
O objetivo deste projeto é simples: expor um pequeno conjunto de endpoints REST para gerenciar livros. Você poderá criar, consultar, atualizar e remover registros usando apenas uma lista em memória. Assim, o foco permanece no design da API, e não em configurações de banco de dados.
Comece criando um diretório para o projeto:
mkdir my-library
cd my-library
Criar um Ambiente Virtual
Para manter as dependências isoladas e consistentes entre diferentes máquinas, crie um ambiente virtual. Este tutorial usa Python 3.13.
python -m venv .venv
Ative o ambiente:
source .venv/bin/activate # macOS/Linux
.venv\Scripts\activate # Windows
A partir daqui, qualquer pacote instalado ficará isolado dentro deste projeto.
Instalar o FastAPI e Rodar o Primeiro App
Instale o FastAPI junto com os extras padrão (que incluem um servidor de desenvolvimento):
pip install "fastapi[standard]"
Agora crie um arquivo chamado main.py e adicione:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Inicie o servidor de desenvolvimento:
fastapi dev main.py
Acesse http://127.0.0.1:8000 para ver sua primeira resposta. Mais importante ainda, acesse http://127.0.0.1:8000/docs — o FastAPI gerou automaticamente uma documentação interativa para o seu app.
Esse recurso fica ainda mais poderoso quando você começa a usar modelos de dados.
Construindo o Modelo de Book e os Endpoints CRUD
Com o projeto funcionando, é hora de criar o núcleo do serviço de biblioteca. Tudo ficará dentro do arquivo main.py, para que você possa observar como o FastAPI organiza rotas, modelos e validação.
Definindo o Modelo de Dados Book
O FastAPI depende dos modelos do Pydantic para validar e serializar dados. Adicione o seguinte logo abaixo da definição do app:
from pydantic import BaseModel
class Book(BaseModel):
id: int
title: str
author: str
year: int
Esse modelo define o que um livro precisa ter. O FastAPI vai usá-lo para:
- validar os dados recebidos
- serializar as respostas
- documentar o schema automaticamente em
/docs
Criando um Armazenamento em Memória
Para fins de aprendizado, uma simples lista pode funcionar como seu “banco de dados” temporário:
library: list[Book] = []
É fácil substituí-la por um banco de dados real conforme o projeto cresce.
Adicionando os Endpoints CRUD
Agora você pode implementar as operações essenciais: listar, criar, atualizar e deletar livros.
Adicione o seguinte abaixo do seu modelo e da lista:
from fastapi import HTTPException
@app.get("/books", response_model=list[Book])
def get_books():
return library
@app.post("/books", response_model=Book, status_code=201)
def create_book(book: Book):
if any(b.id == book.id for b in library):
raise HTTPException(status_code=400, detail="Book with this ID already exists.")
library.append(book)
return book
@app.put("/books/{book_id}", response_model=Book)
def update_book(book_id: int, updated: Book):
for index, stored in enumerate(library):
if stored.id == book_id:
library[index] = updated
return updated
raise HTTPException(status_code=404, detail="Book not found.")
@app.delete("/books/{book_id}", status_code=204)
def delete_book(book_id: int):
for index, stored in enumerate(library):
if stored.id == book_id:
del library[index]
return
raise HTTPException(status_code=404, detail="Book not found.")
Cada rota demonstra um conceito fundamental do FastAPI:
- GET retorna modelos Pydantic serializados.
- POST valida o corpo da requisição e define códigos de status apropriados.
- PUT usa parâmetros de rota para localizar e atualizar um item.
- DELETE retorna uma resposta vazia com status code 204 quando bem-sucedido.
A documentação interativa agora exibe todos os quatro endpoints, com schemas de requisição e resposta gerados automaticamente.
Testando Sua API
Você pode testar sua API usando curl, Postman ou diretamente através da documentação interativa disponível em:
O FastAPI oferece um playground OpenAPI integrado, onde você pode executar requisições, inspecionar payloads e explorar schemas sem escrever nenhuma linha de código cliente.
Considerações Finais
Agora você tem uma REST API totalmente funcional usando FastAPI e Pydantic. Mais importante ainda, viu como é possível construir algo estruturado, validado e documentado automaticamente com muito pouco código.
O FastAPI escala com facilidade, desde pequenos projetos até sistemas de produção, e esse pequeno exemplo CRUD é a base de praticamente qualquer serviço que você venha a criar.