herrmartins/course-plat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8fcb5aac66a6cfb82d952a78075d024221bbb2ca
course-plat/DEPLOYMENT.md
T
Rafael Dias Martins 8fcb5aac66 Initial commit
2026-08-31 14:10:20 -03:00

9.0 KiB
Raw Blame History

Deploy em Produção

Guia completo para deploy da aplicação Course Plat em VPS/servidor.

Índice

  1. Requisitos
  2. Variáveis de Ambiente
  3. Deploy com Docker
  4. Scripts de Backup
  5. Monitoramento e Manutenção
  6. Troubleshooting

Requisitos

Servidor

  • Ubuntu 22.04+ ou similar
  • 2GB RAM (mínimo), 4GB+ recomendado
  • 20GB+ de disco
  • Docker e Docker Compose instalados

Instalação do Docker

# Atualizar sistema
sudo apt update && sudo apt upgrade -y

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Instalar Docker Compose
sudo apt install docker-compose-plugin -y

# Adicionar usuário ao grupo docker
sudo usermod -aG docker $USER
newgrp docker

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

Variáveis de Ambiente

Criar arquivo .env.production

cd /path/to/course-plat
cp .env.example .env.production
nano .env.production

Variáveis Obrigatórias

# ===== NEXT.JS =====
NODE_ENV=production
NEXTAUTH_URL=https://seu-dominio.com.br
NEXTAUTH_SECRET=gerar-um-segredo-aleatorio-min-32-caracteres

# ===== MONGODB =====
MONGO_USERNAME=admin
MONGO_PASSWORD=senha-forte-aqui
MONGO_DB=course-plat

# ===== STORAGE (MinIO) =====
STORAGE_TYPE=s3  # ou "local" para armazenamento em disco
S3_ENDPOINT=http://minio:9000  # interno do docker
S3_REGION=us-east-1
S3_ACCESS_KEY=minioadmin  # mesmo que MINIO_ROOT_USER
S3_SECRET_KEY=minioadmin  # mesmo que MINIO_ROOT_PASSWORD
S3_BUCKET=course-plat

# ===== MINIO =====
MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=senha-forte-aqui
MINIO_BUCKET=course-plat

# ===== APP =====
APP_PORT=3000

Gerar NEXTAUTH_SECRET

openssl rand -base64 32

Deploy com Docker

1. Preparar Servidor

# Clonar repositório
git clone seu-repositorio.git /var/www/course-plat
cd /var/www/course-plat

# Criar arquivo de ambiente
cp .env.example .env.production
nano .env.production  # preencher variáveis

2. Buildar Imagem

# Build da imagem da aplicação
docker build -f docker/production/Dockerfile -t course-plat:latest .

3. Iniciar Serviços

# Iniciar todos os serviços
docker compose -f docker/production/docker-compose.yml up -d

# Ver status
docker compose -f docker/production/docker-compose.yml ps

# Ver logs
docker compose -f docker/production/docker-compose.yml logs -f app

4. Configurar Firewall

# UFW - Ubuntu/Debian
sudo ufw allow 22/tcp   # SSH
sudo ufw allow 80/tcp   # HTTP
sudo ufw allow 443/tcp  # HTTPS
sudo ufw enable

5. Configurar Reverse Proxy (Opcional)

Se usar Nginx no host (não container):

# /etc/nginx/sites-available/course-plat
server {
    listen 80;
    server_name seu-dominio.com.br;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        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;
    }
}

sudo ln -s /etc/nginx/sites-available/course-plat /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

6. SSL com Certbot (Let's Encrypt)

# Instalar Certbot
sudo apt install certbot python3-certbot-nginx -y

# Obter certificado
sudo certbot --nginx -d seu-dominio.com.br

# Renovação automática já é configurada
sudo certbot renew --dry-run

Scripts de Backup

Backup MongoDB

Criar docker/production/backup-mongodb.sh:

#!/bin/bash
# Backup MongoDB em produção

BACKUP_DIR="/var/backups/course-plat/mongodb"
RETENTION_DAYS=7
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
CONTAINER_NAME="course-plat-mongodb"

mkdir -p "$BACKUP_DIR"

# Backup
docker exec "$CONTAINER_NAME" mongodump \
  --uri="mongodb://${MONGO_USERNAME}:${MONGO_PASSWORD}@localhost:27017/${MONGO_DB}?authSource=admin" \
  --archive="$BACKUP_DIR/mongodb-$TIMESTAMP.gz" \
  --gzip

echo "Backup MongoDB concluído: mongodb-$TIMESTAMP.gz"

# Remover backups antigos
find "$BACKUP_DIR" -name "mongodb-*.gz" -mtime +$RETENTION_DAYS -delete

Backup Completo

Criar docker/production/backup-all.sh:

#!/bin/bash
# Backup completo do sistema

TIMESTAMP=$(date +%Y%m%d-%H%M%S)
BACKUP_BASE="/var/backups/course-plat"

# Backup MongoDB
./docker/production/backup-mongodb.sh

# Backup MinIO
./docker/minio/backup-minio.sh

# Backup volumes Docker
docker run --rm \
  -v course-plat_mongodb_data:/data/mongo \
  -v course-plat_minio_data:/data/minio \
  -v course-plat_app_storage:/data/app \
  -v "$BACKUP_BASE":/backup \
  alpine tar czf "/backup/volumes-$TIMESTAMP.tar.gz" -C /data .

echo "Backup completo concluído!"

Configurar Cron

# Tornar scripts executáveis
chmod +x docker/production/backup-mongodb.sh
chmod +x docker/production/backup-all.sh

# Editar crontab
crontab -e

# Adicionar:
# 0 2 * * * cd /var/www/course-plat && ./docker/production/backup-all.sh >> /var/log/course-plat-backup.log 2>&1

Monitoramento e Manutenção

Ver Status dos Serviços

# Status completo
docker compose -f docker/production/docker-compose.yml ps

# Logs em tempo real
docker compose -f docker/production/docker-compose.yml logs -f

# Logs de serviço específico
docker compose -f docker/production/docker-compose.yml logs -f app
docker compose -f docker/production/docker-compose.yml logs -f mongodb
docker compose -f docker/production/docker-compose.yml logs -f minio

Atualizar Aplicação

cd /var/www/course-plat

# Pull do código
git pull origin main

# Rebuildar
docker build -f docker/production/Dockerfile -t course-plat:latest .

# Recrear container
docker compose -f docker/production/docker-compose.yml up -d --force-recreate app

Acessar MongoDB

# Terminal do MongoDB
docker exec -it course-plat-mongodb mongosh -u admin -p

# Comando restore
docker exec -i course-plat-mongodb mongorestore \
  --uri="mongodb://admin:password@localhost:27017/course-plat?authSource=admin" \
  --gzip --archive < backup.gz

Acessar MinIO

# Terminal do MinIO
docker exec -it course-plat-minio sh

# Usar mc (MinIO Client)
docker exec -it course-plat-minio mc alias set local http://localhost:9000 minioadmin minioadmin
docker exec -it course-plat-minio mc ls local/course-plat

Troubleshooting

App não inicia

# Ver logs
docker compose -f docker/production/docker-compose.yml logs app

# Entrar no container
docker exec -it course-plat-app sh

# Ver variáveis de ambiente
docker exec course-plat-app env

MongoDB não conecta

# Ver se container está rodando
docker ps | grep mongo

# Testar conexão
docker exec course-plat-mongodb mongosh --eval "db.adminCommand('ping')"

# Ver logs
docker logs course-plat-mongodb

MinIO com Access Denied

# Verificar política do bucket
docker exec course-plat-minio mc anonymous get local/course-plat

# Setar como privado (se necessário)
docker exec course-plat-minio mc anonymous set none local/course-plat

# Verificar credenciais
docker exec course-plat-minio mc admin user list local

Espaço em disco

# Ver uso de disco
df -h

# Limpar volumes não usados
docker volume prune

# Limpar imagens antigas
docker image prune -a

# Ver tamanho dos volumes
docker system df -v

Performance

# Métricas do container
docker stats course-plat-app course-plat-mongodb course-plat-minio

# Ver processo Node.js
docker exec course-plat-app ps aux

# Memória do MongoDB
docker exec course-plat-mongodb mongosh --eval "db.serverStatus().mem"

Comandos Úteis

# Reiniciar todos os serviços
docker compose -f docker/production/docker-compose.yml restart

# Parar tudo
docker compose -f docker/production/docker-compose.yml down

# Parar e remover volumes
docker compose -f docker/production/docker-compose.yml down -v

# Ver recursos usados
docker system df

# Limpar build cache
docker builder prune

# Backup rápido do MongoDB
docker exec course-plat-mongodb mongodump --gzip --archive > backup-$(date +%Y%m%d).gz

# Restore do MongoDB
docker exec -i course-plat-mongodb mongorestore --gzip --archive < backup-YYYYMMDD.gz

Segurança

  1. Senhas fortes: Use senhas únicas e fortes para todos os serviços
  2. Firewall: Mantenha apenas portas necessárias abertas
  3. SSL: Sempre use HTTPS em produção
  4. Backups: Teste restores regularmente
  5. Atualizações: Mantenha Docker e sistema atualizados
  6. Monitoring: Configure alertas para disco, CPU e memória

URLs de Acesso

Serviço URL
Aplicação https://seu-dominio.com.br
MinIO Console (interna) http://localhost:9001
Mongo Express (opcional) http://localhost:8081
API Health Check https://seu-dominio.com.br/api/health
Reference in New Issue View Git Blame Copy Permalink