Aller au contenu

n8n Automatisation du flux de travail Feuille de chaleur

Aperçu général

n8n est une plate-forme d'automatisation des flux de travail puissante et ouverte qui permet aux utilisateurs de connecter différents systèmes, services et API pour créer des flux de travail automatisés avec un codage minimal. Ce qui distingue n8n d'autres outils d'automatisation, c'est sa combinaison unique de flexibilité, d'extensibilité et de capacités d'IA, ce qui le rend adapté à la fois pour des automatisations simples et des workflows d'entreprise complexes.

En tant que solution auto-portable, n8n donne aux utilisateurs un contrôle complet sur leurs données et leurs flux de travail, en répondant aux préoccupations de confidentialité et de sécurité qui viennent avec des solutions cloud-only. Son interface visuelle à base de nœuds permet de créer des flux de travail intuitifs tout en offrant les options de profondeur et de personnalisation dont les utilisateurs techniques ont besoin. Avec le support des transformations JavaScript, la logique conditionnelle, le traitement des erreurs et une bibliothèque croissante d'intégrations, n8n est devenu un favori parmi les développeurs et les équipes techniques qui cherchent à automatiser les processus sans sacrifier le contrôle ou les capacités.

À l'ère de l'IA, n8n s'est positionné comme un outil clé pour orchestrer les flux de travail de l'IA, avec des nœuds intégrés pour les services d'IA populaires et la possibilité de créer des intégrations personnalisées avec n'importe quel modèle ou service d'IA accessible par API. Cela en fait un outil essentiel pour les organisations qui cherchent à intégrer l'IA dans leurs processus opérationnels tout en maintenant la gouvernance et le contrôle.

Installation et configuration

Installation autonome

# 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

Installation en nuage

n8n offre une version en nuage à n8n.cloud avec différents niveaux de tarification, de libre à entreprise.

Configuration de l'environnement

# 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
```_

## Concepts fondamentaux

### Flux de travail
Les flux de travail sont les principaux éléments de construction en n8n. Ils se composent de nœuds reliés ensemble pour définir un flux de processus.

### Noeuds
Les nœuds représentent des actions, des déclencheurs ou des opérations dans un workflow. Chaque noeud a des fonctionnalités spécifiques, comme l'envoi d'un courriel, la requête d'une base de données ou le traitement des données.

### Connexions
Les connexions relient les nœuds, définissant le flux de données d'un noeud à l'autre.

### Déclencheurs
Les déclencheurs sont des nœuds spéciaux qui démarrent une exécution de workflow, tels que des webhooks, des calendriers ou des événements à partir de systèmes externes.

### Exécutions
Les exécutions sont des cas d'exécution d'un workflow, manuellement ou automatiquement déclenché.

## Création de flux de travail de base

### Créer un nouveau flux de travail
1. Naviguez vers l'interface n8n (par défaut : `n8n.example.com`)
2. Cliquez sur "Flux de travail" dans la barre latérale
3. Cliquez sur "Créer un nouveau workflow"
4. Saisissez un nom pour votre workflow
5. Cliquez sur "Enregistrer"

### Ajout et connexion de nœuds
1. Cliquez sur le bouton "+" pour ajouter un noeud
2. Rechercher le type de noeud souhaité
3. Configuration des paramètres du noeud
4. Connectez les nœuds en faisant glisser du point de sortie d'un noeud au point d'entrée d'un autre.
5. Cliquez sur "Exécuter le flux de travail" pour tester

### Exemple de flux de travail de base
```javascript
// 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 \\\\}\\\\}"
\\\\}
```_

## Déclencheurs et calendrier

### Déclencheur Webhook
```javascript
// 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

Déclencheur de calendrier

// 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
      \\\\}
    ]
  \\\\}
\\\\}

Déclencher les changements de fichiers

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

Manipulation des données

Numéro de fonction

// 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 \\\\}];
\\\\}

Découpe du nœud des piles

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

Numéro de fusion

// 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"
\\\\}

Gestion des erreurs et contrôle du débit

Erreur de flux de travail

// 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 \\\\}\\\\}"
\\\\}

FI Noeud

// 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
  \\\\}
\\\\}

Commutateur

// 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
\\\\}

Numéro d'attente

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

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

Travailler avec les API

Noeud de requête 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
    \\\\}
  \\\\}
\\\\}

Authentification 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"
\\\\}

Noeud de réponse Webhook

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

Opérations de bases de données

Noeud Postgres

// 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() \\\\}\\\\}"
  ]
\\\\}

MangoDB Noeud

// 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
  \\\\}
\\\\}

Opérations de fichiers

Lien vers les fichiers binaires

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

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

Noeud de fichier binaire écrit

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

CSV Noeud

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

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

Intégration de l'IA

Noeud OpenAI

// 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
  \\\\}
\\\\}

Noeud anthropique

// 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
  \\\\}
\\\\}

Traitement des documents AI

// 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
  \\\\}
\\\\}

Caractéristiques avancées

Sous- flux de travail

// 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
  \\\\} \\\\}\\\\}"
\\\\}

Gestion des pouvoirs

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

Authentification du Webhook

// 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"
\\\\}

Limite des taux

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

Variables de flux de travail

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

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

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

Déploiement et production

Variables d'environnement

# 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

Compose Docker pour la production

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:

Élargissement avec plusieurs travailleurs

# 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

Sauvegarde et restauration

# 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

Meilleures pratiques

Organisation des flux de travail

  • ** Convention de Naming** : Utiliser des noms descriptifs clairs pour les flux de travail et les nœuds
  • Documentation: Ajouter des descriptions aux flux de travail et aux nœuds complexes
  • Modalisation : Diviser les processus complexes en sous-flux de travail
  • Tags: Utilisez des balises pour catégoriser et organiser les workflows
  • ** Contrôle de version**: Exporter régulièrement des flux de travail importants

Optimisation des performances

  • ** Traitement par lots** : Utilisez Split In Battches pour les gros ensembles de données
  • Pagination: Mettre en œuvre une pagination appropriée pour les appels API
  • Cachage: Utilisez Set/Get Variable nœuds pour stocker des données répétées
  • Concurrence limitée: utilisation d'un nœud Limit pour prévenir les services externes accablants
  • Efficacité de la base de données: écrire des requêtes efficaces et utiliser des index

Gestion des erreurs

  • Erreur des flux de travail: Créer des flux de travail dédiés au traitement des erreurs
  • ** Mécanismes de réessayer** : Mettre en œuvre la logique de réessayer pour les défaillances transitoires
  • Validation: Valider les données avant traitement
  • Loging: Enregistrer les événements importants et les erreurs
  • ** Notifications**: Mettre en place des alertes pour les défaillances critiques

Sécurité

  • Crédits: Utiliser le système d'identification intégré au lieu du codage dur
  • ** Variables environnementales**: Stockage des informations sensibles dans les variables d'environnement
  • Authentification: Sécurisation des terminaux Webhook avec authentification
  • Contrôle d'accès: Mettre en œuvre les autorisations d'utilisateur appropriées
  • Logs de vérification: Surveiller les exécutions et les changements

Dépannage

Questions communes

Flux de travail non déclencheur

  • Care: Configuration de déclenchement incorrecte, URL de webhook non accessible, ou problèmes de programmation
  • Solution: Vérifier les paramètres de déclenchement, vérifier l'accessibilité du webhook et confirmer les paramètres de fuseau horaire

Défauts d'exécution des nœuds

  • Care: Format de données non valide, champs obligatoires manquants ou limites de taux d'API
  • Solution: Utilisez les nœuds de fonction pour valider et transformer les données, implémenter le traitement des erreurs et ajouter des limites de vitesse

Problèmes de performance

  • Care : Traitement de gros ensembles de données, requêtes inefficaces ou contraintes en matière de ressources
  • Solution: Implémenter le traitement par lots, optimiser les requêtes de base de données et déployer n8n à l'échelle

Erreurs d'authentification

  • Carace: Créances expirées, clés d'API incorrectes, ou problèmes de jeton OAuth
  • Solution : Mettre à jour les identifiants, vérifier les autorisations des clés API et rafraîchir les jetons OAuth

*Cette feuille de triche complète n8n fournit tout le nécessaire pour construire des automatisations de workflow sophistiquées. De la configuration de base aux modèles de déploiement de production avancés, utilisez ces exemples et les meilleures pratiques pour créer des workflows d'automatisation puissants et flexibles avec la plate-forme polyvalente de n8n. *