FastAPI com Docker Compose: guia completo para criar sua primeira aplicação

O FastAPI é um framework web moderno para Python, projetado para entregar alta performance e simplicidade no desenvolvimento de APIs. Sua arquitetura assíncrona nativa e validação automática de dados fazem dele uma escolha excepcional para criar aplicações web escaláveis, especialmente aquelas que envolvem inteligência artificial.

Neste tutorial completo, você vai aprender passo a passo como criar e configurar uma aplicação FastAPI em um servidor Ubuntu utilizando Docker Compose. Essa abordagem não apenas simplifica o processo de deployment, mas também estabelece uma base sólida para integrar recursos de IA em suas aplicações.

Por que combinar FastAPI com Docker?

Antes de mergulharmos no tutorial, vale entender por que essa combinação é tão poderosa:

• Isolamento de ambiente: Docker garante que sua aplicação funcione de forma consistente em qualquer máquina

• Facilidade de deployment: Docker Compose simplifica a orquestração de múltiplos containers

• Reprodutibilidade: O ambiente de desenvolvimento é idêntico ao de produção

• Performance: FastAPI + Docker oferecem latência mínima e alto throughput

• Escalabilidade: Facilita a replicação de containers conforme a demanda aumenta

Requisitos para começar

Para seguir este tutorial, você precisará de:

• Um servidor rodando Ubuntu (versões suportadas: 24.04, 22.04, 20.04)

• Usuário não-root com privilégios sudo

• Firewall ativo e configurado

• Familiaridade básica com linha de comando Linux

Importante: Certifique-se de executar sudo apt-get update no terminal para garantir que seu sistema tenha as versões mais recentes dos pacotes disponíveis.

Configurando o ambiente Python

No Ubuntu 24.04, o Python 3 já vem instalado por padrão. Para verificar a instalação, abra o terminal e execute:

python3 --version

Caso o Python 3 não esteja instalado, você pode instalá-lo com:

sudo apt install python3

Em seguida, instale os gerenciadores de pacotes pip e ferramentas de desenvolvimento Python. O pip é essencial para instalar bibliotecas do Python Package Index, enquanto o pacote dev é necessário para compilar módulos Python que incluem código compilado:

sudo apt install python3-pip python3-dev

Criando e ativando o ambiente virtual

Observação: Se você está usando Ubuntu < 24.04, pode pular esta etapa e ir direto para a instalação do Docker.

Criar um ambiente virtual é uma prática recomendada para isolar as dependências do seu projeto. Navegue até seu diretório de trabalho e execute:

python3 -m venv fastapi-env

Este comando cria um novo ambiente virtual em um diretório chamado fastapi-env. Agora, ative o ambiente virtual:

source fastapi-env/bin/activate

Após a ativação, você notará que o prompt do terminal será prefixado com o nome do seu ambiente virtual:

(fastapi-env) ubuntu@user:

Instalando e habilitando o Docker

Agora vamos instalar o Docker e o Docker Compose. Execute o seguinte comando:

sudo apt install -y docker.io

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

sudo systemctl start docker
sudo systemctl enable docker

Para garantir que você tenha a versão mais recente e estável do Docker Compose, faça o download diretamente do repositório oficial no GitHub. Primeiro, confirme a versão mais recente disponível na página de releases do Docker Compose e execute:

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

Torne o binário docker-compose executável:

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

Verifique a instalação executando:

docker-compose --version

Criando sua aplicação FastAPI

Agora é hora de criar uma aplicação Python que utiliza o framework FastAPI. Vamos construir uma API simples que analisa o sentimento de textos usando um modelo de IA pré-treinado.

Crie um arquivo main.py:

nano main.py

Adicione o seguinte código ao arquivo:

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)

Esta aplicação demonstra o poder do FastAPI para criar APIs de machine learning. O endpoint /analyzer-sentiment/ recebe um texto e retorna a análise de sentimento com o nível de confiança da predição.

Criando o Dockerfile e configuração YAML

O próximo passo é criar um Dockerfile que define o ambiente onde sua aplicação FastAPI será executada. Crie um arquivo Dockerfile no diretório do projeto:

nano Dockerfile

Adicione o seguinte conteúdo:

FROM python:3.12-slim

WORKDIR /app

COPY . /app

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

EXPOSE 80

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

Entendendo o Dockerfile

Vamos analisar cada instrução:

Agora crie o arquivo docker-compose.yml:

nano docker-compose.yml

Adicione a seguinte configuração:

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

Componentes do docker-compose.yml

• version: Especifica a versão do Docker Compose (3.8)

• services: Define os serviços a serem criados

• web: Nome do serviço que executa sua aplicação FastAPI

• build: Especifica o diretório onde está o Dockerfile

• ports: Mapeia a porta 8000 do host para a porta 80 do container

• volumes: Monta o diretório atual como volume, permitindo hot reload durante o desenvolvimento

Construindo e executando o container Docker

Use o Docker Compose para construir a imagem Docker:

sudo docker-compose build

Este comando constrói a imagem Docker a partir do Dockerfile. Após a conclusão do build, inicie a aplicação:

sudo docker-compose up

Você verá logs indicando que o servidor Uvicorn está rodando e pronto para receber requisições.

Acessando sua aplicação FastAPI

Com o container em execução, você pode acessar sua aplicação de diferentes formas:

Documentação interativa (Swagger UI)
Navegue até http://localhost:8000/docs no seu navegador para acessar a documentação interativa automática gerada pelo FastAPI.

Documentação alternativa (ReDoc)
Acesse http://localhost:8000/redoc para visualizar uma documentação alternativa com design diferente.

Testando a API
Você pode fazer requisições POST para http://localhost:8000/analyzer-sentiment/ enviando um JSON no formato:

{
  "text": "Esta é uma aplicação incrível!"
}

Gerenciando seu container Docker (opcional)

Aqui estão alguns comandos úteis para gerenciar seu ambiente containerizado:

Para parar o container

Pressione Ctrl + C ou Command + . no terminal onde o Docker Compose está rodando.

Para executar em background

Use a flag -d (detached mode):

sudo docker-compose up -d

Para parar e remover containers

sudo docker-compose down

Para visualizar logs

sudo docker-compose logs -f

Para listar containers ativos

sudo docker ps

Próximos passos e otimizações

Agora que você tem uma aplicação FastAPI rodando com Docker Compose, considere estas melhorias:

1. Adicione variáveis de ambiente

Crie um arquivo .env para gerenciar configurações sensíveis:

APP_ENV=production
DATABASE_URL=postgresql://user:password@db:5432/dbname

2. Configure volumes para persistência de dados

Modifique o docker-compose.yml para incluir volumes persistentes:

volumes:
  - ./data:/app/data

3. Implemente health checks

Adicione verificações de saúde ao seu serviço:

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost/health"]
  interval: 30s
  timeout: 10s
  retries: 3

4. Configure múltiplos serviços

Adicione banco de dados ao seu docker-compose.yml:

services:
  web:
    # configuração existente
  
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: senha123
      POSTGRES_DB: meuapp

Perguntas frequentes

Q: Posso usar este setup em produção?
A: Sim, mas considere adicionar configurações de segurança, reverse proxy (como Nginx), certificados SSL e monitoramento.

Q: Como atualizo minha aplicação?
A: Faça as alterações no código, reconstrua a imagem com docker-compose build e reinicie com docker-compose up.

Q: O Docker Compose é adequado para escalabilidade?
A: Para desenvolvimento, sim. Para produção em larga escala, considere Kubernetes ou Docker Swarm.

Q: Como faço backup dos dados?
A: Use volumes Docker nomeados e ferramentas como docker cp ou backup automático de volumes.

Conclusão

Neste tutorial, você aprendeu como criar e configurar uma aplicação FastAPI completa em um servidor Ubuntu utilizando Docker Compose. Esta combinação oferece desenvolvimento ágil, deployment simplificado e uma base sólida para aplicações modernas que integram machine learning e APIs de alta performance.

Com FastAPI e Docker, você tem nas mãos ferramentas poderosas para construir aplicações robustas e escaláveis. O próximo passo é explorar recursos avançados do FastAPI, como autenticação JWT, WebSockets, e integração com bancos de dados.

Compartilhe suas experiências e dúvidas nos comentários abaixo. Feliz coding!