Crie um aplicativo com FastAPI para Python

FastAPI é uma estrutura da Web rápida e leve para criar interfaces de programação de aplicativos modernos usando Python 3.6 e superior. Neste tutorial, abordaremos os fundamentos da criação de um aplicativo com FastAPI e você terá uma ideia do motivo pelo qual ele foi indicado como um dos melhores frameworks de código aberto de 2021.

Quando estiver pronto para desenvolver seus próprios aplicativos FastAPI, você não precisará procurar muito para encontrar um local para hospedá-los. Os serviços de Hospedagem de Aplicativos e Hospedagem de Banco de Dados da Kinsta fornecem uma Plataforma como Serviço que é forte em Python.

Vamos aprender o básico primeiro.

Vantagens do FastAPI

Abaixo estão algumas das vantagens que a estrutura FastAPI traz para um projeto.

• Velocidade: como o nome indica, FastAPI é uma estrutura muito rápida. Sua velocidade é comparável à do Go e do Node.js, geralmente considerados entre as opções mais rápidas para criar APIs.
• Fácil de aprender e codificar: FastAPI já descobriu quase tudo que você precisa para fazer uma API pronta para produção. Como desenvolvedor usando FastAPI, você não precisa codificar tudo do zero. Com apenas algumas linhas de código, você pode ter uma API RESTful pronta para implantação.
• Documentação abrangente: FastAPI usa os padrões de documentação OpenAPI, para que a documentação possa ser gerada dinamicamente. Esta documentação fornece informações detalhadas sobre pontos de extremidade, respostas, parâmetros e códigos de retorno do FastAPI.
• APIs com menos bugs: FastAPI oferece suporte à validação de dados personalizados, o que permite aos desenvolvedores criar APIs com menos bugs. Os desenvolvedores do FastAPI se gabam de que a estrutura resulta em menos bugs induzidos por humanos — até 40% menos.
• Dicas de tipo: o módulo de tipos foi introduzido no Python 3.5. Isso permite que você declare o type de uma variável. Quando o tipo de uma variável é declarado, os IDEs são capazes de fornecer melhor suporte e prever erros com mais precisão.

Como começar com FastAPI

Para seguir este tutorial e começar a usar o FastAPI, você precisará fazer algumas coisas primeiro.

Certifique-se de ter um editor de texto/IDE do programador, como o Visual Studio Code. Outras opções incluem Sublime Text e Espresso.

É uma prática comum ter seus aplicativos Python e suas instâncias em execução em ambientes virtuais. Os ambientes virtuais permitem que diferentes conjuntos e configurações de pacotes sejam executados simultaneamente e evitam conflitos devido a versões de pacotes incompatíveis.

Para criar um ambiente virtual, abra seu terminal e execute este comando:

 $ python3 -m venv env

Você também precisará ativar o ambiente virtual. O comando para fazer isso varia dependendo do sistema operacional e do shell que você está usando. Aqui estão alguns exemplos de ativação CLI para vários ambientes:

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Alguns IDEs compatíveis com Python também podem ser configurados para ativar o ambiente virtual atual.)

Agora, instale FastAPI:

 $ pip3 install fastapi

FastAPI é uma estrutura para criar APIs, mas para testar suas APIs, você precisará de um servidor web local. O Uvicorn é um servidor da web ASGI (Asynchronous Server Gateway Interface) ultrarrápido para Python, ótimo para desenvolvimento. Para instalar o Uvicorn, execute este comando:

 $ pip3 install "uvicorn[standard]"

Após a instalação bem-sucedida, crie um arquivo chamado main.py no diretório de trabalho do seu projeto. Este arquivo será o ponto de entrada do seu aplicativo.

Um exemplo rápido de FastAPI

Você testará sua instalação do FastAPI configurando rapidamente um endpoint de exemplo. No seu arquivo main.py , cole o seguinte código e salve o arquivo:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

O snippet acima cria um endpoint FastAPI básico. Abaixo está um resumo do que cada linha faz:

• from fastapi import FastAPI : A funcionalidade para sua API é fornecida pela classe FastAPI Python.
• app = FastAPI() : Isso cria uma instância FastAPI.
• @app.get("/") : Este é um decorador python que especifica ao FastAPI que a função abaixo dele é responsável pela manipulação de solicitações.
• @app.get("/") : Este é um decorador que especifica a rota. Isso cria um método GET na rota do site. O resultado é então retornado pela função wrapper.
• Outras possíveis operações usadas para comunicação incluem @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() e @app.trace() .

No diretório de arquivos, execute o seguinte comando em seu terminal para iniciar o servidor API:

 $ uvicorn main:app --reload

Neste comando, main é o nome do seu módulo. O objeto app é uma instância do seu aplicativo e é importado para o servidor ASGI. O sinalizador --reload informa ao servidor para recarregar automaticamente quando você fizer qualquer alteração.

Você deve ver algo assim em seu terminal:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

Em seu navegador, navegue até http://localhost:8000 para confirmar se sua API está funcionando. Você deve ver “Hello”: “World” como um objeto JSON na página. Isso ilustra como é fácil criar uma API com FastAPI. Tudo o que você precisava fazer era definir uma rota e retornar seu dicionário Python, como visto na linha seis do trecho acima.

Usando dicas de digitação

Se você usa Python, está acostumado a anotar variáveis ​​com tipos de dados básicos, como int , str , float e bool . No entanto, a partir da versão 3.9 do Python, foram introduzidas estruturas de dados avançadas. Isso permite que você trabalhe com estruturas de dados como dictionaries , tuples e lists . Com as dicas de tipo do FastAPI, você pode estruturar o esquema de seus dados usando modelos pydantic e, em seguida, usar os modelos pydantic para type hint e se beneficiar da validação de dados que é fornecida.

No exemplo abaixo, o uso de dicas de tipo em Python é demonstrado com uma calculadora de preço de refeição simples, calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Observe que as dicas de tipo não alteram a execução do seu código.

Documentação da API interativa FastAPI

FastAPI usa Swagger UI para fornecer documentação de API interativa automática. Para acessá-lo, navegue até http://localhost:8000/docs e você verá uma tela com todos os seus endpoints, métodos e esquemas.

Essa documentação de API automática baseada em navegador é fornecida pela FastAPI e você não precisa fazer mais nada para aproveitá-la.

Uma documentação de API alternativa baseada em navegador, também fornecida pela FastAPI, é o Redoc. Para acessar o Redoc, navegue até http://localhost:8000/redoc , onde será apresentada uma lista de seus endpoints, os métodos e suas respectivas respostas.

Configurando rotas no FastAPI

O decorador @app permite especificar o método da rota, como @app.get ou @app.post , e suporta GET , POST , PUT e DELETE , bem como as opções menos comuns, HEAD , PATCH e TRACE .

Construindo seu aplicativo com FastAPI

Neste tutorial, você aprenderá a criar um aplicativo CRUD com FastAPI. O aplicativo será capaz de:

• Criar um usuário
• Ler o registro do banco de dados de um usuário
• Atualizar um usuário existente
• Excluir um usuário específico

Para executar essas operações CRUD, você criará métodos que expõem os endpoints da API. O resultado será um banco de dados na memória que pode armazenar uma lista de usuários.

Você usará a biblioteca pydantic para executar validação de dados e gerenciamento de configurações usando anotações de tipo Python. Para os propósitos deste tutorial, você declarará a forma de seus dados como classes com atributos.

Este tutorial usará o banco de dados na memória. Isso é para você começar rapidamente a usar o FastAPI para criar suas APIs. Porém, para produção, você pode utilizar qualquer banco de dados de sua preferência, como PostgreSQL, MySQL, SQLite ou até mesmo Oracle.

Construindo o aplicativo

Você começará criando seu modelo de usuário. O modelo do usuário terá os seguintes atributos:

• id : Um identificador exclusivo universal (UUID)
• first_name : O primeiro nome do usuário
• last_name : O sobrenome do usuário
• gender : o sexo do usuário
• roles , que é uma lista contendo funções de admin e user

Comece criando um novo arquivo chamado models.py em seu diretório de trabalho e cole o seguinte código em models.py para criar seu modelo:

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

No código acima:

• Sua classe User estende BaseModel , que é importada de pydantic .
• Você definiu os atributos do usuário, conforme discutido acima.

O próximo passo é criar seu banco de dados. Substitua o conteúdo do seu arquivo main.py pelo seguinte código:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

Em main.py :

• Você inicializou o db com um tipo de List e passou no modelo User
• Você criou um banco de dados na memória com quatro usuários, cada um com os atributos necessários, como first_name , last_name , gender e roles . Ao usuário Eunit são atribuídos os papéis de admin e user , enquanto os outros três usuários são atribuídos apenas ao papel de user .

Ler registros do banco de dados

Você configurou com sucesso seu banco de dados na memória e o preencheu com usuários, portanto, a próxima etapa é configurar um terminal que retornará uma lista de todos os usuários. É aqui que entra o FastAPI.

No seu arquivo main.py , cole o seguinte código logo abaixo do endpoint Hello World :

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Esse código define o endpoint /api/v1/users e cria uma função assíncrona, get_users , que retorna todo o conteúdo do banco de dados, db .

Salve seu arquivo e você pode testar seu terminal de usuário. Execute o seguinte comando em seu terminal para iniciar o servidor API:

 $ uvicorn main:app --reload

Em seu navegador, navegue até http://localhost:8000/api/v1/users . Isso deve retornar uma lista de todos os seus usuários, conforme abaixo:

Nesta fase, seu arquivo main.py ficará assim:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Criar registros de banco de dados

A próxima etapa é criar um endpoint para criar um novo usuário em seu banco de dados. Cole o trecho a seguir em seu arquivo main.py :

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

Neste snippet, você definiu o endpoint para enviar um novo usuário e utilizou o decorador @app.post para criar um método POST .

Você também criou a função create_user , que aceita o user do modelo User e anexou (adicionou) o user recém-criado ao banco de dados, db . Por fim, o endpoint retorna um objeto JSON do id do usuário recém-criado.

Você terá que usar a documentação da API automática fornecida pelo FastAPI para testar seu endpoint, conforme visto acima. Isso ocorre porque você não pode fazer uma solicitação de postagem usando o navegador da web. Navegue até http://localhost:8000/docs para testar usando a documentação fornecida pelo SwaggerUI.

Excluir registros do banco de dados

Como você está criando um aplicativo CRUD, seu aplicativo precisará ter a capacidade de excluir um recurso especificado. Para este tutorial, você criará um endpoint para excluir um usuário.

Cole o seguinte código em seu arquivo main.py :

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

Aqui está um detalhamento linha por linha de como esse código funciona:

• @app.delete("/api/v1/users/{id}") : Você criou o endpoint de exclusão usando o decorador @app.delete() . O caminho ainda é /api/v1/users/{id} , mas recupera o id , que é uma variável de caminho correspondente ao id do usuário.
• async def delete_user(id: UUID): : Cria a função delete_user , que recupera o id da URL.
• for user in db: : informa ao aplicativo para percorrer os usuários no banco de dados e verificar se o id passado corresponde a um usuário no banco de dados.
• db.remove(user) : Se o id corresponder a um usuário, o usuário será excluído; caso contrário, será gerada uma HTTPException com um código de status 404.

Atualizar registros do banco de dados

Você criará um endpoint para atualizar os detalhes de um usuário. Os detalhes que podem ser atualizados incluem os seguintes parâmetros: first_name , last_name e roles .

Em seu arquivo models.py , cole o seguinte código em seu modelo User , que está após a classe User(BaseModel): ::

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

Neste snippet, a classe UpdateUser estende BaseModel . Em seguida, você define os parâmetros de usuário atualizáveis, como first_name , last_name e roles , como opcionais.

Agora você criará um endpoint para atualizar os detalhes de um determinado usuário. No arquivo main.py , cole o seguinte código após o decorador @app.delete :

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

No código acima, você fez o seguinte:

• Criado @app.put("/api/v1/users/{id}") , o endpoint de atualização. Possui um parâmetro variável id que corresponde ao id do usuário.
• Criou um método chamado update_user , que recebe a classe UpdateUser e o id .
• Usou um loop for para verificar se o usuário associado ao id passado está no banco de dados.
• Verificado se algum dos parâmetros do usuário is not None (não nulo). Se algum parâmetro, como first_name , last_name ou roles , não for nulo, ele será atualizado.
• Se a operação for bem-sucedida, o ID do usuário será retornado.
• Se o usuário não foi localizado, uma exceção HTTPException com um código de status de 404 e uma mensagem de Could not find user with id: {id} é gerada.

Para testar esse endpoint, verifique se o servidor Uvicorn está em execução. Se não estiver em execução, digite este comando:

 uvicorn main:app --reload

Abaixo está uma captura de tela do teste.

Veja como FastAPI pode eliminar bugs induzidos por humanos em até 40% Comece aqui: Click to Tweet

Resumo

Neste tutorial, você aprendeu sobre a estrutura FastAPI para Python e viu por si mesmo a rapidez com que um aplicativo baseado em FastAPI pode ser instalado e executado. Você aprendeu como criar endpoints de API CRUD usando a estrutura — criando, lendo, atualizando e excluindo registros de banco de dados.

Agora, se você quiser levar o desenvolvimento de seu aplicativo da web para o próximo nível, certifique-se de verificar a plataforma da Kinsta para hospedagem de aplicativos e hospedagem de banco de dados. Como o FastAPI, é extremamente simples.