Tutorial FastAPI: Uma introdução ao uso da FastAPI

A API (Interface de Programação de Aplicativos) é a espinha dorsal da arquitetura moderna porque permite que os aplicativos sejam modulares e desacoplados. Isso significa que você pode criar aplicativos de forma rápida e fácil, o que lhe permite mantê-los e atualizá-los com facilidade. 

As APIs também são muito importantes no aprendizado de máquina porque permitem que diferentes aplicativos compartilhem dados e trabalhem juntos, economizando tempo e esforço. Há muitas estruturas diferentes para a criação de APIs em Python. Algumas das estruturas mais populares para a criação de APIs em Python são Django, Flask e FastAPI. Este tutorial é um mergulho profundo em uma das estruturas chamadas FastAPI.

O que é uma API?

API significa Interface de Programação de Aplicativos. Uma API é um intermediário de software que permite que dois aplicativos se comuniquem entre si. Quando você usa um aplicativo no telefone, o aplicativo se conecta à Internet e envia dados a um servidor. O servidor processa os dados e os envia de volta ao seu telefone. O aplicativo em seu telefone interpreta os dados e os apresenta a você de forma legível. 

Uma API é como um garçom em um restaurante. O garçom recebe seu pedido e o envia para a cozinha. A cozinha então prepara a comida e a envia de volta ao garçom. O garçom traz a comida até você. 

Da mesma forma, uma API recebe uma solicitação de um aplicativo e a envia a um servidor. Em seguida, o servidor processa a solicitação e envia os dados de volta para o aplicativo. Em seguida, o aplicativo interpreta os dados e os apresenta ao usuário.

Image Source: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Se quiser saber mais sobre pipelines de aprendizado de máquina, APIs e MLOps, confira nosso Tutorial de aprendizado de máquina, pipelines, implantação e MLOps.

O que é FastAPI

O FastAPI é uma estrutura da Web de alto desempenho para a criação de APIs com Python 3.7+ com base em dicas de tipo Python padrão. Ele ajuda os desenvolvedores a criar aplicativos de forma rápida e eficiente. O FastAPI foi desenvolvido com base no servidor da Web Starlette e inclui recursos que facilitam a criação de aplicativos da Web, como validação automática de dados, tratamento de erros e documentos de API interativos. 

Nesta seção, analisaremos todos esses recursos individualmente. Primeiro, vamos dar uma olhada nos principais recursos, conforme indicado na documentação original da FastAPI.

• Desempenho: No mesmo nível do NodeJS e da linguagem Go.
• Velocidade: Aumente a velocidade de desenvolvimento de 2 a 3 vezes.
• Fácil: Excelente suporte ao editor. Conclusão em qualquer lugar. Fácil de aprender e usar.
• Robusto: Código pronto para produção com documentação interativa automática.
• Baseado em OpenAPI: Totalmente compatível com OpenAPI e JSON Schema.

Instalação do FastAPI

O FastAPI requer o Python 3.7+. Ele pode ser instalado usando o pip. Você precisará instalar o FastAPI e o servidor ASGI `uvicorn`.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Criar uma API simples

Vamos começar a criar diretamente uma API de brinquedo muito simples. Estou usando o VS Code para implementar isso, mas você pode usar qualquer editor que desejar.

```

from typing import Union

from fastapi import FastAPI




app = FastAPI()




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}

```

(Exemplo reproduzido da documentação original). Agradecimentos a @tiangolo.

Agora, usando um terminal de linha de comando, execute essa API com o seguinte comando:

```

uvicorn main:app –reload

```

`main` é o nome do arquivo Python, e `app` é a variável que armazena a classe FastAPI. Você pode dar a eles o nome que quiser. Depois de executar o comando acima, você verá algo parecido com isto em seu terminal:

Acesse o link em seu navegador e, se você vir uma página que mostre "Hello World", a API estará em funcionamento.

Imagem do autor

Parabéns por criar sua primeira API. 

Documentos interativos da API

O FastAPI gera um "esquema" com todas as suas APIs usando o padrão OpenAPI para definir APIs. Um "esquema" é uma definição ou descrição de algo. Não o código que o implementa, mas apenas uma descrição abstrata. O esquema OpenAPI é o que alimenta os dois sistemas de documentação interativa incluídos na FastAPI.

Para ver a documentação, basta adicionar `/docs` à url (`http://127.0.0.1:8000/docs`). Esse link mostrará a documentação interativa automática da API.

Imagem do autor

Clique no botão `Try it out` no canto superior direito para testar a API.

Imagem do autor

Você pode ver que o corpo da resposta é um dicionário. Essa é a chamada de retorno da função `read_item` definida no `main.py`. Você também pode ver o URL da solicitação `http://127.0.0.1:8000/items/1?q=orange`. `1` e `orange` foram nossas entradas para a API.

Há uma alternativa de documentação automática interativa disponível no FastAPI. Para verificar isso, acesse http://127.0.0.1:8000/redoc`. É assim que ele se parece:

Imagem do autor

Exemplos mais avançados

Ao criar uma API, o "caminho" define a rota ou o ponto final da solicitação. No entanto, há mais uma escolha que precisamos fazer aqui, ou seja, "Operação". A palavra "operação" aqui se refere a um dos "métodos" do HTTP. Ao usar um (ou mais) desses chamados "métodos", você pode se comunicar com cada um dos vários caminhos compatíveis com o protocolo HTTP. Normalmente, você usaria:

• POST: para criar dados.
• GET: para ler dados.
• PUT: para atualizar dados.
• DELETE: para excluir dados.
• E alguns outros avançados 

A FastAPI é compatível com todos os métodos http. 

O fato de o FastAPI ser baseado em dicas de tipo Python é outro aspecto importante dessa estrutura. As dicas de tipo são compatíveis com as versões do Python 3.6 e posteriores. As dicas de tipo são um tipo especializado de sintaxe que permite declarar o tipo de uma variável. 

Declarar tipos para suas variáveis permite que os editores e outras ferramentas forneçam assistência aprimorada. Vamos ver um exemplo avançado.

Modificaremos nosso arquivo `main.py` para incluir uma nova solicitação `PUT` que receberá várias entradas de diferentes tipos de dados. 

```

from typing import Union




from fastapi import FastAPI

from pydantic import BaseModel




app = FastAPI()




class Item(BaseModel):

    name: str

    price: float

    is_offer: Union[bool, None] = None




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}




@app.put("/items/{item_id}")

def update_item(item_id: int, item: Item):

    return {"item_name": item.name, "item_id": item_id}

```

(Exemplo reproduzido da documentação original). Agradecimentos a @tiangolo.

A mudança:

Foi adicionada uma solicitação `put` que recebe duas entradas. O `item_id` é um número inteiro e o tipo `item` aponta para a classe personalizada `Item` criada e que herda o `BaseModel` do `pydantic`. A classe `Item` contém três atributos: `name`, `price`, `is_offer`, e todos eles têm tipos de dados diferentes.

A FastAPI verificará: 

• `name` é um `str`.
• `price` é um `float`.
• `is_offer` é um bool, se presente.

A vantagem de usar dicas de tipo é que você declara uma vez os tipos de parâmetros, corpo, etc. como parâmetros de função com o Python padrão (3.6+). Você receberá:

• Suporte ao editor, incluindo preenchimento automático, verificações de tipo
• Validação de dados
• Conversão de dados de entrada
• Conversão de dados de saída
• Erros que são fáceis de entender.

Comparação do FastAPI com o Django e o Flask

Todos esses três frameworks são frameworks Python da Web que você pode usar para desenvolver aplicativos da Web. Cada um deles tem seus próprios pontos fortes e fracos.

O Django é uma estrutura completa que inclui tudo o que você precisa para começar, inclusive um ORM integrado e um painel de administração. Ele pode ser um pouco complicado para iniciantes, mas sua documentação abrangente facilita o aprendizado.

O Flask é um microframework leve e fácil de usar. Ele não inclui tantos recursos quanto o Django, mas é perfeito para projetos simples.

A FastAPI é uma nova estrutura projetada para ser rápida e fácil de usar. Ele inclui recursos como validação automática de dados e documentação. 

Benchmarks de desempenho FastAPI

De acordo com os resultados dos testes realizados pela techempower, o FastAPI é superior a todas as outras estruturas em termos de desempenho geral. 

Fonte: https://www.techempower.com/benchmarks/

Exemplo: Criação de um pipeline de aprendizado de máquina de ponta a ponta com PyCaret e implementação com FastAPI 

Nesta seção, criaremos rapidamente um pipeline de aprendizado de máquina e, em seguida, criaremos uma API para servir o modelo. Usaremos uma biblioteca Python de baixo código, a PyCaret, para construir um pipeline e criar uma API. O PyCaret tem integração com o FastAPI, o que torna extremamente fácil criar e servir modelos de aprendizado de máquina como uma API.

PyCaret

PyCaret é uma biblioteca de aprendizado de máquina de código aberto e baixo em Python que automatiza os fluxos de trabalho de aprendizado de máquina. É uma ferramenta completa de aprendizado de máquina e gerenciamento de modelos que acelera exponencialmente o ciclo de experimentos e o torna mais produtivo.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

Usaremos o conjunto de dados `insurance` neste exemplo. É um caso de uso de regressão para prever despesas médicas com base em idade, sexo, IMC e região. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Imagem do autor

Em seguida, inicializaremos a função `setup` do pycaret. Essa função inicializa o experimento no PyCaret e cria o pipeline de transformação com base em todos os parâmetros passados na função. 

A `setup` deve ser executada antes de qualquer outra função. Ele requer dois parâmetros para funcionar: `data` e `target`. Todos os argumentos restantes em `setup` são opcionais. A função `setup` é responsável pelo controle da totalidade dos procedimentos de pré-processamento de dados. Consulte a documentação do PyCaret para obter um resumo abrangente de todos os procedimentos de pré-processamento compatíveis com o PyCaret.

```

from pycaret.regression import *

s = setup(data, target = 'charges')

```

Imagem do autor Saída truncada.

Quando a configuração estiver concluída, poderemos iniciar o treinamento e a seleção do modelo com apenas uma linha de código: `compare_models`. Por meio do uso de validação cruzada, essa função treina e avalia o desempenho do modelo de todos os estimadores na biblioteca de modelos. O resultado dessa função é uma grade de pontuação que contém as pontuações médias obtidas da validação cruzada.