Se você está mergulhando no mundo do desenvolvimento web moderno, é provável que já tenha ouvido falar do FastAPI. É um dos frameworks que mais crescem para construir APIs em Python. Neste post do blog, vamos explorar como usar o FastAPI para criar e lidar com requisições POST. Quer você seja um desenvolvedor experiente ou apenas esteja começando, este guia irá ajudá-lo a entender os conceitos básicos e além.
O que é FastAPI?
FastAPI é um framework web moderno, rápido (de alto desempenho) para construir APIs com Python 3.7+ baseado em dicas de tipo padrão do Python. Ele foi projetado para ser fácil de usar e fornecer alto desempenho comparável ao Node.js e ao Go. O framework também é muito intuitivo e direto, tornando-o uma excelente escolha para iniciantes e especialistas.
Por que usar FastAPI?
Há várias razões pelas quais os desenvolvedores estão escolhendo o FastAPI em vez de outros frameworks:
- Velocidade: FastAPI é rápido. Na verdade, é um dos frameworks web mais rápidos disponíveis hoje.
- Facilidade de uso: Com documentação interativa automática (graças ao Swagger UI e ReDoc), é incrivelmente fácil testar suas APIs.
- Validação de dados: FastAPI utiliza Pydantic para validação de dados, o que garante que os dados que sua API recebe sejam válidos.
- Pronto para Async: Ele suporta programação assíncrona "out of the box", tornando-o adequado para aplicações web modernas e de alto desempenho.
Configurando o FastAPI
Antes de mergulharmos nas requisições POST, vamos rapidamente configurar o FastAPI. Você precisará do Python instalado em seu sistema. Então, você pode instalar o FastAPI e um servidor ASGI, como o Uvicorn, usando o pip:
pip install fastapi uvicorn
Uma vez que você tenha o FastAPI instalado, pode criar uma aplicação simples do FastAPI. Vamos começar criando um arquivo chamado main.py:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Para rodar a aplicação, use o Uvicorn:
uvicorn main:app --reload
Abra seu navegador e navegue até http://127.0.0.1:8000. Você deve ver uma resposta JSON: {"Hello": "World"}.
Criando um Endpoint POST
Agora que temos um aplicativo FastAPI básico em funcionamento, vamos adicionar um endpoint POST. As requisições POST são usadas para submeter dados a serem processados para um recurso específico. Para lidar com uma requisição POST no FastAPI, você usa o decorador @app.post.
Aqui está um exemplo simples de como lidar com uma requisição POST:
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
Neste exemplo:
- Definimos uma instância de
FastAPI. - Criamos um modelo Pydantic
Itemque descreve a estrutura dos dados do corpo da requisição. - Usamos o decorador
@app.postpara definir um endpoint POST/items/. - A função
create_itemrecebe um objetoItemcomo entrada e o retorna.
Para testar isso, você pode usar um cliente de API como o apidog ou simplesmente usar a interface Swagger UI interativa fornecida pelo FastAPI em http://127.0.0.1:8000/docs.
Lidando com Dados e Validações
O FastAPI valida automaticamente os dados da requisição em relação ao modelo Pydantic. Se os dados não estiverem em conformidade com o modelo, o FastAPI retorna um código de status 422 com detalhes sobre os erros de validação.
Por exemplo, se você enviar uma requisição POST para /items/ com o seguinte corpo JSON:
{
"name": "Nome do item",
"price": 25.5
}
O FastAPI aceitará essa requisição porque atende aos requisitos do modelo Item. No entanto, se você omitir o campo price, o FastAPI rejeitará a requisição e retornará um erro.
Usando Apidog para Testar sua Requisição POST do FastAPI
Apidog é uma ferramenta poderosa para testar APIs. Ela permite que você crie e salve requisições de API, organize-as em coleções e as compartilhe com sua equipe.
Aqui está como você pode usar o Apidog para testar sua requisição POST:
- Abra o Apidog e crie uma nova requisição.
2. Defina o método da requisição como POST.
3. Insira a URL do recurso que você deseja atualizar. Adicione quaisquer cabeçalhos ou parâmetros adicionais que você deseja incluir e, em seguida, clique no botão “Enviar” para enviar a requisição.
4. Verifique se a resposta é o que você esperava.
Requisições POST Avançadas
Agora, vamos explorar alguns cenários mais avançados. O FastAPI permite fazer muito mais com requisições POST. Por exemplo, você pode:
- Lidar com Uploads de Arquivos: Use
FileeUploadFiledofastapi. - Processar Dados de Formulário: Use
Formdofastapi. - Usar Parâmetros de Caminho: Combine
parâmetros de caminhocom requisições POST.
Lidando com Uploads de Arquivos
Aqui está um exemplo de como lidar com uploads de arquivos com FastAPI:
from fastapi import FastAPI, File, UploadFile
app = FastAPI()
@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
return {"filename": file.filename}
Esse endpoint aceitará um arquivo e retornará o nome do arquivo. Você pode testar isso com o apidog ou o Swagger UI.
Processando Dados de Formulário
Para processar dados de formulário, use a classe Form do FastAPI:
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
return {"username": username}
Este exemplo cria um endpoint de login que aceita dados de formulário. Você pode testar isso usando um envio de formulário em seu navegador ou uma ferramenta de teste de API.
Usando Parâmetros de Caminho
Você também pode combinar parâmetros de caminho com requisições POST:
from fastapi import FastAPI
app = FastAPI()
@app.post("/users/{user_id}/items/")
def create_item_for_user(user_id: int, item: Item):
return {"user_id": user_id, "item": item}
Esse endpoint cria um item para um usuário específico, identificado pelo parâmetro de caminho user_id.
Conclusão
FastAPI é um framework poderoso que facilita a construção de APIs robustas com Python. Seu suporte para validação de dados, documentação interativa e alto desempenho o torna uma excelente escolha para o desenvolvimento web moderno.
Neste post do blog, cobrimos como configurar uma aplicação FastAPI e lidar com requisições POST. Também exploramos tópicos mais avançados, como uploads de arquivos, processamento de dados de formulários e combinação de parâmetros de caminho com requisições POST. Agora, você deve ter uma compreensão sólida de como usar o FastAPI para criar e lidar com requisições POST.
Lembre-se, quer você esteja construindo uma API simples ou uma aplicação complexa, o FastAPI tem as ferramentas que você precisa para ter sucesso. Boa codificação!
