vendaweb-api/docs/deployment.md

Deploy e Configuração - DRE Gerencial

Visão Geral

Este guia cobre o processo completo de deploy e configuração do sistema DRE Gerencial em diferentes ambientes.

Pré-requisitos

1. Ambiente de Desenvolvimento

• Node.js 18+
• PostgreSQL 13+
• npm ou yarn
• Git

2. Ambiente de Produção

• Servidor Linux (Ubuntu 20.04+ recomendado)
• PostgreSQL 13+
• Nginx (opcional, para proxy reverso)
• PM2 ou similar (para gerenciamento de processos)

Configuração do Ambiente

1. Variáveis de Ambiente

Desenvolvimento (.env.local)

# Database
POSTGRES_DB=dre_gerencial
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=postgres
POSTGRES_PASSWORD=dev_password

# Next.js
NEXT_PUBLIC_APP_URL=http://localhost:3000
NODE_ENV=development

Produção (.env.production)

# Database
POSTGRES_DB=dre_gerencial_prod
POSTGRES_HOST=prod-db-host
POSTGRES_PORT=5432
POSTGRES_USER=prod_user
POSTGRES_PASSWORD=secure_prod_password

# Next.js
NEXT_PUBLIC_APP_URL=https://dre-gerencial.com
NODE_ENV=production

# Security
NEXTAUTH_SECRET=your-secret-key
NEXTAUTH_URL=https://dre-gerencial.com

2. Configuração do Banco de Dados

Desenvolvimento

# Criar banco de desenvolvimento
createdb dre_gerencial

# Conectar e verificar
psql -h localhost -U postgres -d dre_gerencial

Produção

# Criar usuário e banco de produção
sudo -u postgres psql
CREATE USER prod_user WITH PASSWORD 'secure_prod_password';
CREATE DATABASE dre_gerencial_prod OWNER prod_user;
GRANT ALL PRIVILEGES ON DATABASE dre_gerencial_prod TO prod_user;
\q

Deploy Local

1. Desenvolvimento

# Instalar dependências
npm install

# Executar migrações
npx drizzle-kit migrate

# Iniciar servidor de desenvolvimento
npm run dev

2. Build de Produção Local

# Build otimizado
npm run build

# Iniciar servidor de produção
npm run start

Deploy em Servidor

1. Preparação do Servidor

Instalar Node.js

# Ubuntu/Debian
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# Verificar instalação
node --version
npm --version

Instalar PostgreSQL

# Ubuntu/Debian
sudo apt update
sudo apt install postgresql postgresql-contrib

# Iniciar serviço
sudo systemctl start postgresql
sudo systemctl enable postgresql

Instalar PM2 (Gerenciador de Processos)

# Instalar PM2 globalmente
sudo npm install -g pm2

# Configurar PM2 para iniciar com o sistema
pm2 startup
pm2 save

2. Deploy da Aplicação

Clonar Repositório

# Criar diretório da aplicação
sudo mkdir -p /var/www/dre-gerencial
sudo chown $USER:$USER /var/www/dre-gerencial

# Clonar repositório
cd /var/www/dre-gerencial
git clone <repository-url> .

# Instalar dependências
npm install --production

Configurar Variáveis de Ambiente

# Criar arquivo de ambiente de produção
cp .env.example .env.production

# Editar variáveis
nano .env.production

Build da Aplicação

# Build para produção
npm run build

# Verificar se build foi bem-sucedido
ls -la .next/

Configurar PM2

# Criar arquivo de configuração PM2
cat > ecosystem.config.js << EOF
module.exports = {
  apps: [{
    name: 'dre-gerencial',
    script: 'npm',
    args: 'start',
    cwd: '/var/www/dre-gerencial',
    instances: 1,
    autorestart: true,
    watch: false,
    max_memory_restart: '1G',
    env: {
      NODE_ENV: 'production',
      PORT: 3000
    }
  }]
};
EOF

# Iniciar aplicação
pm2 start ecosystem.config.js

# Verificar status
pm2 status
pm2 logs dre-gerencial

3. Configuração do Nginx (Opcional)

Instalar Nginx

sudo apt install nginx
sudo systemctl start nginx
sudo systemctl enable nginx

Configurar Proxy Reverso

# Criar configuração do site
sudo nano /etc/nginx/sites-available/dre-gerencial

# Conteúdo do arquivo
server {
    listen 80;
    server_name dre-gerencial.com www.dre-gerencial.com;

    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_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;
        proxy_cache_bypass $http_upgrade;
    }
}

# Habilitar site
sudo ln -s /etc/nginx/sites-available/dre-gerencial /etc/nginx/sites-enabled/

# Testar configuração
sudo nginx -t

# Recarregar Nginx
sudo systemctl reload nginx

Configurar SSL com Let's Encrypt

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

# Obter certificado SSL
sudo certbot --nginx -d dre-gerencial.com -d www.dre-gerencial.com

# Verificar renovação automática
sudo certbot renew --dry-run

Deploy com Docker

1. Dockerfile

# Dockerfile
FROM node:18-alpine AS base

# Install dependencies only when needed
FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app

# Install dependencies based on the preferred package manager
COPY package.json package-lock.json* ./
RUN npm ci --only=production

# Rebuild the source code only when needed
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Build the application
RUN npm run build

# Production image, copy all the files and run next
FROM base AS runner
WORKDIR /app

ENV NODE_ENV production

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public

# Set the correct permission for prerender cache
RUN mkdir .next
RUN chown nextjs:nodejs .next

# Automatically leverage output traces to reduce image size
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT 3000
ENV HOSTNAME "0.0.0.0"

CMD ["node", "server.js"]

2. Docker Compose

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - POSTGRES_DB=dre_gerencial
      - POSTGRES_HOST=db
      - POSTGRES_PORT=5432
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=dre_gerencial
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    restart: unless-stopped

volumes:
  postgres_data:

3. Deploy com Docker

# Build e executar
docker-compose up -d

# Verificar logs
docker-compose logs -f app

# Parar serviços
docker-compose down

Deploy Automatizado

1. GitHub Actions

Workflow de Deploy

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        cache: 'npm'
    
    - name: Install dependencies
      run: npm ci
    
    - name: Run tests
      run: npm test
    
    - name: Build application
      run: npm run build
    
    - name: Deploy to server
      uses: appleboy/ssh-action@v0.1.5
      with:
        host: ${{ secrets.HOST }}
        username: ${{ secrets.USERNAME }}
        key: ${{ secrets.SSH_KEY }}
        script: |
          cd /var/www/dre-gerencial
          git pull origin main
          npm ci --production
          npm run build
          pm2 restart dre-gerencial          

2. Configuração de Secrets

No GitHub, adicionar os seguintes secrets:

• HOST: IP do servidor
• USERNAME: usuário do servidor
• SSH_KEY: chave SSH privada

Monitoramento

1. PM2 Monitoring

# Monitorar aplicação
pm2 monit

# Ver logs em tempo real
pm2 logs dre-gerencial --lines 100

# Reiniciar aplicação
pm2 restart dre-gerencial

# Parar aplicação
pm2 stop dre-gerencial

2. Logs do Sistema

# Logs do Nginx
sudo tail -f /var/log/nginx/access.log
sudo tail -f /var/log/nginx/error.log

# Logs do PostgreSQL
sudo tail -f /var/log/postgresql/postgresql-13-main.log

3. Monitoramento de Recursos

# Uso de CPU e memória
htop

# Espaço em disco
df -h

# Status dos serviços
systemctl status nginx
systemctl status postgresql

Backup e Restore

1. Backup do Banco de Dados

# Backup completo
pg_dump -h localhost -U postgres -d dre_gerencial_prod > backup_$(date +%Y%m%d).sql

# Backup apenas dados
pg_dump -h localhost -U postgres -d dre_gerencial_prod --data-only > data_backup_$(date +%Y%m%d).sql

# Backup apenas schema
pg_dump -h localhost -U postgres -d dre_gerencial_prod --schema-only > schema_backup_$(date +%Y%m%d).sql

2. Restore do Banco de Dados

# Restore completo
psql -h localhost -U postgres -d dre_gerencial_prod < backup_20240101.sql

# Restore apenas dados
psql -h localhost -U postgres -d dre_gerencial_prod < data_backup_20240101.sql

3. Backup Automático

# Criar script de backup
cat > /home/user/backup_dre.sh << EOF
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/home/user/backups"
DB_NAME="dre_gerencial_prod"

mkdir -p $BACKUP_DIR

# Backup do banco
pg_dump -h localhost -U postgres -d $DB_NAME > $BACKUP_DIR/dre_backup_$DATE.sql

# Manter apenas os últimos 7 backups
cd $BACKUP_DIR
ls -t dre_backup_*.sql | tail -n +8 | xargs -r rm

echo "Backup completed: dre_backup_$DATE.sql"
EOF

# Tornar executável
chmod +x /home/user/backup_dre.sh

# Agendar backup diário
crontab -e
# Adicionar linha:
0 2 * * * /home/user/backup_dre.sh

Troubleshooting

1. Problemas Comuns

Aplicação não inicia

# Verificar logs
pm2 logs dre-gerencial

# Verificar se porta está em uso
netstat -tlnp | grep :3000

# Verificar variáveis de ambiente
pm2 env 0

Erro de conexão com banco

# Verificar se PostgreSQL está rodando
sudo systemctl status postgresql

# Testar conexão
psql -h localhost -U postgres -d dre_gerencial_prod

# Verificar logs do PostgreSQL
sudo tail -f /var/log/postgresql/postgresql-13-main.log

Erro de permissões

# Verificar permissões do diretório
ls -la /var/www/dre-gerencial

# Corrigir permissões
sudo chown -R $USER:$USER /var/www/dre-gerencial
chmod -R 755 /var/www/dre-gerencial

2. Comandos Úteis

Reiniciar serviços

# Reiniciar aplicação
pm2 restart dre-gerencial

# Reiniciar Nginx
sudo systemctl restart nginx

# Reiniciar PostgreSQL
sudo systemctl restart postgresql

Verificar status

# Status da aplicação
pm2 status

# Status dos serviços do sistema
sudo systemctl status nginx postgresql

# Uso de recursos
free -h
df -h

Próximos Passos

1. Implementar CI/CD completo
2. Adicionar monitoramento com Prometheus/Grafana
3. Implementar backup automatizado
4. Adicionar alertas por email/Slack
5. Implementar load balancing para alta disponibilidade
6. Adicionar CDN para assets estáticos
7. Implementar cache com Redis
8. Adicionar health checks automatizados