Automatiser avec n8n en auto-hébergement : IA, Sécurité, et Scalabilité

Assurez-vous d’avoir :

• Un Raspberry Pi (Pi 4 avec 4 ou 8 Go de RAM recommandé) ou une VM Debian/Ubuntu (2 Go de RAM minimum).
• Raspberry Pi OS (64 bits) ou Ubuntu 20.04+ sur la VM.
• Une carte SD ou un disque avec 16 Go minimum (32 Go recommandé).
• Une connexion Internet stable.
• Un ordinateur pour configurer via SSH ou terminal.
• Un domaine (optionnel, pour un accès externe sécurisé).
• Une clé API pour un LLM (par exemple, OpenAI ou Hugging Face, voir Étape 5).
  

N8N : Explications

Voici quelques cas d’usage réels que vous pouvez automatiser avec n8n :

• Veille automatisée : surveiller un site ou une API et vous envoyer une alerte.

• Traitement d’email : recevoir un email, en extraire le contenu et l’ajouter à un tableau Notion ou Google Sheets.

• Archivage : détecter un nouveau fichier dans un dossier, le renommer, l’archiver, puis notifier par message.

• Intégration d’IA : envoyer du texte à ChatGPT ou Mistral et recevoir une réponse contextualisée.

• Gestion de base de données : lorsqu’un formulaire est rempli, stocker les données et envoyer une confirmation.

• Détection d’événements système : couplé à un Raspberry Pi, lancer une action domotique en fonction d’un capteur.

Et ce n’est qu’un début. Tout est possible tant que vous avez une API ou un outil capable d’émettre un signal.

Comment fonctionne n8n ?

L’interface de n8n est entièrement graphique : vous créez des workflows sous forme de nœuds connectés entre eux.

Chaque nœud représente une action ou une condition :

• Trigger Node : point de départ (ex. : nouveau fichier, requête HTTP, CRON)

• Action Node : envoie un email, fait un appel HTTP, exécute un script

• IF Node : vérifie une condition

• Function Node : ajoute une logique personnalisée avec JavaScript

• Error Node : gère les erreurs

Le tout fonctionne en flux de données : chaque nœud reçoit des entrées, effectue un traitement, puis transmet ses résultats au nœud suivant.

Pourquoi auto-héberger n8n ?

Voici les avantages d’un hébergement personnel :

• Gratuit à vie (contrairement aux versions cloud payantes)

• Aucune limitation sur les workflows ou les exécutions

• Vie privée garantie (pas d’envoi de vos données vers l’extérieur)

• Performances ajustables : vous décidez des ressources (Raspberry Pi, serveur dédié, VPS, etc.)

• Personnalisation totale : vous pouvez ajouter vos propres fonctions, modules, ou extensions

Dans un précédent article, nous avons exploré les bases de l’auto-hébergement. Aujourd’hui, allons plus loin avec n8n, une solution d’automatisation open-source extrêmement puissante, extensible, et surtout hébergeable soi-même.

Vous découvrirez ici non seulement comment installer n8n proprement en Docker, mais aussi comment le sécuriser, l’étendre avec de l’intelligence artificielle locale ou open-source, et scaler votre infrastructure pour des projets plus ambitieux.

Étape 1 : Préparer l’environnement

1. Mettre à jour le système : Connectez-vous via SSH (ssh user@<IP>) ou ouvrez un terminal sur la VM :
   bash

   sudo apt update && sudo apt full-upgrade -y

2. Configurer le stockage : Créez un dossier pour les données n8n :
   bash

   sudo mkdir -p /mnt/storage/n8n-data
   sudo chown -R $USER:$USER /mnt/storage

   Si vous utilisez un disque externe, montez-le :
   bash

   sudo mount /dev/sda1 /mnt/storage
   sudo nano /etc/fstab

   Ajoutez :

   /dev/sda1  /mnt/storage  ext4  defaults  0  2

   Sauvegardez (Ctrl+O, Enter, Ctrl+X).

Étape 2 : Installer Docker et Docker Compose

1. Installer Docker :
   bash

   sudo apt install docker.io -y
   sudo systemctl enable docker
   sudo systemctl start docker
   sudo usermod -aG docker $USER

   Déconnectez-vous et reconnectez-vous.
2. Installer Docker Compose :
   bash

   sudo apt install docker-compose -y

   Vérifiez :
   bash

   docker --version
   docker-compose --version

Étape 3 : Configurer n8n avec Docker Compose

1. Créer un dossier pour n8n :
   bash

   mkdir ~/n8n && cd ~/n8n

2. Créer le fichier .env : Utilisez nano, un éditeur simple pour les débutants :
   bash

   nano .env

   Ajoutez :
   env

   N8N_BASIC_AUTH_USER=admin
   N8N_BASIC_AUTH_PASSWORD=mon_mot_de_passe_sécurisé
   N8N_HOST=localhost
   N8N_PORT=5678
   WEBHOOK_URL=http://<IP_de_la_VM_ou_Raspberry>:5678

   • Remplacez <IP_de_la_VM_ou_Raspberry> par l’IP de votre machine (trouvez-la avec hostname -I).
   • Générez un mot de passe sécurisé :
     bash

     openssl rand -base64 12

   Sauvegardez (Ctrl+O, Enter, Ctrl+X) et protégez :
   bash

   chmod 600 .env

3. Créer le fichier docker-compose.yml :
   bash

   nano docker-compose.yml

   Collez :
   yaml

   version: '3.8'
   services:
     n8n:
       image: n8nio/n8n:latest
       environment:
         - N8N_BASIC_AUTH_ACTIVE=true
         - N8N_BASIC_AUTH_USER=${N8N_BASIC_AUTH_USER}
         - N8N_BASIC_AUTH_PASSWORD=${N8N_BASIC_AUTH_PASSWORD}
         - N8N_HOST=${N8N_HOST}
         - N8N_PORT=${N8N_PORT}
         - N8N_PROTOCOL=http
         - WEBHOOK_URL=${WEBHOOK_URL}
       ports:
         - "5678:5678"
       volumes:
         - /mnt/storage/n8n-data:/home/node/.n8n
       restart: unless-stopped

   Sauvegardez (Ctrl+O, Enter, Ctrl+X). Créez le dossier des données :
   bash

   sudo mkdir -p /mnt/storage/n8n-data
   sudo chown -R 1000:1000 /mnt/storage/n8n-data

4. Lancer n8n :
   bash

   docker-compose up -d

   Vérifiez :
   bash

   docker-compose ps

5. Accéder à n8n : Ouvre un navigateur sur http://<IP_de_la_VM_ou_Raspberry>:5678. Connecte-toi avec admin et le mot de passe défini dans .env.

Étape 4 : Créer vos premiers workflows

Workflow 1 : Notification par e-mail

1. Connectez-vous à n8n : Allez sur http://<IP>:5678 et créez un nouveau workflow.
2. Ajoutez un nœud Watch Folder :
   • Cliquez sur + dans l’interface n8n.
   • Cherchez Watch Folder et ajoutez-le.
   • Configurez :
     • Path : /mnt/storage/watch-folder (créez ce dossier sur votre VM ou Raspberry Pi : mkdir /mnt/storage/watch-folder).
     • Watch for : New Files.
3. Ajoutez un nœud Send Email :
   • Ajoutez un nœud Send Email.
   • Configurez :
     • Credentials : Ajoutez un compte e-mail (par exemple, Gmail avec un mot de passe d’application).
     • To : Votre adresse e-mail.
     • Subject : Nouveau fichier détecté.
     • Message : Un fichier a été ajouté : {{ $node[« Watch Folder »].json[« fileName »] }}.
4. Testez :
   • Activez le workflow (bouton en haut à droite).
   • Copiez un fichier dans /mnt/storage/watch-folder :
     bash

     touch /mnt/storage/watch-folder/test.txt

   • Vérifiez votre boîte de réception pour l’e-mail.

Workflow 2 : Tweet automatique

1. Ajoutez un nœud Schedule :
   • Ajoutez Schedule (ou Cron).
   • Configurez pour exécuter toutes les heures : 0 * * * *.
2. Ajoutez un nœud Twitter :
   • Ajoutez Twitter (ou X API si disponible).
   • Configurez les credentials avec une clé API X (obtenue via developer.x.com).
   • Message : Test automatisé depuis n8n ! #AutoHébergement.
3. Testez :
   • Activez le workflow.
   • Attendez l’heure suivante ou exécutez manuellement (bouton Execute Workflow).
   • Vérifiez votre compte X pour le message.

Pourquoi c’est un bon exemple pour débuter ?

Ces workflows simples et utiles cochent une grande majorité des cases pour apprendre les fondamentaux de n8n :

✅ Connexion à des services externes (Réseaux sociaux, Courriel, …)
✅ Passage de données entre les nœuds via expressions ({{$json[...]}})
✅ Automatisation concrète et immédiatement utile au quotidien
✅ Interface claire et logique.

Étape 5 : Intégrer un LLM pour l’IA

1. OpenAI :
   • Créez un compte sur platform.openai.com.
   • Générez une clé API (par exemple, sk-xxxxxxxxxxxxxxxxxxxx).
   • Stockez-la dans .env :
     bash

     nano ~/n8n/.env

     Ajoutez :
     env

     OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxx

     Sauvegardez et protégez : chmod 600 .env.
2. Hugging Face (alternative gratuite) :
   • Créez un compte sur huggingface.co.
   • Générez une clé API.
   • Stockez-la dans .env :
     env

     HUGGINGFACE_API_KEY=hf_xxxxxxxxxxxxxxxx

Workflow 3 : Traduction avec un LLM

1. Ajoutez un nœud Webhook :
   • Ajoutez Webhook.
   • Configurez :
     • HTTP Method : POST.
     • Path : translate.
   • Notez l’URL générée (par exemple, http://<IP>:5678/webhook/translate).
2. Ajoutez un nœud HTTP Request :
   • Ajoutez HTTP Request.
   • Pour OpenAI :
     • URL : https://api.openai.com/v1/chat/completions.
     • Method : POST.
     • Headers :
       json

       {
         "Authorization": "Bearer {{ $env.OPENAI_API_KEY }}",
         "Content-Type": "application/json"
       }

     • Body :
       json

       {
         "model": "gpt-3.5-turbo",
         "messages": [
           {
             "role": "user",
             "content": "Traduisez en français : {{ $node['Webhook'].json['body']['text'] }}"
           }
         ],
         "max_tokens": 100
       }

   • Pour Hugging Face (par exemple, modèle de traduction) :
     • URL : https://api-inference.huggingface.co/models/Helsinki-NLP/opus-mt-en-fr.
     • Headers :
       json

       {
         "Authorization": "Bearer {{ $env.HUGGINGFACE_API_KEY }}",
         "Content-Type": "application/json"
       }

     • Body :
       json

       {
         "inputs": "{{ $node['Webhook'].json['body']['text'] }}"
       }

3. Ajoutez un nœud Set :
   • Ajoutez Set pour formater la réponse.
   • Values to Set :
     • Name : translated_text.
     • Value (pour OpenAI) : {{ $node[‘HTTP Request’].json[‘choices’][0][‘message’][‘content’] }}.
     • Value (pour Hugging Face) : {{ $node[‘HTTP Request’].json[0][‘translation_text’] }}.
4. Testez :
   • Activez le workflow.
   • Envoyez une requête :
     bash

     curl -X POST http://<IP>:5678/webhook/translate -d '{"text": "Hello world"}'

   • Vérifiez la réponse dans n8n (onglet Executions).

Option : LLM auto-hébergé avec Ollama

docker run -d -p 11434:11434 --name ollama ollama/ollama
docker exec ollama ollama pull llama3

• URL : http://localhost:11434/api/generate.
• Body :
  json

  {
    "model": "llama3",
    "prompt": "Traduisez en français : {{ $node['Webhook'].json['body']['text'] }}"
  }

Étape 6 : Sécuriser l’accès

1. Installer Nginx :
   bash

   sudo apt install nginx -y

2. Configurer Nginx :
   bash

   sudo nano /etc/nginx/sites-available/n8n

   Ajoutez :
   nginx

   server {
       listen 80;
       server_name n8n.votre-domaine.com;
       return 301 https://$host$request_uri;
   }
   
   server {
       listen 443 ssl;
       server_name n8n.votre-domaine.com;
       ssl_certificate /etc/letsencrypt/live/n8n.votre-domaine.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/n8n.votre-domaine.com/privkey.pem;
   
       location / {
           proxy_pass http://localhost:5678;
           proxy_set_header Host $host;
           proxy_set_header X-Real-IP $remote_addr;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
       }
   }

   Activez et redémarrez :
   bash

   sudo ln -s /etc/nginx/sites-available/n8n /etc/nginx/sites-enabled/
   sudo nginx -t
   sudo systemctl restart nginx

3. Ajouter HTTPS :
   bash

   sudo apt install certbot python3-certbot-nginx -y
   sudo certbot --nginx -d n8n.votre-domaine.com

   Mettez à jour .env :
   env

   WEBHOOK_URL=https://n8n.votre-domaine.com
   N8N_PROTOCOL=https

   Redémarrez n8n :
   bash

   docker-compose down
   docker-compose up -d

4. Pare-feu :
   bash

   sudo apt install ufw -y
   sudo ufw allow 80
   sudo ufw allow 443
   sudo ufw enable

Étape 7 : Sauvegardes

L’auto-hébergement de n8n nécessite un minimum de rigueur pour garantir la pérennité de vos workflows, la sécurité de vos données et des performances stables, même en cas de montée en charge.

Volumes Docker : où sont stockées les données ?

Par défaut, n8n enregistre tous ses workflows, credentials et historiques dans un répertoire monté dans le conteneur Docker :

1. Sauvegarder les workflows :
   bash

   nano ~/n8n/backup.sh

   Ajoutez :
   bash

   #!/bin/bash
   BACKUP_DIR="/mnt/storage/backups"
   mkdir -p $BACKUP_DIR
   tar -czf $BACKUP_DIR/n8n-data-$(date +%F).tar.gz /mnt/storage/n8n-data

   Planifiez :
   bash

   chmod +x ~/n8n/backup.sh
   crontab -e

   Ajoutez :

   0 2 * * * /home/user/n8n/backup.sh

Étape 8 : Performances & Dimentionnement

Les performances de n8n dépendent du type de workflows exécutés, et de la charge simultanée (surtout en mode Queue avec workers).

📌 Astuce : n8n est léger, mais les services connectés (IA, OCR, base de données…) peuvent vite saturer vos ressources.

Surveillance des ressources

Méthode rapide : docker stats

Exécutez :

→ Vous verrez l’usage CPU / RAM / Réseau de vos conteneurs en temps réel.

Méthode avancée : Prometheus + Grafana

🎯 Déjà abordé dans cet article :
🔗 Surveiller ses Raspberry Pi avec Grafana, Prometheus et Node Exporter

Vous pouvez appliquer ce tutoriel à votre serveur n8n :

• Installez node_exporter sur votre hôte

• Configurez Prometheus pour scrapper les métriques

• Créez un dashboard Grafana pour surveiller :

  • CPU / RAM

  • Disque

  • Réseau

  • Utilisation de Redis et PostgreSQL si vous êtes en mode queue

Astuces supplémentaires pour de meilleures performances

• Nettoyez régulièrement les anciennes exécutions (paramètre N8N_EXECUTIONS_DATA_PRUNE=true)

• Activez le mode queue avec des workers si vos workflows sont longs ou nombreux

• Utilisez un reverse proxy comme NGINX avec gzip et HTTP/2 activés

• Placez n8n derrière un Load Balancer (Traefik, HAProxy…) pour les très gros déploiements