Guía Completa: Sistema de Automatización con n8n y Evolution API usando Docker

Aprende a configurar un sistema completo de automatización empresarial con n8n y Evolution API (WhatsApp) utilizando Docker Compose. Esta guía incluye configuración paso a paso, buenas prácticas de seguridad y ejemplos reales.

Tabla de Contenidos

1. Introducción
2. Arquitectura del Sistema
3. Requisitos Previos
4. Instalación Paso a Paso
5. Configuración Detallada
6. Buenas Prácticas
7. Ejemplos de Uso
8. Consideraciones de Seguridad
9. Solución de Problemas
10. Mantenimiento y Respaldos

1. Introducción

Este proyecto implementa un sistema robusto de automatización empresarial que combina:

• n8n: Plataforma de automatización de workflows (alternativa open-source a Zapier)
• Evolution API: API completa para integración con WhatsApp Business
• PostgreSQL: Base de datos relacional para persistencia de datos
• Redis: Sistema de caché para optimización de rendimiento

¿Para qué sirve este sistema?

• Automatizar respuestas de WhatsApp
• Integrar WhatsApp con CRM, bases de datos y otros servicios
• Crear workflows complejos sin programar
• Gestionar múltiples instancias de WhatsApp
• Procesar y almacenar mensajes de forma segura

2. Arquitectura del Sistema

El sistema está compuesto por 5 contenedores Docker que trabajan en conjunto:

┌─────────────────────────────────────────────────────────┐
│                    Red Docker (app_net)                  │
│                                                           │
│  ┌──────────┐      ┌─────────────────┐                  │
│  │   n8n    │◄────►│  n8n-postgres   │                  │
│  │ :4567    │      │     :5432       │                  │
│  └──────────┘      └─────────────────┘                  │
│       ▲                                                  │
│       │                                                  │
│       ▼                                                  │
│  ┌──────────────┐  ┌──────────────────┐  ┌──────────┐  │
│  │ evolution-api│◄─┤evolution-postgres│  │evolution-│  │
│  │    :8080     │  │      :5433       │  │  redis   │  │
│  └──────────────┘  └──────────────────┘  │  :6379   │  │
│         ▲                                 └──────────┘  │
│         └──────────────────────────────────────┘        │
└─────────────────────────────────────────────────────────┘

Componentes:

Servicio	Puerto	Función	Dependencias
n8n	4567	Motor de automatización	n8n-postgres
n8n-postgres	5432 (interno)	BD para workflows de n8n	–
evolution-api	8080	API de WhatsApp	evolution-postgres, evolution-redis
evolution-postgres	5433	BD para datos de WhatsApp	–
evolution-redis	6379	Caché y sesiones	–

3. Requisitos Previos

Software Necesario:

• Docker: versión 20.10 o superior
• Docker Compose: versión 2.0 o superior
• Sistema Operativo: Linux, Windows 10/11 con WSL2, o macOS

Recursos del Servidor:

• RAM: Mínimo 4GB (recomendado 8GB)
• CPU: 2 cores (recomendado 4 cores)
• Disco: Mínimo 20GB libres
• Red: Conexión estable a Internet

Dominios (Opcional pero Recomendado):

• Dominio para n8n (ej: n8n.tudominio.com)
• Dominio para Evolution API (ej: wa.tudominio.com)
• Certificado SSL (Let’s Encrypt recomendado)

⚠️ Importante

Para producción, es obligatorio usar HTTPS. WhatsApp Business API requiere conexiones seguras.

4. 🔧 Instalación Paso a Paso

Paso 1: Crear la estructura de directorios

mkdir -p ~/automatizaciones/server-automatico
cd ~/automatizaciones/server-automatico

Paso 2: Crear el archivo docker-compose.yml

Crea un archivo llamado docker-compose.yml con el siguiente contenido:

name: Gastly AI
services:
  n8n:
    image: n8nio/n8n
    ports:
      - "${N8N_PORT}:5678"
    environment:
      # --- Configuracion de base de datos Postgres ---
      - DB_TYPE=${DB_TYPE}
      - DB_POSTGRESDB_HOST=n8n-postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${DB_POSTGRESDB_DATABASE}
      - DB_POSTGRESDB_USER=${DB_POSTGRESDB_USER}
      - DB_POSTGRESDB_PASSWORD=${DB_POSTGRESDB_PASSWORD}
      # --- Auth básica ---
      - N8N_BASIC_AUTH_ACTIVE=${N8N_BASIC_AUTH_ACTIVE}
      - N8N_BASIC_AUTH_USER=${N8N_BASIC_AUTH_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_BASIC_AUTH_PASSWORD}
      # --- Config dominio / webhooks ---
      - N8N_HOST=127.0.0.1
      - N8N_PORT=${N8N_PORT}
      - N8N_PROTOCOL=${N8N_PROTOCOL}
      - WEBHOOK_TUNNEL_URL=${WEBHOOK_TUNNEL_URL}
      # --- Configuracion de timezone ---
      - TZ=${TZ}
    depends_on:
      n8n-postgres:
        condition: service_healthy
    volumes:
      - ./n8n_data:/home/node/.n8n
    networks:
      - app_net

  n8n-postgres:
    image: postgres:15
    container_name: n8n-postgres
    restart: always
    environment:
      - POSTGRES_DB=${DB_POSTGRESDB_DATABASE}
      - POSTGRES_USER=${DB_POSTGRESDB_USER}
      - POSTGRES_PASSWORD=${DB_POSTGRESDB_PASSWORD}
      - TZ=${TZ}
    volumes:
      - ./n8n_postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_POSTGRESDB_USER} -d ${DB_POSTGRESDB_DATABASE}"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - app_net

  evolution-api:
    image: atendai/evolution-api:latest
    container_name: evolution-api
    restart: always
    ports:
      - "${EVOLUTION_PORT}:8080"
    environment:
      - SERVER_PORT=8080
      - SERVER_URL=${EVOLUTION_URL}
      - AUTHENTICATION_API_KEY=${EVOLUTION_AUTHENTICATION_API_KEY}
      - LOG_LEVEL=${EVOLUTION_LOG_LEVEL}
      - BAILEYS_VERSION="2.3000.1025220211"
      - CONFIG_SESSION_PHONE_VERSION=2.3000.1023204200

      # DB
      - DATABASE_ENABLED=true
      - DATABASE_PROVIDER=${EVOLUTION_DATABASE_PROVIDER}
      - DATABASE_CONNECTION_CLIENT_NAME=evolution
      - DATABASE_CONNECTION_URI=${EVOLUTION_DATABASE_CONNECTION_URI}

      # Redis
      - CACHE_REDIS_ENABLED=${EVOLUTION_CACHE_REDIS_ENABLED}
      - CACHE_REDIS_URI=${EVOLUTION_CACHE_REDIS_URI}
      - CACHE_REDIS_PREFIX_KEY=${EVOLUTION_CACHE_REDIS_PREFIX_KEY}
      - CACHE_REDIS_SAVE_INSTANCES=${EVOLUTION_CACHE_REDIS_SAVE_INSTANCES}
      - CACHE_LOCAL_ENABLED=${EVOLUTION_CACHE_LOCAL_ENABLED}
    depends_on:
      evolution-postgres:
        condition: service_healthy
      evolution-redis:
        condition: service_started
    networks:
      - app_net

  evolution-postgres:
    image: postgres:15
    container_name: evolution-postgres
    ports:
      - "${EVOLUTION_DB_PORT}:5432"
    restart: always
    environment:
      - POSTGRES_USER=${EVOLUTION_DB_USER}
      - POSTGRES_PASSWORD=${EVOLUTION_DB_PASSWORD}
      - POSTGRES_DB=${EVOLUTION_DB_NAME}
      - TZ=${TZ}
    volumes:
      - ./evolution_postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${EVOLUTION_DB_USER} -d ${EVOLUTION_DB_NAME}"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - app_net

  evolution-redis:
    image: redis:7-alpine
    ports:
      - 6379:6379
    container_name: evolution-redis
    restart: always
    command: redis-server --save 20 1 --loglevel warning
    volumes:
      - ./evolution_redis:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
    networks:
      - app_net

volumes:
  n8n_data:
  n8n_postgres_data:
  evolution_postgres_data:
  evolution_redis:

networks:
  app_net:
    driver: bridge

Paso 3: Crear el archivo .env

Crea un archivo .env con las variables de entorno:

# --- General ---
TZ=America/Lima

# --- N8N Base de datos ---
DB_TYPE=postgresdb
DB_POSTGRESDB_HOST=n8n-postgres
DB_POSTGRESDB_PORT=5432
DB_POSTGRESDB_DATABASE=n8n
DB_POSTGRESDB_USER=n8n_user
DB_POSTGRESDB_PASSWORD=super_password_segura

# --- N8N Auth básica ---
N8N_BASIC_AUTH_ACTIVE=true
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=otra_password_segura

# --- N8N Dominio / Webhooks ---
N8N_HOST=n8n.tudominio.com
N8N_PORT=4567
N8N_PROTOCOL=https
WEBHOOK_TUNNEL_URL=https://n8n.tudominio.com

# =========================
# Evolution API Config
EVOLUTION_PORT=8080
EVOLUTION_URL=https://wa.tudominio.com
EVOLUTION_LOG_LEVEL=info 

# Evolution Database
EVOLUTION_DB_USER=evolution
EVOLUTION_DB_PASSWORD=evolutionpass
EVOLUTION_DB_NAME=evolutiondb
EVOLUTION_DB_PORT=5433

EVOLUTION_AUTHENTICATION_API_KEY=change-me
EVOLUTION_DATABASE_ENABLED=true
EVOLUTION_DATABASE_PROVIDER=postgresql
EVOLUTION_DATABASE_CONNECTION_URI=postgresql://evolution:evolutionpass@evolution-postgres:5432/evolutiondb

# Redis
EVOLUTION_CACHE_REDIS_ENABLED=true
EVOLUTION_CACHE_REDIS_URI=redis://evolution-redis:6379/0
EVOLUTION_CACHE_REDIS_PREFIX_KEY=evolution
EVOLUTION_CACHE_REDIS_SAVE_INSTANCES=false
EVOLUTION_CACHE_LOCAL_ENABLED=false
EVOLUTION_REDIS_PASSWORD=

Paso 4: Iniciar los servicios

# Iniciar todos los servicios
docker-compose up -d

# Verificar que todos los contenedores estén corriendo
docker-compose ps

# Ver los logs en tiempo real
docker-compose logs -f

✅ Verificación

Si todo está correcto, deberías ver:

• n8n disponible en: http://localhost:4567
• Evolution API disponible en: http://localhost:8080
• Todos los healthchecks en estado «healthy»

5. ⚙️ Configuración Detallada

5.1 Variables de Entorno Explicadas

🕐 Zona Horaria

TZ=America/Lima

Define la zona horaria para todos los servicios. Importante para logs y programación de tareas.

Valores comunes:

• America/Lima – Perú
• America/Mexico_City – México
• America/Bogota – Colombia
• America/Argentina/Buenos_Aires – Argentina
• Europe/Madrid – España

🔐 Autenticación de n8n

N8N_BASIC_AUTH_ACTIVE=true
N8N_BASIC_AUTH_USER=admin
N8N_BASIC_AUTH_PASSWORD=otra_password_segura

Importante: Cambia estas credenciales antes de desplegar en producción.

🌐 Configuración de Webhooks

N8N_PROTOCOL=https
WEBHOOK_TUNNEL_URL=https://n8n.tudominio.com

El WEBHOOK_TUNNEL_URL debe ser accesible desde Internet para recibir webhooks de servicios externos.

🔑 API Key de Evolution

EVOLUTION_AUTHENTICATION_API_KEY=change-me

⚠️ CRÍTICO: Genera una API key segura. Ejemplo:

# Generar una API key aleatoria
openssl rand -hex 32

5.2 Configuración de Reverse Proxy (Nginx)

Para exponer los servicios con HTTPS, usa Nginx como reverse proxy:

# /etc/nginx/sites-available/n8n.conf
server {
    listen 80;
    server_name n8n.tudominio.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name n8n.tudominio.com;

    ssl_certificate /etc/letsencrypt/live/n8n.tudominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.tudominio.com/privkey.pem;

    location / {
        proxy_pass http://localhost:4567;
        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;
    }
}

# /etc/nginx/sites-available/evolution.conf
server {
    listen 80;
    server_name wa.tudominio.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name wa.tudominio.com;

    ssl_certificate /etc/letsencrypt/live/wa.tudominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/wa.tudominio.com/privkey.pem;

    location / {
        proxy_pass http://localhost:8080;
        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;
    }
}

5.3 Obtener Certificados SSL

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

# Obtener certificados
sudo certbot --nginx -d n8n.tudominio.com
sudo certbot --nginx -d wa.tudominio.com

# Renovación automática (ya configurada por defecto)
sudo certbot renew --dry-run

6. 🎯 Buenas Prácticas

6.1 Seguridad

✅ DO – Hacer

• ✓ Usar contraseñas fuertes y únicas para cada servicio
• ✓ Cambiar la API key de Evolution antes de producción
• ✓ Implementar HTTPS obligatoriamente
• ✓ Restringir acceso a puertos de base de datos
• ✓ Mantener los contenedores actualizados
• ✓ Usar variables de entorno para secretos
• ✓ Implementar firewall (UFW o iptables)
• ✓ Habilitar autenticación de dos factores cuando sea posible

❌ DON’T – No Hacer

• ✗ Exponer puertos de base de datos a Internet
• ✗ Usar contraseñas por defecto
• ✗ Commitear el archivo .env a Git
• ✗ Ejecutar sin HTTPS en producción
• ✗ Ignorar actualizaciones de seguridad
• ✗ Usar la misma contraseña para múltiples servicios

6.2 Rendimiento

• Redis Cache: Mantén habilitado el caché de Redis para Evolution API
• Recursos: Monitorea el uso de CPU y RAM regularmente
• Logs: Configura rotación de logs para evitar llenar el disco
• Conexiones: Limita el número de conexiones simultáneas según tu hardware

6.3 Respaldos

Crea un script de respaldo automático:

#!/bin/bash
# backup.sh

BACKUP_DIR="/backups/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR

# Respaldar bases de datos
docker exec n8n-postgres pg_dump -U n8n_user n8n > $BACKUP_DIR/n8n_backup.sql
docker exec evolution-postgres pg_dump -U evolution evolutiondb > $BACKUP_DIR/evolution_backup.sql

# Respaldar volúmenes
tar -czf $BACKUP_DIR/n8n_data.tar.gz ./n8n_data
tar -czf $BACKUP_DIR/evolution_redis.tar.gz ./evolution_redis

# Respaldar archivo .env
cp .env $BACKUP_DIR/.env.backup

# Eliminar backups antiguos (más de 30 días)
find /backups -type d -mtime +30 -exec rm -rf {} \;

echo "Backup completado: $BACKUP_DIR"

Programa el script con cron:

# Ejecutar backup diario a las 2 AM
0 2 * * * /ruta/al/backup.sh >> /var/log/backup.log 2>&1

6.4 Monitoreo

Comandos útiles para monitoreo:

# Ver estado de contenedores
docker-compose ps

# Ver uso de recursos
docker stats

# Ver logs de un servicio específico
docker-compose logs -f n8n
docker-compose logs -f evolution-api

# Ver logs de errores únicamente
docker-compose logs --tail=100 | grep -i error

# Verificar salud de bases de datos
docker exec n8n-postgres pg_isready -U n8n_user
docker exec evolution-postgres pg_isready -U evolution

7. 💼 Ejemplos de Uso

7.1 Conectar WhatsApp con Evolution API

Paso 1: Crear una instancia

curl -X POST https://wa.tudominio.com/instance/create \
  -H "apikey: TU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "instanceName": "mi-whatsapp",
    "qrcode": true,
    "integration": "WHATSAPP-BAILEYS"
  }'

Paso 2: Obtener código QR

curl -X GET https://wa.tudominio.com/instance/connect/mi-whatsapp \
  -H "apikey: TU_API_KEY"

Escanea el código QR con WhatsApp para conectar.

Paso 3: Enviar un mensaje

curl -X POST https://wa.tudominio.com/message/sendText/mi-whatsapp \
  -H "apikey: TU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "number": "51999999999",
    "text": "¡Hola! Este es un mensaje de prueba."
  }'

7.2 Workflow de n8n: Auto-respuesta de WhatsApp

Ejemplo de workflow en n8n para responder automáticamente a mensajes:

1. Webhook Trigger: Recibe mensajes de Evolution API
2. IF Node: Verifica si el mensaje contiene «hola»
3. HTTP Request: Envía respuesta automática vía Evolution API

{
  "nodes": [
    {
      "name": "Webhook",
      "type": "n8n-nodes-base.webhook",
      "position": [250, 300],
      "webhookId": "auto-respuesta",
      "parameters": {
        "path": "whatsapp-webhook",
        "responseMode": "onReceived",
        "httpMethod": "POST"
      }
    },
    {
      "name": "IF",
      "type": "n8n-nodes-base.if",
      "position": [450, 300],
      "parameters": {
        "conditions": {
          "string": [
            {
              "value1": "={{$json.data.message.conversation}}",
              "operation": "contains",
              "value2": "hola"
            }
          ]
        }
      }
    },
    {
      "name": "Enviar Respuesta",
      "type": "n8n-nodes-base.httpRequest",
      "position": [650, 300],
      "parameters": {
        "url": "https://wa.tudominio.com/message/sendText/mi-whatsapp",
        "method": "POST",
        "headerParameters": {
          "parameters": [
            {
              "name": "apikey",
              "value": "TU_API_KEY"
            }
          ]
        },
        "bodyParameters": {
          "parameters": [
            {
              "name": "number",
              "value": "={{$json.data.key.remoteJid}}"
            },
            {
              "name": "text",
              "value": "¡Hola! Gracias por tu mensaje. ¿En qué puedo ayudarte?"
            }
          ]
        }
      }
    }
  ]
}

7.3 Integración con Base de Datos

Workflow para guardar mensajes en PostgreSQL:

{
  "nodes": [
    {
      "name": "Webhook WhatsApp",
      "type": "n8n-nodes-base.webhook",
      "position": [250, 300]
    },
    {
      "name": "Guardar en BD",
      "type": "n8n-nodes-base.postgres",
      "position": [450, 300],
      "credentials": {
        "postgres": "evolution-db"
      },
      "parameters": {
        "operation": "insert",
        "table": "mensajes",
        "columns": "telefono,mensaje,fecha",
        "values": "={{$json.data.key.remoteJid}},={{$json.data.message.conversation}},={{$now}}"
      }
    }
  ]
}

7.4 Notificaciones Programadas

Enviar mensajes programados usando Cron en n8n:

1. Cron Node: Ejecutar todos los días a las 9 AM
2. HTTP Request: Obtener lista de clientes de tu API/BD
3. Loop: Iterar sobre cada cliente
4. HTTP Request: Enviar mensaje personalizado

8. 🔒 Consideraciones de Seguridad

8.1 Firewall (UFW)

# Instalar UFW
sudo apt install ufw

# Configurar reglas básicas
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Permitir SSH
sudo ufw allow 22/tcp

# Permitir HTTP y HTTPS
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Habilitar firewall
sudo ufw enable

# Verificar estado
sudo ufw status verbose

8.2 Fail2Ban para Protección contra Ataques

# Instalar Fail2Ban
sudo apt install fail2ban

# Configurar para Nginx
sudo nano /etc/fail2ban/jail.local

[nginx-http-auth]
enabled = true
port = http,https
logpath = /var/log/nginx/error.log
maxretry = 3
bantime = 3600

[nginx-noscript]

enabled = true port = http,https logpath = /var/log/nginx/access.log maxretry = 6 bantime = 3600

8.3 Rotación de Logs

# /etc/logrotate.d/docker-containers
/var/lib/docker/containers/*/*.log {
    rotate 7
    daily
    compress
    size=10M
    missingok
    delaycompress
    copytruncate
}

8.4 Actualización de Contenedores

#!/bin/bash
# update-containers.sh

cd /ruta/a/tu/proyecto

# Detener servicios
docker-compose down

# Actualizar imágenes
docker-compose pull

# Reiniciar servicios
docker-compose up -d

# Limpiar imágenes antiguas
docker image prune -a -f

echo "Contenedores actualizados"

8.5 Checklist de Seguridad

Item	Estado	Prioridad
Contraseñas fuertes configuradas	☐	🔴 Alta
HTTPS configurado con certificado válido	☐	🔴 Alta
API Key de Evolution cambiada	☐	🔴 Alta
Firewall configurado	☐	🔴 Alta
Puertos de BD no expuestos públicamente	☐	🔴 Alta
Archivo .env en .gitignore	☐	🟡 Media
Backups automáticos configurados	☐	🟡 Media
Fail2Ban instalado	☐	🟡 Media
Rotación de logs configurada	☐	🟢 Baja
Monitoreo de recursos activo	☐	🟢 Baja

9. 🔍 Solución de Problemas

Problema 1: Contenedor no inicia

Síntoma:

El contenedor se reinicia constantemente o no inicia.

Diagnóstico:

# Ver logs del contenedor
docker-compose logs nombre-del-servicio

# Ver estado detallado
docker inspect nombre-del-contenedor

Soluciones:

• Verificar que las variables de entorno estén correctas
• Comprobar que los puertos no estén en uso
• Revisar permisos de volúmenes
• Verificar recursos disponibles (RAM, disco)

Problema 2: No se puede conectar a la base de datos

Síntoma:

Error de conexión a PostgreSQL.

Diagnóstico:

# Verificar que el contenedor de BD esté corriendo
docker-compose ps

# Probar conexión manual
docker exec -it n8n-postgres psql -U n8n_user -d n8n

Soluciones:

• Esperar a que el healthcheck pase (puede tomar 30-60 segundos)
• Verificar credenciales en .env
• Reiniciar contenedores: docker-compose restart

Problema 3: Evolution API no genera código QR

Síntoma:

No se genera el código QR para conectar WhatsApp.

Diagnóstico:

# Ver logs de Evolution
docker-compose logs -f evolution-api

# Verificar estado de la instancia
curl -X GET https://wa.tudominio.com/instance/fetchInstances \
  -H "apikey: TU_API_KEY"

Soluciones:

• Eliminar y recrear la instancia
• Verificar que Redis esté funcionando
• Comprobar versión de Baileys compatible
• Limpiar caché de Redis

Problema 4: Webhooks no funcionan

Síntoma:

Los webhooks de n8n no reciben datos.

Diagnóstico:

# Probar webhook manualmente
curl -X POST https://n8n.tudominio.com/webhook/test \
  -H "Content-Type: application/json" \
  -d '{"test": "data"}'

Soluciones:

• Verificar que WEBHOOK_TUNNEL_URL sea accesible desde Internet
• Comprobar configuración de Nginx/reverse proxy
• Revisar firewall y puertos abiertos
• Verificar certificado SSL válido

Problema 5: Alto uso de disco

Síntoma:

El disco se llena rápidamente.

Diagnóstico:

# Ver tamaño de volúmenes
du -sh ./n8n_data
du -sh ./evolution_postgres_data
du -sh ./n8n_postgres_data

# Ver logs de Docker
sudo du -sh /var/lib/docker/containers/*/*-json.log

Soluciones:

• Configurar rotación de logs
• Limpiar imágenes antiguas: docker image prune -a
• Limpiar volúmenes no usados: docker volume prune
• Implementar backups y limpiar datos antiguos

Comandos Útiles de Diagnóstico

# Ver recursos en tiempo real
docker stats

# Ver todos los contenedores (incluso detenidos)
docker ps -a

# Reiniciar un servicio específico
docker-compose restart evolution-api

# Reconstruir contenedores
docker-compose up -d --force-recreate

# Ver redes Docker
docker network ls
docker network inspect server-automatico_app_net

# Acceder a shell de un contenedor
docker exec -it evolution-api /bin/sh

# Ver variables de entorno de un contenedor
docker exec evolution-api env

10. 🛠️ Mantenimiento y Respaldos

10.1 Rutina de Mantenimiento Semanal

#!/bin/bash
# mantenimiento-semanal.sh

echo "=== Iniciando mantenimiento semanal ==="

# 1. Verificar estado de servicios
echo "1. Verificando servicios..."
docker-compose ps

# 2. Verificar uso de disco
echo "2. Verificando uso de disco..."
df -h

# 3. Limpiar logs antiguos
echo "3. Limpiando logs..."
find /var/log -name "*.log" -mtime +30 -delete

# 4. Limpiar imágenes Docker no usadas
echo "4. Limpiando imágenes Docker..."
docker image prune -a -f

# 5. Verificar backups
echo "5. Verificando backups..."
ls -lh /backups | tail -5

# 6. Actualizar contenedores (opcional)
# docker-compose pull
# docker-compose up -d

echo "=== Mantenimiento completado ==="

10.2 Script de Respaldo Completo

#!/bin/bash
# backup-completo.sh

TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_ROOT="/backups"
BACKUP_DIR="$BACKUP_ROOT/$TIMESTAMP"
PROJECT_DIR="/ruta/a/tu/proyecto"

mkdir -p $BACKUP_DIR

echo "=== Iniciando backup $TIMESTAMP ==="

# 1. Backup de bases de datos
echo "1. Respaldando bases de datos..."
docker exec n8n-postgres pg_dump -U n8n_user n8n | gzip > $BACKUP_DIR/n8n_db.sql.gz
docker exec evolution-postgres pg_dump -U evolution evolutiondb | gzip > $BACKUP_DIR/evolution_db.sql.gz

# 2. Backup de volúmenes
echo "2. Respaldando volúmenes..."
cd $PROJECT_DIR
tar -czf $BACKUP_DIR/n8n_data.tar.gz n8n_data/
tar -czf $BACKUP_DIR/evolution_redis.tar.gz evolution_redis/

# 3. Backup de configuración
echo "3. Respaldando configuración..."
cp .env $BACKUP_DIR/.env.backup
cp docker-compose.yml $BACKUP_DIR/docker-compose.yml.backup

# 4. Crear checksum
echo "4. Creando checksums..."
cd $BACKUP_DIR
sha256sum * > checksums.txt

# 5. Comprimir todo
echo "5. Comprimiendo backup..."
cd $BACKUP_ROOT
tar -czf backup_$TIMESTAMP.tar.gz $TIMESTAMP/
rm -rf $TIMESTAMP/

# 6. Limpiar backups antiguos (mantener últimos 30 días)
echo "6. Limpiando backups antiguos..."
find $BACKUP_ROOT -name "backup_*.tar.gz" -mtime +30 -delete

# 7. Verificar tamaño
BACKUP_SIZE=$(du -h $BACKUP_ROOT/backup_$TIMESTAMP.tar.gz | cut -f1)
echo "=== Backup completado: $BACKUP_SIZE ==="
echo "Ubicación: $BACKUP_ROOT/backup_$TIMESTAMP.tar.gz"

# 8. Opcional: Subir a cloud storage
# aws s3 cp $BACKUP_ROOT/backup_$TIMESTAMP.tar.gz s3://mi-bucket/backups/

10.3 Restauración desde Backup

#!/bin/bash
# restaurar-backup.sh

BACKUP_FILE=$1
RESTORE_DIR="/tmp/restore_$(date +%s)"

if [ -z "$BACKUP_FILE" ]; then
    echo "Uso: ./restaurar-backup.sh /ruta/al/backup_YYYYMMDD_HHMMSS.tar.gz"
    exit 1
fi

echo "=== Iniciando restauración ==="

# 1. Extraer backup
echo "1. Extrayendo backup..."
mkdir -p $RESTORE_DIR
tar -xzf $BACKUP_FILE -C $RESTORE_DIR

# 2. Detener servicios
echo "2. Deteniendo servicios..."
docker-compose down

# 3. Restaurar bases de datos
echo "3. Restaurando bases de datos..."
gunzip < $RESTORE_DIR/*/n8n_db.sql.gz | docker exec -i n8n-postgres psql -U n8n_user n8n
gunzip < $RESTORE_DIR/*/evolution_db.sql.gz | docker exec -i evolution-postgres psql -U evolution evolutiondb

# 4. Restaurar volúmenes
echo "4. Restaurando volúmenes..."
tar -xzf $RESTORE_DIR/*/n8n_data.tar.gz -C ./
tar -xzf $RESTORE_DIR/*/evolution_redis.tar.gz -C ./

# 5. Restaurar configuración
echo "5. Restaurando configuración..."
cp $RESTORE_DIR/*/.env.backup .env
cp $RESTORE_DIR/*/docker-compose.yml.backup docker-compose.yml

# 6. Reiniciar servicios
echo "6. Reiniciando servicios..."
docker-compose up -d

# 7. Limpiar
rm -rf $RESTORE_DIR

echo "=== Restauración completada ==="

10.4 Monitoreo con Script

#!/bin/bash
# monitor.sh

# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo "=== Estado del Sistema ==="
echo ""

# 1. Estado de contenedores
echo "📦 Contenedores:"
docker-compose ps

# 2. Uso de recursos
echo ""
echo "💻 Uso de Recursos:"
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# 3. Uso de disco
echo ""
echo "💾 Uso de Disco:"
df -h | grep -E "Filesystem|/$|/var"

# 4. Verificar servicios
echo ""
echo "🔍 Verificación de Servicios:"

# n8n
if curl -s -o /dev/null -w "%{http_code}" http://localhost:4567 | grep -q "200\|401"; then
    echo -e "${GREEN}✓${NC} n8n: OK"
else
    echo -e "${RED}✗${NC} n8n: ERROR"
fi

# Evolution API
if curl -s -o /dev/null -w "%{http_code}" http://localhost:8080 | grep -q "200\|401"; then
    echo -e "${GREEN}✓${NC} Evolution API: OK"
else
    echo -e "${RED}✗${NC} Evolution API: ERROR"
fi

# PostgreSQL n8n
if docker exec n8n-postgres pg_isready -U n8n_user &>/dev/null; then
    echo -e "${GREEN}✓${NC} PostgreSQL (n8n): OK"
else
    echo -e "${RED}✗${NC} PostgreSQL (n8n): ERROR"
fi

# PostgreSQL Evolution
if docker exec evolution-postgres pg_isready -U evolution &>/dev/null; then
    echo -e "${GREEN}✓${NC} PostgreSQL (Evolution): OK"
else
    echo -e "${RED}✗${NC} PostgreSQL (Evolution): ERROR"
fi

# Redis
if docker exec evolution-redis redis-cli ping &>/dev/null; then
    echo -e "${GREEN}✓${NC} Redis: OK"
else
    echo -e "${RED}✗${NC} Redis: ERROR"
fi

echo ""
echo "=== Fin del Reporte ==="

10.5 Programación de Tareas (Crontab)

# Editar crontab
crontab -e

# Agregar las siguientes líneas:

# Backup diario a las 2 AM
0 2 * * * /ruta/al/backup-completo.sh >> /var/log/backup.log 2>&1

# Mantenimiento semanal (Domingos a las 3 AM)
0 3 * * 0 /ruta/al/mantenimiento-semanal.sh >> /var/log/mantenimiento.log 2>&1

# Monitoreo cada hora
0 * * * * /ruta/al/monitor.sh >> /var/log/monitor.log 2>&1

# Limpiar logs cada semana
0 4 * * 0 find /var/log -name "*.log" -mtime +30 -delete

🎓 Conclusión

Has configurado exitosamente un sistema completo de automatización empresarial con n8n y Evolution API. Este sistema te permite:

• ✅ Automatizar procesos de negocio sin programar
• ✅ Integrar WhatsApp con múltiples servicios
• ✅ Gestionar comunicaciones de forma escalable
• ✅ Mantener datos seguros y respaldados