# Deploy em Produção

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

## Índice

1. [Requisitos](#requisitos)
2. [Variáveis de Ambiente](#variáveis-de-ambiente)
3. [Deploy com Docker](#deploy-com-docker)
4. [Scripts de Backup](#scripts-de-backup)
5. [Monitoramento e Manutenção](#monitoramento-e-manutenção)
6. [Troubleshooting](#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

```bash
# 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`

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

### Variáveis Obrigatórias

```bash
# ===== 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

```bash
openssl rand -base64 32
```

---

## Deploy com Docker

### 1. Preparar Servidor

```bash
# 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

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

### 3. Iniciar Serviços

```bash
# 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

```bash
# 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):

```nginx
# /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;
    }
}
```

```bash
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)

```bash
# 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`:

```bash
#!/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`:

```bash
#!/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

```bash
# 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

```bash
# 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

```bash
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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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 |