APIs REST com FastAPI: do zero ao deploy

O que é FastAPI?

FastAPI é um framework Python moderno para construir APIs. Ele foi criado por Sebastian Ramirez e se destaca por três motivos: performance comparável a Node.js e Go, validação automática de dados e documentação interativa gerada sem esforço.

O FastAPI usa type hints do Python para validar requisições e gerar documentação. Isso significa que o mesmo código que define seus endpoints também serve como contrato da API.

pip install fastapi uvicorn

Sua primeira API

Vamos criar uma API simples para gerenciar tarefas:

from fastapi import FastAPI

app = FastAPI(title="API de Tarefas", version="1.0.0")

@app.get("/")
def raiz():
    return {"mensagem": "API de Tarefas funcionando!"}

@app.get("/status")
def status():
    return {"status": "online", "versao": "1.0.0"}

Para rodar o servidor:

uvicorn main:app --reload

Acesse http://localhost:8000/docs para ver a documentação interativa gerada automaticamente pelo Swagger UI.

Modelos com Pydantic

O FastAPI usa o Pydantic para validação de dados. Você define um modelo e o framework garante que os dados recebidos estão no formato correto:

from pydantic import BaseModel
from typing import Optional

class TarefaCriar(BaseModel):
    titulo: str
    descricao: Optional[str] = None
    concluida: bool = False

class TarefaResposta(BaseModel):
    id: int
    titulo: str
    descricao: Optional[str]
    concluida: bool

Se alguém enviar um JSON sem o campo titulo, o FastAPI retorna automaticamente um erro 422 com a descrição do problema.

Endpoints CRUD

Agora vamos implementar as operações completas de criar, ler, atualizar e deletar:

from fastapi import FastAPI, HTTPException

app = FastAPI()

tarefas = {}
contador_id = 0

@app.post("/tarefas", response_model=TarefaResposta, status_code=201)
def criar_tarefa(tarefa: TarefaCriar):
    global contador_id
    contador_id += 1
    nova_tarefa = TarefaResposta(id=contador_id, **tarefa.model_dump())
    tarefas[contador_id] = nova_tarefa
    return nova_tarefa

@app.get("/tarefas", response_model=list[TarefaResposta])
def listar_tarefas(concluida: Optional[bool] = None):
    resultado = list(tarefas.values())
    if concluida is not None:
        resultado = [t for t in resultado if t.concluida == concluida]
    return resultado

@app.get("/tarefas/{tarefa_id}", response_model=TarefaResposta)
def buscar_tarefa(tarefa_id: int):
    if tarefa_id not in tarefas:
        raise HTTPException(status_code=404, detail="Tarefa nao encontrada")
    return tarefas[tarefa_id]

@app.put("/tarefas/{tarefa_id}", response_model=TarefaResposta)
def atualizar_tarefa(tarefa_id: int, tarefa: TarefaCriar):
    if tarefa_id not in tarefas:
        raise HTTPException(status_code=404, detail="Tarefa nao encontrada")
    tarefa_atualizada = TarefaResposta(id=tarefa_id, **tarefa.model_dump())
    tarefas[tarefa_id] = tarefa_atualizada
    return tarefa_atualizada

@app.delete("/tarefas/{tarefa_id}", status_code=204)
def deletar_tarefa(tarefa_id: int):
    if tarefa_id not in tarefas:
        raise HTTPException(status_code=404, detail="Tarefa nao encontrada")
    del tarefas[tarefa_id]

Middlewares e CORS

Para permitir que um frontend acesse sua API, você precisa configurar o CORS:

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Você também pode criar middlewares personalizados para logging ou autenticação:

import time
from fastapi import Request

@app.middleware("http")
async def medir_tempo(request: Request, call_next):
    inicio = time.time()
    response = await call_next(request)
    duracao = time.time() - inicio
    response.headers["X-Tempo-Processamento"] = str(round(duracao, 4))
    return response

Deploy com Uvicorn e Docker

Para colocar sua API em produção, crie um Dockerfile simples:

# Dockerfile
FROM python:3.12-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

E o requirements.txt:

fastapi==0.115.0
uvicorn==0.30.0

Para rodar:

docker build -t api-tarefas .
docker run -p 8000:8000 api-tarefas

Conclusão

O FastAPI combina performance, validação e documentação de forma elegante. Com type hints e Pydantic, você escreve menos código e ganha mais segurança. A documentação interativa acelera o desenvolvimento e a comunicação com o time de frontend. Para projetos que precisam de uma API robusta e moderna, o FastAPI é uma escolha excelente.