Pular para o conteúdo principal
InicioTutoriaisPython

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

Explore a estrutura FastAPI e descubra como você pode usá-la para criar APIs em Python
abr. de 2024  · 13 min leer

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.

Um projeto simples de arquitetura de API

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:

Terminal de comando

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

API em execução no host local no navegador

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.

Documentação automatizada criada pela FastAPI

Imagem do autor

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

Documentação automatizada criada pelo FastAPI 2

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:

Documentação automatizada criada pelo FastAPI 3

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. 

 

Django

Frasco

FastAPI

Comunidade

Big. 

66 mil estrelas no GitHub

Big. 

61 mil estrelas no GitHub

Big. 

50 mil estrelas no GitHub

Desempenho

O Django é enorme. Ele não é o melhor em termos de desempenho.

O Flask é uma microestrutura da Web. Seu desempenho é melhor do que o do Django.

O FastAPI é uma das estruturas da Web mais rápidas com suporte nativo a assíncrono, o que aumenta a eficiência da estrutura. 

Suporte assíncrono

Sim, com latência limitada.

Não. 

Needs Asyncio

A FastAPI oferece suporte assíncrono nativo.

Facilidade de uso

O Django é enorme e, portanto, um pouco complicado de aprender.

O Flask é fácil de aprender e bastante simples de usar.

A FastAPI é a mais simples das três.

Documentação interativa

Não interativo

Não

Sim (OpenAI, Redoc)

Verificação de dados

Não

Não

Sim


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. 

Benchmarks de desempenho de API

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’)

```

Conjunto de dados de amostra

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')

```

Saída da função de configuração do PyCaret

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.

Pré-processamento para aprendizado de máquina em Python

Interessado em saber mais sobre como preparar seus dados limpos para modelagem? Faça nosso curso Preprocessing for Machine Learning in Python.

Comece Agora
```

best = compare_models()

```

Saída da função compare_models do PyCaret

Imagem do autor

Com base nisso, o modelo de melhor desempenho é o `Gradient Boosting Regressor`. Se quisermos, podemos analisar o modelo por meio da visualização e tentar melhorar o desempenho por meio do ajuste de hiperparâmetros ou do conjunto de modelos, mas não faremos isso neste tutorial. 

Iremos direto para a criação da API do melhor modelo para atender às previsões na produção usando o FastAPI. Lembre-se de que o PyCaret tem integração com o FastAPI, portanto, ele pode criar automaticamente uma API REST a partir do modelo usando a função `create_api`.

```

create_api (best, 'insurance_prediction_model')

```

API criada com sucesso

Agora, para executar essa API, abra o terminal do prompt de comando, navegue até a pasta onde está o Notebook e execute o seguinte comando `python insurance_prediction_model.py`. 

Linha de comando

Vá para `http://127.0.0.1:8000/docs` e você verá a mesma interface de usuário que viu anteriormente neste tutorial

API em http:::127.0.0.1:8000:docs

Imagem do autor

API em http:::127.0.0.18000:docs

Imagem do autor

Você também pode ver a documentação interativa alternativa acessando `http://127.0.0.1:8000/redoc'

API em http:::127.0.0.1:8000:docs3

Imagem do autor

Lembre-se de que tanto a documentação interativa padrão quanto a redoc são alimentadas pelos padrões OpenAPI. 

Se você quiser ver o arquivo que o PyCaret criou quando você usou a função `create_api`, pode verificar o arquivo na mesma pasta do seu Notebook. A aparência é a seguinte:

```

import pandas as pd

from pycaret.regression import load_model, predict_model

from fastapi import FastAPI

import uvicorn




# Create the app

app = FastAPI()




# Load trained Pipeline

model = load_model('my_lr_api')




# Define predict function

@app.post('/predict')

def predict(age, sex, bmi, children, smoker, region):

    data = pd.DataFrame([[age, sex, bmi, children, smoker, region]])

    data.columns = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']

    predictions = predict_model(model, data=data) 

    return {'prediction': list(predictions['Label'])}




if __name__ == '__main__':

    uvicorn.run(app, host='127.0.0.1', port=8000)




```

Conclusão

O artigo discutiu a ideia de API e por que elas são usadas. A API é importante na arquitetura moderna porque permite que diferentes programas de software compartilhem dados e funcionalidades. Isso possibilita a criação de sistemas complexos que são mais confiáveis e fáceis de manter.

Em seguida, vamos nos aprofundar em uma estrutura relativamente nova em Python chamada FastAPI. A FastAPI é uma API mais recente, projetada para ser fácil de usar e eficiente. É uma ótima opção para os desenvolvedores que desejam criar uma API de forma rápida e fácil.

Histórico de estrelas do GitHub - criado usando star-history.com

Histórico de estrelas do GitHub - criado usando star-history.com

Se você também quiser saber como criar uma API simples a partir de um modelo de aprendizado de máquina em Python usando o Flask, confira este tutorial fácil de seguir, Transformando modelos de aprendizado de máquina em APIs em Python.

Perguntas frequentes sobre a FastAPI

A FastAPI é assíncrona?

A FastAPI oferece suporte imediato a código assíncrono usando as palavras-chave Python async/await.

A FastAPI está pronta para a produção?

O FastAPI está totalmente pronto para produção, com excelente documentação, suporte e uma interface fácil de usar.

Qual é a diferença entre o FastAPI e o Flask?

A FastAPI é compatível com chamadas assíncronas. Ele é leve, mais rápido e mais fácil de aprender do que o Flask. Tanto o Flask quanto o FastAPI têm comunidades enormes.

O FastAPI também tem um servidor de desenvolvimento integrado?

Não, o FastAPI não tem um servidor de desenvolvimento integrado. Para isso, é necessário usar o `uvicorn`.

O FastAPI é compatível com o Python 2?

Não, o FastAPI só está disponível no Python 3.6+.

A FastAPI está disponível somente em Python?

Sim

A FastAPI é mais rápida do que a linguagem de programação Go?

Não. De acordo com a techempower, a Golang Fiber é a 50ª API mais rápida do mundo. A FastAPI está em 183º lugar.

A FastAPI é compatível com o Pydantic?

O FastAPI é totalmente compatível com o Pydantic (e baseado nele).

Temas

Cursos de Python

Certificação disponível

Course

Pré-processamento para aprendizado de máquina em Python

4 hr
42.6K
Saiba como limpar e preparar seus dados para o aprendizado de máquina!
See DetailsRight Arrow
Start Course
Veja MaisRight Arrow
Relacionado

blog

Como aprender Python do zero em 2024: um guia especializado

Descubra como aprender Python, suas aplicações e a demanda por competências em Python. Comece sua jornada em Python hoje mesmo ​com nosso guia detalhado.
Matt Crabtree's photo

Matt Crabtree

19 min

blog

Mais de 60 projetos Python para todos os níveis de conhecimento

60 ideias de projetos de ciência de dados que os cientistas de dados podem usar para criar um portfólio sólido, independentemente de sua especialização.
Bekhruz Tuychiev's photo

Bekhruz Tuychiev

16 min

tutorial

Como comentar um bloco de código em Python

O uso de comentários é fundamental para trabalhar efetivamente com Python. Neste breve tutorial, aprenda a comentar um bloco de código em Python.
Adel Nehme's photo

Adel Nehme

3 min

tutorial

Como aparar uma cadeia de caracteres em Python: Três métodos diferentes

Aprenda os fundamentos do corte de caracteres à esquerda e à direita de uma string em Python.
Adel Nehme's photo

Adel Nehme

5 min

tutorial

Declaração de caso de troca do Python: Um guia para iniciantes

Explore o match-case do Python: um guia sobre sua sintaxe, aplicativos em ciência de dados, ML e uma análise comparativa com o switch-case tradicional.
Matt Crabtree's photo

Matt Crabtree

5 min

tutorial

Tutorial de Python

Em Python, tudo é objeto. Números, cadeias de caracteres (strings), DataFrames, e até mesmo funções são objetos. Especificamente, qualquer coisa que você usa no Python tem uma classe, um modelo associado por trás.
DataCamp Team's photo

DataCamp Team

3 min

See MoreSee More