Zum Hauptinhalt springen
S-EDV news
Schönfelder EDV
← Alle Anleitungen
📘 Anleitung Künstliche Intelligenz 02.06.2026 · 11 min Lesezeit

n8n mit Docker: KI-Workflows und Automatisierung self-hosted

n8n self-hosten mit Docker Compose: produktionsreifes Setup mit Postgres, HTTPS-Reverse-Proxy, Encryption-Key sichern, erster KI-Workflow mit dem AI Agent, plus Update- und Backup-Routine.

MS
Marcel Schönfelder
IT-Freelancer & Inhaber
n8n Workflow-Editor mit verketteten KI-Knoten auf einem Docker-Server

n8n self-hosten mit Docker macht aus einem kleinen Linux-Server eine vollwertige Automatisierungs-Zentrale: n8n (Aussprache „n-eight-n“) ist ein Open-Source-Workflow-Tool, mit dem Du per Drag-and-drop Dienste verbindest, Daten zwischen APIs umherschiebst und – das ist der spannende Teil – KI-Knoten wie den AI Agent mit Chat-Modellen, Memory und Vector-Stores zu echten LLM-Automatisierungen verkettest. Im Gegensatz zu reinen LLM-App-Plattformen wie Dify ist n8n eine generische Workflow-Engine: Du baust nicht nur Chatbots, sondern jede Art von Automatisierung – mit oder ohne KI. Diese Anleitung zeigt Dir Schritt für Schritt, wie Du n8n produktionsreif per Docker Compose mit Postgres betreibst, hinter HTTPS absicherst und den ersten KI-Workflow startest.

Voraussetzungen

n8n selbst ist eine Node.js-Anwendung und läuft rein CPU-basiert – Du brauchst keine GPU für n8n. Eine GPU ist nur relevant, wenn Du parallel ein lokales LLM (z. B. Ollama) betreibst, das n8n als Chat-Modell anspricht; dafür kommt das nvidia-container-toolkit ins Spiel (mehr dazu am Ende). Für n8n gilt:

  • Betriebssystem: Linux-Server mit Docker Engine und Docker Compose Plugin, z. B. Debian 12 oder Ubuntu 24.04.
  • Hardware (klein/Single-User): ca. 1 vCPU und 1–2 GB RAM reichen zum Ausprobieren.
  • Hardware (produktiv mit Postgres): empfohlen 2 vCPU und 4 GB RAM.
  • Docker: aktuelle Docker Engine plus docker compose (v2-Plugin). Test: docker compose version.
  • Domain & HTTPS: für den Produktivbetrieb eine Subdomain (z. B. n8n.DEINE-DOMAIN.de) mit gültigem TLS-Zertifikat über einen Reverse Proxy. Pflicht für Webhooks und OAuth.
  • Tools: git zum Klonen des Setups und openssl zum Erzeugen sicherer Schlüssel.

Wenn Docker Compose für Dich neu ist, lies vorab die Grundlagen zu Docker Compose und Stacks – die Begriffe Service, Volume und Healthcheck setze ich hier voraus.

Schritt 1: Offizielles Compose-Setup holen

n8n pflegt das Repository n8n-io/n8n-hosting mit einem fertigen, produktionsnahen Compose-Setup. Die Variante withPostgres enthält bereits alles: die docker-compose.yml, eine .env-Vorlage und ein init-data.sh, das beim ersten Start einen separaten Datenbank-Benutzer anlegt.

git clone https://github.com/n8n-io/n8n-hosting
cd n8n-hosting/docker-compose/withPostgres
ls -la

Du siehst dort docker-compose.yml, .env und init-data.sh. Wir arbeiten direkt in diesem Verzeichnis weiter. Wenn Du das Setup lieber an einen festen Ort wie /opt/n8n legst, kopiere die drei Dateien einfach dorthin.

Schritt 2: Sichere Werte erzeugen und in die .env eintragen

Die mitgelieferte .env enthält Platzhalter wie changeUser und changePassword. Diese musst Du vor dem ersten Start ersetzen – sonst läuft Deine Datenbank mit Default-Zugangsdaten. Erzeuge zunächst ein paar sichere Zufallswerte:

# Je einen Wert fuer DB-Passwort, Runner-Token und Encryption-Key:
openssl rand -hex 32   # -> Postgres-Passwort (root)
openssl rand -hex 32   # -> Postgres-Passwort (non-root)
openssl rand -hex 32   # -> RUNNERS_AUTH_TOKEN
openssl rand -hex 32   # -> N8N_ENCRYPTION_KEY

Trage die Werte in die .env ein. Eine produktionstaugliche Vorlage sieht so aus (echte Zufallswerte statt der Platzhalter einsetzen):

# Postgres
POSTGRES_USER=n8n_root
POSTGRES_PASSWORD=DEIN-ROOT-PASSWORT
POSTGRES_DB=n8n
POSTGRES_NON_ROOT_USER=n8n_app
POSTGRES_NON_ROOT_PASSWORD=DEIN-APP-PASSWORT

# n8n
N8N_VERSION=stable
RUNNERS_AUTH_TOKEN=DEIN-RUNNER-TOKEN
N8N_ENCRYPTION_KEY=DEIN-ENCRYPTION-KEY

# Domain / HTTPS (produktiv)
N8N_HOST=n8n.DEINE-DOMAIN.de
WEBHOOK_URL=https://n8n.DEINE-DOMAIN.de/
N8N_EDITOR_BASE_URL=https://n8n.DEINE-DOMAIN.de/

# Zeitzone
GENERIC_TIMEZONE=Europe/Berlin
TZ=Europe/Berlin

Merke Dir den N8N_ENCRYPTION_KEY an einem sicheren Ort. n8n verschlüsselt damit alle gespeicherten Credentials. Geht der Key verloren, sind sämtliche hinterlegten Zugangsdaten unbrauchbar – das ist die häufigste teure Panne beim Self-Hosting. Wenn Du den Key nicht selbst setzt, generiert n8n ihn beim ersten Start automatisch und legt ihn unter /home/node/.n8n/config im Volume ab; dann ist das Volume-Backup zwingend.

Schritt 3: Die docker-compose.yml verstehen und anpassen

Hier die vollständige, lauffähige docker-compose.yml in der withPostgres-Variante. Sie startet drei Dienste: postgres (Datenbank), n8n (die Anwendung mit Web-UI) und n8n-runner (ein separater Task-Runner-Container für die Code-Ausführung). Daten liegen in Named Volumes, damit sie Container-Neustarts überleben.

services:
  postgres:
    image: postgres:16
    restart: always
    environment:
      - POSTGRES_USER
      - POSTGRES_PASSWORD
      - POSTGRES_DB
      - POSTGRES_NON_ROOT_USER
      - POSTGRES_NON_ROOT_PASSWORD
    volumes:
      - db_storage:/var/lib/postgresql/data
      - ./init-data.sh:/docker-entrypoint-initdb.d/init-data.sh
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -h localhost -U ${POSTGRES_USER} -d ${POSTGRES_DB}']
      interval: 5s
      timeout: 5s
      retries: 10

  n8n:
    image: docker.n8n.io/n8nio/n8n:${N8N_VERSION}
    restart: always
    environment:
      # Datenbank
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_NON_ROOT_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_NON_ROOT_PASSWORD}
      # Domain / HTTPS
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=${WEBHOOK_URL}
      - N8N_EDITOR_BASE_URL=${N8N_EDITOR_BASE_URL}
      # Sicherheit
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      # Zeitzone
      - GENERIC_TIMEZONE=${GENERIC_TIMEZONE}
      - TZ=${TZ}
      # Task-Runner (extern)
      - N8N_RUNNERS_ENABLED=true
      - N8N_RUNNERS_MODE=external
      - N8N_RUNNERS_AUTH_TOKEN=${RUNNERS_AUTH_TOKEN}
      - N8N_RUNNERS_BROKER_LISTEN_ADDRESS=0.0.0.0
    ports:
      - '5678:5678'
    volumes:
      - n8n_storage:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

  n8n-runner:
    image: docker.n8n.io/n8nio/runners:${N8N_VERSION}
    restart: always
    environment:
      - N8N_RUNNERS_AUTH_TOKEN=${RUNNERS_AUTH_TOKEN}
      - N8N_RUNNERS_TASK_BROKER_URI=http://n8n:5679
    depends_on:
      - n8n

volumes:
  db_storage:
  n8n_storage:

Drei Dinge sind wichtig: Der n8n-Container wartet per depends_on auf den Healthcheck von Postgres. Das Mapping 5678:5678 macht die Web-UI erreichbar. Und der Task-Runner verbindet sich über N8N_RUNNERS_TASK_BROKER_URI zurück zu n8n (Port 5679 ist der interne Broker-Port).

Schritt 4: Stack starten und Logs prüfen

Jetzt den Stack hochfahren:

docker compose up -d
docker compose ps

Alle drei Container sollten den Status running (Postgres zusätzlich healthy) zeigen. Falls etwas hakt, schau in die Logs:

docker compose logs -f n8n

Erscheint die Zeile Editor is now accessible via: ..., läuft n8n. Beachte: Umgebungsvariablen werden nur beim Container-Start gelesen. Änderst Du später die .env oder die compose-Datei, musst Du mit docker compose up -d neu erstellen – ein bloßer Anwendungs-Neustart greift nicht.

Schritt 5: Reverse Proxy mit HTTPS davorsetzen (Pflicht für Produktion)

n8n setzt per Default N8N_SECURE_COOKIE=true. Rufst Du die UI über http://SERVER-IP:5678 auf, verweigert n8n den Login mit der Meldung, dass ein Secure Cookie über eine unsichere URL nicht möglich ist. Lösung: ein Reverse Proxy mit TLS davor. Caddy ist dafür am schnellsten, weil es Let’s-Encrypt-Zertifikate automatisch holt. Eine minimale Caddyfile:

n8n.DEINE-DOMAIN.de {
    reverse_proxy 127.0.0.1:5678
}

Alternativ mit Nginx als Reverse Proxy (Zertifikate z. B. per certbot):

server {
    listen 443 ssl;
    server_name n8n.DEINE-DOMAIN.de;

    ssl_certificate     /etc/letsencrypt/live/n8n.DEINE-DOMAIN.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.DEINE-DOMAIN.de/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1: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;
        # Webhooks/Editor brauchen WebSocket-Upgrade:
        proxy_set_header Upgrade    $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Wichtig: Setze WEBHOOK_URL und N8N_EDITOR_BASE_URL in der .env auf Deine öffentliche https://-Adresse (Schritt 2). Sonst zeigen Webhook- und OAuth-Callback-URLs auf localhost:5678, und externe Dienste erreichen n8n nicht. Nur für einen reinen lokalen Test ohne Proxy kannst Du übergangsweise N8N_SECURE_COOKIE=false setzen – niemals in Produktion.

Schritt 6: Web-UI öffnen und Owner-Account anlegen

Rufe die UI auf: produktiv https://n8n.DEINE-DOMAIN.de, beim lokalen Test http://localhost:5678. Beim ersten Aufruf zeigt n8n einen Setup-Screen, in dem Du den Owner-Account mit E-Mail und Passwort anlegst. Das ist das integrierte User-Management; das früher übliche N8N_BASIC_AUTH_ACTIVE ist abgekündigt und entfernt.

Nach dem Setup landest Du im Workflow-Editor. Lege Dir zum Aufwärmen einen ersten Mini-Workflow an: Füge einen Manual Trigger hinzu, danach einen Set-Node, der ein Feld hallo = welt erzeugt, und klicke auf Execute Workflow. So siehst Du sofort, dass Trigger, Node-Verkettung und Ausführung funktionieren.

Schritt 7: Ersten KI-Workflow mit dem AI Agent bauen

Jetzt der eigentliche Mehrwert: KI-Automatisierung über die Advanced-AI- bzw. LangChain-Knoten. Diese sind sogenannte Cluster Nodes: Ein Root-Node (AI Agent, intern n8n-nodes-langchain.agent) bündelt mehrere Sub-Nodes. So baust Du einen einfachen KI-Assistenten:

  1. Neuen Workflow anlegen und einen Chat Trigger als Einstieg setzen (alternativ Manual oder Webhook).
  2. Den Root-Node AI Agent hinzufügen und mit dem Trigger verbinden.
  3. Am AI Agent den Sub-Node Chat Model anhängen, z. B. OpenAI Chat Model, und dort Deine API-Credentials hinterlegen.
  4. Optional Simple Memory anhängen, damit der Agent den Gesprächsverlauf behält.
  5. Optional Tools (etwa HTTP-Request- oder Calculator-Tools) ergänzen, damit der Agent aktiv Aktionen ausführen kann.
  6. Für RAG einen Vector Store als Sub-Node anbinden – von Simple/In-Memory über PGVector bis Qdrant.

Tippe in den Chat-Test eine Frage ein und beobachte, wie der Agent das Chat-Modell aufruft, ggf. Tools nutzt und antwortet. Genau hier wird der Unterschied zu reinen LLM-App-Plattformen sichtbar: In n8n hängst Du an die KI-Antwort beliebige weitere Workflow-Schritte – Datenbank-Eintrag, E-Mail, Ticket-System – und automatisierst so ganze Prozesse statt nur einen Chatbot.

Die LLM-Inferenz selbst läuft nicht in n8n: Du lagerst sie an eine externe API (OpenAI & Co.) oder an ein separates Ollama aus. Wer Embeddings und Vektorsuche lokal betreiben will, kombiniert n8n gut mit einem lokalen Qdrant-RAG-System mit Embeddings.

Schritt 8: Credentials sicher speichern und Verschlüsselung verstehen

Alle Zugangsdaten (API-Keys, OAuth-Tokens, DB-Passwörter), die Du in n8n hinterlegst, werden mit dem N8N_ENCRYPTION_KEY verschlüsselt und in der Postgres-Datenbank abgelegt. Der Schlüssel selbst liegt im n8n-Volume unter /home/node/.n8n. Daraus folgt die wichtigste Backup-Regel: Du musst beide Teile sichern – das n8n-Volume (Key und Settings) und die Postgres-DB (Workflows, Credentials, Executions). Sicherst Du nur eines, ist ein Restore wertlos.

Den Key kannst Du jederzeit aus dem Container prüfen:

docker compose exec n8n cat /home/node/.n8n/config

Schritt 9: Update und Backup

Der Update-Workflow ist bewusst simpel: neues Image ziehen, Container neu erstellen, Volumes bleiben erhalten.

docker compose pull
docker compose up -d
docker image prune -f

Backup hat zwei Teile. Erstens das n8n-Volume als Archiv (enthält Encryption-Key und Settings):

docker run --rm -v n8n_storage:/source -v $(pwd):/backup alpine \
  tar czf /backup/n8n-backup-$(date +%Y%m%d).tar.gz -C /source .

Zweitens ein logischer Dump der Datenbank (enthält Workflows, Credentials, Verlauf):

docker compose exec postgres pg_dump -U "$POSTGRES_NON_ROOT_USER" n8n > n8n-db-$(date +%Y%m%d).sql

Bewahre beide Dateien zusammen auf und teste den Restore mindestens einmal. Hinweis zur Lizenz: Beim Self-Hosting gilt die n8n Community Edition unter der Sustainable Use License – für mehrere aktive Owner-/Enterprise-Features lohnt ein Blick in die Lizenzhinweise.

Troubleshooting

  • Login schlägt fehl („configured to use a secure cookie … insecure URL“): Du rufst n8n über http oder eine IP auf. Setze einen Reverse Proxy mit TLS davor (Schritt 5) oder – nur zum Testen – N8N_SECURE_COOKIE=false.
  • Gespeicherte Credentials werden nach Neustart als unbrauchbar gemeldet: Der N8N_ENCRYPTION_KEY hat sich geändert oder das Volume ging verloren. Stelle den ursprünglichen Key wieder her; ohne ihn lassen sich die Credentials nicht entschlüsseln.
  • Webhooks/OAuth-Redirects landen auf localhost: WEBHOOK_URL (und N8N_EDITOR_BASE_URL) wurden nicht auf die öffentliche https-URL gesetzt. Werte korrigieren und mit docker compose up -d neu erstellen.
  • Postgres-Login funktioniert nicht, obwohl Du das Passwort geändert hast: init-data.sh legt den Non-Root-User nur beim Erst-Init des leeren DB-Volumes an. Nachträgliche Änderungen greifen erst nach einem DB-Reset (Volume neu).
  • Cron-/Schedule-Trigger feuern zur falschen Zeit: GENERIC_TIMEZONE (Default America/New_York) und TZ getrennt auf Europe/Berlin setzen.
  • Änderungen an der .env wirken nicht: Env-Vars werden nur beim Start gelesen. Immer docker compose up -d (Neuerstellung) statt nur Restart.

Häufige Fragen

Brauche ich für n8n eine GPU?

Nein. n8n läuft komplett CPU-basiert; versuche nicht, n8n eine GPU zuzuweisen. Eine GPU samt nvidia-container-toolkit ist nur dann sinnvoll, wenn Du ein separates lokales LLM wie Ollama in einem eigenen Container betreibst, das n8n dann als Chat-Modell anspricht. Für CPU-Betrieb genügt das normale Ollama-Image; für GPU-Betrieb gibst Du dem Ollama-Container per deploy.resources.reservations.devices Zugriff auf die NVIDIA-GPU.

SQLite oder Postgres – was soll ich nehmen?

Zum schnellen Ausprobieren reicht der ephemere docker run mit SQLite (Daten im Volume /home/node/.n8n). Produktiv solltest Du Postgres nehmen – das ist die Variante aus dieser Anleitung. Postgres skaliert besser und macht Backups sauberer.

Worin unterscheidet sich n8n von Dify?

Dify ist eine LLM-App-Plattform, die auf das Bauen von KI-Apps und Agenten spezialisiert ist. n8n ist eine generische Workflow-Automatisierung, bei der KI nur einer von vielen Knoten ist. In n8n verkettest Du KI-Antworten mit beliebigen weiteren Schritten (Datenbanken, E-Mail, APIs). Wenn Du primär KI-Apps brauchst, wirf einen Blick auf die Anleitung zu Dify als KI-App- und Agenten-Plattform.

Wozu der separate Runner-Container?

Der Task-Runner (n8nio/runners) führt Code-Knoten in einem isolierten Prozess aus. Das entlastet den Hauptprozess und ist die aktuelle, empfohlene Architektur. Er nutzt dasselbe Versions-Tag wie n8n und verbindet sich per N8N_RUNNERS_AUTH_TOKEN über den Broker-Port 5679 zurück zu n8n.

Wie aktualisiere ich auf eine bestimmte Version statt auf stable?

Setze in der .env N8N_VERSION auf einen konkreten Tag, z. B. 1.81.0. Verfügbar sind latest (stable), next (unstable) und konkrete Versionsnummern. Danach docker compose pull und docker compose up -d.

Was passiert, wenn ich nur die Datenbank sichere?

Dann fehlt Dir beim Restore der Encryption-Key aus dem n8n-Volume und alle Credentials in der DB bleiben unentschlüsselbar. Sichere immer beide Teile zusammen.

Fazit

Mit dem offiziellen withPostgres-Compose von n8n hast Du in unter einer halben Stunde eine produktionsnahe Automatisierungs-Plattform: Postgres als Datenbank, persistente Volumes, ein separater Task-Runner und die Web-UI auf Port 5678. Die zwei Dinge, die Du nicht vergessen darfst, sind ein Reverse Proxy mit HTTPS (wegen der Secure Cookies und für Webhooks/OAuth) und das Sichern von N8N_ENCRYPTION_KEY plus beider Datenspeicher. Danach steht Dir mit den AI-Agent-Knoten der gesamte Werkzeugkasten für KI-Automatisierung offen – von einfachen Chat-Assistenten bis zu komplexen RAG-Workflows mit Vector-Store. Weil n8n generisch ist, hängst Du an jede KI-Antwort beliebige weitere Schritte und automatisierst echte Geschäftsprozesse statt nur Gespräche.

Weiterführende Anleitungen und Quellen

Passende Anleitungen aus unserem Wissensbereich:

Offizielle Quellen:

Verwandt

Weiter lesen

Alle Artikel →
Server-Racks im Rechenzentrum als Sinnbild für eine lokale Vektordatenbank
02.06.2026 ·12 min

LibreChat: self-hosted ChatGPT- und Claude-Alternative mit Docker

LibreChat per Docker Compose self-hosten: Multi-Provider-Chat für OpenAI, Anthropic Claude, Azure und lokale Modelle via Ollama. Mit kompletter compose.yaml, .env-Secrets, librechat.yaml, MeiliSearch-Suche, RAG-Uploads und Update- und Backup-Workflow für Debian 12 und Ubuntu 24.04.
Lokaler NVR-Server mit KI-Videoüberwachung und Objekterkennung
02.06.2026 ·10 min

Frigate mit Docker: KI-Videoüberwachung (NVR) mit Objekterkennung

Baue dir mit Frigate und Docker einen lokalen NVR mit KI-Objekterkennung auf: RTSP-Kameras, Personen- und Auto-Erkennung, Hardware-Beschleunigung per Intel iGPU, Coral oder NVIDIA – alles selbst gehostet, ohne Cloud.
Lokale Transkription von Audio und Video mit Whisper auf dem eigenen Docker-Server
02.06.2026 ·11 min

Audio und Video lokal transkribieren mit Whisper (Docker)

So transkribierst du Meetings, Interviews und Videos komplett lokal und DSGVO-konform: Whishper (faster-whisper) per Docker Compose installieren, Datei hochladen, Modell und Sprache wählen und Untertitel als SRT/VTT exportieren – ganz ohne Cloud-Upload.