Saltar a contenido

n8n flujo de trabajo Automatización Cheat Sheet

Sinopsis

n8n es una potente plataforma de automatización de flujos de trabajo de código abierto que permite a los usuarios conectar diferentes sistemas, servicios y APIs para crear flujos de trabajo automatizados con codificación mínima. Lo que distingue a n8n de otras herramientas de automatización es su combinación única de flexibilidad, extensibilidad y capacidades de IA, lo que lo hace adecuado tanto para automatizaciones simples como para complejos flujos de trabajo de empresa.

Como una solución autoanfitriona, n8n da a los usuarios control completo sobre sus datos y flujos de trabajo, abordando preocupaciones de privacidad y seguridad que vienen con soluciones solo en la nube. Su interfaz visual basada en nodos permite la creación de flujo de trabajo intuitivo, al tiempo que ofrece las opciones de profundidad y personalización que necesitan los usuarios técnicos. Con soporte para transformaciones JavaScript, lógica condicional, manejo de errores y una creciente biblioteca de integraciones, n8n ha surgido como un favorito entre desarrolladores y equipos técnicos que buscan automatizar procesos sin sacrificar el control o las capacidades.

En la era AI, n8n se ha posicionado como una herramienta clave para orquestar los flujos de trabajo AI, con nodos incorporados para los servicios populares de AI y la capacidad de crear integraciones personalizadas con cualquier modelo o servicio AI accesible por API. Esto hace que sea un instrumento esencial para las organizaciones que buscan incorporar la IA en sus procesos empresariales manteniendo al mismo tiempo la gobernanza y el control.

Instalación y configuración

Instalación autoestablecida

# Using npm
npm install n8n -g
n8n start

# Using Docker
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

# Using Docker Compose
# Create docker-compose.yml with:
# version: '3'
# services:
#   n8n:
#     image: n8nio/n8n
#     restart: always
#     ports:
#       - "5678:5678"
#     volumes:
#       - ~/.n8n:/home/node/.n8n
#     environment:
#       - N8N_ENCRYPTION_KEY=your-secret-key
#       - N8N_PROTOCOL=https
#       - N8N_HOST=n8n.example.com

docker-compose up -d

Instalación en la nube

n8n ofrece una versión en la nube en n8n.cloud con varios niveles de precios, de libre a empresa.

Configuración del medio ambiente

# Basic configuration
export N8N_ENCRYPTION_KEY=your-secret-key
export N8N_PROTOCOL=https
export N8N_HOST=n8n.example.com
export N8N_PORT=5678

# Database configuration (PostgreSQL)
export DB_TYPE=postgresdb
export DB_POSTGRESDB_HOST=postgres
export DB_POSTGRESDB_PORT=5432
export DB_POSTGRESDB_DATABASE=n8n
export DB_POSTGRESDB_USER=n8n
export DB_POSTGRESDB_PASSWORD=password

# Queue configuration (Redis)
export QUEUE_BULL_REDIS_HOST=redis
export QUEUE_BULL_REDIS_PORT=6379

# Authentication
export N8N_BASIC_AUTH_ACTIVE=true
export N8N_BASIC_AUTH_USER=admin
export N8N_BASIC_AUTH_PASSWORD=password

Conceptos básicos

Corrientes de trabajo

Los flujos de trabajo son los principales bloques de construcción en n8n. Consisten en nodos conectados para definir un flujo de proceso.

Nodos

Los ganglios representan acciones, desencadenantes o operaciones en un flujo de trabajo. Cada nodo tiene funcionalidad específica, como enviar un correo electrónico, consultar una base de datos o procesar datos.

Conexión

Las conexiones unen los nodos, definiendo el flujo de datos de un nodo a otro.

Triggers

Los desencadenantes son nodos especiales que inician una ejecución de flujo de trabajo, como webhooks, cronogramas o eventos de sistemas externos.

Ejecuciones

Las ejecuciones son casos de un flujo de trabajo que se está ejecutando, ya sea manual o automáticamente activado.

Creación de flujo de trabajo básico

Crear un nuevo flujo de trabajo

  1. Navegue a la interfaz n8n (por defecto: n8n.example.com_)
  2. Haga clic en "Operaciones de trabajo" en la barra lateral
  3. Haga clic en "Crear nuevo flujo de trabajo"
  4. Introduzca un nombre para su flujo de trabajo
  5. Haga clic en "Guardar"

Agregar y conectar los nodos

  1. Haga clic en el botón "+" para añadir un nodo
  2. Buscar el tipo de nodo deseado
  3. Configurar la configuración del nodo
  4. Conectar nodos arrastrando desde el punto de salida de un nodo al punto de entrada de otro
  5. Haga clic en "Ejecutar flujo de trabajo" para probar

Ejemplo de flujo de trabajo básico

// HTTP Request Node Configuration
\\\\{
  "url": "https://api.example.com/data",
  "method": "GET",
  "authentication": "Basic Auth",
  "username": "user",
  "password": "pass"
\\\\}

// Function Node to Transform Data
function transform(items) \\\\{
  return items.map(item => \\\\{
    return \\\\{
      id: item.json.id,
      name: item.json.name.toUpperCase(),
      created: new Date(item.json.created_at).toISOString()
    \\\\};
  \\\\});
\\\\}

// Send Email Node Configuration
\\\\{
  "to": "recipient@example.com",
  "subject": "Data Report",
  "text": "=== Please find the data report attached ===",
  "attachments": "=\\\\{\\\\{ $json.report \\\\}\\\\}"
\\\\}

Triggers and Scheduling

Webhook Trigger

// Webhook Node Configuration
\\\\{
  "path": "incoming-data",
  "responseMode": "onReceived",
  "responseData": "firstEntryJson"
\\\\}

// Access in browser or via curl
// https://n8n.example.com/webhook/incoming-data
// curl -X POST -H "Content-Type: application/json" -d '\\\\{"data":"test"\\\\}' https://n8n.example.com/webhook/incoming-data

Programa Trigger

// Cron Node Configuration
\\\\{
  "triggerTimes": \\\\{
    "item": [
      \\\\{
        "mode": "everyWeek",
        "hour": 9,
        "minute": 0,
        "dayOfWeek": 1 // Monday
      \\\\}
    ]
  \\\\}
\\\\}

// Every 5 minutes
\\\\{
  "triggerTimes": \\\\{
    "item": [
      \\\\{
        "mode": "everyX",
        "unit": "minutes",
        "value": 5
      \\\\}
    ]
  \\\\}
\\\\}

Trigger on File Changes

// Watch Files Node Configuration
\\\\{
  "folder": "/data/incoming",
  "includeSubfolders": true,
  "fileExtensions": [
    "csv",
    "xlsx"
  ]
\\\\}

Manipulación de datos

Función Nodo

// Basic transformation
function transform(items) \\\\{
  return items.map(item => \\\\{
    return \\\\{
      ...item.json,
      fullName: `$\\{item.json.firstName\\} $\\{item.json.lastName\\}`,
      age: calculateAge(item.json.birthDate)
    \\\\};
  \\\\});
\\\\}

function calculateAge(birthDate) \\\\{
  const today = new Date();
  const birth = new Date(birthDate);
  let age = today.getFullYear() - birth.getFullYear();
  const monthDiff = today.getMonth() - birth.getMonth();

  if (monthDiff < 0||(monthDiff === 0 && today.getDate() < birth.getDate())) \\\\{
    age--;
  \\\\}

  return age;
\\\\}

// Filtering data
function filter(items) \\\\{
  return items.filter(item => \\\\{
    return item.json.status === 'active' && item.json.age > 18;
  \\\\});
\\\\}

// Aggregating data
function aggregate(items) \\\\{
  const result = \\\\{
    count: items.length,
    sum: 0,
    average: 0,
    min: Infinity,
    max: -Infinity
  \\\\};

  items.forEach(item => \\\\{
    const value = item.json.amount;
    result.sum += value;
    result.min = Math.min(result.min, value);
    result.max = Math.max(result.max, value);
  \\\\});

  result.average = result.sum / result.count;

  return [\\\\{ json: result \\\\}];
\\\\}

Dividir en murciélagos Nodo

// Split In Batches Node Configuration
\\\\{
  "batchSize": 10,
  "options": \\\\{
    "includeBatchIndex": true
  \\\\}
\\\\}

Merge Node

// Merge Node Configuration
\\\\{
  "mode": "merge",
  "mergeByFields": \\\\{
    "values": [
      \\\\{
        "field1": "id",
        "field2": "userId"
      \\\\}
    ]
  \\\\}
\\\\}

// Concatenate mode
\\\\{
  "mode": "concatenate"
\\\\}

// Multiplex mode (combine all items from all inputs)
\\\\{
  "mode": "multiplex"
\\\\}

Manejo de errores y control de flujo

Flujo de trabajo de error

// Error Trigger Node
// This node triggers when another workflow fails

// Error Workflow Example
// 1. Error Trigger Node
// 2. Send Email Node with error details
\\\\{
  "to": "admin@example.com",
  "subject": "Workflow Error: \\\\{\\\\{ $workflow.name \\\\}\\\\}",
  "text": "Error in workflow: \\\\{\\\\{ $workflow.name \\\\}\\\\}\n\nError: \\\\{\\\\{ $json.error \\\\}\\\\}\n\nExecution ID: \\\\{\\\\{ $execution.id \\\\}\\\\}"
\\\\}

IF Node

// IF Node Configuration
\\\\{
  "conditions": \\\\{
    "string": [
      \\\\{
        "value1": "=\\\\{\\\\{ $json.status \\\\}\\\\}",
        "operation": "equal",
        "value2": "success"
      \\\\}
    ]
  \\\\}
\\\\}

// Multiple conditions with AND/OR
\\\\{
  "conditions": \\\\{
    "string": [
      \\\\{
        "value1": "=\\\\{\\\\{ $json.status \\\\}\\\\}",
        "operation": "equal",
        "value2": "pending"
      \\\\}
    ],
    "number": [
      \\\\{
        "value1": "=\\\\{\\\\{ $json.amount \\\\}\\\\}",
        "operation": "larger",
        "value2": 1000
      \\\\}
    ],
    "boolean": [
      \\\\{
        "value1": "=\\\\{\\\\{ $json.isVIP \\\\}\\\\}",
        "operation": "equal",
        "value2": true
      \\\\}
    ],
    "combinationMode": "any" // "all" for AND, "any" for OR
  \\\\}
\\\\}

Nodo de conmutación

// Switch Node Configuration
\\\\{
  "rules": \\\\{
    "values": [
      \\\\{
        "conditions": \\\\{
          "string": [
            \\\\{
              "value1": "=\\\\{\\\\{ $json.status \\\\}\\\\}",
              "operation": "equal",
              "value2": "new"
            \\\\}
          ]
        \\\\},
        "outputIndex": 0
      \\\\},
      \\\\{
        "conditions": \\\\{
          "string": [
            \\\\{
              "value1": "=\\\\{\\\\{ $json.status \\\\}\\\\}",
              "operation": "equal",
              "value2": "processing"
            \\\\}
          ]
        \\\\},
        "outputIndex": 1
      \\\\},
      \\\\{
        "conditions": \\\\{
          "string": [
            \\\\{
              "value1": "=\\\\{\\\\{ $json.status \\\\}\\\\}",
              "operation": "equal",
              "value2": "completed"
            \\\\}
          ]
        \\\\},
        "outputIndex": 2
      \\\\}
    ]
  \\\\},
  "fallbackOutput": 3
\\\\}

Espera Node

// Wait Node Configuration
\\\\{
  "amount": 5,
  "unit": "minutes"
\\\\}

// Wait until specific date
\\\\{
  "dateTime": "=\\\\{\\\\{ new Date($json.scheduledTime).toISOString() \\\\}\\\\}"
\\\\}

Trabajando con API

Nodo de solicitud HTTP

// Basic GET request
\\\\{
  "url": "https://api.example.com/users",
  "method": "GET",
  "authentication": "None",
  "options": \\\\{\\\\}
\\\\}

// POST request with JSON body
\\\\{
  "url": "https://api.example.com/users",
  "method": "POST",
  "authentication": "Bearer Token",
  "token": "\\\\{\\\\{ $node['Get Token'].json.access_token \\\\}\\\\}",
  "bodyContentType": "json",
  "body": \\\\{
    "name": "\\\\{\\\\{ $json.name \\\\}\\\\}",
    "email": "\\\\{\\\\{ $json.email \\\\}\\\\}",
    "role": "user"
  \\\\},
  "options": \\\\{
    "redirect": \\\\{
      "follow": true,
      "maxRedirects": 5
    \\\\},
    "timeout": 10000
  \\\\}
\\\\}

// Handling pagination
\\\\{
  "url": "https://api.example.com/users",
  "method": "GET",
  "authentication": "None",
  "options": \\\\{
    "qs": \\\\{
      "page": "=\\\\{\\\\{ $parameter.page||1 \\\\}\\\\}",
      "limit": 100
    \\\\}
  \\\\}
\\\\}

Auténtica OAuth

// OAuth2 Configuration
\\\\{
  "authentication": "OAuth2",
  "oAuth2Api": "custom",
  "authUrl": "https://auth.example.com/oauth/authorize",
  "accessTokenUrl": "https://auth.example.com/oauth/token",
  "clientId": "your-client-id",
  "clientSecret": "your-client-secret",
  "scope": "read write",
  "authQueryParameters": "",
  "authentication": "body"
\\\\}

Nodo de respuesta de Webhook

// Webhook Response Node Configuration
\\\\{
  "respondWith": "json",
  "responseBody": "=\\\\{\\\\{ \\\\{ success: true, data: $json.processedData \\\\} \\\\}\\\\}",
  "options": \\\\{
    "responseCode": 200,
    "responseHeaders": \\\\{
      "X-Powered-By": "n8n"
    \\\\}
  \\\\}
\\\\}

Operaciones de base de datos

Postgres Node

// Query execution
\\\\{
  "operation": "executeQuery",
  "query": "SELECT * FROM users WHERE status = $1 AND created_at > $2",
  "values": [
    "=\\\\{\\\\{ $json.status \\\\}\\\\}",
    "=\\\\{\\\\{ $json.date \\\\}\\\\}"
  ]
\\\\}

// Insert operation
\\\\{
  "operation": "insert",
  "table": "users",
  "columns": "firstName,lastName,email,createdAt",
  "values": [
    "=\\\\{\\\\{ $json.first_name \\\\}\\\\}",
    "=\\\\{\\\\{ $json.last_name \\\\}\\\\}",
    "=\\\\{\\\\{ $json.email \\\\}\\\\}",
    "=\\\\{\\\\{ new Date().toISOString() \\\\}\\\\}"
  ]
\\\\}

// Update operation
\\\\{
  "operation": "update",
  "table": "users",
  "updateKey": "id",
  "columns": "status,updatedAt",
  "values": [
    "active",
    "=\\\\{\\\\{ new Date().toISOString() \\\\}\\\\}"
  ]
\\\\}

MongoDB Node

// Find documents
\\\\{
  "operation": "find",
  "collection": "users",
  "options": \\\\{
    "limit": 100,
    "sort": \\\\{
      "createdAt": -1
    \\\\}
  \\\\},
  "query": "=\\\\{\\\\{ \\\\{ status: $json.status \\\\} \\\\}\\\\}"
\\\\}

// Insert document
\\\\{
  "operation": "insertOne",
  "collection": "logs",
  "document": "=\\\\{\\\\{ \\\\{
    action: $json.action,
    userId: $json.userId,
    timestamp: new Date(),
    details: $json.details
  \\\\} \\\\}\\\\}"
\\\\}

// Update document
\\\\{
  "operation": "updateOne",
  "collection": "users",
  "filter": "=\\\\{\\\\{ \\\\{ _id: $json.userId \\\\} \\\\}\\\\}",
  "update": "=\\\\{\\\\{ \\\\{
    $set: \\\\{
      status: $json.newStatus,
      updatedAt: new Date()
    \\\\}
  \\\\} \\\\}\\\\}",
  "options": \\\\{
    "upsert": false
  \\\\}
\\\\}

Operaciones de archivo

Read Binary Files Node

// Read Binary Files Node Configuration
\\\\{
  "filePath": "/data/reports/latest.pdf"
\\\\}

// Read multiple files with pattern
\\\\{
  "filePath": "/data/reports/*.csv"
\\\\}

Nodo de archivo binario

// Write Binary File Node Configuration
\\\\{
  "filePath": "=\\\\{\\\\{ '/data/processed/' + $json.filename \\\\}\\\\}",
  "fileName": "=\\\\{\\\\{ $json.filename \\\\}\\\\}",
  "binaryPropertyName": "data",
  "options": \\\\{
    "encoding": "utf8",
    "createParentPath": true
  \\\\}
\\\\}

CSV Node

// Parse CSV
\\\\{
  "operation": "parse",
  "options": \\\\{
    "headerRow": true,
    "delimiter": ",",
    "includeEmptyLines": false,
    "skipLines": 0
  \\\\}
\\\\}

// Create CSV
\\\\{
  "operation": "create",
  "options": \\\\{
    "headerRow": true,
    "delimiter": ",",
    "includeEmptyLines": false
  \\\\}
\\\\}

Integración

OpenAI Node

// Text completion
\\\\{
  "authentication": "apiKey",
  "apiKey": "\\\\{\\\\{ $node['Credentials'].json.openai_api_key \\\\}\\\\}",
  "operation": "completion",
  "model": "gpt-4",
  "options": \\\\{
    "prompt": "=\\\\{\\\\{ 'Summarize the following text in 3 bullet points:\\n\\n' + $json.text \\\\}\\\\}",
    "maxTokens": 500,
    "temperature": 0.7,
    "topP": 1,
    "presencePenalty": 0,
    "frequencyPenalty": 0,
    "stop": []
  \\\\}
\\\\}

// Chat completion
\\\\{
  "authentication": "apiKey",
  "apiKey": "\\\\{\\\\{ $node['Credentials'].json.openai_api_key \\\\}\\\\}",
  "operation": "chatCompletion",
  "messages": "=\\\\{\\\\{ [
    \\\\{ role: 'system', content: 'You are a helpful assistant.' \\\\},
    \\\\{ role: 'user', content: $json.userMessage \\\\}
  ] \\\\}\\\\}",
  "model": "gpt-4",
  "options": \\\\{
    "temperature": 0.7,
    "maxTokens": 1000
  \\\\}
\\\\}

Nodo antropópico

// Claude message
\\\\{
  "authentication": "apiKey",
  "apiKey": "\\\\{\\\\{ $node['Credentials'].json.anthropic_api_key \\\\}\\\\}",
  "operation": "message",
  "model": "claude-3-opus-20240229",
  "messages": "=\\\\{\\\\{ [
    \\\\{ role: 'user', content: $json.userMessage \\\\}
  ] \\\\}\\\\}",
  "options": \\\\{
    "temperature": 0.7,
    "maxTokens": 1000
  \\\\}
\\\\}

AI Document Processing

// Document processing workflow
// 1. Read Binary Files Node (PDF)
// 2. PDF Extract Node
\\\\{
  "operation": "extractText"
\\\\}
// 3. Text Splitter Node
\\\\{
  "operation": "splitByCharacter",
  "options": \\\\{
    "chunkSize": 1000,
    "chunkOverlap": 200
  \\\\}
\\\\}
// 4. OpenAI Node (for each chunk)
\\\\{
  "operation": "chatCompletion",
  "messages": "=\\\\{\\\\{ [
    \\\\{ role: 'system', content: 'Extract key information from this document chunk.' \\\\},
    \\\\{ role: 'user', content: $json.text \\\\}
  ] \\\\}\\\\}",
  "model": "gpt-4",
  "options": \\\\{
    "temperature": 0.3
  \\\\}
\\\\}
// 5. Merge Node (combine all extracted information)
// 6. OpenAI Node (final summary)
\\\\{
  "operation": "chatCompletion",
  "messages": "=\\\\{\\\\{ [
    \\\\{ role: 'system', content: 'Create a comprehensive summary of this document based on the extracted information.' \\\\},
    \\\\{ role: 'user', content: $json.extractedInfo \\\\}
  ] \\\\}\\\\}",
  "model": "gpt-4",
  "options": \\\\{
    "temperature": 0.5
  \\\\}
\\\\}

Características avanzadas

Subworkflows

// Execute Workflow Node Configuration
\\\\{
  "workflowId": 123,
  "options": \\\\{
    "waitForResponse": true
  \\\\}
\\\\}

// Passing data to subworkflow
\\\\{
  "workflowId": 123,
  "options": \\\\{
    "waitForResponse": true
  \\\\},
  "parameters": "=\\\\{\\\\{ \\\\{
    userId: $json.id,
    action: 'process',
    data: $json.payload
  \\\\} \\\\}\\\\}"
\\\\}

Gestión de las credenciales

// Access credentials in HTTP Request Node
\\\\{
  "url": "https://api.example.com/data",
  "method": "GET",
  "authentication": "Basic Auth",
  "username": "=\\\\{\\\\{ $credentials.username \\\\}\\\\}",
  "password": "=\\\\{\\\\{ $credentials.password \\\\}\\\\}"
\\\\}

Webhook Authentication

// Webhook Node with Basic Auth
\\\\{
  "path": "secure-endpoint",
  "authentication": \\\\{
    "basicAuth": \\\\{
      "user": "admin",
      "password": "secret"
    \\\\}
  \\\\},
  "responseMode": "onReceived",
  "responseData": "firstEntryJson"
\\\\}

// Webhook Node with Custom Auth (Header)
\\\\{
  "path": "api-endpoint",
  "httpMethod": "POST",
  "authentication": \\\\{
    "customAuth": \\\\{
      "checkOn": "header",
      "name": "X-API-KEY",
      "value": "your-secret-api-key"
    \\\\}
  \\\\},
  "responseMode": "lastNode",
  "responseData": "firstEntryJson"
\\\\}

Tasa de limitación

// Limit Node Configuration
\\\\{
  "maxConcurrency": 5,
  "options": \\\\{
    "batchSize": 10,
    "batchInterval": 1000
  \\\\}
\\\\}

Flujo de trabajo Variables

// Set Variable Node
\\\\{
  "variableName": "totalAmount",
  "value": "=\\\\{\\\\{ $json.amount \\\\}\\\\}"
\\\\}

// Get Variable Node
\\\\{
  "variableName": "totalAmount"
\\\\}

// Using variables in expressions
"=\\\\{\\\\{ $vars.totalAmount * 1.1 \\\\}\\\\}" // Add 10% tax

Despliegue y producción

Medio ambiente

# Set environment variables for production
export N8N_ENCRYPTION_KEY=your-production-key
export N8N_PROTOCOL=https
export N8N_HOST=n8n.yourdomain.com
export N8N_PORT=5678
export N8N_BASIC_AUTH_ACTIVE=true
export N8N_BASIC_AUTH_USER=admin
export N8N_BASIC_AUTH_PASSWORD=secure-password

# Database configuration
export DB_TYPE=postgresdb
export DB_POSTGRESDB_HOST=production-db.yourdomain.com
export DB_POSTGRESDB_PORT=5432
export DB_POSTGRESDB_DATABASE=n8n_prod
export DB_POSTGRESDB_USER=n8n_user
export DB_POSTGRESDB_PASSWORD=db-password

# Queue configuration
export QUEUE_BULL_REDIS_HOST=redis.yourdomain.com
export QUEUE_BULL_REDIS_PORT=6379

Docker Compose para Producción

version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_ENCRYPTION_KEY=$\\\\{N8N_ENCRYPTION_KEY\\\\}
      - N8N_PROTOCOL=https
      - N8N_HOST=$\\\\{N8N_HOST\\\\}
      - N8N_PORT=5678
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=$\\\\{N8N_BASIC_AUTH_USER\\\\}
      - N8N_BASIC_AUTH_PASSWORD=$\\\\{N8N_BASIC_AUTH_PASSWORD\\\\}
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=$\\\\{DB_USER\\\\}
      - DB_POSTGRESDB_PASSWORD=$\\\\{DB_PASSWORD\\\\}
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
      - EXECUTIONS_PROCESS=main
      - EXECUTIONS_MODE=queue
      - GENERIC_TIMEZONE=UTC
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:14
    restart: always
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=$\\\\{DB_USER\\\\}
      - POSTGRES_PASSWORD=$\\\\{DB_PASSWORD\\\\}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $\\\\{DB_USER\\\\} -d n8n"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    restart: always
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  n8n_data:
  postgres_data:
  redis_data:

Escalada con múltiples trabajadores

# Main process (API, UI, Webhook)
export EXECUTIONS_PROCESS=main
export EXECUTIONS_MODE=queue

# Worker processes (execute workflows)
export EXECUTIONS_PROCESS=worker
export EXECUTIONS_MODE=queue

Respaldo y restauración

# Export workflows
n8n export:workflow --all --output=workflows-backup.json

# Import workflows
n8n import:workflow --input=workflows-backup.json

# Backup credentials (encrypted)
n8n export:credentials --all --output=credentials-backup.json

# Import credentials
n8n import:credentials --input=credentials-backup.json --separate

Buenas prácticas

Workflow Organization

  • ** Convención sobre la nominación**: Use nombres claros y descriptivos para flujos de trabajo y nodos
  • Documentación: Añadir descripciones a flujos de trabajo y nodos complejos
  • Modularización: Romper procesos complejos en subflujos de trabajo
  • Tags: Use tags to categorize and organize workflows
  • Version Control: Exportar flujos de trabajo importantes regularmente

Optimización del rendimiento

  • Procesamiento de la red: Use Split In Batches para grandes conjuntos de datos
  • Pagination: Implementar la paginación adecuada para las llamadas API
  • Caching: Use Set/Get Variable nodes to cache repeated data
  • Limit Concurrency: Use Limit node para prevenir servicios externos abrumadores
  • Eficiencia de la base de datos: Escribe consultas eficientes e índices de uso

Manejo de errores

  • Error Workflows: Crear flujos de trabajo dedicados de manejo de errores
  • Retry Mechanisms: Implementar la lógica de retry para fallas transitorias
  • Validación: Validar los datos antes del procesamiento
  • Logging: Lograr eventos y errores importantes
  • Notificaciones: Establecer alertas para fallos críticos

Seguridad

  • Credentials: Utilice el sistema de credenciales integradas en lugar de codificación dura
  • ** Variables del medio ambiente**: Almacenar información confidencial en variables ambientales
  • Authentication: Puntos finales webhook seguros con autenticación
  • Access Control: Implementar permisos de usuario adecuados
  • Audit Logs: Monitorear las ejecuciones de flujo de trabajo y los cambios

Solución de problemas

Cuestiones comunes

El flujo de trabajo no es desencadenante

  • Causa: Configuración incorrecta del disparador, URL del Webhook no accesible, o problemas de programación
  • Solución: Verificar la configuración del disparador, comprobar la accesibilidad del Webhook y confirmar la configuración de la zona horaria

Fallos de ejecución de nodos

  • Causa: Formato de datos inválidos, campos requeridos perdidos o límites de la tasa de API
  • Solución: Utilizar los nodos de la función para validar y transformar datos, implementar el manejo de errores y añadir la tasa límite

Cuestiones de ejecución

  • Causa: Procesar grandes conjuntos de datos, consultas ineficientes o limitaciones de recursos
  • Solución: Implementar procesamiento por lotes, optimizar las consultas de base y escala n8n de despliegue

Errores de autenticación

  • Causa: Las credenciales gastadas, las claves incorrectas de API o problemas de token OAuth
  • Solución: Actualizar las credenciales, verificar los permisos de clave de API y refrescar las fichas de OAuth

-...

*Esta completa hoja de trampa n8n proporciona todo lo necesario para construir sofisticados automatización de flujo de trabajo. Desde la configuración básica hasta patrones avanzados de implementación de la producción, utilice estos ejemplos y mejores prácticas para crear flujos de trabajo de automatización potentes y flexibles con la plataforma versátil de n8n. *