Desplegar Next.js en EC2 / Servidor Independiente

# En tu servidor (Ubuntu 22.04+)
# 1. Construir el bundle de producción
NODE_ENV=production npm ci
NODE_ENV=production npx next build
 
# 2. Iniciar con PM2 (gestor de procesos)
npm install -g pm2
pm2 start npm --name "myapp" -- start
pm2 save
pm2 startup
 
# 3. Proxy inverso Nginx (después de 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. Verificar
curl -I https://myapp.com

# Si usas ufw directamente en el servidor
sudo ufw allow 22/tcp    # SSH
sudo ufw allow 80/tcp    # HTTP (Nginx)
sudo ufw allow 443/tcp   # HTTPS (Nginx)
sudo ufw enable

# Instalar nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
 
# Instalar 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

# Clonar tu repositorio
git clone https://github.com/your-org/your-app.git /home/nextjs/app
cd /home/nextjs/app
 
# Instalar dependencias de producción
npm ci
 
# Compilar para producción
NODE_ENV=production npx next build

.next/
├── cache/              # Caché ISR, caché de optimización de imágenes, caché de compilación
├── server/             # Bundles del lado del servidor (páginas App Router, rutas API)
│   ├── app/            # Páginas App Router compiladas
│   ├── chunks/         # Chunks del servidor compartidos
│   └── pages/          # Páginas Pages Router compiladas (si las hay)
├── static/             # Bundles JS/CSS del lado del cliente (con fingerprint)
│   └── chunks/         # Bundles del cliente divididos por código
├── BUILD_ID            # Identificador único de compilación
├── build-manifest.json # Mapea rutas a bundles del cliente
└── trace               # Datos de rastreo de compilación

NODE_ENV=production npx next start -p 3000
# Visita http://<server-ip>:3000 para verificar, luego Ctrl+C

# .env.production
# Solo del lado del servidor (no expuesto al navegador)
DATABASE_URL="postgresql://user:pass@db-host:5432/mydb"
NEXTAUTH_SECRET="your-secret-key-here"
NEXTAUTH_URL="https://myapp.com"
 
# Del lado del cliente (incrustado en el bundle JS en tiempo de COMPILACIÓN)
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",
      },
    },
  ],
};

# Instalar 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",          // Usa todos los núcleos de CPU disponibles
      exec_mode: "cluster",      // Modo cluster para equilibrio de carga
      max_memory_restart: "512M", // Reinicia si la memoria excede 512MB
      env: {
        NODE_ENV: "production",
        PORT: 3000,
      },
      // Registro
      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,
    },
  ],
};

# Crear directorio de registros
mkdir -p /home/nextjs/logs
 
# Iniciar la aplicación
pm2 start ecosystem.config.js
 
# Guardar la lista de procesos (para que PM2 sepa qué reiniciar después del reinicio)
pm2 save
 
# Generar el script de inicio (ejecuta el comando que genera como root)
pm2 startup
# Copia-pega el comando generado, p.ej.:
# sudo env PATH=$PATH:/home/nextjs/.nvm/versions/node/v20.x.x/bin pm2 startup systemd -u nextjs --hp /home/nextjs
 
# Verificar que los procesos se están ejecutando
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;
 
    # Redirigir todo HTTP a HTTPS
    return 301 https://$host$request_uri;
}
 
server {
    listen 443 ssl http2;
    server_name myapp.com www.myapp.com;
 
    # Certificados SSL (gestionados por 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;
 
    # Compresión 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;
 
    # Headers de seguridad
    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;
 
    # Servir activos estáticos de Next.js directamente desde Nginx (omite Node.js)
    location /_next/static/ {
        alias /home/nextjs/app/.next/static/;
        expires 365d;
        access_log off;
        add_header Cache-Control "public, immutable";
    }
 
    # Servir activos del directorio público directamente
    location /public/ {
        alias /home/nextjs/app/public/;
        expires 30d;
        access_log off;
    }
 
    # Favicon y robots.txt
    location = /favicon.ico {
        alias /home/nextjs/app/public/favicon.ico;
        access_log off;
    }
 
    # Proxy todas las otras solicitudes a Next.js
    location / {
        proxy_pass http://nextjs_upstream;
        proxy_http_version 1.1;
 
        # Headers requeridos
        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;
 
        # Soporte WebSocket (requerido para streaming Server Actions, HMR en desarrollo)
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
 
        # Timeouts
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
 
        # Almacenamiento en búfer
        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  # Eliminar sitio por defecto
sudo nginx -t                              # Probar configuración
sudo systemctl reload nginx

# Instalar certbot
sudo apt install certbot python3-certbot-nginx -y
 
# Obtener e instalar certificado (el plugin Nginx configura SSL automáticamente)
sudo certbot --nginx -d myapp.com -d www.myapp.com
 
# Verificar que la renovación automática está configurada
sudo certbot renew --dry-run
 
# Certbot instala un temporizador systemd automáticamente; verifica que exista:
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 "=== Deploy iniciado en $(date) ===" | tee "$LOG_FILE"
 
cd "$APP_DIR"
 
# Extraer código más reciente
echo "Extrayendo código más reciente..." | tee -a "$LOG_FILE"
git pull origin main 2>&1 | tee -a "$LOG_FILE"
 
# Instalar dependencias (ci para instalaciones limpias)
echo "Instalando dependencias..." | tee -a "$LOG_FILE"
npm ci 2>&1 | tee -a "$LOG_FILE"
 
# Compilar la aplicación
echo "Compilando..." | tee -a "$LOG_FILE"
NODE_ENV=production npx next build 2>&1 | tee -a "$LOG_FILE"
 
# Recargar procesos PM2 gracefully (sin tiempo de inactividad)
echo "Recargando procesos PM2..." | tee -a "$LOG_FILE"
pm2 reload myapp 2>&1 | tee -a "$LOG_FILE"
 
echo "=== Deploy completado en $(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),
    },
  });
}

# Instalar el módulo de rotación de registros
pm2 install pm2-logrotate
 
# Configurar los parámetros de rotación
pm2 set pm2-logrotate:max_size 50M       # Rotar cuando el registro alcance 50MB
pm2 set pm2-logrotate:retain 30          # Mantener 30 archivos rotados
pm2 set pm2-logrotate:compress true      # Comprimir registros antiguos con gzip
pm2 set pm2-logrotate:dateFormat YYYY-MM-DD_HH-mm-ss

# Instalar el agente CloudWatch
sudo apt install amazon-cloudwatch-agent -y
 
# Configurarlo para monitorear archivos de registro de 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, // Deshabilitar caché en memoria, usar solo almacén 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) {
    // Escanear claves con esta etiqueta y eliminarlas
    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/       # Solo las dependencias que tu aplicación realmente usa (~50MB)
├── server.js           # Punto de entrada mínimo del servidor Node.js
├── package.json
└── .next/
    └── server/         # Bundles del servidor compilados

# Después de compilar con 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

# Establecer límite de memoria (reinicia si se excede)
pm2 start ecosystem.config.js   # max_memory_restart ya está configurado en la config
 
# Monitorear en tiempo real
pm2 monit

# Trabajo cron para podar caché ISR más antigua de 7 días
# Agregar a 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", // Límite de heap de 1 GB
      max_memory_restart: "1200M",             // Umbral de reinicio de PM2 por encima del límite de V8
      // ... resto de config
    },
  ],
};