Como usar o FastAPI para construir serviços de API de alto desempenho
Como usar o FastAPI para construir serviços de API de alto desempenho
FastAPI é um framework web moderno e rápido (eficiente), projetado especificamente para construir APIs. Ele é baseado em dicas de tipo do Python e suporta programação assíncrona, permitindo que os desenvolvedores construam serviços de API de alto desempenho, alta disponibilidade e baixa latência. Este artigo irá detalhar como usar o FastAPI para construir serviços de API de alto desempenho, e iremos explicar passo a passo, ajudando você a realizar todo o processo desde a configuração do ambiente até a implantação.
Passo 1: Preparação do Ambiente
Você precisa garantir que o Python 3.6+ esteja instalado em seu ambiente de desenvolvimento. Se ainda não estiver instalado, você pode visitar o site oficial do Python para baixar e instalar.
Instalando FastAPI e Uvicorn
O FastAPI em si não fornece serviços, é necessário um servidor ASGI para hospedá-lo. Aqui, usamos o Uvicorn, um servidor ASGI de alto desempenho. Você pode instalar o FastAPI e o Uvicorn usando o seguinte comando:
pip install fastapi uvicornPasso 2: Construindo a API Básica
Vamos criar um aplicativo FastAPI simples.
Criando o Arquivo do Aplicativo
No diretório do seu projeto, crie um arquivo Python, como main.py, e escreva o seguinte código:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World!"}No código acima, primeiro importamos o FastAPI e criamos uma instância app. Em seguida, definimos uma rota GET que retorna uma resposta JSON simples ao acessar o caminho raiz /.
Iniciando o Servidor
Inicie seu servidor FastAPI com o seguinte comando:
uvicorn main:app --reloadmain: refere-se ao nome do arquivo, sem a extensão .py.app: refere-se à instância FastAPI.--reload: no modo de desenvolvimento, reinicia automaticamente o servidor quando os arquivos são alterados.
Passo 3: Definindo Rotas e Modelos de Dados
Para construir APIs complexas, você precisará usar o Pydantic para definir modelos de dados.
Criando Modelos de Dados
Adicione o seguinte conteúdo em main.py:
from pydantic import BaseModel
class Item(BaseModel):
name: str
price: float
is_available: bool = TrueEste código usa o Pydantic para criar um modelo de dados Item, que contém três propriedades: nome do item, preço e disponibilidade.
Adicionando Novas Rotas
Em seguida, podemos definir uma nova rota POST para receber dados do tipo Item:
@app.post("/items/")
async def create_item(item: Item):
return {"item_name": item.name, "item_price": item.price}Nesta rota, o FastAPI irá validar automaticamente os dados recebidos e mapeá-los para o modelo Item.
Passo 4: Geração Automática de Documentação
Uma das maiores vantagens do FastAPI é a capacidade de gerar documentação de API automaticamente. Você pode visualizar acessando os seguintes endereços:
- Swagger UI:
http://127.0.0.1:8000/docs - ReDoc:
http://127.0.0.1:8000/redoc
Nesta documentação gerada, você pode testar a API de forma interativa e visualizar o formato de solicitação e resposta de cada rota.
Passo 5: Adicionando Autenticação
Na aplicação real, a autenticação é uma parte importante. Vamos adicionar uma autenticação simples baseada em papéis.
Adicionando Dependências de Segurança
Use o método Depends do FastAPI e OAuth2PasswordBearer para implementar a autenticação:
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
async def fake_decode_token(token):
return {"sub": token}
async def get_current_user(token: str = Depends(oauth2_scheme)):
user = fake_decode_token(token)
if user is None:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenciais de autenticação inválidas")
return userProtegendo Rotas
Em seguida, você pode adicionar autenticação às rotas que precisam ser protegidas:
@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_userPasso 6: Implantando o Aplicativo FastAPI
Quando você terminar o desenvolvimento, pode ser necessário implantar o aplicativo em um servidor em nuvem. Você pode optar por usar o Docker para a implantação.
Criando o Dockerfile
No diretório do projeto, crie um arquivo chamado Dockerfile e insira o seguinte conteúdo:
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8
COPY ./app /appConstruindo a Imagem Docker
No seu terminal, use o seguinte comando para construir a imagem Docker:
docker build -t myfastapiapp .Executando o Contêiner Docker
Execute seu aplicativo FastAPI:
docker run -d --name fastapi -p 80:80 myfastapiappResumo
Neste artigo, explicamos detalhadamente como usar o FastAPI para construir serviços de API de alto desempenho, desde a preparação do ambiente até a criação da API básica, definição de rotas e modelos de dados, além de adicionar autenticação e o processo de implantação. O FastAPI oferece muitos recursos poderosos, tornando a construção de APIs modernas simples e eficiente. Você pode explorar mais funcionalidades e características através da documentação oficial. Esperamos que este artigo ajude você a começar rapidamente com o FastAPI e a aumentar a eficiência do desenvolvimento de seus projetos!
