n8n auf Hetzner installieren: Docker Compose, HTTPS und Updates

Firewall in der Hetzner Console anlegen

Öffne in der Hetzner Console „Firewalls“ und wähle „Create Firewall“ (Q18). Lege drei eingehende Regeln an: TCP 22 für SSH, TCP 80 und TCP 443 für HTTP und HTTPS. Was keine Regel erlaubt, verwirft die Firewall. Lässt du die ausgehenden Regeln leer, bleibt ausgehender Verkehr erlaubt, und Hetzner berechnet für Cloud Firewalls nichts (Q18). Port 80 muss offen sein, weil Caddy für das Zertifikat die Ports 80 und 443 braucht (Q29, Q31). Wer SSH auf die eigene IP-Adresse beschränkt, sperrt sich bei wechselnder Adresse selbst aus (eigene Einschätzung).

Abweichung von der n8n-Anleitung: Sie öffnet die Ports mit ufw auf dem Server (Q1). Hetzner rät, nur eine Firewall zu verwenden, um Regelkonflikte zu vermeiden (Q22). Dazu kommt, dass von Docker veröffentlichte Container-Ports laut Docker-Dokumentation die ufw-Regeln umgehen (Q27). Die Cloud Firewall läuft außerhalb des Servers; Docker-Regeln auf dem Server betreffen sie nicht (eigene Einschätzung).

Server anlegen

Wähle „Servers“ und „Add server“ (Q17) und stelle ein:

• Location: Nürnberg (nbg1), Falkenstein (fsn1) oder Helsinki (hel1). Die Preisliste führt den CPX22 für alle drei (Abruf 10.11.2026); welche Standorte gerade bestellbar sind, zeigt erst die Bestellung in der Cloud Console (Q16, Q21).
• Image: Ubuntu 24.04. Docker und die SSH-Anleitung von Hetzner nennen diese Version (Q26, Q22).
• Type: Regular Performance, CPX22 mit 2 vCPU, 4 GB RAM, 80 GB NVMe und 20 TB (EU) Traffic. Hetzners günstigere CX-Reihe war am 07.11.2026 nicht verfügbar, kaufbar war der CPX22 (Q16). Die n8n-Anleitung nennt für die meisten Fälle den Typ CPX11, kommt in den Preisdaten vom 07.11.2026 aber nicht vor; für n8n Assistant verlangt sie mindestens 4 GB RAM und 2 vCPU (Q1). Der CPX22 erfüllt diese Grenze genau.
• Networking: IPv4 und IPv6. Die öffentliche IPv4-Adresse kostet 0,50 € im Monat extra und steht getrennt auf der Rechnung, IPv6 ist kostenlos (Q16, Q20). Ohne IPv4 erreichen den Server nur Clients mit IPv6 (eigene Einschätzung).
• SSH key: Füge jetzt deinen öffentlichen Schlüssel hinzu, denn nach dem Anlegen geht das in der Console nicht mehr (Q17). Hetzner empfiehlt Ed25519, wenn dein Gerät es unterstützt (Q23):

ssh-keygen -t ed25519

• Firewalls: wähle die Firewall aus Schritt 1.
• Backups: aktiviere sie. Das kostet 20 % des Serverpreises, hier 3,90 € im Monat, für tägliche Kopien in sieben Slots (Q19, Q20).
• Name: zum Beispiel n8n-1; ein Name darf pro Projekt nur einmal vorkommen (Q17).

„Create & Buy now“ legt den Server an (Q17). Ab dann zahlst du stündlich bis zum Monatspreis (Q20).

DNS-Eintrag setzen

Lege beim DNS-Anbieter einen A-Record für die Subdomain an, etwa n8n, mit der IPv4-Adresse des Servers als Ziel (Q2). Nutzt du IPv6, gehört ein AAAA-Record mit der IPv6-Adresse dazu. Caddy stellt ein Zertifikat nur aus, wenn die A- und AAAA-Einträge der Domain auf den Server zeigen, und die Einträge sollen vor dem ersten Start von Caddy stimmen (Q29).

Per SSH verbinden und den Zugang absichern

Melde dich als root an. Mit hinterlegtem Schlüssel und ohne Passwort bist du direkt verbunden (Q17). Lege dann nach der Hetzner-Anleitung einen Benutzer mit sudo-Rechten an und kopiere deinen Schlüssel dorthin (Q22):

ssh root@DEINE-SERVER-IP
adduser n8nadmin
usermod -aG sudo n8nadmin
rsync --archive --chown=n8nadmin:n8nadmin ~/.ssh /home/n8nadmin

Der Pfad ~/.ssh darf nicht auf einen Schrägstrich enden, sonst funktioniert der Befehl nicht (Q22). Teste in einem zweiten Terminal Anmeldung und sudo, bevor du root sperrst (Q22):

ssh n8nadmin@DEINE-SERVER-IP
sudo su - root
exit

Setze danach in der Datei /etc/ssh/sshd_config die Werte PermitRootLogin no und PasswordAuthentication no, und starte SSH neu. Das Passwort sperrst du nur, wenn du per Schlüssel anmeldest (Q22):

sudo nano /etc/ssh/sshd_config
sudo systemctl restart ssh

Ob die Werte gelten, zeigt der Befehl sudo sshd -T | grep -E 'permitrootlogin|passwordauthentication', denn er gibt die wirksame Konfiguration aus (Q33). Das lohnt sich, weil bei jedem Schlüsselwort der erste gefundene Wert gilt (Q33) und eine eingebundene Datei die Zeile in sshd_config überstimmen kann (eigene Einschätzung). Ab hier arbeitest du als n8nadmin mit sudo.

Docker installieren

Installiere Docker Engine nach der Docker-Anleitung für Ubuntu mit dem apt-Repository (Q26). Ubuntu 24.04 ist dort als unterstützt gelistet. Das Convenience-Skript von Docker nennt die Anleitung nur für Test- und Entwicklungsumgebungen, deshalb gilt hier das Repository:

# Docker-Schlüssel und Repository einrichten
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

# Docker installieren und prüfen
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo docker run hello-world
sudo docker compose version

Die n8n-Anleitung nutzt stattdessen das Hetzner-Image „Docker CE“ und installiert das Compose-Plugin nach (Q1, Q24). Beide Wege führen zu Docker mit Compose.

Dateien anlegen: .env, init-data.sh, Caddyfile und compose.yaml

Lege den Projektordner an und erzeuge die Datei .env. Ersetze n8n.deine-firma.de durch deine Domain. Die Zufallswerte erzeugt openssl rand -hex 24, wie es auch das Einzeiler-Skript von n8n macht (Q15). Docker Compose liest .env automatisch und setzt die Werte in die Compose-Datei ein (Q28):

mkdir -p ~/n8n/caddy && cd ~/n8n
cat > .env <<EOF
N8N_DOMAIN=n8n.deine-firma.de
N8N_VERSION=2.46.7
POSTGRES_USER=postgres
POSTGRES_PASSWORD=$(openssl rand -hex 24)
POSTGRES_DB=n8n
POSTGRES_NON_ROOT_USER=n8n
POSTGRES_NON_ROOT_PASSWORD=$(openssl rand -hex 24)
N8N_ENCRYPTION_KEY=$(openssl rand -hex 24)
N8N_RUNNERS_AUTH_TOKEN=$(openssl rand -hex 24)
EOF
chmod 600 .env

N8N_VERSION pinnt die Version von n8n und Task Runner. Am 09.11.2026 war 2.46.7 die aktuelle Version, das Image mit diesem Tag gibt es für n8n und für die Runner (Q15). Prüfe die aktuelle Nummer vor dem Start.

POSTGRES_USER ist der Superuser der Datenbank, den n8n nicht nutzen soll. Das Skript init-data.sh legt beim ersten Start der Datenbank den eingeschränkten Benutzer POSTGRES_NON_ROOT_USER an, wie im Beispiel des n8n-Hosting-Repositorys (Q4, Q40). Ausführungsrechte braucht die Datei nicht: Das Postgres-Image bindet nicht ausführbare .sh-Dateien per Source ein (Q40).

cat > init-data.sh <<'INIT'
#!/bin/bash
set -e
if [ -n "${POSTGRES_NON_ROOT_USER:-}" ] && [ -n "${POSTGRES_NON_ROOT_PASSWORD:-}" ]; then
  psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<EOSQL
CREATE USER ${POSTGRES_NON_ROOT_USER} WITH PASSWORD '${POSTGRES_NON_ROOT_PASSWORD}';
GRANT ALL PRIVILEGES ON DATABASE ${POSTGRES_DB} TO ${POSTGRES_NON_ROOT_USER};
GRANT CREATE ON SCHEMA public TO ${POSTGRES_NON_ROOT_USER};
EOSQL
else
  echo "SETUP INFO: No Environment variables given!"
fi
INIT

Die Caddyfile (~/n8n/caddy/Caddyfile) leitet die Domain an n8n weiter. Sie enthält zunächst einen Zugangsschutz für die Ersteinrichtung: Caddy veröffentlicht n8n schon, bevor das Owner-Konto existiert, und wer die Einrichtung zuerst abschließt, wird laut n8n Besitzer der Instanz (Q11). Den Passwort-Hash erzeugt Caddy selbst; der Befehl fragt das Passwort ohne Anzeige ab (Q39):

sudo docker run --rm -it caddy:2 caddy hash-password

Trage den ausgegebenen Hash anstelle von HASH_HIER_EINTRAGEN ein. setup ist ein frei gewählter Benutzername:

{$N8N_DOMAIN} {
    # Nur für die Ersteinrichtung: nach dem Anlegen des Owner-Kontos entfernen
    basic_auth {
        setup HASH_HIER_EINTRAGEN
    }
    reverse_proxy n8n:5678 {
        flush_interval -1
    }
}

Die Compose-Datei ~/n8n/compose.yaml:

services:
  caddy:
    image: caddy:2
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    environment:
      N8N_DOMAIN: ${N8N_DOMAIN}
    volumes:
      - ./caddy:/etc/caddy
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - n8n

  postgres:
    image: postgres:18
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_NON_ROOT_USER: ${POSTGRES_NON_ROOT_USER}
      POSTGRES_NON_ROOT_PASSWORD: ${POSTGRES_NON_ROOT_PASSWORD}
      # Nicht entfernen: ohne diese Zeile schreibt Postgres 18 außerhalb des Volumes
      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: unless-stopped
    environment:
      N8N_HOST: ${N8N_DOMAIN}
      N8N_PROTOCOL: https
      N8N_WEBHOOK_URL: https://${N8N_DOMAIN}/
      N8N_PROXY_HOPS: "1"
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
      GENERIC_TIMEZONE: Europe/Berlin
      TZ: Europe/Berlin
      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}
      N8N_RUNNERS_MODE: external
      N8N_RUNNERS_BROKER_LISTEN_ADDRESS: 0.0.0.0
      N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN}
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy

  runners:
    image: n8nio/runners:${N8N_VERSION}
    restart: unless-stopped
    environment:
      N8N_RUNNERS_TASK_BROKER_URI: http://n8n:5679
      N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN}
    depends_on:
      - n8n

volumes:
  caddy_data:
  caddy_config:
  db_storage:
  n8n_data:

Die Datei setzt sich aus Beispielen der Dokumentation zusammen (Q1, Q3, Q4, Q5). Das bedeuten die Teile:

• PostgreSQL statt SQLite. n8n nutzt standardmäßig SQLite und rät bei Dauerbetrieb mit mehr als einer Handvoll Workflows oder Nutzer zu Postgres (Q3). Unterstützt sind die Versionen 16, 17 und 18 (Stand Juli 2026, Q9). Die Zeile PGDATA und der Healthcheck stammen aus der n8n-Anleitung (Q3). n8n verbindet sich nicht mit dem Superuser, sondern mit dem eingeschränkten Benutzer POSTGRES_NON_ROOT_USER, den init-data.sh anlegt (Q4, Q40). Das Skript läuft nur, wenn das Datenverzeichnis beim Start leer ist; auf einer bestehenden Datenbank legt es den Benutzer nicht nachträglich an (Q40).
• Webhook-URL und Proxy. Hinter einem Reverse Proxy braucht n8n N8N_WEBHOOK_URL und N8N_PROXY_HOPS=1, und der Proxy muss die X-Forwarded-Header setzen (Q6). Caddy setzt X-Forwarded-For, -Proto und -Host standardmäßig (Q30). Das Beispiel-Repository und ältere Anleitungen nutzen WEBHOOK_URL; seit n8n 2.35.0 ist es veraltet, N8N_WEBHOOK_URL gilt ab 2.30.0 (Q2, Q7).
• Eigener Verschlüsselungsschlüssel. Ohne N8N_ENCRYPTION_KEY erzeugt n8n beim ersten Start einen zufälligen Schlüssel im Ordner .n8n (Q8). Ohne ihn sind gespeicherte Zugangsdaten nach einer Wiederherstellung nicht lesbar (Q11). Mit dem Schlüssel in .env gehört diese Datei in jede Sicherung; den Ordner .n8n ersetzt sie nicht (Abschnitt „Backups einrichten“).
• Task Runner extern. Laut n8n sind Runner die einzige Isolationsschicht zwischen Code-Nodes und n8n. Für Produktion empfiehlt n8n den externen Modus, der interne ist ab n8n 3.0 veraltet, und das Runner-Image muss zur n8n-Version passen (Q10). Das Muster stammt aus dem n8n-Hosting-Repository (Q4).
• Kein veröffentlichter n8n-Port. Caddy erreicht n8n über das Compose-Netz mit n8n:5678, wie in der Caddyfile der n8n-Anleitung (Q1). Das Beispiel-Repository veröffentlicht Port 5678 zusätzlich (Q5); das entfällt hier, damit n8n nur über HTTPS erreichbar ist.
• Caddy-Volumes. Das Caddy-Image rät, die Caddyfile nicht als Einzeldatei einzubinden, weil Änderungen sonst erst nach dem Neuerstellen des Containers greifen können, und verlangt ein dauerhaftes Datenverzeichnis, in dem auch die Zertifikate liegen (Q31). Deshalb wird der Ordner ./caddy eingebunden und caddy_data als Volume gehalten. {$N8N_DOMAIN} liest die Domain aus der Umgebung (Q30).
• Ohne n8n Assistant. Die aktuelle Compose-Seite von n8n bündelt den Sandbox-Stack für n8n Assistant mit einem privilegierten Docker-in-Docker-Container und verlangt mindestens 4 GB RAM (Q3). Diesen Stack lässt die Datei weg. Wer n8n Assistant will, folgt dem optionalen Abschnitt der Hetzner-Anleitung (Q1).

Starten und prüfen

cd ~/n8n
sudo docker compose up -d
sudo docker compose ps

Der erste Start kann einige Minuten dauern (Q1). Caddy holt das Zertifikat von einer öffentlichen ACME-Stelle wie Let’s Encrypt oder ZeroSSL (Q29). Ob n8n antwortet, prüft der Aufruf curl -sf -u setup https://n8n.deine-firma.de/healthz, den n8n selbst für diesen Test nutzt (Q3); -u setup fragt das Passwort des Zugangsschutzes ab. Öffne danach die Domain im Browser. Caddy verlangt zuerst Benutzer setup und das Passwort, erst dahinter erscheint die Einrichtung von n8n. Lege dort das Owner-Konto an: Wer die Einrichtung zuerst abschließt, wird laut n8n Besitzer der Instanz (Q11), und der Zugangsschutz verhindert, dass das ein Fremder vor dir tut. Entferne erst danach den Block basic_auth aus der Caddyfile und lade Caddy neu (Q31):

nano ~/n8n/caddy/Caddyfile    # den Block basic_auth { ... } löschen
cd ~/n8n
sudo docker compose exec -w /etc/caddy caddy caddy reload

Ab jetzt ist die Instanz ohne Zugangsschutz erreichbar, auch für Webhook-Aufrufe von außen. Angemeldet bist du mit dem Owner-Konto von n8n.

Bleibt die Seite leer oder meldet der Browser einen Zertifikatsfehler, zeigt sudo docker compose logs caddy die Ursache. Die Voraussetzungen aus der Caddy-Dokumentation sind die üblichen Verdächtigen: DNS zeigt nicht auf den Server, Port 80 oder 443 ist zu, das Datenverzeichnis ist nicht beschreibbar (Q29).

Backups einrichten

Ein Backup besteht aus zwei Ebenen. Die erste hast du beim Anlegen aktiviert: Hetzner kopiert die Platte täglich automatisch und hält sieben Stände, der Preis liegt bei 20 % des Serverpreises (Q19, Q20). Zurückholen kannst du einen Stand, indem du den Server aus dem Backup neu aufbaust oder einen neuen Server daraus erstellst (Q19). Zur Konsistenz einer laufenden Datenbank sagt die Hetzner-Dokumentation nichts.

Die zweite Ebene sind eigene Sicherungen der Daten. Ein vollständiges Backup besteht laut n8n aus dem Ordner .n8n, der externen Datenbank und der Deployment-Konfiguration (Q11). Der Ordner liegt in diesem Setup im Docker-Volume n8n_data (eingebunden unter /home/node/.n8n) und enthält die Datei config mit dem Verschlüsselungsschlüssel, bei Dateisystem-Speicher auch Binär- und Ausführungsdaten (Q11). Die Datei .env ersetzt nur den ausdrücklich gesetzten Schlüssel, nicht diesen Ordner. Das Skript unten sichert Datenbank, Volume und Konfiguration; die Dokumentation warnt vor dem Kopieren im Betrieb nur bei SQLite, hier liegt die Datenbank in Postgres (eigene Einschätzung).

Der Datenbank-Dump läuft im Postgres-Container (Q32), das Volume sichert ein kurzlebiger Container mit --volumes-from, wie die Docker-Dokumentation es zeigt (Q42). Das Skript legt pro Lauf ein Verzeichnis mit Zeitstempel an und füllt es mit Dump, Volume-Archiv und den Konfigurationsdateien .env, compose.yaml, init-data.sh und Caddyfile. Erst wenn alle Teile fertig sind, bekommt das Verzeichnis seinen endgültigen Namen. Bei jedem Fehler bricht das Skript ab und löscht das unfertige Verzeichnis; frühere Sicherungen bleiben unberührt. umask 077 macht die Dateien nur für deinen Benutzer lesbar:

cat > ~/n8n/backup.sh <<'SCRIPT'
#!/bin/bash
set -euo pipefail
umask 077
cd "$(dirname "$0")"
d=$(date +%Y-%m-%d-%H%M%S)
tmp="sicherung-$d.tmp"
mkdir "$tmp"
# räumt bei jedem Abbruch auf; nach dem mv gibt es $tmp nicht mehr
trap 'rm -rf "$tmp"' EXIT
sudo docker compose exec -T postgres sh -c 'pg_dump -U "$POSTGRES_USER" "$POSTGRES_DB"' > "$tmp/n8n-db.sql"
sudo docker run --rm --volumes-from "$(sudo docker compose ps -aq n8n)" alpine tar czf - -C /home/node/.n8n . > "$tmp/n8n-data.tar.gz"
cp .env compose.yaml init-data.sh "$tmp/"
cp caddy/Caddyfile "$tmp/"
mv "$tmp" "sicherung-$d"
ls -l "sicherung-$d"
SCRIPT
bash ~/n8n/backup.sh

Bei einem Fehler endet bash ~/n8n/backup.sh mit einem Exit-Code ungleich 0 und legt kein Sicherungsverzeichnis an. Kopiere das ganze Verzeichnis sicherung-… regelmäßig an einen Ort außerhalb des Servers, am besten automatisiert per Cronjob oder systemd-Timer; mit .env enthält es die Passwörter und den Schlüssel. Ein Cronjob gehört in die Crontab von root (sudo crontab -e), weil sudo im Skript sonst ein Passwort verlangt (eigene Einschätzung). Dort steht der volle Pfad, etwa /bin/bash /home/n8nadmin/n8n/backup.sh, denn ~ zeigt bei root auf /root. Die so erzeugten Verzeichnisse gehören root und sind für n8nadmin nicht lesbar: Lass die externe Kopie deshalb ebenfalls als root laufen, oder übergib die fertige Sicherung mit sudo chown -R n8nadmin: sicherung-… an deinen Benutzer.

Die Wiederherstellung läuft laut n8n in der Reihenfolge n8n stoppen, .n8n zurückspielen, Datenbank zurückspielen, Konfiguration wiederherstellen, n8n starten (Q11). Die Konfiguration steckt in diesem Setup in den vier Dateien des Pakets (eigene Einschätzung). Auf einem neu aufgesetzten Server mit leerer Datenbank legst du ~/n8n an und kopierst das Sicherungsverzeichnis hinein, etwa per scp -r. Die Dateien daraus stellst du her, .env wird nicht neu erzeugt. Zuerst startet nur die Datenbank, und --wait hält den Ablauf an, bis ihr Healthcheck besteht (Q43). So legt n8n sein Schema nicht vor dem Import an (Q4). psql setzt nach einem SQL-Fehler standardmäßig fort; ON_ERROR_STOP=1 beendet es dann mit Fehlercode (Q44), und die Verkettung mit && startet n8n nur nach erfolgreichem Import:

mkdir -p ~/n8n/caddy && cd ~/n8n
P=sicherung-2026-11-10-031500   # dein Sicherungsverzeichnis in ~/n8n
cp "$P/.env" "$P/compose.yaml" "$P/init-data.sh" .
cp "$P/Caddyfile" caddy/
chmod 644 init-data.sh   # die Sicherung speichert sie mit 600, der Postgres-Container muss sie lesen können
sudo docker compose create n8n
sudo docker run --rm -i --volumes-from "$(sudo docker compose ps -aq n8n)" alpine tar xzf - -C /home/node/.n8n < "$P/n8n-data.tar.gz" \
  && sudo docker compose up -d --wait postgres \
  && sudo docker compose exec -T postgres sh -c 'psql -v ON_ERROR_STOP=1 -U "$POSTGRES_USER" -d "$POSTGRES_DB"' < "$P/n8n-db.sql" \
  && sudo docker compose up -d

Den Namen hinter P= ersetzt du durch deine Sicherung. Die Caddyfile im Paket stammt aus dem Betrieb; steht darin noch basic_auth, entferne den Block, denn das Owner-Konto steckt ja in der Sicherung. Bricht ein Schritt ab, startet n8n nicht; ein neuer Versuch braucht wieder eine leere Datenbank, am einfachsten auf einem frisch angelegten Server. Übe das einmal auf einem Testserver, bevor du es brauchst (eigene Einschätzung). Der Ablauf ist für ein leeres Volume und eine leere Datenbank gedacht, nicht für einen Server mit laufenden Daten.

Updates einspielen

n8n empfiehlt, mindestens einmal im Monat zu aktualisieren, vorher die Release Notes auf Breaking Changes zu prüfen und ein vollständiges Backup zu machen (Q11, Q12). Mit der gepinnten Version ist ein Update eine neue Nummer in .env, danach die Befehle aus der n8n-Dokumentation (Q12, Q4):

cd ~/n8n
nano .env    # N8N_VERSION auf die neue Nummer setzen
sudo docker compose pull
sudo docker compose down
sudo docker compose up -d

Verwende down ohne die Option -v: Sie löscht auch die Volumes, und damit Datenbank und Schlüssel (Q4). Der Tag postgres:18 bleibt in der Hauptversion 18; ein Sprung der Hauptversion lässt die Datenbank bei einer bestehenden Installation nicht mehr starten und braucht vorher einen Dump (Q3, Q4). Das Betriebssystem aktualisierst du getrennt mit sudo apt update && sudo apt upgrade (Q1).