Skip to content

DOCKER_DEPLOY.md

Latest commit

 

History

History
530 lines (388 loc) · 11.8 KB

DOCKER_DEPLOY.md

File metadata and controls

530 lines (388 loc) · 11.8 KB

🐳 Guia de Deploy com Docker - DigiVerse

Este guia detalha como executar o DigiVerse usando Docker, permitindo que frontend e backend rodem de forma independente.

📋 Índice

🎯 Visão Geral

A infraestrutura Docker do DigiVerse consiste em 4 serviços:

Serviço Descrição Porta Container Name
web Frontend React com Nginx 80 digiverse_web
backend API Fastify 3000 digiverse_backend
postgres Banco de dados PostgreSQL 5432 digiverse_postgres
redis Cache Redis 6379 digiverse_redis

Características

  • ✅ Frontend Independente: Frontend pode rodar mesmo com backend em manutenção
  • ✅ Multi-stage Builds: Builds otimizados para produção
  • ✅ Health Checks: Monitoramento automático de saúde dos serviços
  • ✅ Volumes Persistentes: Dados do PostgreSQL e Redis preservados
  • ✅ Network Isolation: Serviços em rede isolada
  • ✅ Auto-restart: Reinício automático em caso de falha

📦 Pré-requisitos

  • Docker >= 20.10
  • Docker Compose >= 2.0
  • Mínimo 2GB RAM disponível
  • Mínimo 5GB espaço em disco

Instalação do Docker

# Linux (Ubuntu/Debian)
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Verificar instalação
docker --version
docker-compose --version

⚙️ Configuração Inicial

1. Variáveis de Ambiente

# Copiar arquivo de exemplo
cp .env.example .env

# Editar variáveis (use seu editor preferido)
nano .env

Variáveis importantes:

# Database
DB_USER=postgres
DB_PASSWORD=senha-segura-aqui
DB_NAME=digimon_db

# JWT (MUDE ISSO EM PRODUÇÃO!)
JWT_SECRET=sua-chave-super-secreta-com-pelo-menos-32-caracteres

# Frontend
WEB_PORT=80
VITE_API_URL=http://localhost:3000

# Backend
PORT=3000

2. Primeira Execução

# 1. Build das imagens
pnpm docker:build

# 2. Iniciar todos os serviços
pnpm docker:up

# 3. Verificar logs
pnpm docker:logs

Aguarde os serviços iniciarem (aproximadamente 1-2 minutos na primeira vez).

3. Acessar a Aplicação

🚀 Comandos Docker

Comandos Completos (Todos os Serviços)

# Build de todas as imagens
pnpm docker:build

# Iniciar todos os serviços em background
pnpm docker:up

# Parar todos os serviços
pnpm docker:down

# Ver logs de todos os serviços
pnpm docker:logs

# Rebuild completo (para mudanças no código)
pnpm docker:rebuild

# Limpar tudo (CUIDADO: apaga volumes/dados)
pnpm docker:clean

Comandos Específicos do Frontend

# Build apenas do frontend
pnpm docker:web:build

# Iniciar apenas o frontend (requer backend rodando)
pnpm docker:web:up

# Parar apenas o frontend
pnpm docker:web:down

# Ver logs do frontend
pnpm docker:web:logs

Comandos Específicos do Backend

# Build apenas do backend
docker-compose build backend

# Iniciar backend + infraestrutura (postgres + redis)
docker-compose up -d backend

# Parar backend
docker-compose stop backend

# Ver logs do backend
docker-compose logs -f backend

Comandos Docker Diretos

# Listar containers rodando
docker ps

# Ver todos os containers (incluindo parados)
docker ps -a

# Executar comandos dentro de um container
docker exec -it digiverse_backend sh
docker exec -it digiverse_web sh

# Ver logs de um container específico
docker logs digiverse_web
docker logs digiverse_backend
docker logs digiverse_postgres

# Reiniciar um serviço específico
docker restart digiverse_web

# Ver uso de recursos
docker stats

# Inspecionar saúde dos serviços
docker inspect --format='{{json .State.Health}}' digiverse_web | jq

🎬 Cenários de Uso

Cenário 1: Desenvolvimento Local com Docker

Ideal para testar o ambiente de produção localmente.

# 1. Iniciar tudo
pnpm docker:up

# 2. Ver logs em tempo real
pnpm docker:logs

# 3. Fazer mudanças no código
# (edite os arquivos normalmente)

# 4. Rebuild e reiniciar
pnpm docker:rebuild

Cenário 2: Frontend Standalone

Frontend rodando enquanto desenvolve o backend sem Docker.

# 1. Iniciar apenas infraestrutura (postgres + redis)
docker-compose up -d postgres redis

# 2. Iniciar backend em modo dev (local)
pnpm backend:dev

# 3. Build e iniciar frontend no Docker
pnpm docker:web:build
pnpm docker:web:up

# Frontend estará em http://localhost:80
# Backend em http://localhost:3000

Cenário 3: Manutenção do Backend

Manter frontend online enquanto atualiza o backend.

# 1. Parar apenas o backend
docker-compose stop backend

# 2. Frontend continua acessível em http://localhost:80
# (mostrará erros de conexão com API, mas interface funciona)

# 3. Fazer manutenção no backend...

# 4. Rebuild e reiniciar backend
docker-compose build backend
docker-compose up -d backend

# 5. Frontend volta a funcionar normalmente

Cenário 4: Testes de Integração

# 1. Subir tudo
pnpm docker:up

# 2. Aguardar health checks
sleep 30

# 3. Rodar testes contra containers
pnpm backend:test

# 4. Limpar ambiente
pnpm docker:down

Cenário 5: Deploy em Servidor

# 1. Clonar repositório no servidor
git clone https://github.com/CAFernandes/API-REST-Digimon.git
cd API-REST-Digimon

# 2. Configurar variáveis de produção
cp .env.example .env
nano .env  # Configurar com valores de produção

# 3. Build e iniciar
pnpm docker:build
pnpm docker:up

# 4. Verificar saúde
docker ps
pnpm docker:logs

🏗️ Arquitetura Docker

Dockerfile do Frontend (packages/web/Dockerfile)

Stage 1: Builder

  • Base: node:18-alpine
  • Instala pnpm
  • Copia dependências e código fonte
  • Executa build do Vite
  • Gera arquivos estáticos em /dist

Stage 2: Production

  • Base: nginx:1.25-alpine
  • Copia arquivos buildados do Stage 1
  • Configuração customizada do Nginx
  • Expõe porta 80
  • Health check em /health

Otimizações:

  • Multi-stage build reduz tamanho final (~150MB vs ~800MB)
  • Apenas arquivos necessários na imagem final
  • Gzip compression habilitado
  • Cache de assets estáticos

Dockerfile do Backend (packages/backend/Dockerfile)

Stage 1: Builder

  • Compila TypeScript para JavaScript
  • Gera Prisma Client

Stage 2: Production

  • Runtime mínimo (Alpine)
  • Executa migrations automaticamente
  • Seeds do banco se necessário
  • Health check em /health

Docker Compose Network

┌────────────────────────────────────────────┐
│         digiverse_network (bridge)         │
│                                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │   web    │  │ backend  │  │ postgres │  │
│  │  :80     │←→│  :3000   │←→│  :5432   │  │
│  └──────────┘  └──────────┘  └──────────┘  │
│                      ↓                     │
│                 ┌──────────┐               │
│                 │  redis   │               │
│                 │  :6379   │               │
│                 └──────────┘               │
└────────────────────────────────────────────┘

Comunicação:

  • web → backend: Requisições HTTP para API
  • backend → postgres: Queries via Prisma
  • backend → redis: Cache (opcional)

Volumes Persistentes

# Listar volumes
docker volume ls

# Inspecionar volume
docker volume inspect digiverse_postgres_data

# Backup do banco de dados
docker exec digiverse_postgres pg_dump -U postgres digiverse_db > backup.sql

# Restaurar backup
docker exec -i digiverse_postgres psql -U postgres digiverse_db < backup.sql

🔧 Troubleshooting

Frontend não carrega / Página em branco

# 1. Verificar se container está rodando
docker ps | grep digiverse_web

# 2. Verificar logs
docker logs digiverse_web

# 3. Verificar health check
docker inspect --format='{{json .State.Health}}' digiverse_web

# 4. Acessar container
docker exec -it digiverse_web sh
ls -la /usr/share/nginx/html  # Verificar arquivos buildados

# 5. Rebuild
pnpm docker:web:build
docker-compose up -d web --force-recreate

Backend não conecta ao banco

# 1. Verificar se postgres está saudável
docker inspect --format='{{json .State.Health}}' digiverse_postgres

# 2. Verificar conectividade
docker exec digiverse_backend ping postgres

# 3. Verificar variáveis de ambiente
docker exec digiverse_backend env | grep DB_

# 4. Verificar migrations
docker exec digiverse_backend npx prisma migrate status

Erro de CORS no frontend

Verifique se VITE_API_URL no .env aponta para o backend correto:

# Desenvolvimento local
VITE_API_URL=http://localhost:3000

# Produção
VITE_API_URL=https://api.seu-dominio.com

Rebuild o frontend após alterar:

pnpm docker:web:build
pnpm docker:web:up

Containers consomem muita memória

# Ver uso de recursos
docker stats

# Limitar memória no docker-compose.yml
services:
  web:
    deploy:
      resources:
        limits:
          memory: 256M
  backend:
    deploy:
      resources:
        limits:
          memory: 512M

Portas já em uso

# Verificar processo usando porta 80
sudo lsof -i :80
sudo lsof -i :3000

# Alterar portas no .env
WEB_PORT=8080
PORT=3001

# Reiniciar
pnpm docker:down
pnpm docker:up

🚀 Produção

Checklist de Produção

  • Alterar JWT_SECRET para valor seguro (32+ caracteres)
  • Alterar DB_PASSWORD para senha forte
  • Configurar REDIS_PASSWORD
  • Atualizar VITE_API_URL para URL de produção
  • Configurar SSL/TLS (HTTPS)
  • Configurar firewall (apenas portas 80/443)
  • Configurar backup automático do PostgreSQL
  • Configurar monitoramento (logs, métricas)
  • Testar disaster recovery

Configuração com SSL/HTTPS

Adicione um reverse proxy (Nginx ou Traefik) na frente:

# docker-compose.prod.yml
services:
  nginx-proxy:
    image: nginxproxy/nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
      - ./certs:/etc/nginx/certs

  web:
    environment:
      VIRTUAL_HOST: seu-dominio.com
      LETSENCRYPT_HOST: seu-dominio.com

Backup Automático

# Criar script de backup
cat > backup.sh << 'EOF'
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
docker exec digiverse_postgres pg_dump -U postgres digimon_db > backup_$DATE.sql
gzip backup_$DATE.sql
# Upload para S3, Google Cloud Storage, etc.
EOF

chmod +x backup.sh

# Agendar com cron (backup diário às 2am)
crontab -e
# Adicionar:
0 2 * * * /path/to/backup.sh

Monitoramento

Considere adicionar:

  • Prometheus + Grafana: Métricas
  • Loki: Agregação de logs
  • Sentry: Error tracking
  • Uptime Robot: Monitoramento de uptime

📚 Referências

🐳 DigiVerse - Containerized Digital Monsters Universe