n8n (Aussprache „n-eight-n“) ist ein Workflow-Werkzeug mit offenem Quellcode (Sustainable Use License), mit dem Sie per Drag-and-drop Dienste verbinden, Daten zwischen APIs übertragen und KI-Knoten wie den AI Agent mit Chat-Modellen, Memory und Vector-Stores zu LLM-Automatisierungen verketten. Diese Anleitung zeigt, wie Sie n8n 2.42 per Docker Compose mit PostgreSQL betreiben, hinter HTTPS absichern und den ersten KI-Workflow starten.

Kurzfassung: Nutzen Sie das offizielle withPostgres-Setup von n8n, ersetzen Sie die Platzhalter in der .env durch Zufallswerte und starten Sie den Stack; die Weboberfläche läuft auf Port 5678. Die drei Kernbefehle:

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

n8n setzt standardmäßig Secure Cookies: Produktiv brauchen Sie einen Reverse Proxy mit TLS. Sichern Sie N8N_ENCRYPTION_KEY und das n8n-Volume, sonst sind alle gespeicherten Credentials verloren.

Voraussetzungen

n8n ist eine Node.js-Anwendung und braucht keine GPU. Für n8n gilt:

Betriebssystem: Linux-Server (x86_64 oder ARM64), z. B. Debian 12/13 oder Ubuntu 24.04.
Hardware zum Ausprobieren: 1 vCPU und 2 GB RAM (im Test belegte der Stack rund 450 MB RAM).
Hardware produktiv mit PostgreSQL: 2 vCPU, 4 GB RAM, 20 GB Speicher.
Docker: aktuelle Docker Engine plus docker compose (v2-Plugin). Test: docker compose version.
Domain & HTTPS: für den Produktivbetrieb eine Subdomain (z. B. n8n.example.de) mit gültigem TLS-Zertifikat über einen Reverse Proxy. Pflicht für Webhooks und OAuth.
Tools: git und openssl.

Ist Docker Compose für Sie neu, lesen Sie vorab die Grundlagen zu Docker Compose und Stacks; die Begriffe Service, Volume und Healthcheck setzt diese Anleitung 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

Im Verzeichnis liegen docker-compose.yml, .env und init-data.sh. Wer das Setup an einem festen Ort wie /opt/n8n betreiben will, kopiert die drei Dateien dorthin.

Verifizieren: ls -la zeigt die drei Dateien, init-data.sh ist ausführbar (-rwxr-xr-x).

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

Die mitgelieferte .env enthält Platzhalter wie changePassword. Ersetzen Sie diese vor dem ersten Start, sonst läuft die Datenbank mit Standard-Zugangsdaten. Erzeugen Sie 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

Tragen Sie die Werte in die .env ein. Vorlage (Platzhalter durch Ihre Werte ersetzen):

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

# n8n
N8N_VERSION=2.42.0
RUNNERS_AUTH_TOKEN=IHR-RUNNER-TOKEN
N8N_ENCRYPTION_KEY=IHR-ENCRYPTION-KEY

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

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

Bewahren Sie den N8N_ENCRYPTION_KEY an einem sicheren Ort auf. n8n verschlüsselt damit alle gespeicherten Credentials; ohne den Key sind sie unbrauchbar. Setzen Sie ihn nicht selbst, erzeugt n8n ihn beim ersten Start und legt ihn unter /home/node/.n8n/config im Volume ab. Der feste Tag 2.42.0 (Stand 29.09.2026) statt stable sorgt für kontrollierte Updates.

Verifizieren: grep -c change .env gibt 0 aus, es stehen also keine Platzhalter mehr in der Datei.

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

Die folgende docker-compose.yml entspricht der offiziellen withPostgres-Variante, ergänzt um Domain-, Zeitzonen- und Schlüssel-Variablen. Sie startet drei Dienste: postgres (Datenbank), n8n (Anwendung mit Web-UI) und n8n-runner (Task-Runner für Code-Knoten).

services:
  postgres:
    image: postgres:18
    restart: always
    environment:
      - POSTGRES_USER
      - POSTGRES_PASSWORD
      - POSTGRES_DB
      - POSTGRES_NON_ROOT_USER
      - POSTGRES_NON_ROOT_PASSWORD
      # postgres:18 nutzt ein anderes Standard-Datenverzeichnis; PGDATA hält den Volume-Pfad stabil
      - PGDATA=/var/lib/postgresql/data
    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_MODE=external
      - N8N_RUNNERS_AUTH_TOKEN=${RUNNERS_AUTH_TOKEN}
      - N8N_RUNNERS_BROKER_LISTEN_ADDRESS=0.0.0.0
    ports:
      - '127.0.0.1:5678:5678'
    volumes:
      - n8n_storage:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

  n8n-runner:
    image: 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:

Der n8n-Container wartet per depends_on auf den Healthcheck von PostgreSQL. Das Mapping 127.0.0.1:5678:5678 macht die Web-UI nur lokal für den Reverse Proxy erreichbar. Der Task-Runner verbindet sich über N8N_RUNNERS_TASK_BROKER_URI mit dem internen Broker-Port 5679. Das Runner-Image liegt nur auf Docker Hub (n8nio/runners), nicht unter docker.n8n.io.

Verifizieren: docker compose config --quiet endet ohne Ausgabe und ohne Fehler.

Schritt 4: Stack starten und Logs prüfen

Starten Sie den Stack:

docker compose up -d
docker compose ps

Bei Problemen helfen die Logs:

docker compose logs -f n8n

Der erste Start dauert wegen der Datenbank-Migrationen einige Minuten; bis dahin liefert die Weboberfläche 404. Umgebungsvariablen liest n8n nur beim Container-Start. Nach Änderungen an .env oder Compose-Datei erstellen Sie die Container mit docker compose up -d neu; ein Neustart allein genügt nicht.

Verifizieren: docker compose ps zeigt drei laufende Container, PostgreSQL mit healthy. Im Log steht Editor is now accessible via, und curl -s http://127.0.0.1:5678/healthz liefert {"status":"ok"}.

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

n8n setzt per Default N8N_SECURE_COOKIE=true. Über http://SERVER-IP:5678 verweigert n8n deshalb den Login. Setzen Sie einen Reverse Proxy mit TLS davor. Caddy holt Let’s-Encrypt-Zertifikate automatisch; eine minimale Caddyfile:

n8n.example.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.example.de;

    ssl_certificate     /etc/letsencrypt/live/n8n.example.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.example.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";
    }
}

Setzen Sie WEBHOOK_URL und N8N_EDITOR_BASE_URL auf die öffentliche https://-Adresse (Schritt 2), sonst zeigen Webhook- und OAuth-Callback-URLs auf localhost:5678. n8n 2.42 meldet WEBHOOK_URL beim Start als veraltet (Nachfolger N8N_WEBHOOK_URL), wertet sie aber weiter aus. Nur für einen lokalen Test ohne Proxy setzen Sie übergangsweise N8N_SECURE_COOKIE=false, nie in Produktion.

Verifizieren: curl -I https://n8n.example.de liefert HTTP/2 200 mit gültigem Zertifikat.

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

Rufen Sie die UI auf: produktiv https://n8n.example.de, lokal http://localhost:5678. Beim ersten Aufruf legen Sie den Owner-Account mit E-Mail und Passwort an.

Test-Workflow im Editor: Manual Trigger, danach ein Set-Node (Feld hallo = welt), dann Execute Workflow.

Verifizieren: Der Owner-Login funktioniert, und der Test-Workflow zeigt am Set-Node die Ausgabe hallo: welt.

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

Die KI-Knoten (Advanced AI, LangChain) sind Cluster Nodes: Ein Root-Node (AI Agent) bündelt mehrere Sub-Nodes. So bauen Sie einen einfachen KI-Assistenten:

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

An die KI-Antwort hängen Sie beliebige weitere Schritte wie Datenbank-Eintrag, E-Mail oder Ticket. Die LLM-Inferenz läuft nicht in n8n, sondern bei einer externen API oder einem separaten Ollama. Für lokale Embeddings und Vektorsuche eignet sich ein lokalen Qdrant-RAG-System mit Embeddings.

Verifizieren: Im Chat-Test antwortet der Agent auf eine Frage, und die Ausführung erscheint unter Executions mit Status „Success“.

Schritt 8: Credentials sicher speichern und Verschlüsselung verstehen

Alle Zugangsdaten (API-Keys, OAuth-Tokens, DB-Passwörter) in n8n 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: Sichern Sie beide Teile, das n8n-Volume (Key, Einstellungen) und die Datenbank (Workflows, Credentials, Ausführungen).

Den Key prüfen Sie im Container:

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

Verifizieren: Die Ausgabe enthält encryptionKey mit demselben Wert wie N8N_ENCRYPTION_KEY in der .env.

Schritt 9: Update und Backup

Für ein Update tragen Sie die neue Version in N8N_VERSION ein, ziehen die Images und erstellen die Container neu; die 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 withpostgres_n8n_storage:/source -v $(pwd):/backup alpine \
  tar czf /backup/n8n-backup-$(date +%Y%m%d).tar.gz -C /source .

Den genauen Volume-Namen (Projektname plus n8n_storage) zeigt docker volume ls. Zweitens ein Dump der Datenbank (Workflows, Credentials, Verlauf). Die Shell kennt die Variablen aus der .env nicht, deshalb laden Sie sie vorher:

set -a && . ./.env && set +a
docker compose exec -T postgres pg_dump -U "$POSTGRES_NON_ROOT_USER" n8n > n8n-db-$(date +%Y%m%d).sql

Testen Sie den Restore mindestens einmal. Nutzen Sie nie docker compose down -v: Das löscht auch das Volume mit dem Encryption-Key. Wer von einem älteren Setup mit postgres:16 kommt, bleibt bei 16 oder migriert per Dump und Restore; PostgreSQL 18 liest das alte Datenverzeichnis nicht.

Verifizieren: tar tzf n8n-backup-*.tar.gz | grep config findet die Datei ./config, und die SQL-Datei endet mit PostgreSQL database dump complete.

Troubleshooting

Login schlägt fehl („configured to use a secure cookie … insecure URL“): Der Aufruf erfolgt über http oder eine IP. Reverse Proxy mit TLS (Schritt 5), 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. Stellen Sie den ursprünglichen Key wieder her.
Webhooks/OAuth-Redirects landen auf localhost: WEBHOOK_URL und N8N_EDITOR_BASE_URL auf die öffentliche https-URL setzen, dann docker compose up -d.
PostgreSQL-Login scheitert nach Passwortänderung: init-data.sh läuft nur beim ersten Start mit leerem DB-Volume. Ändern Sie das Passwort danach per ALTER USER in psql.
Schedule-Trigger feuern zur falschen Zeit: GENERIC_TIMEZONE und TZ auf Europe/Berlin setzen.
Änderungen an der .env wirken nicht: Immer docker compose up -d (Neuerstellung) statt Restart.
„runners:… not found“ beim Pull: Das Runner-Image heißt n8nio/runners (Docker Hub), nicht docker.n8n.io/n8nio/runners.
Code-Knoten bricht mit „Task request timed out“ ab: Der Runner hat die Aufgabe nicht binnen 60 Sekunden angenommen, typisch bei ausgelasteter CPU. Mehr CPU zuteilen oder N8N_RUNNERS_TASK_REQUEST_TIMEOUT erhöhen.
„database files are incompatible with server“: Ein PostgreSQL-16-Volume trifft auf postgres:18. Image auf postgres:16 zurücksetzen oder per Dump migrieren.

Häufige Fragen

Brauche ich für n8n eine GPU?

Nein. n8n läuft komplett auf der CPU. Eine GPU lohnt nur für ein separates lokales LLM wie Ollama, das n8n als Chat-Modell anspricht.

SQLite oder Postgres: was soll ich nehmen?

Zum Ausprobieren reicht ein einzelner Container mit SQLite. Produktiv empfiehlt sich PostgreSQL wie in dieser Anleitung: Es skaliert besser und lässt sich sauber sichern.

Worin unterscheidet sich n8n von Dify?

Dify ist auf KI-Apps und Agenten spezialisiert. In n8n ist KI einer von vielen Knoten einer generischen Workflow-Automatisierung. In n8n verketten Sie KI-Antworten mit beliebigen weiteren Schritten. Für reine KI-Apps siehe 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. Er nutzt dasselbe Versions-Tag wie n8n und authentifiziert sich per N8N_RUNNERS_AUTH_TOKEN.

Wie aktualisiere ich auf eine bestimmte Version statt auf stable?

Setzen Sie in der .env N8N_VERSION auf einen konkreten Tag, z. B. 2.42.0. Daneben gibt es stable bzw. latest und next (Vorabversion). Danach docker compose pull und docker compose up -d.

Was passiert, wenn ich nur die Datenbank sichere?

Dann fehlt beim Restore der Encryption-Key aus dem n8n-Volume, und alle Credentials bleiben unlesbar. Sichern Sie immer beide Teile.

Fazit

Mit dem offiziellen withPostgres-Setup betreiben Sie n8n in etwa einer halben Stunde mit PostgreSQL, persistenten Volumes und separatem Task-Runner. Unverzichtbar sind HTTPS über einen Reverse Proxy und die Sicherung von N8N_ENCRYPTION_KEY samt beider Datenspeicher. Darauf bauen Sie mit den AI-Agent-Knoten Chat-Assistenten und RAG-Workflows.

Weiterführende Anleitungen und Quellen

Offizielle Quellen: