Como Construir uma Aplicação API Rápida usando Docker Compose

Introdução

FastAPI é um framework web moderno para Python, projetado para oferecer alto desempenho, tornando-se uma excelente escolha para o desenvolvimento de aplicações, especialmente aquelas com integração de AI.

Este tutorial irá guiar você pelo processo de criação e configuração de uma aplicação FastAPI em um computador Ubuntu usando Docker Compose. Este método simplifica a implantação e fornece uma forte base para a integração de AI em suas aplicações.

Construir um App FastAPI usando Docker Compose

• Configuração do Ambiente Python
• Criar um Ambiente Virtual
• Instalar o Docker
• Criar uma Aplicação FastAPI
• Criar arquivo Dockerfile e Docker Compose
• Construir e Executar Container Docker
• Acessar Aplicação FastAPI
• Gerenciar Container Docker

Pré-requisitos

Para seguir este tutorial, você precisará de:

• Um servidor rodando Ubuntu juntamente com um usuário não-root com privilégios de sudo e uma firewall ativa. Para orientação sobre como configurar isso, por favor escolha sua distribuição da lista e siga com nossa guia de configuração inicial do servidor. Certifique-se de trabalhar com uma versão suportada do Ubuntu. Neste tutorial, estamos usando uma máquina Ubuntu 24.04 LTS.

• Familiaridade com a linha de comando do Linux. Para uma Introdução ou atualização sobre a linha de comando, você pode visitar este guia sobre primer do Linux command line.

• Execute sudo apt-get update no terminal do Ubuntu para certificar-se de que o seu sistema tem as versões mais recentes e atualizações de segurança para o software disponível nos repositórios configurados no seu sistema.

Passo 1 – Configuração do Ambiente Python

Em um computador Ubuntu 24.04, Python 3 já está instalado por padrão. Abra o terminal e execute o seguinte comando para verificar duas vezes a instalação de Python 3:

python3 --version

Se o Python 3 já estiver instalado no seu computador, este comando retornará a versão atual da instalação de Python 3. Caso contrário, você pode executar o seguinte comando e obter a instalação do Python 3:

sudo apt install python3

A próxima etapa é instalar os gerenciadores de pacotes pip e dev no seu sistema. o gerenciador de pacotes pip é essencial para instalar pacotes do Python Package Index, enquanto o pacote dev é necessário para construir módulos Python que incluem código compilado.
Execute o seguinte comando no terminal:

sudo apt install python3-pip python3-dev

Passo 2 – Criar e Ativar Ambiente Virtual

<$>[nota]
Se você estiver usando a versão do Ubuntu < 24.04, você não precisa criar um ambiente virtual. Pule para o próximo passo<$>.

O próximo passo é criar um ambiente virtual dentro da instalação do Ubuntu para isolar pacotes do Python do seu ambiente de sistema. Para fazer isso, vá para seu diretório de trabalho e execute o comando a seguir:

python3 -m venv fastapi-env

Este comando criará um novo ambiente virtual em um diretório chamado fastapi-env. Quaisquer pacotes que você instalar a partir de agora serão isolados de outros projetos.

A seguir, você precisa ativar este ambiente virtual para garantir que os pacotes que você instalar a partir de agora sejam instalados neste ambiente isolado.

source fastapi-env/bin/activate

Após a execução, você notará que o prompt do terminal é prefixado com o nome do seu ambiente virtual, como este:

Output
(fastapi-env) ubuntu@user:

Passo 3 – Instalar e habilitar o Docker

O próximo passo é instalar o Docker e o Docker Compose dentro do seu ambiente virtual.

sudo apt install -y docker.io

Após a instalação do Docker, inicie o serviço do Docker e habilite-o para iniciar na inicialização do sistema:

sudo systemctl start docker
sudo systemctl enable docker

Para ter a versão mais recente estavel do Docker Compose, você vai baixá-la do seu repositório oficial no GitHub, em vez de usar o apt.

Primeiro, confirme se a versão mais recente está disponível na página de lançamentos oficiais do GitHub do Docker, em seguida, execute o comando CURL abaixo no terminal.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/bin/docker-compose

Execute o comando seguinte para tornar o arquivo binário docker-compose executável para qualquer usuário do computador.

sudo chmod +x /usr/bin/docker-compose

Verifique a instalação executando:

docker-compose --version

Passo 4 – Criar o Aplicativo FastAPI

Agora é hora de começar a criar um aplicativo Python que use o framework FastAPI. Primeiro, crie um arquivo main.py:

nano main.py

O seguinte é um aplicativo Python de exemplo que cria uma simples API web usando o framework FastAPI e um modelo AI pré-treinado para analisar o sentimento de um texto fornecido.

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import pipeline

app = FastAPI()

sentiment_analyzer = pipeline("sentiment-analysis")

class TextRequest(BaseModel):
    text: str

class SentimentResponse(BaseModel):
    sentiment: str
    confidence: float

@app.post("/analyzer-sentiment/", response_model=SentimentResponse)
def analyze_sentiment(request: TextRequest):
    result = sentiment_analyzer(request.text)[0]
    sentiment = result['label']
    confidence = result['score']

    return SentimentResponse(sentiment=sentiment, confidence=confidence)

Para executar este aplicativo com sucesso, você precisará das dependências necessárias, mas você não precisa instalá-las manualmente. A instalação destes pacotes será gerenciada dentro do Dockerfile, que é mencionado no próximo passo.

Passo 5 – Criar Dockerfile e arquivo de configuração YAML

A seguir, você criará um arquivo Dockerfile para essa aplicação. Esse Dockerfile define o ambiente em que sua aplicação FastAPI irá executar. Crie um arquivo Dockerfile no diretório do projeto executando:

nano Dockerfile

No editor de texto, adicione o seguinte conteúdo:

FROM python:3.12-slim

WORKDIR /app

COPY . /app

RUN pip install --no-cache-dir fastapi  pydantics transformers uvicorn

EXPOSE 80

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

O Docker Compose simplifica a gerenciamento de aplicações com vários contêineres. Em seguida, você precisará criar um arquivo de configuração docker-compose.yml no diretório do projeto.

nano docker-compose.yml

Adicione o seguinte conteúdo ao arquivo vazio:

version: '3.8'
services:
  web:
    build: .
    ports:
     - "8000:80"
    volumes:
     - .:/app

Nessa configuração,

• version: Especifica a versão do Docker Compose a ser usada.
• services: Define os serviços a serem criados.
• web: Especifica o nome do serviço que está executando sua aplicação FastAPI.
• build: Especifica o diretório de onde o imagem Docker deve ser construída. Neste caso, é o mesmo diretório onde está o arquivo docker-compose.yml.
• ports: Mapeia a porta 8000 no computador host para a porta 80 dentro do contêiner.
• volumes: Monta o diretório atual como um volume dentro do contêiner, permitindo que você recarregue o código em tempo real.

Passo 6 – Construir e Executar o Container Docker

Use o Docker Compose para construir esta imagem Docker e iniciar o container:

sudo docker-compose build

Este comando constrói a imagem Docker a partir do arquivo Dockerfile na pasta atual. Agora, para executar a aplicação real, execute o seguinte comando no terminal:

sudo docker-compose up

Passo 7 – Acessar a Sua Aplicação FastAPI

Uma vez que o container estiver em execução, você pode acessar sua aplicação FastAPI navegando até http://localhost:8000 no seu navegador web.

Passo 8 [OPCIONAL] – Gerenciar Seu Container Docker

Aqui estão algumas dicas para ajudar você a melhor controlar o ambiente containerizado que está executando sua aplicação FastAPI.

• Para parar o container em execução, pressione Ctrl + C ou Command + ..

• Para obter o controle de volta enquanto o container está em execução em background, use:

  sudo docker-compose up -d
  

  Copiar

• Para parar e remover seu container, execute:

  sudo docker-compose down
  

  Copiar

Conclusão

Neste tutorial, você aprendeu a criar e configurar um aplicativo FastAPI em uma máquina Ubuntu usando Docker Compose. Com a velocidade de FastAPI e a eficiência de Docker, você pode construir aplicações robustas e escaláveis com confiança.