n8n Installation Guide: Der komplette Einrichtungs-Weg für deinen Server

Willkommen, Automatisierungs-Enthusiast! Du möchtest n8n – das mächtige Workflow-Automatisierungstool – auf deinem eigenen Server installieren? Egal ob für persönliche Projekte, Business-Automatisierung oder Hobby-Experimente: Dieser Guide führt dich Schritt für Schritt durch die komplette Installation.

Was ist n8n und warum selbst hosten?

n8n ist ein Open-Source-Workflow-Automatisierungstool, das wie eine visuelle Programmierumgebung funktioniert. Du verbindest verschiedene "Nodes" (z.B. für APIs, Datenbanken, Dateisysteme), um komplexe Prozesse zu automatisieren.

Vorteile der eigenen Installation:

• Datenhoheit: Deine Workflows und Daten bleiben auf deinem Server

• Keine Limits: Keine Einschränkungen bei Ausführungen oder Workflows

• Kostenkontrolle: Keine monatlichen Gebühren für hohe Nutzung

• Volle Kontrolle: Eigenes Branding, Custom Nodes, direkter Datenbankzugriff

• Offline-Fähigkeit: Funktioniert auch ohne Internetverbindung (je nach Workflow)

Kapitel 1: Vorbereitung – Dein Server vor der Installation

Systemvoraussetzungen

Minimal (für Test/Low-Usage):

• CPU: 2 Kerne

• RAM: 2 GB

• Speicher: 10 GB SSD

• OS: Ubuntu 20.04/22.04, Debian 10/11, CentOS 8

Empfohlen (für Produktivumgebung):

• CPU: 4+ Kerne

• RAM: 4+ GB

• Speicher: 25+ GB SSD

• OS: Ubuntu 22.04 LTS

Vorbereitungsschritte:

1. Server-Zugang sicherstellen:

bash

# Verbindung zu deinem Server herstellen
ssh username@deine-server-ip

2. System updaten:

bash

sudo apt update && sudo apt upgrade -y

3. Benötigte Pakete installieren:

bash

sudo apt install -y curl git wget nano htop ufw

4. Firewall konfigurieren (falls aktiv):

bash

sudo ufw allow 22/tcp        # SSH
sudo ufw allow 80/tcp        # HTTP
sudo ufw allow 443/tcp       # HTTPS
sudo ufw allow 5678/tcp      # n8n Standard-Port
sudo ufw enable

Kapitel 2: Installation – Drei verschiedene Wege

Methode 1: Docker (Empfohlen – Einfachste Methode)

1. Docker installieren:

bash

# Docker installieren
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Docker ohne sudo nutzen können
sudo usermod -aG docker $USER
newgrp docker  # Oder neu einloggen

2. Docker Compose installieren:

bash

sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

3. n8n mit Docker Compose installieren:

Erstelle eine Datei docker-compose.yml:

bash

mkdir n8n && cd n8n
nano docker-compose.yml

Füge folgende Konfiguration ein:

yaml

version: '3.8'

services:
  n8n:
    image: n8nio/n8n
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    environment:
      - N8N_PROTOCOL=https
      - N8N_HOST=deine-domain.de  # Oder deine IP
      - N8N_PORT=5678
      - N8N_WEBHOOK_URL=https://deine-domain.de/
      - NODE_ENV=production
      - WEBHOOK_URL=https://deine-domain.de/
      - N8N_ENCRYPTION_KEY=ersetze-mit-einem-sicheren-schluessel
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=ersetze-mit-sicherem-passwort
      - N8N_METRICS=true
      - GENERIC_TIMEZONE=Europe/Berlin
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres
    networks:
      - n8n_network

  postgres:
    image: postgres:15
    container_name: n8n_postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=ersetze-mit-sicherem-passwort
      - POSTGRES_DB=n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - n8n_network

volumes:
  n8n_data:
  postgres_data:

networks:
  n8n_network:
    driver: bridge

4. Starte n8n:

bash

docker-compose up -d

5. Status prüfen:

bash

docker ps
docker logs n8n

Methode 2: Node.js Installation (Für Customizing)

1. Node.js installieren:

bash

# Node.js 18.x (empfohlen)
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs

# Prüfen
node --version
npm --version

2. n8n installieren:

bash

# Globale Installation
sudo npm install -g n8n

# Oder als Service
sudo npm install -g pm2

3. n8n als Service einrichten:

Erstelle eine Service-Datei:

bash

sudo nano /etc/systemd/system/n8n.service

Füge folgendes ein:

ini

[Unit]
Description=n8n Workflow Automation
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/bin/n8n start
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal
SyslogIdentifier=n8n
Environment=NODE_ENV=production
Environment=N8N_PORT=5678
Environment=N8N_PROTOCOL=https
Environment=N8N_HOST=deine-domain.de

[Install]
WantedBy=multi-user.target

4. Service starten:

bash

sudo systemctl daemon-reload
sudo systemctl start n8n
sudo systemctl enable n8n
sudo systemctl status n8n

Methode 3: Kubernetes (Für skalierbare Umgebungen)

Für fortgeschrittene Nutzer – nur, wenn du Kubernetes bereits nutzt:

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: n8n
spec:
  replicas: 1
  selector:
    matchLabels:
      app: n8n
  template:
    metadata:
      labels:
        app: n8n
    spec:
      containers:
      - name: n8n
        image: n8nio/n8n:latest
        ports:
        - containerPort: 5678
        env:
        - name: N8N_PROTOCOL
          value: "https"
        - name: N8N_HOST
          value: "deine-domain.de"

Kapitel 3: Konfiguration & Absicherung

1. Reverse Proxy mit Nginx (Empfohlen für Produktivumgebung)

Nginx installieren:

bash

sudo apt install -y nginx
sudo systemctl start nginx
sudo systemctl enable nginx

Nginx-Konfiguration für n8n erstellen:

bash

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

Füge diese Konfiguration ein:

nginx

server {
    listen 80;
    server_name deine-domain.de;  # Oder deine IP
    
    # Redirect zu HTTPS
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name deine-domain.de;
    
    # SSL Zertifikate - siehe nächstes Kapitel
    ssl_certificate /etc/letsencrypt/live/deine-domain.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/deine-domain.de/privkey.pem;
    
    # Sicherheitseinstellungen
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    
    location / {
        proxy_pass http://localhost:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        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;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 300s;
    }
    
    # Größere Uploads erlauben
    client_max_body_size 50M;
}

Konfiguration aktivieren:

bash

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

2. SSL-Zertifikat mit Let's Encrypt

Certbot installieren:

bash

sudo apt install -y certbot python3-certbot-nginx

Zertifikat erstellen:

bash

sudo certbot --nginx -d deine-domain.de
# Folge den Anweisungen

Auto-Renewal testen:

bash

sudo certbot renew --dry-run

3. n8n Konfigurationsdatei anpassen

Für Docker: Bearbeite deine docker-compose.yml mit diesen wichtigen Umgebungsvariablen:

yaml

environment:
  - N8N_ENCRYPTION_KEY=erzeuge-mit: openssl rand -base64 32
  - EXECUTIONS_DATA_PRUNE=true
  - EXECUTIONS_DATA_MAX_AGE=168  # Daten nach 7 Tagen löschen
  - N8N_USER_MANAGEMENT_DISABLED=false  # User-Auth aktivieren
  - N8N_BASIC_AUTH_ACTIVE=true
  - N8N_BASIC_AUTH_USER=dein-username
  - N8N_BASIC_AUTH_PASSWORD=starkes-passwort

Kapitel 4: Backup & Datenmanagement

1. Automatisches Backup einrichten

Backup-Skript erstellen:

bash

sudo nano /usr/local/bin/n8n-backup.sh

bash

#!/bin/bash
BACKUP_DIR="/backup/n8n"
DATE=$(date +%Y%m%d_%H%M%S)

# Backup für Docker
docker exec n8n_postgres pg_dump -U n8n n8n > $BACKUP_DIR/db_backup_$DATE.sql
docker cp n8n:/home/node/.n8n $BACKUP_DIR/n8n_data_$DATE

# Komprimieren
tar -czf $BACKUP_DIR/n8n_backup_$DATE.tar.gz $BACKUP_DIR/db_backup_$DATE.sql $BACKUP_DIR/n8n_data_$DATE

# Alte Backups löschen (älter als 30 Tage)
find $BACKUP_DIR -name "*.tar.gz" -mtime +30 -delete

echo "Backup completed: $BACKUP_DIR/n8n_backup_$DATE.tar.gz"

Skript ausführbar machen und Cron-Job einrichten:

bash

sudo chmod +x /usr/local/bin/n8n-backup.sh
sudo crontab -e

Füge diese Zeile hinzu (für tägliches Backup um 2 Uhr):

text

0 2 * * * /usr/local/bin/n8n-backup.sh

2. Datenbank-Verwaltung

Postgres optimieren (für Docker):

bash

# In die Datenbank einloggen
docker exec -it n8n_postgres psql -U n8n

# Wichtige Queries:
-- Alle Workflows anzeigen
SELECT COUNT(*) FROM workflow_entity;

-- Große Workflows finden
SELECT name, LENGTH(nodes::text) as size FROM workflow_entity ORDER BY size DESC LIMIT 10;

Kapitel 5: Monitoring & Wartung

1. System-Überwachung einrichten

Mit Docker Compose Monitoring hinzufügen:

yaml

  prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - n8n_network

  grafana:
    image: grafana/grafana
    container_name: grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    networks:
      - n8n_network

2. Logging konfigurieren

Docker Logs verwalten:

bash

# Logs anzeigen
docker logs n8n --tail 50

# Logs in Datei schreiben
docker-compose logs -f > /var/log/n8n/n8n.log 2>&1 &

# Log Rotation einrichten
sudo nano /etc/docker/daemon.json

json

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

Kapitel 6: Troubleshooting & häufige Probleme

1. n8n startet nicht

bash

# Logs prüfen
docker logs n8n
journalctl -u n8n.service -f

# Port prüfen
sudo netstat -tulpn | grep 5678

# Docker Container neustarten
docker-compose down && docker-compose up -d

2. Datenbank-Probleme

bash

# Datenbank-Verbindung testen
docker exec n8n_postgres pg_isready -U n8n

# Datenbank zurücksetzen (VORSICHT!)
docker-compose down -v
docker-compose up -d

3. Performance-Issues

bash

# RAM Usage prüfen
docker stats n8n n8n_postgres

# Optimierung: Executions limitieren
environment:
  - EXECUTIONS_DATA_PRUNE=true
  - EXECUTIONS_DATA_MAX_AGE=72  # 3 Tage
  - EXECUTIONS_DATA_PRUNE_MAX_COUNT=10000

Kapitel 7: Next Steps – Nach der Installation

1. Erste Workflows erstellen

1. Öffne https://deine-domain.de/

2. Login mit deinen Credentials

3. Erstelle deinen ersten Workflow:

   • Webhook Node für Trigger

   • HTTP Request Node für API Calls

   • Code Node für Custom Logic

   • Email/Slack Node für Notifications

2. Wichtige Integrationen einrichten

• GitHub/GitLab: Automatische Deployment-Pipelines

• Slack/Discord: Benachrichtigungen

• Google Sheets/Calendar: Daten-Synchronisation

• REST APIs: Eigene Services einbinden

3. Sicherheits-Checkliste nach der Installation

• SSL aktiviert und gültig

• Basic Authentication aktiviert

• Strong Passwords gesetzt

• Firewall richtig konfiguriert

• Backups eingerichtet und getestet

• Updates automatisiert (watchtower für Docker)

• Logging und Monitoring aktiv

Bonus: Automatische Updates mit Watchtower

bash

# Watchtower zu docker-compose.yml hinzufügen
  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_POLL_INTERVAL=3600  # Jede Stunde prüfen
    restart: unless-stopped

Zusammenfassung: Dein n8n-Server ist fertig!

Du hast jetzt:
✅ n8n auf deinem eigenen Server installiert
✅ SSL-Zertifikat für sichere Verbindung
✅ Backup-System eingerichtet
✅ Reverse Proxy für bessere Performance
✅ Monitoring-Grundlagen konfiguriert

Nächste Schritte:

1. Teste deine Installation unter https://deine-domain.de/

2. Erstelle einen einfachen Test-Workflow

3. Richte wichtige Integrationen ein

4. Dokumentiere deine Workflows

5. Teile deine n8n-Instanz mit Team-Mitgliedern (wenn gewünscht)

---

Wichtig: Vergiss nicht, regelmäßig:

• Backups zu testen

• Logs zu überprüfen

• Updates einzuspielen

• Sicherheits-Checks durchzuführen

Hilfe gefällig? Die n8n-Community ist sehr aktiv:

• Offizielle Docs: https://docs.n8n.io

• GitHub: https://github.com/n8n-io/n8n

• Community Forum: https://community.n8n.io

Viel Erfolg mit deiner eigenen n8n-Instanz! 🚀