Recebendo Dados de uma Requisição - FastAPI

O FastAPI é uma poderosa ferramenta para criar APIs, e seu suporte ao processamento de dados enviados em requisições é direto e altamente configurável. Nesta abordagem, veremos como manipular o corpo da requisição, validar dados e construir uma interface simples para interagir com nossa API.

Obtendo Dados do Corpo da Requisição

Dados enviados pelo cliente, como informações em formato JSON, podem ser extraídos do corpo da requisição usando a classe Body do FastAPI. Essa funcionalidade permite mapear diretamente os dados enviados para parâmetros de funções manipuladoras de rotas.

Criando uma Interface Web para Testar a API

Antes de configurar o backend, criaremos uma página HTML que simula um cliente enviando dados ao servidor. A estrutura do projeto será organizada da seguinte forma:

.
├── public
│   └── index.html
├── main.py

O arquivo index.html conterá:

<!DOCTYPE html>
<html>
<head>
    <title>Exemplo FastAPI</title>
    <meta charset="utf-8" />
</head>
<body>
    <div id="message"></div>
    <p>
        Nome: <br />
        <input id="username" />
    </p>
    <p>
        Idade: <br />
        <input id="userage" type="number" />
    </p>
    <button onclick="send()">Enviar</button>
    <script>
        async function send() {
            const username = document.getElementById("username").value;
            const userage = document.getElementById("userage").value;

            const response = await fetch("/hello", {
                method: "POST",
                headers: { 
                    "Accept": "application/json", 
                    "Content-Type": "application/json" 
                },
                body: JSON.stringify({ 
                    name: username,
                    age: userage
                })
            });

            if (response.ok) {
                const data = await response.json();
                document.getElementById("message").textContent = data.message;
            } else {
                console.error(response);
            }
        }
    </script>
</body>
</html>

Neste exemplo:

O usuário insere o nome e a idade nos campos de texto.
Ao clicar no botão "Enviar", a função send() é executada, enviando os dados ao endpoint /hello através de uma requisição POST.
A resposta do servidor, contendo a mensagem personalizada, é exibida na página.

Configurando o Backend

O servidor, configurado no arquivo main.py, receberá e processará os dados enviados pelo cliente:

from fastapi import FastAPI, Body
from fastapi.responses import FileResponse

app = FastAPI()

@app.get("/")
def root():
    return FileResponse("public/index.html")

@app.post("/hello")
def hello(data: dict = Body()):
    name = data["name"]
    age = data["age"]
    return {"message": f"Resposta do servidor: {name}, sua idade é {age}"}

O endpoint / serve a página HTML criada anteriormente.
O endpoint /hello processa as requisições POST, extrai os dados do corpo JSON e os utiliza para construir uma mensagem personalizada.

Exemplo de página HTML para enviar e receber dados de servidor FastAPI

Extraindo Valores Específicos

Em vez de receber todo o corpo da requisição como um único objeto, podemos mapear valores específicos diretamente para os parâmetros da função. Isso é feito com a opção embed=True:

@app.post("/hello")
def hello(name: str = Body(embed=True), age: int = Body(embed=True)):
    return {"message": f"{name}, sua idade é {age}"}

Nesse caso, os valores enviados no JSON, como {"name": "Tom", "age": 24}, são automaticamente vinculados aos parâmetros name e age.

Validação de Dados com FastAPI

A classe Body permite aplicar validações diretamente nos parâmetros, garantindo que os dados enviados estejam dentro dos limites esperados.

min_length: Define o comprimento mínimo de uma string.
max_length: Define o comprimento máximo de uma string.
pattern: Aplica uma expressão regular ao valor.
lt (less than): Valor deve ser menor que o especificado.
le (less than or equal): Valor deve ser menor ou igual ao especificado.
gt (greater than): Valor deve ser maior que o especificado.
ge (greater than or equal): Valor deve ser maior ou igual ao especificado.

No exemplo a seguir, o nome deve ter entre 3 e 20 caracteres, e a idade deve estar entre 18 e 110 anos:

@app.post("/hello")
def hello(
    name: str = Body(embed=True, min_length=3, max_length=20),
    age: int = Body(embed=True, ge=18, lt=111)
):
    return {"message": f"{name}, sua idade é {age}"}

Com essas práticas, conseguimos criar um servidor API eficiente, com validação embutida e suporte a dados enviados pelo cliente.