Aprenda a usar FastAPI com Python! Tutorial

No mundo do desenvolvimento web moderno, a necessidade de construir APIs rápidas, eficientes e de fácil manutenção nunca foi tão crítica. Com a proliferação de aplicações web e móveis, os desenvolvedores estão constantemente em busca de ferramentas que não apenas acelerem o desenvolvimento, mas também garantam a robustez e a segurança do produto final. Neste contexto, o FastAPI surge como uma luz brilhante, prometendo revolucionar a forma como construímos Web Services em Python.

Este tutorial é um ponto de partida para aqueles que desejam mergulhar no mundo do FastAPI, cobrindo desde a configuração inicial do ambiente de desenvolvimento até a criação de sua primeira aplicação. Será uma jornada enriquecedora, passando pelas peculiaridades do trabalho com rotas, parâmetros, autenticação de usuários e, até mesmo, a integração com banco de dados. Preparado para descobrir por que o FastAPI está rapidamente se tornando o futuro dos Web Services em Python? Vamos lá!

1. Introdução ao FastAPI: O Futuro dos Web Services em Python

Desenvolvido por Sebastián Ramírez, o FastAPI é um framework web moderno e rápido (high-performance) para construir APIs com Python 3.6+ baseado em padrões Python tipo hints. Sua natureza assíncrona o torna extremamente rápido, sendo uma das opções mais eficientes disponíveis no mercado quando comparado a outras soluções tradicionais.

O FastAPI não apenas permite que os desenvolvedores criem APIs de forma mais rápida e com menos linhas de código, mas também proporciona uma documentação automática para suas APIs. Isso é possível graças ao Swagger UI e ao Redoc, duas ferramentas poderosas embutidas no FastAPI que facilitam a vida dos desenvolvedores e dos consumidores da API.

Outro grande destaque do FastAPI é sua capacidade de validar e serializar dados usando o Pydantic, proporcionando uma forma declarativa e eficiente de definir modelos de dados. Isso melhora significativamente a segurança e a robustez das aplicações, garantindo que os dados manipulados estejam sempre corretos e sejam fáceis de debugar.

2. Preparando o Ambiente de Desenvolvimento para FastAPI

Antes de mergulharmos na criação de nossa primeira aplicação FastAPI, precisamos preparar nosso ambiente de desenvolvimento. Isso inclui a instalação do Python (se ainda não estiver instalado) e a instalação do FastAPI e do Uvicorn, um servidor ASGI para executar nossa aplicação.

Instalação do Python

Certifique-se de que você tem o Python 3.6 ou superior instalado em sua máquina. Você pode verificar isso executando python --version ou python3 --version no terminal. Se você não tiver o Python instalado, visite o site oficial do Python para baixar e instalar a versão mais recente compatível com seu sistema operacional.

Instalação do FastAPI e do Uvicorn

Com o Python devidamente instalado, o próximo passo é instalar o FastAPI e o Uvicorn. Abra um terminal e execute o seguinte comando:

pip install fastapi uvicorn

Este comando instalará o FastAPI junto com o Uvicorn, que será nosso servidor ASGI para executar a aplicação.

3. Primeiros passos: Criando sua primeira aplicação com FastAPI

Agora que temos nosso ambiente preparado, é hora de criar nossa primeira aplicação FastAPI. Vamos começar com um exemplo simples para entender como o FastAPI funciona e como podemos começar a construir nossa própria API.

Criando um arquivo principal

Primeiramente, crie um novo arquivo chamado main.py. Este arquivo será o ponto de entrada da nossa aplicação. Abra este arquivo em seu editor de código favorito e vamos começar a codificar.

Definindo uma rota básica

Para criar uma rota básica com FastAPI, primeiro precisamos importar o FastAPI e criar uma instância da aplicação. Depois, definimos uma rota utilizando o decorador @app.get. Veja o exemplo abaixo:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
 return {"Hello": "World"}

Neste exemplo, definimos uma rota simples que responde ao método GET na raiz do nosso servidor (/). Quando alguém acessa essa rota, a função read_root é chamada e retorna um simples dicionário JSON com a mensagem “Hello World”.

Executando sua aplicação

Para executar sua aplicação, abra um terminal no diretório do seu arquivo main.py e execute o comando:

uvicorn main:app --reload

O comando acima inicia um servidor local na porta 8000, e a flag --reload garante que o servidor seja reiniciado automaticamente sempre que você fizer modificações no código. Agora, você pode acessar http://127.0.0.1:8000 no seu navegador para ver sua aplicação FastAPI em ação.

4. Entendendo Rotas e Endpoints no FastAPI

No universo do FastAPI, as rotas e endpoints são componentes essenciais que dirigem o fluxo de dados entre o cliente e o servidor. Uma rota é basicamente uma URL (por exemplo, “/items”), enquanto um endpoint é a função Python acionada pela requisição a essa rota.

Como Definir Rotas em FastAPI

Definir rotas em FastAPI é um processo direto:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
 return {"Hello": "World"}

Neste exemplo, a rota é “/”, e o endpoint é a função read_root, que retorna uma saudação simples.

Tipos de Operações HTTP

FastAPI suporta todos os principais métodos HTTP: GET, POST, PUT, DELETE, entre outros. Cada um desses métodos pode ser associado a uma função específica em sua aplicação, permitindo criar APIs RESTful com facilidade.

5. Trabalhando com Path e Query Parameters

Os parâmetros de caminho (path) e de consulta (query) permitem que você aceite dados dinâmicos em suas rotas, tornando seus endpoints flexíveis e poderosos.

Parâmetros de Caminho

Os parâmetros de caminho são especificados nas rotas e capturados na função do endpoint:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
 return {"item_id": item_id}

Neste exemplo, item_id é um parâmetro de caminho que a função read_item usa para devolver um ID de item específico.

Parâmetros de Consulta

Os parâmetros de consulta são inseridos no URL após um “?” e são capturados como argumentos das funções:

@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):
 return fake_items_db[skip : skip + limit]

Na função read_item, os parâmetros skip e limit são usados para controlar a paginação dos itens retornados.

6. O Poder dos Request Bodies: Criando Interfaces de Entrada de Dados

Os corpos das requisições (request bodies) são essenciais para receber dados complexos. No FastAPI, você pode definir facilmente modelos de dados esperados usando o Pydantic.

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
 name: str
 description: str = None
 price: float
 tax: float = None

app = FastAPI()

@app.post("/items/")
async def create_item(item: Item):
 return item

Neste exemplo, o modelo Item define a estrutura dos dados que o endpoint espera receber, permitindo uma entrada de dados rica e validada automaticamente.

7. Validação de Dados com Pydantic Models no FastAPI

A validação de dados no FastAPI é simplificada graças às modelos Pydantic, que oferecem uma maneira declarativa de definir a estrutura dos dados, juntamente com regras de validação.

Definindo um Modelo Pydantic

Veja como um modelo simples pode ser definido:

from pydantic import BaseModel, Field

class User(BaseModel):
 username: str = Field(..., min_length=3, max_length=50)
 email: str = Field(..., regex='^[a-z0-9.]+@[a-z0-9.]+\.[a-z]{2,3}$')
 age: int = Field(..., gt=0, lt=100)

# Agora, esse modelo pode ser usado para validar os dados de entrada de um endpoint.

As regras de validação, como min_length e regex, garantem que apenas dados válidos sejam aceitos, melhorando a segurança e a integridade dos dados de sua aplicação.

8. Gerenciamento de Respostas e o uso de Response Model

Ao construir uma API com FastAPI, um dos passos cruciais é definir como sua aplicação lida com as respostas das requisições. Isso não é apenas sobre o que você retorna, mas também como você estrutura essas respostas para promover clareza e consistência em sua API.

Definindo Response Models

No FastAPI, você pode utilizar modelos de resposta (response models) para determinar a estrutura e o tipo de dados retornados pelas suas rotas. Esses modelos são criados usando Pydantic, que permite a validação de dados e a serialização automática de objetos Python em JSON.

Vantagens dos Response Models

Uma das principais vantagens de usar modelos de resposta é a documentação automática das suas APIs. FastAPI utiliza esses modelos para gerar uma documentação precisa e interativa, permitindo que outros desenvolvedores entendam facilmente o que esperar do seu serviço.

Além disso, os response models ajudam a garantir que somente os dados apropriados sejam enviados ao cliente, protegendo possíveis dados sensíveis ou irrelevantes.

9. Autenticação de Usuários: Implementando Segurança em sua Aplicação

A segurança é um dos aspectos mais críticos ao desenvolver uma aplicação web. No FastAPI, existem diversas ferramentas e técnicas para implementar a autenticação e garantir que somente usuários autorizados possam acessar certos endpoints.

Autenticação Básica

Uma das formas mais simples de autenticação é a autenticação básica, em que os usuários fornecem um nome de usuário e senha que são verificados pelo servidor para conceder acesso. Embora simples, esse método deve ser usado com cautela e sempre sobre uma conexão segura (HTTPS), para proteger as credenciais dos usuários.

Token de Acesso

Uma abordagem mais segura envolve a utilização de tokens de acesso, como JWT (JSON Web Tokens). Nesse método, o usuário recebe um token após um login bem-sucedido e deve enviar esse token nas requisições subsequentes para acessar rotas protegidas.

OAuth2

FastAPI também suporta OAuth2 com Password (e hashing), além de fluxos mais complexos como o uso de Bearer Tokens. Esses métodos oferecem uma camada adicional de segurança e flexibilidade, permitindo, por exemplo, a autenticação através de serviços de terceiros como o Google ou o Facebook.

10. Manipulação de Erros e Exceções para uma API Robusta

Uma API robusta não se destaca apenas pelas suas funcionalidades, mas também por como ela lida com os erros. A gestão eficaz de erros e exceções é fundamental para garantir a estabilidade da aplicação e uma boa experiência para o usuário final.

Tratamento de Exceções Personalizado

FastAPI oferece maneiras de definir tratamentos de exceções personalizados, permitindo que você retorne mensagens de erro claras e específicas para cada situação. Isso é feito através do uso de HTTPException ou criando seus próprios manipuladores de exceções com @app.exception_handler().

Validação de Dados e Erros

Outra área importante é a validação de dados. Ao utilizar modelos Pydantic, FastAPI automaticamente valida os dados de entrada, retornando erros detalhados quando os dados não correspondem ao esperado. Isso ajuda a prevenir muitos erros comuns e garante que a API receba apenas dados válidos e esperados.

Log de Erros

Por fim, manter um registro (log) dos erros que ocorrem pode ser extremamente útil para diagnosticar problemas, entender as áreas que precisam de melhorias e manter a saúde geral da aplicação. FastAPI é compatível com várias bibliotecas de logging, permitindo uma integração fácil e eficaz.

11. Testando sua Aplicação FastAPI com Pytest

Testar sua aplicação é crítico para garantir a qualidade e a estabilidade do software. O Pytest é uma poderosa ferramenta que pode ajudar você a escrever testes eficientes para sua aplicação FastAPI. Vamos aprender como integrar o Pytest e utilizar suas capacidades para testar nossa aplicação.

Configurando o Pytest

Primeiramente, instale o Pytest no seu ambiente de desenvolvimento usando pip install pytest. Após a instalação, crie um arquivo test_main.py na raiz do seu projeto. Este arquivo será utilizado para escrever seus testes.

Escrevendo Testes Básicos

Para testar uma rota simples, você pode utilizar o cliente de teste fornecido pelo FastAPI, que simula solicitações para a API. Abaixo está um exemplo de teste para uma rota que retorna uma mensagem de boas-vindas:

from fastapi.testclient import TestClient
from .main import app

client = TestClient(app)

def test_read_main():
 response = client.get("/")
 assert response.status_code == 200
 assert response.json() == {"message": "Welcome to FastAPI"}

Este teste verifica se a rota / retorna um status 200 (OK) e se o conteúdo da resposta é o esperado.

12. Banco de Dados e FastAPI: Integrando Modelos SQL e NoSQL

Integrar bases de dados em sua aplicação FastAPI permite criar aplicações dinâmicas e interativas. FastAPI é flexível, suportando tanto bancos de dados SQL quanto NoSQL.

Integrando com SQL

Usar um banco de dados SQL como PostgreSQL, MySQL, ou SQLite com FastAPI é relativamente simples. Você precisará de um ORM (Object-Relational Mapping) como SQLAlchemy para interagir com o banco de dados. A configuração básica envolve criar modelos de dados, sessões de banco de dados e dependências que serão utilizadas nas rotas para realizar operações de banco de dados.

Integrando com NoSQL

Para bancos de dados NoSQL como MongoDB, a integração também é direta, mas as operações são realizadas de maneira diferente. Você pode usar bibliotecas como motor para interagir com MongoDB de forma assíncrona. A preparação envolve definir esquemas de documentos e utilizar esses esquemas nas rotas para manipular os dados.

13. Deploy da Aplicação FastAPI: Opções e Melhores Práticas

O deploy da sua aplicação FastAPI pode ser feito de várias formas, mas alguns métodos são mais comuns e recomendados, como o uso de contêineres Docker e plataformas de cloud como AWS, Google Cloud e Heroku.

Usando Docker

Criar um dockerfile para sua aplicação permite empacotá-la juntamente com todas as suas dependências em um contêiner, facilitando o deploy em qualquer ambiente. O Docker também simplifica a configuração de variáveis de ambiente e outros pré-requisitos do sistema.

Deploy em Plataformas de Cloud

Plataformas de cloud oferecem serviços prontos para uso que podem simplificar o deploy da sua aplicação. Elas permitem escalar sua aplicação facilmente, ajustando recursos conforme a demanda. Cada plataforma tem suas particularidades, então é importante avaliar qual delas se adequa melhor às necessidades da sua aplicação.

14. Documentação Automática: Explorando o Swagger UI e o Redoc em FastAPI

Uma das vantagens de usar FastAPI é a geração automática de documentação para a sua API. A documentação é criada usando padrões OpenAPI, e FastAPI fornece duas interfaces para visualizá-la: Swagger UI e Redoc.

Swagger UI

A Swagger UI é acessada normalmente através do endereço /docs na sua aplicação. Ela oferece uma interface interativa onde os usuários podem ver todas as rotas disponíveis, modelos de dados e até mesmo testar a API diretamente pelo navegador.

Redoc

O Redoc é acessado através do endereço /redoc e oferece uma visualização mais limpa e organizada da documentação da API. Embora não permita interações como testes diretos das rotas, é uma excelente opção para apresentar a documentação para consumidores da API ou desenvolvedores.

Utilizar a documentação automática do FastAPI não só facilita o entendimento da sua API por terceiros, mas também promove melhores práticas de desenvolvimento, garantindo que sua API esteja bem documentada e fácil de usar.