Implantar Next.js no EC2 / Servidor Standalone

# No seu servidor (Ubuntu 22.04+)
# 1. Compile o pacote de produção
NODE_ENV=production npm ci
NODE_ENV=production npx next build
 
# 2. Inicie com PM2 (gerenciador de processos)
npm install -g pm2
pm2 start npm --name "myapp" -- start
pm2 save
pm2 startup
 
# 3. Proxy reverso Nginx (após instalar nginx)
sudo apt install nginx certbot python3-certbot-nginx -y
sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
 
# 4. Certificado SSL
sudo certbot --nginx -d myapp.com -d www.myapp.com
 
# 5. Verifique
curl -I https://myapp.com

# Se estiver usando ufw diretamente no servidor
sudo ufw allow 22/tcp    # SSH
sudo ufw allow 80/tcp    # HTTP (Nginx)
sudo ufw allow 443/tcp   # HTTPS (Nginx)
sudo ufw enable

# Instale o nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
 
# Instale o Node.js 20 LTS
nvm install 20
nvm alias default 20
node -v  # v20.x.x

sudo adduser --disabled-password nextjs
sudo usermod -aG sudo nextjs
sudo su - nextjs

# Clone seu repositório
git clone https://github.com/your-org/your-app.git /home/nextjs/app
cd /home/nextjs/app
 
# Instale as dependências de produção
npm ci
 
# Compile para produção
NODE_ENV=production npx next build

.next/
├── cache/              # Cache ISR, cache de otimização de imagem, cache de build
├── server/             # Pacotes do lado do servidor (App Router pages, API routes)
│   ├── app/            # Páginas compiladas do App Router
│   ├── chunks/         # Chunks compartilhados do servidor
│   └── pages/          # Páginas compiladas do Pages Router (se houver)
├── static/             # Pacotes JS/CSS do lado do cliente (com fingerprint)
│   └── chunks/         # Pacotes do cliente com code-split
├── BUILD_ID            # Identificador único da compilação
├── build-manifest.json # Mapeia rotas para pacotes do cliente
└── trace               # Dados de rastreamento da compilação

NODE_ENV=production npx next start -p 3000
# Visite http://<ip-do-servidor>:3000 para verificar, depois Ctrl+C

# .env.production
# Apenas do lado do servidor (não exposto ao navegador)
DATABASE_URL="postgresql://user:pass@db-host:5432/mydb"
NEXTAUTH_SECRET="your-secret-key-here"
NEXTAUTH_URL="https://myapp.com"
 
# Lado do cliente (incorporado no pacote JS no momento da COMPILAÇÃO)
NEXT_PUBLIC_API_URL="https://api.myapp.com"
NEXT_PUBLIC_POSTHOG_KEY="phc_xxxxxxxxxxxx"

// ecosystem.config.js
module.exports = {
  apps: [
    {
      name: "myapp",
      script: "node_modules/.bin/next",
      args: "start -p 3000",
      cwd: "/home/nextjs/app",
      env: {
        NODE_ENV: "production",
        DATABASE_URL: "postgresql://user:pass@db-host:5432/mydb",
        NEXTAUTH_SECRET: "your-secret-key-here",
        NEXTAUTH_URL: "https://myapp.com",
      },
    },
  ],
};

# Instale o PM2 globalmente
npm install -g pm2

// ecosystem.config.js
module.exports = {
  apps: [
    {
      name: "myapp",
      script: "node_modules/.bin/next",
      args: "start -p 3000",
      cwd: "/home/nextjs/app",
      instances: "max",          // Use todos os núcleos de CPU disponíveis
      exec_mode: "cluster",      // Modo cluster para balanceamento de carga
      max_memory_restart: "512M", // Reinicie se a memória exceder 512MB
      env: {
        NODE_ENV: "production",
        PORT: 3000,
      },
      // Logging
      error_file: "/home/nextjs/logs/err.log",
      out_file: "/home/nextjs/logs/out.log",
      log_date_format: "YYYY-MM-DD HH:mm:ss Z",
      merge_logs: true,
    },
  ],
};

# Crie o diretório de logs
mkdir -p /home/nextjs/logs
 
# Inicie o aplicativo
pm2 start ecosystem.config.js
 
# Salve a lista de processos (para que o PM2 saiba o que reiniciar após a reinicialização)
pm2 save
 
# Gere o script de inicialização (execute o comando que ele exibe como root)
pm2 startup
# Copie e cole o comando gerado, por exemplo:
# sudo env PATH=$PATH:/home/nextjs/.nvm/versions/node/v20.x.x/bin pm2 startup systemd -u nextjs --hp /home/nextjs
 
# Verifique se os processos estão em execução
pm2 ls

sudo apt install nginx -y

# /etc/nginx/sites-available/myapp
upstream nextjs_upstream {
    server 127.0.0.1:3000;
    keepalive 64;
}
 
server {
    listen 80;
    server_name myapp.com www.myapp.com;
 
    # Redirecione todo o HTTP para HTTPS
    return 301 https://$host$request_uri;
}
 
server {
    listen 443 ssl http2;
    server_name myapp.com www.myapp.com;
 
    # Certificados SSL (gerenciados pelo certbot)
    ssl_certificate /etc/letsencrypt/live/myapp.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/myapp.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
 
    # Compressão Gzip
    gzip on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript image/svg+xml;
 
    # Cabeçalhos de segurança
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
 
    # Sirva os ativos estáticos do Next.js diretamente do Nginx (contorna o Node.js)
    location /_next/static/ {
        alias /home/nextjs/app/.next/static/;
        expires 365d;
        access_log off;
        add_header Cache-Control "public, immutable";
    }
 
    # Sirva os ativos do diretório public diretamente
    location /public/ {
        alias /home/nextjs/app/public/;
        expires 30d;
        access_log off;
    }
 
    # Favicon e robots.txt
    location = /favicon.ico {
        alias /home/nextjs/app/public/favicon.ico;
        access_log off;
    }
 
    # Proxy todas as outras requisições para o Next.js
    location / {
        proxy_pass http://nextjs_upstream;
        proxy_http_version 1.1;
 
        # Cabeçalhos necessários
        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_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Port $server_port;
 
        # Suporte WebSocket (necessário para streaming de Server Actions, HMR em dev)
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
 
        # Timeouts
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
 
        # Buffering
        proxy_buffering on;
        proxy_buffer_size 128k;
        proxy_buffers 4 256k;
    }
}

sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default  # Remova o site padrão
sudo nginx -t                              # Teste a configuração
sudo systemctl reload nginx

# Instale o certbot
sudo apt install certbot python3-certbot-nginx -y
 
# Obtenha e instale o certificado (o plugin Nginx configura o SSL automaticamente)
sudo certbot --nginx -d myapp.com -d www.myapp.com
 
# Verifique se a renovação automática está configurada
sudo certbot renew --dry-run
 
# O Certbot instala um timer systemd automaticamente; verifique-o:
sudo systemctl list-timers | grep certbot

#!/bin/bash
# /home/nextjs/deploy.sh
set -euo pipefail
 
APP_DIR="/home/nextjs/app"
LOG_FILE="/home/nextjs/logs/deploy-$(date +%Y%m%d-%H%M%S).log"
 
echo "=== Implantação iniciada em $(date) ===" | tee "$LOG_FILE"
 
cd "$APP_DIR"
 
# Puxe o código mais recente
echo "Puxando o código mais recente..." | tee -a "$LOG_FILE"
git pull origin main 2>&1 | tee -a "$LOG_FILE"
 
# Instale as dependências (ci para instalações limpas)
echo "Instalando dependências..." | tee -a "$LOG_FILE"
npm ci 2>&1 | tee -a "$LOG_FILE"
 
# Compile o aplicativo
echo "Compilando..." | tee -a "$LOG_FILE"
NODE_ENV=production npx next build 2>&1 | tee -a "$LOG_FILE"
 
# Recarregue graciosamente os processos PM2 (sem tempo de inatividade)
echo "Recarregando processos PM2..." | tee -a "$LOG_FILE"
pm2 reload myapp 2>&1 | tee -a "$LOG_FILE"
 
echo "=== Implantação concluída em $(date) ===" | tee -a "$LOG_FILE"

chmod +x /home/nextjs/deploy.sh

// app/api/health/route.ts
import { NextResponse } from "next/server";
 
export const dynamic = "force-dynamic";
 
export async function GET() {
  return NextResponse.json({
    status: "ok",
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
    node_version: process.version,
    memory: {
      rss_mb: Math.round(process.memoryUsage().rss / 1024 / 1024),
      heap_used_mb: Math.round(process.memoryUsage().heapUsed / 1024 / 1024),
    },
  });
}

# Instale o módulo de rotação de logs
pm2 install pm2-logrotate
 
# Configure as configurações de rotação
pm2 set pm2-logrotate:max_size 50M       # Rotacione quando o log atingir 50MB
pm2 set pm2-logrotate:retain 30          # Mantenha 30 arquivos rotacionados
pm2 set pm2-logrotate:compress true      # Comprima logs antigos
pm2 set pm2-logrotate:dateFormat YYYY-MM-DD_HH-mm-ss

# Instale o agente do CloudWatch
sudo apt install amazon-cloudwatch-agent -y
 
# Configure-o para monitorar os arquivos de log do PM2
# /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json

{
  "logs": {
    "logs_collected": {
      "files": {
        "collect_list": [
          {
            "file_path": "/home/nextjs/logs/out.log",
            "log_group_name": "myapp/stdout",
            "log_stream_name": "{instance_id}"
          },
          {
            "file_path": "/home/nextjs/logs/err.log",
            "log_group_name": "myapp/stderr",
            "log_stream_name": "{instance_id}"
          }
        ]
      }
    }
  }
}

// lib/logger.ts
import pino from "pino";
 
export const logger = pino({
  level: process.env.LOG_LEVEL ?? "info",
  formatters: {
    level: (label) => ({ level: label }),
  },
  timestamp: pino.stdTimeFunctions.isoTime,
});

// next.config.ts
import type { NextConfig } from "next";
 
const nextConfig: NextConfig = {
  cacheHandler: "./cache-handler.ts",
  cacheMaxMemorySize: 0, // Desabilita o cache em memória, usa apenas armazenamento externo
};
 
export default nextConfig;

// cache-handler.ts
import { CacheHandler } from "next/dist/server/lib/incremental-cache";
import { createClient } from "redis";
 
const client = createClient({ url: process.env.REDIS_URL });
client.connect();
 
export default class RedisCacheHandler extends CacheHandler {
  async get(key: string) {
    const data = await client.get(key);
    return data ? JSON.parse(data) : null;
  }
 
  async set(key: string, data: unknown, ctx: { revalidate?: number }) {
    const ttl = ctx.revalidate ?? 60;
    await client.set(key, JSON.stringify(data), { EX: ttl });
  }
 
  async revalidateTag(tag: string) {
    // Escaneia por chaves com esta tag e as exclui
    const keys = await client.keys(`*:${tag}:*`);
    if (keys.length > 0) {
      await client.del(keys);
    }
  }
}

// next.config.ts
import type { NextConfig } from "next";
 
const nextConfig: NextConfig = {
  output: "standalone",
};
 
export default nextConfig;

.next/standalone/
├── node_modules/       # Apenas as dependências que seu aplicativo realmente usa (~50MB)
├── server.js           # Ponto de entrada mínimo do servidor Node.js
├── package.json
└── .next/
    └── server/         # Pacotes do servidor compilados

# Após compilar com output: "standalone"
cp -r public .next/standalone/public
cp -r .next/static .next/standalone/.next/static

cd .next/standalone
NODE_ENV=production node server.js

# Defina o limite de memória (reinicia se excedido)
pm2 start ecosystem.config.js   # max_memory_restart já definido na configuração
 
# Monitore em tempo real
pm2 monit

# Tarefa cron para limpar o cache ISR com mais de 7 dias
# Adicione ao crontab -e
0 3 * * * find /home/nextjs/app/.next/cache -type f -mtime +7 -delete 2>/dev/null

// ecosystem.config.js
module.exports = {
  apps: [
    {
      name: "myapp",
      script: "node_modules/.bin/next",
      args: "start -p 3000",
      node_args: "--max-old-space-size=1024", // Limite de heap de 1 GB
      max_memory_restart: "1200M",             // Limite de reinício do PM2 acima do limite V8
      // ... resto da configuração
    },
  ],
};