Como implantar um aplicativo FastAPI?

Embora existam muitos provedores de hospedagem, apenas alguns oferecem uma Common Gateway Interface (CGI) ou o módulo mod_wsgi para oferecer suporte à hospedagem Python. Mas entre os desenvolvedores que participaram da Pesquisa de desenvolvedores do Stack Overflow de 2023, a conteinerização com o Docker assume a liderança no desenvolvimento e na implantação de aplicativos.

Para aplicativos Python desenvolvidos usando uma estrutura como a FastAPI, a implantação por meio de um contêiner como serviço (CaaS) é tão simples quanto enviar seu código para o GitHub. Neste blog, você aprenderá a dockerizar seu aplicativo FastAPI e implantá-lo por meio de um CaaS.

Principais conclusões

• O Docker e a FastAPI são uma dupla forte; eles permitem implantações simplificadas e empacotadas com dependências incluídas.

• A FastAPI é excelente em operações assíncronas, validação de dados e OpenAPI, mas fica aquém do apoio da comunidade e da compatibilidade.

• O Back4app facilita a implantação do FastAPI, sincronizando com o GitHub para atualizações automáticas e oferecendo configuração de banco de dados na nuvem.

O que é FastAPI?

O FastAPI é uma estrutura web Python leve e de código aberto para o desenvolvimento de APIs RESTful. Lançada em 2018, ela oferece suporte ao modelo Pydantic e ao Starlette, colocando-a no mesmo nível de desempenho do Node.js e do Golang. A estrutura também é personalizável, permitindo que você projete sua base de código de forma flexível.

Com seu suporte para o esquema JSON e a sugestão de tipo nas versões 3.6 e posteriores do Python, o modelo Pydantic permite que o FastAPI analise dados facilmente e os valide em tempo de execução.

A estrutura Starlette introduz a ASGI (Asynchronous Server Gateway Interface) na FastAPI; isso permite que você execute operações assíncronas nas APIs RESTful do Python e execute seu código no servidor ASGI da Uvicorn.

Como o Nodemon no Node.js, o servidor Uvicorn ouve as alterações nas rotas da API e reinicia o tempo de execução para cada atualização.

Embora apenas 7,42% dos desenvolvedores que participaram da Pesquisa de desenvolvedores do Stack Overflow de 2023 tenham indicado que usam o FastAPI, até o momento, o GitHub coloca seu total de usuários em 203 mil. Com mais de 498 colaboradores e 190 versões no momento em que este artigo foi escrito, o FastAPI recebe atualizações e patches consistentes.

No entanto, colocar o FastAPI no mesmo nível de desempenho do Golang e do Node.js ainda é um debate entre os desenvolvedores.

Enquanto outros concordam, alguns afirmam que, embora seja um aprimoramento significativo para o desenvolvimento web em Python, o FastAPI ainda não se compara ao desempenho de nenhum dos dois.

Vantagens da FastAPI

• Suporte para operações assíncronas: Além das operações síncronas padrão do Python, a FastAPI oferece suporte a declarações de funções usando async/await. Graças ao Starlette, que também oferece suporte ao WebSocket. Isso adiciona simultaneidade ao seu programa, permitindo que o aplicativo execute outras operações enquanto espera por operações mais lentas, como consultas a bancos de dados.

• Suporte para validação de dados: Usando o Pydantic BaseModel, a FastAPI aproveita as dicas de tipo de dados do Python para manter o rigor durante a análise de dados. Isso evita que o tipo de dados errado entre no banco de dados. Portanto, ao contrário dos modelos dinâmicos que exigem bibliotecas de validação adicionais, a validação do modelo é direta e está prontamente disponível na FastAPI.

• Totalmente padronizado: A FastAPI está em conformidade com a especificação OpenAPI para servir APIs HTTP na Web, facilitando o entendimento da API que os aplicativos de consumo e os clientes desejam usar. Na parte interna, ele também usa a declaração JSON Schema para garantir que os dados de teste e os dados enviados pelo usuário ao vivo sejam válidos antes de enviá-los ao banco de dados.

• Flexibilidade: Ao contrário do Django, o FastAPI não limita o desenvolvedor a um padrão arquitetônico de base de código específico. Em vez disso, ele deixa essa decisão para o desenvolvedor. Portanto, você pode projetar sua base de código com convenções de nomenclatura flexíveis e declarar configurações gerais do aplicativo e conjuntos de testes unitários em qualquer lugar. A modularização do código e a separação de preocupações (SOC) também são simples.
  
  E se estiver usando programação orientada a objetos (OOP), o que recomendamos, você poderá facilmente compor seus modelos em suas classes de endpoint. À medida que você constrói, anexar endpoints de API às suas rotas também é simples.

• Ele tem uma curva de aprendizado fácil: Apesar de ter uma comunidade de usuários menor do que estruturas como Flask e Django, o FastAPI se destaca por sua documentação e tutoriais amplamente abrangentes. Com um histórico de desenvolvimento, especialmente em Python ou JavaScript, você pode aprendê-lo facilmente. Sua simplicidade e flexibilidade gerais contribuem para processos de desenvolvimento mais rápidos.

Limitações

• Pouco suporte da comunidade: O FastAPI não tem muitos usuários como o Django ou o Flask. Ele ainda é relativamente novo. Portanto, o suporte da comunidade é menor, o que pode ser um desafio, especialmente para novos desenvolvedores.

• Compatibilidade limitada de versões: O FastAPI só oferece suporte a versões posteriores do Python, começando com o Python 3.6 em diante. Portanto, os computadores ou servidores que executam versões do Python anteriores à 3.6 devem fazer a atualização para instalar e executar o FastAPI com êxito.

Opções de implantação do FastAPI

A infraestrutura como serviço (IaaS) e o contêiner como serviço (CaaS) são infraestruturas de nuvem dimensionáveis para a implantação de aplicativos.

Embora você possa implantar um aplicativo FastAPI por meio de um servidor virtual privado (VPS) ou hospedagem compartilhada, nenhum deles é tão dimensionável quanto um IaaS ou um CaaS.

IaaS

Uma IaaS é uma plataforma que fornece recursos de computação sob demanda na nuvem. Ela fornece todos os recursos virtualizados necessários para configurar um servidor de implementação para seu aplicativo, geralmente em uma base de pagamento conforme o uso.

Além da infraestrutura de computação, um IaaS inclui armazenamento e outros recursos de rede, como balanceadores de carga, VPNs, firewalls, gerenciamento de DNS e muito mais. Você é responsável por gerenciar seu ambiente de computação e pode personalizar ou dimensionar seus recursos para atender aos requisitos do seu aplicativo.

CaaS

Um CaaS é uma plataforma como serviço (PaaS) que permite implantar seu aplicativo na nuvem como contêineres. Ao contrário de uma IaaS, uma CaaS gerencia toda a linha de base de computação necessária para hospedar seu aplicativo sob o capô.

Isso inclui o ambiente de tempo de execução do contêiner, a orquestração, o armazenamento, o balanceamento de carga e muito mais. Assim, você pode se concentrar na criação do seu aplicativo em vez de se preocupar com o gerenciamento da infraestrutura.

Como você está implantando seu aplicativo como um contêiner, isso torna a integração CI/CD simples, sem se preocupar com configurações técnicas. Isso torna o lançamento e as atualizações do aplicativo mais rápidos.

Processo de implementação da API da FAST

Vamos analisar o processo de implantação passo a passo, começando com os pré-requisitos. Mas como implantaremos nosso aplicativo FastAPI usando contêineres do Back4App, vamos ver rapidamente quais são eles antes de continuar.

Visão geral dos contêineres do Back4app

O Back4App Containers é uma plataforma de nuvem que permite implantar aplicativos em docker rapidamente na nuvem. A plataforma é sincronizada com seu repositório do GitHub e atualiza automaticamente sua implantação sempre que você envia uma versão. Dessa forma, ela ajuda a eliminar atualizações manuais de contêineres e tempos de inatividade do servidor.

Com o Back4App Containers, você só precisa enviar seu código e as versões subsequentes para o GitHub a partir de sua máquina local, e a plataforma lida com a orquestração de imagens de contêineres. A Back4App também apresenta rastreamento de implantação em tempo real e registro em tempo real.

Assim, você pode rastrear as etapas de implantação e determinar o ponto de falha, se houver algum. E se o seu aplicativo falhar no tempo de execução, o que pode acontecer em uma linguagem interpretada como Python, o registro em tempo real ajuda a rastrear os erros no console para corrigi-los rapidamente.

Aqui estão os principais recursos do Back4App:

• Sincronize facilmente seu aplicativo Back4App com seu repositório de base de código no GitHub.

• Implante seu aplicativo na nuvem por meio de um contêiner do Back4App, enviando seu código e as atualizações subsequentes para o repositório do GitHub.

• Tudo o que você precisa é de um Dockerfile. A Back4App cuida de todas as instalações de dependências para você.

• Criptografe suas variáveis de ambiente facilmente durante a implementação e as versões subsequentes.

• Monitore as implementações em tempo real e gerencie as reversões.

• Monitore o histórico de uso do aplicativo com registros em tempo real.

• Implemente aplicativos móveis e da Web na nuvem

Faça o download e instale o Python

Usaremos o Python 3.10.6 neste blog. Mas você pode usar qualquer versão do Python que não seja anterior à 3.6. Acesse python.org para baixar e instalar a versão mais recente do Python compatível com seu sistema operacional, caso ainda não tenha feito isso. Caso contrário, ignore esta seção.

Após o download, clique no arquivo de instalação e siga as instruções na tela para instalar o Python em sua máquina local.

Certifique-se de marcar a opção Add python.exe to PATH para adicionar o Python ao caminho da variável do sistema; isso o torna executável por meio da linha de comando.

Se estiver usando um Mac, ele já vem com o Python 2.7 por padrão. Você pode atualizá-lo para a versão mais recente usando o Homebrew pelo terminal:

brew install python3

Execute o seguinte comando em seu terminal para verificar sua versão do Python.

python --version

Ativar um ambiente virtual Python e instalar o FastAPI

Em seguida, crie um novo diretório de projeto e abra a linha de comando para essa pasta. Em seguida, ative um ambiente virtual Python usando o venv.

Esse pacote vem com o Python e não requer instalação. Ele permite que você gerencie as dependências do Python de forma isolada, em vez de instalá-las globalmente.

Execute o seguinte comando no terminal para criar um ambiente virtual, substituindo env_name pelo nome do ambiente de sua preferência.

py -m venv env_name

Execute o seguinte comando para ativar o ambiente virtual.

.\env_name\Scripts\activate

Instalar o FastAPI e o Uvicorn

A próxima etapa é instalar a estrutura FastAPI e o tempo de execução do servidor Uvicorn no ambiente virtual ativo. Isso também instala o Pydantic e o Starlette.

Crie um arquivo requirements.txt na raiz do projeto e insira os pacotes a serem instalados, conforme mostrado abaixo.

fastapi
uvicorn

Abaixo está a demonstração em VSCode. Você pode anexar mais dependências a esse arquivo conforme a necessidade.

Execute o seguinte comando no terminal para instalar as dependências listadas. Certifique-se de que o ambiente virtual ainda esteja ativo.

pip install install -r requirements.txt

O comando instala o pacote especificado conforme mostrado abaixo.

Depois de instalado, atualize o arquivo requirements.txt usando o seguinte comando:

pip freeze > requirements.txt

O comando acima substitui o arquivo requirements.txt pelas dependências instaladas, incluindo seus números de versão corretos. Certifique-se de fazer isso sempre que instalar uma nova dependência em seu ambiente virtual.

O arquivo requirements.txt tem a seguinte aparência após a atualização:

Introdução ao projeto

Escreveremos um aplicativo FastAPI “Hello World” simples e o implantaremos usando os contêineres Back4App gratuitos. Não se preocupe se seu projeto for complexo. A implantação é feita na mesma etapa, e você também recebe um tempo de atividade mensal gratuito.

No entanto, se o seu aplicativo lida com muitas solicitações diariamente, talvez você queira fazer upgrade após a implantação para proporcionar aos visitantes uma experiência de usuário mais tranquila e sem tempo de inatividade.

Código do aplicativo

Crie um novo diretório de roteador na pasta raiz do projeto e crie um arquivo main.py dentro desse diretório. Esse arquivo lida com os pontos de extremidade da API do aplicativo e com o roteador. Pule para a seção a seguir se já tiver um projeto a ser implantado.

Aqui está o código “Hello World”:

from fastapi import FastAPI, APIRouter
import uvicorn

app = FastAPI()
class HelloWorld():
    def read_hello(self):
        return {"data": "Hello World"}
router = APIRouter()
router.add_api_route('/api/v2/hello-world', 
endpoint = HelloWorld().read_hello, methods=["GET"])
app.include_router(router)

if __name__ == "__main__":
   uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Para executar o servidor uvicorn e testar o endpoint da API hello-world, execute o arquivo main.py por meio da linha de comando:

python main.py

Isso inicia o servidor de desenvolvimento na porta 8000, conforme especificado.

Como essa é uma solicitação GET, podemos testá-la diretamente em qualquer navegador da Web. Veja abaixo o resultado.

Dockerize o aplicativo

Em seguida, crie um Dockerfile na pasta raiz do seu projeto. Você pode fazer isso criando um novo arquivo no VS Code e nomeando-o Dockerfile.

Depois de criado, digite os seguintes comandos para criar uma imagem do Docker:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "router.main:app", "--host", "0.0.0.0", "--port", "8000"]

Enviar para o GitHub

Acesse sua conta do GitHub e vá para Repositórios. Inicie um novo repositório clicando em New (Novo ) no canto superior direito.

Acesse sua conta do GitHub e vá para Repositórios. Inicie um novo repositório clicando em New (Novo) no canto superior direito.

Se já tiver enviado seu código para o GitHub, adicione o Dockerfile à cópia em seu computador local e envie novamente para seu repositório.

Dê um nome ao seu repositório e clique em Create repository (Criar repositório ) no canto inferior direito.

Em seguida, inicialize um repositório local usando o comando init, conforme mostrado:

git init

Ignore a pasta venv e o arquivo .env usando o .gitignore para evitar enviá-los para o repositório. Para fazer isso, crie um arquivo .gitignore na pasta raiz do projeto e insira as pastas e os arquivos que deseja ignorar, conforme mostrado abaixo.

Execute os seguintes comandos em seu terminal, um após o outro, para enviar seu código para o repositório.

1. git add .
2. git commit -m "commit message"
3. git branch -m main
4. git remote add origin <URL of the created repository>
5. git push -u origin main

Implantar o aplicativo com um contêiner Back4App

Se ainda não tiver feito isso, certifique-se de criar uma nova conta Back4App. Para acelerar o processo, use a opção de login do Google ou do GitHub .

Quando estiver conectado, clique no widget Criar novo aplicativo.

Vá para Contêineres como serviço.

Na página seguinte, clique em Import GitHub Repo. Conceda permissão ao GitHub para autorizar o Back4App quando solicitado.

Em Acesso ao repositório, no modal aberto, clique em Selecionar repositórios. Selecione o repositório que contém o projeto que você deseja implantar e clique em Salvar.

O Back4App sincronizará o repositório selecionado automaticamente. Depois de ser redirecionado para o Back4App, clique em Select (Selecionar ) à direita do repositório do GitHub adicionado. Em seguida, preencha o campo App Name (Nome do aplicativo ) com seu nome de aplicativo preferido.

Se o aplicativo FastAPI tiver segredos mascarados em um arquivo .env, clique em Environment Variables (Variáveis de ambiente) para inserir suas variáveis de ambiente. Clique em Add variable e digite o nome da variável usando caracteres maiúsculos.

Certifique-se de usar a mesma convenção de nomenclatura que as variáveis no arquivo .env do seu projeto para evitar erros de nome.

Essa etapa criptografa e adiciona os valores das variáveis à sua implantação. Por fim, clique em Create App para implantar o aplicativo FastAPI.

A instância de implementação do aplicativo FastAPI é executada conforme mostrado abaixo.

Para visualizar a versão ao vivo de seu aplicativo, clique no URL na barra lateral esquerda. Acessar https://testapp-omisolaidowu.b4a.run/api/v2/hello-world, nesse caso, retorna a resposta esperada.

Conclusão

Uma tarefa é desenvolver um aplicativo usando a FastAPI do Python. Mas outra coisa é implementá-lo sem problemas para atender aos clientes.

Além de ajudar na implantação mais rápida, o CaaS é menos técnico. Embora você tenha visto como implantar um aplicativo FastAPI, isso não é tudo.

Talvez você queira implantar o aplicativo do lado do cliente em uma instância de contêiner separada e conectar-se aos pontos de extremidade FastAPI usando a URL gerada como URL de base.

Se você gostou deste artigo, consulte nosso tutorial sobre Como implantar um aplicativo Flask.