Skip to content

Deploy

Esta seção descreve os processos e práticas para deploy da API de Gerenciamento de Carros em diferentes ambientes.

Visão Geral do Deploy

O processo de deploy da API pode ser realizado em diferentes ambientes:

  • Desenvolvimento: Ambiente local para desenvolvimento e testes
  • Homologação: Ambiente de testes pré-produção
  • Produção: Ambiente de acesso público com alta disponibilidade

Pré-requisitos para Deploy

Servidor

  • Sistema Operacional: Linux (Ubuntu 20.04 LTS ou superior recomendado)
  • Python: Versão 3.13 ou superior
  • Poetry: Gerenciador de dependências
  • Git: Para obtenção do código-fonte
  • Banco de Dados: PostgreSQL 12+ ou MySQL 8+ (recomendado para produção)

Recursos de Hardware

  • CPU: 2 ou mais núcleos
  • RAM: Mínimo de 2GB (recomendado 4GB+)
  • Disco: Mínimo de 5GB livres
  • Rede: Conexão estável com internet

Configuração de Ambiente

Variáveis de Ambiente para Produção

Crie um arquivo .env com as configurações específicas de produção:

# Banco de dados
DATABASE_URL=postgresql+asyncpg://usuario:senha@localhost:5432/car_api_prod

# Segurança
JWT_SECRET_KEY=sua_chave_super_secreta_segura_e_aleatoria_aqui
JWT_ALGORITHM=HS256
JWT_EXPIRATION_MINUTES=30

# Logging
LOG_LEVEL=INFO

Segurança de Chaves

  • Armazene a JWT_SECRET_KEY em um sistema de gerenciamento de segredos (como HashiCorp Vault, AWS Secrets Manager, etc.)
  • Nunca commite chaves secretas no repositório
  • Use diferentes chaves para cada ambiente

Métodos de Deploy

Deploy Tradicional

1. Obtenção do Código

# Clone o repositório
git clone <URL_DO_REPOSITORIO>
cd car_api

# Alterne para a versão desejada (tag ou branch)
git checkout v1.0.0  # ou a tag desejada

2. Instalação de Dependências

# Instale as dependências
poetry install --only=main --no-dev

# Opcional: Crie um ambiente virtual dedicado
poetry env use python3.13

3. Configuração do Banco de Dados

# Execute as migrações
poetry run alembic upgrade head

4. Execução da Aplicação

# Execute com Uvicorn em modo de produção
poetry run uvicorn car_api.app:app \
    --host 0.0.0.0 \
    --port 8000 \
    --workers 4 \
    --timeout-keep-alive 30 \
    --proxy-headers

Deploy com Docker

Dockerfile

FROM python:3.13-slim

WORKDIR /app

# Instale dependências do sistema
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Instale Poetry
RUN pip install poetry

# Copie arquivos de configuração
COPY pyproject.toml poetry.lock ./

# Instale dependências
RUN poetry config virtualenvs.create false
RUN poetry install --only=main --no-dev

# Copie código-fonte
COPY . .

# Execute migrações e inicie a aplicação
RUN poetry run alembic upgrade head

EXPOSE 8000

CMD ["uvicorn", "car_api.app:app", "--host", "0.0.0.0", "--port", "8000"]

docker-compose.yml

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql+asyncpg://car_api:senha_segura@db:5432/car_api
      - JWT_SECRET_KEY=${JWT_SECRET_KEY}
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:15
    environment:
      - POSTGRES_DB=car_api
      - POSTGRES_USER=car_api
      - POSTGRES_PASSWORD=senha_segura
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

Execução com Docker

# Suba os serviços
docker-compose up -d

# Verifique o status
docker-compose ps

Deploy em Nuvem

Heroku

  1. Prepare o arquivo Procfile:
web: uvicorn car_api.app:app --host 0.0.0.0 --port ${PORT:-5000}
  1. Configure variáveis de ambiente:
heroku config:set DATABASE_URL=...
heroku config:set JWT_SECRET_KEY=...
  1. Faça deploy:
git push heroku main

AWS

  1. Use Elastic Beanstalk ou ECS/EKS para deploy
  2. Configure RDS para banco de dados
  3. Use Parameter Store ou Secrets Manager para variáveis sensíveis

Google Cloud Platform

  1. Use Google App Engine ou Google Kubernetes Engine
  2. Configure Cloud SQL para banco de dados
  3. Use Secret Manager para variáveis sensíveis

Configurações de Produção

Servidor Web

Para produção, use um servidor ASGI como Uvicorn com múltiplos workers:

# Com múltiplos workers
poetry run uvicorn car_api.app:app \
    --host 0.0.0.0 \
    --port 8000 \
    --workers 4 \
    --timeout-keep-alive 30 \
    --proxy-headers \
    --forwarded-allow-ips '*'

Proxy Reverso

Configure um proxy reverso como Nginx:

server {
    listen 80;
    server_name seu-dominio.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

SSL/TLS

Configure HTTPS usando Let's Encrypt:

# Instale certbot
sudo apt install certbot python3-certbot-nginx

# Obtenha certificado
sudo certbot --nginx -d seu-dominio.com

Monitoramento e Logging

Logging

Configure logging adequado para produção:

import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

Monitoramento

Implemente soluções de monitoramento:

  • Métricas: Prometheus + Grafana
  • Tracing: Jaeger ou OpenTelemetry
  • Alertas: Configuração de alertas para falhas críticas

Estratégias de Deploy

Blue-Green Deploy

Execute duas versões idênticas do aplicativo (blue e green) e alterne o tráfego entre elas:

  1. A versão green está ativa
  2. Implemente a nova versão na instância blue
  3. Teste a instância blue
  4. Alterne o tráfego para a instância blue
  5. A instância green agora está disponível para o próximo deploy

Canary Deploy

Gradualmente direcione parte do tráfego para a nova versão:

  1. Implemente a nova versão com capacidade reduzida
  2. Direcione 5% do tráfego para a nova versão
  3. Monitore métricas e erros
  4. Gradualmente aumente o tráfego (10%, 25%, 50%, 100%)
  5. Desative a versão antiga

Rollback

Tenha um plano de rollback para reverter rapidamente para uma versão estável:

# Com Docker
docker-compose down
git checkout <versao_anterior>
docker-compose up -d

# Com Git
git checkout <versao_anterior>
poetry install
poetry run alembic downgrade <versao_anterior>
systemctl restart car_api

Backup e Recuperação

Backup de Dados

Configure backups regulares do banco de dados:

# Exemplo para PostgreSQL
pg_dump -h localhost -U car_api -d car_api > backup_$(date +%Y%m%d_%H%M%S).sql

# Agende com cron
0 2 * * * pg_dump -h localhost -U car_api -d car_api > /backups/backup_$(date +%Y%m%d).sql

Recuperação de Dados

# Recuperar backup
psql -h localhost -U car_api -d car_api < backup_arquivo.sql

Checklist de Deploy

Antes de cada deploy, verifique:

  • [ ] Testes automatizados passaram
  • [ ] Cobertura de testes está acima do limite
  • [ ] Banco de dados está acessível
  • [ ] Variáveis de ambiente estão configuradas
  • [ ] Chaves de segurança estão seguras
  • [ ] Configurações de produção estão corretas
  • [ ] Monitoramento está configurado
  • [ ] Plano de rollback está disponível
  • [ ] Equipe está ciente do deploy
  • [ ] Horário apropriado para deploy foi escolhido

Melhores Práticas

Segurança

  • Use HTTPS em todos os ambientes
  • Mantenha dependências atualizadas
  • Revise permissões de acesso regularmente
  • Implemente logging de eventos de segurança

Performance

  • Monitore tempo de resposta
  • Implemente cache quando apropriado
  • Otimize consultas ao banco de dados
  • Use CDNs para conteúdo estático

Manutenibilidade

  • Documente o processo de deploy
  • Automatize o máximo possível
  • Use versionamento semântico
  • Mantenha logs claros e úteis

Com estas práticas e configurações, você poderá realizar deploys seguros, confiáveis e eficientes da API de Gerenciamento de Carros.