n8n Database Workflows: PostgreSQL, MySQL, MongoDB (Guía Completa Tutorial 2025)

Introducción

Las bases de datos son el corazón de cualquier sistema empresarial moderno, pero gestionarlas manualmente es ineficiente, propenso a errores y no escala. ¿Y si pudieras automatizar completamente tus procesos de bases de datos sin escribir código complejo?

n8n es una plataforma open-source de automatización de workflows que revoluciona cómo interactuamos con bases de datos. En esta guía exhaustiva aprenderás a integrar PostgreSQL, MySQL y MongoDB con n8n para crear pipelines ETL robustos, automatizar backups, sincronizar datos entre sistemas y mucho más.

Lo que aprenderás en este tutorial:

• Configurar conexiones seguras a PostgreSQL, MySQL y MongoDB en n8n
• Crear workflows ETL completos para extracción, transformación y carga de datos
• Automatizar backups y mantenimiento de bases de datos
• Implementar sincronización bidireccional entre múltiples sistemas
• Optimizar performance y prevenir errores comunes
• Aplicar mejores prácticas de seguridad (SQL injection, credentials, SSL)
• Casos de uso reales: analytics en tiempo real, migraciones, data validation

Ya seas desarrollador, data engineer, DevOps o administrador de sistemas, esta guía te dará las herramientas para transformar tus procesos de datos.

—

¿Qué es n8n y Por Qué Usarlo para Bases de Datos?

n8n: Automatización Visual sin Límites

n8n (pronunciado «n-eight-n») es una plataforma de automatización de workflows open-source que permite conectar más de 400 aplicaciones, APIs y servicios mediante una interfaz visual tipo flowchart.

Ventajas sobre alternativas como Zapier o Make:

• ✅ Open Source: Código fuente disponible, sin vendor lock-in
• ✅ Self-Hosted: Control total de tus datos en tu homelab/servidor
• ✅ Sin Límites de Ejecución: No pagas por número de «tasks»
• ✅ JavaScript Nativo: Transformaciones complejas con código cuando lo necesites
• ✅ Integraciones de Bases de Datos Nativas: Nodos específicos para PostgreSQL, MySQL, MongoDB
• ✅ Fair-Code License: Versión cloud opcional, pero nunca obligatoria

Por Qué Integrar Bases de Datos con n8n

Las bases de datos tradicionales requieren scripts mantenidos, cron jobs frágiles y código custom para cada integración. n8n elimina esta complejidad:

Casos de uso que automatiza n8n:

1. ETL Pipelines: Extraer de APIs → Transformar → Cargar en BD
2. Sincronización Multi-Sistema: Mantener CRM, ERP y Data Warehouse actualizados
3. Backups Automatizados: Dumps programados a cloud storage (S3, Google Drive)
4. Data Validation: Checks de calidad automáticos + alertas
5. Real-Time Analytics: Agregaciones on-the-fly para dashboards
6. Migraciones: Mover datos entre bases de datos diferentes

Resultado: Reduces errores, ahorras tiempo de desarrollo y creas pipelines mantenibles visualmente.

—

PostgreSQL, MySQL o MongoDB: ¿Cuál Elegir?

Antes de configurar n8n, es crucial elegir la base de datos correcta para tu caso de uso. Aquí está la comparativa definitiva:

Comparativa Técnica Completa

| Característica | PostgreSQL | MySQL | MongoDB |

|—————-|————|——-|———|

| Tipo | Relacional (RDBMS) | Relacional (RDBMS) | NoSQL Documental |

| Licencia | PostgreSQL (open) | GPL/Commercial | SSPL (restrictiva) |

| ACID Compliance | ✅ 100% | ✅ 100% (InnoDB) | ⚠️ Parcial |

| JSON Support | ⭐⭐⭐⭐⭐ JSONB | ⭐⭐⭐ Básico | ⭐⭐⭐⭐⭐ Nativo |

| Transacciones | ✅ Completas | ✅ Completas | ✅ Desde v4.0 |

| Performance Lecturas | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |

| Performance Escrituras | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |

| Complex Queries | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ |

| Schema Flexibility | ⭐⭐ Rígido | ⭐⭐ Rígido | ⭐⭐⭐⭐⭐ Schema-less |

| Integración n8n | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |

| Cloud Support | RDS, GCP, Azure | RDS, GCP, Azure | Atlas (managed) |

| Full-Text Search | ✅ ts_vector | ✅ FULLTEXT | ✅ Text indexes |

¿Cuándo Usar Cada Una?

PostgreSQL ✅ La Opción Más Completa

Ideal para:

• Aplicaciones empresariales complejas con múltiples relaciones (JOINs)
• Sistemas financieros que requieren integridad de datos estricta
• Analytics pesado con queries complejas
• Data warehousing y business intelligence
• Cuando necesitas JSONB (flexibilidad + poder SQL)

Casos de uso: ERP, CRM corporativos, plataformas ecommerce, sistemas bancarios, aplicaciones SaaS complejas.

MySQL ✅ Simplicidad y Performance en Lecturas

Ideal para:

• Aplicaciones web de lectura intensiva (blogs, foros)
• WordPress, Drupal, Joomla (ecosistema LAMP)
• Startups que necesitan simplicidad y rapidez
• Presupuestos limitados (menor consumo RAM)

Casos de uso: Content Management Systems, aplicaciones CRUD simples, sitios web con alto tráfico de lectura.

MongoDB ✅ Flexibilidad Sin Esquemas

Ideal para:

• Datos no estructurados o que cambian frecuentemente
• Prototipado rápido (no necesitas definir schema)
• Catálogos de productos con atributos variables
• Logs, eventos y telemetría en tiempo real
• Aplicaciones mobile con sincronización offline

Casos de uso: Aplicaciones mobile, sistemas de logging, catálogos ecommerce dinámicos, IoT data ingestion.

Recomendación: Para la mayoría de casos de uso con n8n, PostgreSQL ofrece el mejor balance entre potencia, flexibilidad (JSONB) y soporte completo en n8n.

—

Instalación y Configuración de n8n con Bases de Datos

Opción 1: Docker Compose (Recomendado para Producción)

Esta configuración instala n8n + PostgreSQL en tu servidor con persistencia de datos:

version: '3.8'
services:
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U n8n']
      interval: 10s
      timeout: 5s
      retries: 5
  n8n:
    image: n8nio/n8n:latest
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - WEBHOOK_URL=https://n8n.tudominio.com/
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
volumes:
  postgres_data:
  n8n_data:

Archivo .env con credenciales:

POSTGRES_PASSWORD=<genera-password-seguro>
N8N_USER=admin
N8N_PASSWORD=<tu-password-n8n>

Levantar servicios:

docker-compose up -d

Accede a n8n en http://localhost:5678

Opción 2: npm (Desarrollo Local)

# Instalar n8n globalmente
npm install -g n8n
# Iniciar n8n
n8n start
# Acceder en http://localhost:5678

—

Configurar Conexiones a Bases de Datos en n8n

Paso 1: Crear Credenciales PostgreSQL

1. En n8n, ve a Credentials (menú lateral)
2. Click Add Credential → Busca «Postgres»
3. Rellena los datos:

Connection:
  Host: localhost (o IP remota)
  Port: 5432
  Database: mi_database
  User: n8n_app  
  Password: **********

SSL:
  ☑ SSL: habilitado (si es remoto)
  
Connection Timeout: 30000

1. Click Test Connection → debe mostrar «Connection successful»
2. Save

Mejores Prácticas de Seguridad:

• ✅ Crear usuario específico para n8n (no usar postgres superuser)
• ✅ Dar solo permisos necesarios (SELECT, INSERT, UPDATE, DELETE)
• ✅ Usar SSL/TLS para conexiones remotas
• ✅ Almacenar passwords en variables de entorno

Crear usuario limitado en PostgreSQL:

-- Conectar como superuser
CREATE USER n8n_app WITH PASSWORD 'secure_password';
-- Dar permisos solo a la base de datos específica
GRANT CONNECT ON DATABASE mi_database TO n8n_app;
GRANT USAGE ON SCHEMA public TO n8n_app;
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO n8n_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO n8n_app;
-- NO dar SUPERUSER, CREATE DATABASE, o DROP TABLE

Configurar MySQL

Similar a PostgreSQL, pero con puerto 3306 por defecto:

Host: localhost
Port: 3306
Database: mydb
User: n8n_app
Password: **********

Configurar MongoDB

Connection Type: Connection String

Connection String:
mongodb://user:password@localhost:27017/mydatabase

O para MongoDB Atlas:
mongodb+srv://user:password@cluster.mongodb.net/mydatabase?retryWrites=true&w=majority

—

Workflow ETL Completo: Extraer, Transformar y Cargar Datos

Vamos a crear un pipeline ETL real que extrae datos de una API pública, los transforma y los carga en PostgreSQL.

Escenario: Pipeline de Datos de Ventas

Objetivo: Extraer datos de ventas de API externa → Limpiar y enriquecer → Guardar en PostgreSQL cada hora.

Paso 1: Trigger Programado

1. Añade nodo Schedule Trigger
2. Configura: Every hour (0 /1 )

Paso 2: Extraer Datos de API

1. Añade nodo HTTP Request
2. Configuración:

Method: GET
URL: https://api.empresa.com/sales
Authentication: Bearer Token
Headers:
  Authorization: Bearer {{$env.API_TOKEN}}

Respuesta ejemplo:

[
  {
    "id": "sale_123",
    "customer_email": "  JUAN@EXAMPLE.COM  ",
    "amount": "1250.50",
    "date": "2025-11-06T10:30:00Z",
    "product_ids": [101, 205, 340]
  }
]

Paso 3: Transformar Datos con Function Node

Añade nodo Function para limpiar y formatear:

const items = $input.all();
return items.map(item => {
  const data = item.json;
  
  return {
    json: {
      // Limpiar email: trim + lowercase
      customer_email: data.customer_email.trim().toLowerCase(),
      
      // Convertir string a decimal
      amount: parseFloat(data.amount),
      
      // Formatear fecha para PostgreSQL
      sale_date: new Date(data.date).toISOString(),
      
      // Extraer dominio del email
      email_domain: data.customer_email.trim().toLowerCase().split('@')[1],
      
      // Calcular número de productos
      product_count: data.product_ids.length,
      
      // Crear JSONB para metadata
      metadata: {
        product_ids: data.product_ids,
        api_id: data.id,
        processed_at: new Date().toISOString()
      }
    }
  };
});

Paso 4: Insertar en PostgreSQL

1. Añade nodo Postgres
2. Configuración:

Operation: Insert
Table: sales
Columns: customer_email, amount, sale_date, email_domain, product_count, metadata

Mapping (usar expressions):
- customer_email: {{ $json.customer_email }}
- amount: {{ $json.amount }}
- sale_date: {{ $json.sale_date }}
- email_domain: {{ $json.email_domain }}
- product_count: {{ $json.product_count }}
- metadata: {{ JSON.stringify($json.metadata) }}

Options:
  ☑ Return Fields: id, created_at

Tabla PostgreSQL necesaria:

CREATE TABLE sales (
  id SERIAL PRIMARY KEY,
  customer_email VARCHAR(255) NOT NULL,
  amount DECIMAL(10,2) NOT NULL,
  sale_date TIMESTAMP NOT NULL,
  email_domain VARCHAR(100),
  product_count INTEGER,
  metadata JSONB,
  created_at TIMESTAMP DEFAULT NOW()
);
-- Índices para performance
CREATE INDEX idx_sales_email ON sales(customer_email);
CREATE INDEX idx_sales_date ON sales(sale_date DESC);
CREATE INDEX idx_sales_metadata ON sales USING GIN(metadata);

Paso 5: Manejo de Errores y Notificaciones

1. Añade nodo Error Trigger (conecta al workflow)
2. Añade nodo Slack o Email para notificar errores:

Message: 
⚠️ Error en ETL Sales Pipeline
Workflow: {{ $workflow.name }}
Error: {{ $json.error.message }}
Timestamp: {{ new Date().toISOString() }}

Resultado

Este workflow:

• ✅ Se ejecuta automáticamente cada hora
• ✅ Extrae datos de API externa
• ✅ Limpia y valida datos
• ✅ Enriquece con campos calculados
• ✅ Inserta en PostgreSQL con performance óptima
• ✅ Notifica si hay errores

Procesamiento: Puede manejar miles de registros por ejecución con batching configurado.

—

Casos de Uso Avanzados con n8n y Bases de Datos

1. Sincronización Bidireccional entre Sistemas

Escenario: Mantener CRM (Salesforce) sincronizado con base de datos interna PostgreSQL.

Estrategia de Sync:

A) Polling (cada 5 minutos):

Schedule Trigger (*/5 * * * *)
  ↓
PostgreSQL: SELECT * FROM customers WHERE updated_at > $lastSync
  ↓
Function: Transform to Salesforce format
  ↓
Salesforce: Upsert records
  ↓
Store $lastSync timestamp

B) Webhook (tiempo real):

Webhook Trigger (URL: https://n8n.tudominio.com/webhook/crm-sync)
  ↓
Validate payload
  ↓
PostgreSQL: INSERT/UPDATE customer
  ↓
HTTP Request: Notify other systems

Manejo de conflictos:

• Last Write Wins (última modificación gana)
• Timestamp comparison (prioridad al más reciente)
• Manual review queue (conflictos complejos)

2. Backups Automatizados a Cloud Storage

Workflow: Backup Diario de PostgreSQL a Google Drive

Schedule Trigger (0 2 * * *) // 2 AM diario
  ↓
Execute Command: pg_dump -U user -d mydb > /tmp/backup.sql
  ↓
Read Binary File: /tmp/backup.sql
  ↓
Compress: Gzip (reduce tamaño 10x)
  ↓
Google Drive: Upload backup_{{ new Date().toISOString().split('T')[0] }}.sql.gz
  ↓
PostgreSQL: INSERT INTO backup_log (filename, size, status)
  ↓
If: Backups > 30 días
  ↓
Google Drive: Delete old backups
  ↓
Slack: Notificar estado del backup

Retention policy implementada:

• Diarios: últimos 7 días
• Semanales: último mes (domingos)
• Mensuales: último año

3. Data Quality Monitoring

Workflow: Validaciones Automáticas de Calidad

-- Queries de validación a ejecutar diariamente
-- 1. Detectar emails duplicados
SELECT email, COUNT(*) as duplicates
FROM users
GROUP BY email
HAVING COUNT(*) > 1;
-- 2. Detectar precios negativos (error de datos)
SELECT id, name, price
FROM products
WHERE price < 0;
-- 3. Detectar registros huérfanos
SELECT o.id, o.user_id
FROM orders o
LEFT JOIN users u ON o.user_id = u.id
WHERE u.id IS NULL;
-- 4. Detectar campos críticos nulos
SELECT COUNT(*) as invalid_records
FROM customers
WHERE email IS NULL OR phone IS NULL;

Workflow n8n:

Schedule Trigger (diario 6 AM)
  ↓
PostgreSQL: Execute validation queries
  ↓
If: Issues found > 0
  ↓
Create Jira Ticket: "Data Quality Issues - {{ $json.count }} problems"
  ↓
Send Slack Alert: @data-team
  ↓
Update Grafana Dashboard

4. Real-Time Analytics Dashboard

Escenario: Dashboard de ventas en tiempo real para management.

Webhook Trigger: POST /webhook/new-sale
  ↓
Validate: Schema check
  ↓
PostgreSQL Insert: Save transaction
  ↓
PostgreSQL Aggregate: Calculate metrics
  SELECT
    COUNT(*) as sales_today,
    SUM(amount) as revenue_today,
    AVG(amount) as avg_order_value
  FROM sales
  WHERE DATE(created_at) = CURRENT_DATE;
  ↓
If: Sale > $10,000
  ↓
Slack Notify: "@sales-manager VIP Sale: ${{ $json.amount }}"
  ↓
Update Dashboard: POST to Grafana/Metabase API

5. Migración de Datos entre Bases de Datos

Escenario: Migrar 10 millones de registros de MySQL legacy a PostgreSQL.

Estrategia con Batching:

Manual Trigger / Schedule
  ↓
Split In Batches (1000 registros por batch)
  ↓
MySQL: SELECT * FROM users LIMIT 1000 OFFSET {{ $nodeContext["Split In Batches"].iteration * 1000 }}
  ↓
Function: Transform MySQL → PostgreSQL format
  // Convertir tipos incompatibles
  // Ejemplo: DATETIME → TIMESTAMP WITH TIME ZONE
  ↓
PostgreSQL: Batch INSERT (1000 registros)
  ON CONFLICT (email) DO UPDATE
  SET name = EXCLUDED.name, updated_at = NOW();
  ↓
PostgreSQL: Log progress
  INSERT INTO migration_log (batch_id, records_migrated, timestamp)
  ↓
Loop hasta completar todos los registros
  ↓
Final Validation:
  Compare counts, checksums, sample records
  ↓
Slack: "Migration completed: {{ $json.total_records }} migrated"

Ventajas:

• ✅ No overload de memoria (procesa en chunks)
• ✅ Recuperable (puedes pausar y reanudar)
• ✅ Logging completo de progreso
• ✅ Validación automática

—

Optimización de Performance en Workflows de Bases de Datos

1. Usar Índices Correctamente

Cuándo crear índices:

• ✅ Columnas en WHERE clauses frecuentes
• ✅ Columnas en JOINs
• ✅ Foreign keys
• ✅ Columnas en ORDER BY

Ejemplo PostgreSQL:

-- Índice simple para búsquedas por email
CREATE INDEX idx_users_email ON users(email);
-- Índice compuesto para queries con múltiples filtros
CREATE INDEX idx_orders_user_date ON orders(user_id, created_at DESC);
-- Índice parcial (solo registros activos)
CREATE INDEX idx_active_users ON users(email) WHERE active = true;
-- Índice GIN para JSONB
CREATE INDEX idx_products_metadata ON products USING GIN(metadata);

Verificar uso de índices:

EXPLAIN ANALYZE
SELECT * FROM orders WHERE user_id = 123 AND created_at > '2025-01-01';
-- Busca "Index Scan" (bueno) vs "Seq Scan" (malo para tablas grandes)

2. Batch Operations en n8n

❌ MAL: Insertar registros uno por uno (lento)

for (const item of items) {
  await postgresNode.execute('INSERT INTO users VALUES ($1, $2)', [item.name, item.email]);
}
// 1000 registros = 1000 queries = 30 segundos

✅ BIEN: Batch insert (rápido)

Configure el nodo PostgreSQL:

• Batch Size: 1000
• n8n automáticamente agrupa las inserciones

Resultado: 1000 registros = 1 query = 2 segundos

3. Connection Pooling

En docker-compose.yml de n8n:

services:
  n8n:
    environment:
      - DB_POSTGRESDB_POOL_SIZE=20  # Ajustar según carga

Guía de tamaño de pool:

• Desarrollo: 2-5
• Producción ligera: 10-20
• Producción pesada: 50-100

4. Query Optimization

-- ❌ MAL: SELECT * (retorna columnas innecesarias)
SELECT * FROM orders WHERE user_id = 123;
-- ✅ BIEN: Solo columnas necesarias
SELECT id, total, created_at FROM orders WHERE user_id = 123;
-- ❌ MAL: N+1 queries problem
SELECT * FROM users;
-- Luego por cada user: SELECT * FROM orders WHERE user_id = ?
-- ✅ BIEN: Single query con JOIN
SELECT u.*, o.id, o.total
FROM users u
LEFT JOIN orders o ON o.user_id = u.id;

5. Comparativa de Performance

| Operación | Sin Optimizar | Optimizado | Mejora |

|———–|—————|————|——–|

| Insert 1000 registros | 30 seg | 2 seg | 15x más rápido |

| Query sin índice (1M registros) | 5 seg | 0.05 seg | 100x más rápido |

| SELECT * vs columnas específicas | 2 GB transferido | 200 MB | 10x menos red |

| Connection pooling (100 workflows) | Timeouts | Sin errores | 100% reliability |

—

Seguridad: Protege tus Datos y Conexiones

1. Prevención de SQL Injection

❌ NUNCA concatenar strings en queries:

// VULNERABLE - No hacer nunca
const email = $json.email;
const query = `SELECT * FROM users WHERE email = '${email}'`;
// Si email = "'; DROP TABLE users; --" → Desastre

✅ SIEMPRE usar parametrized queries:

// En nodo PostgreSQL de n8n:
// Query field:
SELECT * FROM users WHERE email = $1 AND active = $2
// Parameters field (JSON array):
[
  {{ $json.email }},
  {{ $json.active }}
]

n8n maneja automáticamente el escaping seguro.

2. Credentials Management

Mejores Prácticas:

1. Variables de Entorno (Recomendado):

# .env file
POSTGRES_PASSWORD=<genera-con-pwgen-o-1password>
MYSQL_PASSWORD=<password-diferente>
# En n8n credentials, usar:
{{ $env.POSTGRES_PASSWORD }}

1. Least Privilege Principle:

-- ✅ Usuario n8n con permisos mínimos
CREATE USER n8n_app WITH PASSWORD 'secure_pass';
GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE users TO n8n_app;
-- ❌ NO dar:
-- GRANT ALL PRIVILEGES (demasiado amplio)
-- SUPERUSER (peligroso)
-- DROP TABLE (n8n nunca necesita esto)

1. SSL/TLS para Conexiones Remotas:

// PostgreSQL credential en n8n
{
  "ssl": {
    "enabled": true,
    "rejectUnauthorized": true,
    "ca": "{{ $env.POSTGRES_SSL_CA }}"  // Certificate authority
  }
}

3. Audit Logging

Implementa tabla de auditoría para rastrear todas las operaciones:

CREATE TABLE audit_log (
  id SERIAL PRIMARY KEY,
  workflow_id VARCHAR(255),
  workflow_name VARCHAR(255),
  operation VARCHAR(50),  -- INSERT, UPDATE, DELETE
  table_name VARCHAR(100),
  rows_affected INTEGER,
  user_email VARCHAR(255),
  ip_address INET,
  timestamp TIMESTAMP DEFAULT NOW()
);

n8n Function node para logging:

const auditData = {
  workflow_id: $workflow.id,
  workflow_name: $workflow.name,
  operation: 'INSERT',
  table_name: 'users',
  rows_affected: $input.all().length,
  user_email: $json.current_user_email,
  ip_address: $json.request_ip,
  timestamp: new Date().toISOString()
};
// Insertar en audit_log
return [{ json: auditData }];

—

Troubleshooting: Soluciones a Errores Comunes

Error 1: «Connection Timeout»

Síntomas: Workflow falla con timeout después de 30 segundos.

Causas posibles:

1. Firewall bloqueando puerto 5432 (PostgreSQL) / 3306 (MySQL)
2. PostgreSQL no escuchando en IP externa
3. Credenciales incorrectas

Soluciones:

# 1. Verificar PostgreSQL escucha en red
# Editar postgresql.conf:
listen_addresses = '*'  # o IP específica
# 2. Permitir conexiones en pg_hba.conf:
host    all    all    0.0.0.0/0    md5
# 3. Reiniciar PostgreSQL:
sudo systemctl restart postgresql
# 4. Test de conectividad desde servidor n8n:
telnet postgres-host 5432
# o
nc -zv postgres-host 5432

Error 2: «Too Many Connections»

Síntomas: Error «FATAL: too many connections for role»

Causas: Connection pool agotado o leaks de conexiones.

Soluciones:

-- Ver conexiones actuales:
SELECT count(*) FROM pg_stat_activity WHERE usename = 'n8n_app';
-- Ver max_connections:
SHOW max_connections;
-- Aumentar límite (postgresql.conf):
max_connections = 200  # default: 100
-- Terminar conexiones idle antiguas:
SELECT pg_terminate_backend(pid)
FROM pg_stat_activity
WHERE state = 'idle'
  AND state_change < NOW() - INTERVAL '10 minutes'
  AND usename = 'n8n_app';

En n8n, reducir pool size si es necesario:

environment:
  - DB_POSTGRESDB_POOL_SIZE=10  # reducir de 20 a 10

Error 3: «Duplicate Key Violation»

Error completo: duplicate key value violates unique constraint "users_email_key"

Solución: Usar UPSERT (INSERT … ON CONFLICT)

-- En lugar de INSERT simple:
INSERT INTO users (email, name) VALUES ('juan@example.com', 'Juan Pérez');
-- Usar ON CONFLICT:
INSERT INTO users (email, name, updated_at)
VALUES ('juan@example.com', 'Juan Pérez', NOW())
ON CONFLICT (email)
DO UPDATE SET
  name = EXCLUDED.name,
  updated_at = NOW();

En n8n: Configurar nodo PostgreSQL con «Upsert» operation.

Error 4: Query Muy Lenta

Diagnóstico:

-- Ver plan de ejecución:
EXPLAIN ANALYZE
SELECT * FROM orders o
JOIN users u ON u.id = o.user_id
WHERE o.created_at > '2025-01-01';
-- Buscar problemas:
-- "Seq Scan" en tablas grandes → falta índice
-- "cost=10000..50000" → query ineficiente

Soluciones:

-- Crear índices faltantes:
CREATE INDEX idx_orders_created_at ON orders(created_at);
CREATE INDEX idx_orders_user_id ON orders(user_id);
-- Actualizar estadísticas:
ANALYZE orders;
-- Vacuum para limpiar:
VACUUM ANALYZE orders;

—

Enlaces Relacionados y Recursos

Para profundizar en automatización y homelabs, explora estos artículos:

• [Nodos n8n: Guía Completa de Automatización 2025](https://www.eldiarioia.es/2025/06/24/nodos-n8n-automatizacion/)
• [Maestría del Nodo HTTP Request en n8n (Tutorial Avanzado 2025)](https://www.eldiarioia.es/2025/06/24/maestria-nodo-http-request-n8n/)
• [Automatización Web Avanzada: Integra n8n con Playwright](https://www.eldiarioia.es/2025/06/24/automatizacion-web-avanzada-integra-n8n-con-browsersbase/)
• [Crea tu Bot de Telegram con n8n Gratis (Guía Completa 2025)](https://www.eldiarioia.es/2025/10/09/crea-tu-bot-de-telegram-con-n8n-gratis-guia-completa/)
• [Portainer: Gestiona Docker con Interfaz Web (Guía Completa 2025)](https://www.eldiarioia.es/2025/10/16/portainer-gestiona-docker-con-interfaz-web/)
• [Tailscale para Homelab: VPN Mesh sin Abrir Puertos (Guía 2025)](https://www.eldiarioia.es/2025/10/25/tailscale-homelab-vpn-mesh/)
• [Homelab con GPU 24GB+: Guía Completa Stack Profesional (2025)](https://www.eldiarioia.es/2025/10/25/homelab-gpu-24gb-guia-completa/)
• [Uptime Kuma: Monitoreo Self-Hosted para tu Homelab (Guía 2025)](https://www.eldiarioia.es/2025/11/05/uptime-kuma-monitoreo-self-hosted-homelab/)

—

Preguntas Frecuentes (FAQ)

¿Puedo usar n8n con bases de datos en la nube como AWS RDS o Google Cloud SQL?

Sí, completamente. n8n funciona con cualquier base de datos accesible por red. Para AWS RDS o Google Cloud SQL:

1. Obtén el endpoint público (ej: mydb.xxx.us-east-1.rds.amazonaws.com)
2. Configura Security Groups para permitir IP de tu servidor n8n
3. Usa las credenciales en n8n igual que con base de datos local
4. Habilita SSL obligatorio para conexiones cloud (seguridad)

¿Cuántos registros puede procesar n8n en un workflow?

Millones de registros con la estrategia correcta:

• Sin batching: Hasta ~10,000 registros por ejecución (limitado por memoria)
• Con «Split In Batches» node: Ilimitado (procesa en chunks de 1,000)
• Producción real: Workflows procesando 100,000+ registros por hora son comunes

Ejemplo: Un usuario reportó procesar 5 millones de registros de migración MySQL → PostgreSQL en 8 horas usando n8n con batching de 5,000 registros.

¿n8n soporta transacciones de bases de datos (ACID)?

Parcialmente. Los nodos PostgreSQL y MySQL de n8n ejecutan cada query como transacción individual por defecto. Para transacciones multi-query (BEGIN, COMMIT, ROLLBACK), tienes dos opciones:

1. Usar «Execute Command» node con query completa:

BEGIN;
INSERT INTO orders (user_id, total) VALUES (123, 100.50);
UPDATE inventory SET stock = stock - 1 WHERE product_id = 456;
COMMIT;

1. Manejar errores con «Error Trigger» para rollback manual en caso de fallo.

¿Cómo hago backups de la base de datos de n8n misma?

n8n almacena workflows y credenciales en su propia base de datos. Para backups:

Opción 1: Export/Import de workflows (JSON)

• En n8n UI: Settings → Export workflows → Descargar JSON
• Guardar en Git para versionado

Opción 2: Backup de base de datos PostgreSQL:

# Backup completo
docker exec n8n-postgres pg_dump -U n8n n8n > n8n-backup-$(date +%Y%m%d).sql
# Restore
docker exec -i n8n-postgres psql -U n8n n8n < n8n-backup-20250106.sql

Opción 3: Automated con n8n workflow (meta-automatización 🤯):

• Schedule trigger diario → Execute Command (pg_dump) → Upload to S3/Google Drive

¿MongoDB con n8n es buena idea o mejor usar PostgreSQL?

Depende del caso de uso:

Usa MongoDB si:

• Tus datos no tienen estructura fija (schema cambia frecuentemente)
• Necesitas almacenar documentos complejos anidados
• Prototipado rápido (no necesitas definir tablas)
• Tienes experiencia previa con MongoDB

Usa PostgreSQL si:

• Tus datos son relacionales (usuarios, órdenes, productos con relaciones claras)
• Necesitas JOINs complejos o queries analíticas
• Requieres integridad referencial estricta (foreign keys)
• Quieres flexibilidad JSON (JSONB) + poder SQL

Recomendación general: PostgreSQL es más versátil para mayoría de casos con n8n. MongoDB solo si tienes un caso de uso que lo justifique.

¿Cómo evito que n8n ejecute queries peligrosas (DROP TABLE, DELETE sin WHERE)?

Mejores prácticas de seguridad:

1. Usuario de BD con permisos limitados:

-- NO dar permisos DROP, TRUNCATE, ALTER
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES TO n8n_app;

1. Validación en Function nodes:

const query = $json.query;
const dangerousKeywords = ['DROP', 'TRUNCATE', 'ALTER TABLE'];
if (dangerousKeywords.some(kw => query.toUpperCase().includes(kw))) {
  throw new Error('Query contains dangerous operations - blocked');
}

1. Review manual de workflows críticos antes de activarlos en producción.

¿n8n puede reemplazar herramientas ETL como Airflow o Talend?

Para casos de uso pequeños/medianos: Sí. n8n cubre el 80% de necesidades ETL con ventajas:

• ✅ Interfaz visual más amigable que Airflow
• ✅ Setup más simple (Docker Compose vs Kubernetes complejo)
• ✅ Ideal para equipos pequeños sin data engineers dedicados

Para casos de uso enterprise grandes: Depende.

• Airflow tiene mejores capacidades de scheduling complejo (DAGs)
• Airflow escala mejor a 1000+ workflows
• n8n es más ágil para prototipar y iterar rápido

Conclusión: n8n es excelente para startups, equipos pequeños y homelabs. Airflow para empresas grandes con equipos de data engineering.

¿Cuánto cuesta ejecutar n8n con bases de datos?

Self-hosted (Recomendado):

• n8n: Gratis (open-source)
• Base de datos: Gratis (PostgreSQL/MySQL/MongoDB open-source)
• Servidor: $5-20/mes (DigitalOcean Droplet, AWS EC2 t3.small, Hetzner VPS)
• Total: $5-20/mes para uso ilimitado

n8n Cloud:

• Starter: $20/mes (5,000 ejecuciones)
• Pro: $50/mes (10,000 ejecuciones)
• Base de datos: Aparte (AWS RDS ~$15/mes PostgreSQL básico)
• Total: ~$35-65/mes

Conclusión: Self-hosted es 10x más barato y sin límites de ejecución. Ideal para homelabs.

¿Puedo usar n8n para cumplir con GDPR y regulaciones de datos?

Sí, con configuración correcta:

1. Self-hosted obligatorio (no enviar datos a terceros)
2. Implementar audit logging:

CREATE TABLE data_access_log (
  id SERIAL PRIMARY KEY,
  user_id INTEGER,
  action VARCHAR(50),  -- 'READ', 'UPDATE', 'DELETE'
  data_type VARCHAR(100),
  timestamp TIMESTAMP DEFAULT NOW(),
  ip_address INET
);

• Workflow automático para eliminar datos > 2 años (según política)
• Export de datos de usuario para GDPR «Right to Access»

1. Encryption at rest: Usar bases de datos con disk encryption (LUKS, AWS EBS encryption)

¿Cómo monitoreo el rendimiento de mis workflows de bases de datos?

Opciones de monitoring:

1. n8n built-in: Executions history → Ver duración, errores, logs
2. PostgreSQL logs:

-- Queries lentas (> 1 segundo)
SELECT query, calls, total_time, mean_time
FROM pg_stat_statements
ORDER BY mean_time DESC
LIMIT 10;

• Exportar métricas de PostgreSQL con postgres_exporter
• Crear dashboards con queries/segundo, latencia, pool usage

1. Custom metrics en workflows:

// Function node al final de workflow
const metrics = {
  workflow: $workflow.name,
  duration_ms: Date.now() - new Date($execution.startedAt).getTime(),
  records_processed: $input.all().length
};
// Insert en tabla metrics para análisis histórico

¿n8n funciona bien con bases de datos de millones de registros?

Sí, pero con estrategias específicas:

Para queries SELECT grandes:

• Usar LIMIT + OFFSET con «Split In Batches»
• Crear índices adecuados (B-tree, GIN para JSONB)
• Pagination en lugar de traer todo

Para INSERT masivos:

• Batch size: 1000-5000 registros
• Connection pooling configurado (20-50 conexiones)
• COPY FROM (PostgreSQL) para millones de registros (más rápido que INSERT)

Ejemplo real: Usuario procesó tabla de 50 millones de registros usando:

Split In Batches (10,000 por chunk)
→ PostgreSQL Aggregate query
→ Export resultados a S3
Tiempo: 12 horas (totalmente automatizado)

¿Qué diferencia hay entre el nodo PostgreSQL y el nodo «Execute Command»?

Nodo PostgreSQL:

• ✅ Interfaz visual para operaciones comunes (SELECT, INSERT, UPDATE, DELETE)
• ✅ Mapping automático de campos
• ✅ Batch operations automáticas
• ✅ Prevención SQL injection automática
• ❌ Limitado a operaciones CRUD simples

Nodo Execute Command:

• ✅ Flexibilidad total (cualquier comando PostgreSQL: CREATE TABLE, ALTER, COPY, etc.)
• ✅ Queries complejas con CTEs, window functions
• ✅ Ejecutar scripts SQL completos
• ❌ Necesitas parametrizar manualmente para seguridad
• ❌ No hay mapping visual

Recomendación: Usa PostgreSQL node para 90% de casos. Execute Command para casos avanzados.

¿Puedo usar n8n para migrar de Oracle Database a PostgreSQL?

Sí, pero con limitaciones. n8n no tiene nodo nativo para Oracle, pero puedes:

Opción 1: JDBC Generic Node (experimental)

• Instalar driver JDBC de Oracle
• Configurar connection string
• Limitaciones: Menos estable que nodos nativos

Opción 2: Hybrid Approach (Recomendado)

Export Oracle → CSV/JSON files → n8n (procesa archivos) → PostgreSQL

Opción 3: Usar herramienta especializada primero:

• pgloader (open-source, Oracle → PostgreSQL)
• AWS DMS (Database Migration Service)
• Luego usar n8n para transformaciones post-migración

Conclusión: Para migraciones Oracle complejas, usa herramienta especializada. n8n es ideal para PostgreSQL ↔ MySQL ↔ MongoDB.

¿Los workflows n8n son seguros para manejar datos sensibles (PII, financieros)?

Sí, con configuración adecuada:

Seguridad implementada correctamente:

1. Self-hosted obligatorio (control total de datos)
2. SSL/TLS end-to-end (n8n → BD, APIs externas)
3. Credentials encryption: n8n encripta credenciales en BD con clave maestra
4. Audit logging: Registrar cada acceso a datos sensibles
5. Network isolation: n8n y BDs en VPN privada (Tailscale, WireGuard)
6. Backups encriptados: Usar GPG o LUKS para backups

Ejemplo completo de setup seguro:

# docker-compose.yml
services:
  n8n:
    environment:
      - N8N_ENCRYPTION_KEY=${ENCRYPTION_KEY}  # 32 chars random
      - N8N_USER_MANAGEMENT_JWT_SECRET=${JWT_SECRET}
    networks:
      - internal_network  # No acceso directo a internet
networks:
  internal_network:
    internal: true  # Aislamiento de red

Certificaciones: n8n no tiene SOC2/ISO27001 oficial (es open-source), pero puedes cumplir regulaciones con auditorías de tu implementación.

—

Conclusión

Integrar bases de datos con n8n transforma radicalmente cómo gestionas datos en tu organización. En esta guía has aprendido:

✅ Configurar conexiones seguras a PostgreSQL, MySQL y MongoDB

✅ Crear pipelines ETL completos para automatizar extracción, transformación y carga

✅ Implementar casos de uso avanzados: backups, sincronización, analytics en tiempo real

✅ Optimizar performance con índices, batching y connection pooling

✅ Aplicar seguridad enterprise-grade (SQL injection prevention, credentials management, audit logging)

✅ Troubleshoot errores comunes con soluciones probadas

Próximos pasos recomendados:

1. Instala n8n con Docker Compose usando la configuración de este artículo
2. Crea tu primer workflow ETL simple: API → Transform → PostgreSQL
3. Implementa backups automatizados de tus bases de datos críticas
4. Explora templates de la comunidad: https://n8n.io/workflows
5. Une la comunidad n8n hispana: https://n8nhispano.com

Las posibilidades son infinitas: desde startups automatizando su stack completo, hasta homelabs con pipelines de datos profesionales. n8n democratiza la automatización de datos, haciéndola accesible sin necesitar un equipo de data engineers.

¿Qué workflow vas a crear primero? 🚀

—

Recursos Adicionales:

• Documentación Oficial n8n: https://docs.n8n.io
• n8n Community Forum: https://community.n8n.io
• PostgreSQL Documentation: https://www.postgresql.org/docs
• Curso n8n en Platzi: https://platzi.com/cursos/n8n (Español)
• n8n GitHub (ejemplos): https://github.com/n8n-io/n8n