433 lines
9.0 KiB
Markdown
433 lines
9.0 KiB
Markdown
# 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 |
|