Conceitos iniciais de FastAPI para Iniciantes

Bem-vindo a esta básica de FastAPI! Se você está começando no mundo do desenvolvimento backend com Python ou procurando um framework moderno, rápido e fácil de usar, você veio ao lugar certo. FastAPI é um framework web de alta performance para a construção de APIs, e sua popularidade tem crescido exponencialmente por bons motivos.

Por que escolher FastAPI?

Antes de mergulharmos no código, vamos entender rapidamente por que o FastAPI se destaca:

Rapidez: Sua performance é comparável a tecnologias como NodeJS e Go, graças à sua base em Starlette (para a parte web) e Pydantic (para a validação de dados).
Fácil de usar: A sintaxe é moderna, intuitiva e projetada para minimizar o tempo de desenvolvimento.
Menos Bugs: Ao usar type hints (dicas de tipo) do Python, o FastAPI valida, serializa e documenta seu código automaticamente, o que reduz drasticamente os erros.
Documentação Automática: Talvez a sua característica mais amada. Ele gera uma documentação interativa da sua API (com Swagger UI e ReDoc) sem nenhum esforço extra.

1. Preparando o Ambiente

Vamos começar. A primeira coisa é garantir que você tenha o Python 3.7+ instalado. Depois, vamos criar um ambiente virtual para isolar as dependências do nosso projeto, o que é uma excelente prática.

# Cria um ambiente virtual chamado 'venv'
python -m venv venv

# Ativa o ambiente virtual
# No Windows:
venv\Scripts\activate
# No macOS/Linux:
source venv/bin/activate

Com o ambiente ativado, instale o FastAPI e o Uvicorn, um servidor ASGI (Asynchronous Server Gateway Interface) ultrarrápido:

pip install fastapi "uvicorn[standard]"

2. Seu Primeiro "Olá, Mundo!"

Crie um arquivo chamado main.py. Este será o ponto de entrada da nossa API. Adicione o seguinte código:

from fastapi import FastAPI

# 1. Cria uma instância do FastAPI
app = FastAPI()

# 2. Define um "path operation decorator"
@app.get("/")
# 3. Define a função da operação de rota
def read_root():
    # 4. Retorna o conteúdo
    return {"message": "Olá, Mundo!"}

Para executar sua API, vá ao terminal e rode o Uvicorn:

uvicorn main:app --reload

main: o nome do arquivo main.py.
app: o objeto FastAPI que criamos dentro do arquivo.
--reload: uma flag que reinicia o servidor automaticamente sempre que você salvar uma alteração no código.

Agora, abra seu navegador e acesse http://127.0.0.1:8000. Você verá o JSON: {"message": "Olá, Mundo!"}.

Dica de Ouro: Confira a documentação automática! Acesse http://127.0.0.1:8000/docs para ver a interface interativa do Swagger UI. Você pode testar seus endpoints diretamente por lá.

3. Parâmetros, Tipos e Validação

Aqui é onde a mágica do FastAPI realmente brilha. Vamos adicionar mais rotas para entender como ele lida com dados.

Parâmetros de Caminho (Path Parameters)

Você pode capturar valores diretamente da URL. Adicione este código ao seu main.py. Note como declaramos item_id como um int. Se você acessar /items/abc no navegador, o FastAPI retornará um erro de validação claro e útil automaticamente.

# Em main.py
@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id, "description": "Este é um item de exemplo."}

Corpo da Requisição (Request Body) com Pydantic

Para operações como POST ou PUT, onde você envia dados, usamos a biblioteca Pydantic para definir o "formato" desses dados. Isso garante que sua API só receba o que espera.

Primeiro, importe BaseModel do Pydantic e defina uma classe para seu item. Adicione isso ao topo do seu `main.py`.

# No topo de main.py
from pydantic import BaseModel
from typing import Optional

class Item(BaseModel):
    name: str
    description: Optional[str] = None # Um campo opcional
    price: float
    tax: Optional[float] = None

Agora, vamos criar um endpoint POST que recebe um objeto desse tipo. O FastAPI fará todo o trabalho de ler o JSON da requisição, validar, converter os tipos e documentar.

# Em main.py
@app.post("/items/")
def create_item(item: Item):
    item_dict = item.dict()
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict.update({"price_with_tax": price_with_tax})
    return item_dict

4. Testando sua API Profissionalmente

Desenvolver sem testes é como navegar em uma tempestade sem mapa. O FastAPI se integra perfeitamente com o `pytest`.

Primeiro, instale as ferramentas necessárias:

pip install pytest httpx

Agora, crie um arquivo chamado test_main.py na mesma pasta. O FastAPI fornece um TestClient que permite fazer requisições à sua API diretamente no código de teste, de forma síncrona e sem precisar de um servidor em execução.

from fastapi.testclient import TestClient
from .main import app # Importa a instância 'app' do seu main.py

# Cria um cliente de teste
client = TestClient(app)

# Teste para a rota raiz
def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Olá, Mundo!"}

# Teste para a criação de um item
def test_create_item():
    response = client.post(
        "/items/",
        json={"name": "Caneta Azul", "price": 3.50, "tax": 0.50},
    )
    assert response.status_code == 200
    data = response.json()
    assert data["name"] == "Caneta Azul"
    assert data["price_with_tax"] == 4.0

# Teste para um erro de validação
def test_create_item_invalid_price():
    response = client.post(
        "/items/",
        json={"name": "Preço Inválido", "price": "muito caro"},
    )
    # 422 é o código HTTP para "Unprocessable Entity"
    assert response.status_code == 422

Para rodar os testes, simplesmente execute o comando pytest no seu terminal. Ele encontrará e executará os testes automaticamente.

Parabéns por chegar até aqui! Você passou pelos pilares do FastAPI: criação de rotas, validação de dados com Pydantic e testes automatizados. Este é um framework incrivelmente poderoso e produtivo, e o que você aprendeu hoje é a base para construir aplicações complexas e robustas.

O próximo passo é explorar conceitos como Injeção de Dependências, segurança com OAuth2, conexão com bancos de dados e muito mais. A documentação oficial do FastAPI é um recurso fantástico para continuar sua jornada. Boas construções!