Daten-Gold schürfen: n8n und Docker für deine Heim-Archive

Servus, liebe Admins und Heimlabor-Enthusiasten!

Als jemand, der seit Jahren im Home Lab herumwerkelt und versucht, alles zu automatisieren, was nicht bei drei auf dem Baum ist, stoße ich immer wieder auf spannende Anwendungsfälle für Daten. Egal ob es die Smart-Home-Daten sind, die ich auswerte, oder eben öffentlich zugängliche Informationen, die man für eigene Projekte nutzen möchte. Stell dir vor, du möchtest nicht nur die Informationen passiv konsumieren, sondern aktiv damit arbeiten, sie vielleicht lokal spiegeln, analysieren oder für eigene Projekte aufbereiten.

Das ist genau der Punkt, wo Tools wie n8n ins Spiel kommen. In meiner Erfahrung ist n8n ein absolutes Schweizer Taschenmesser, wenn es darum geht, Datenflüsse zu orchestrieren. Kombiniert mit Docker für die einfache Bereitstellung auf deinem Linux-Server, hast du eine unschlagbare Kombination. Ich zeige dir heute, wie du ein solches Setup aufsetzt, um hypothetisch Daten aus einer externen Quelle automatisiert abzurufen, zu verarbeiten und für deine Zwecke nutzbar zu machen. Das Prinzip lässt sich auf unzählige Szenarien anwenden, sei es das Abgreifen von API-Daten, das Parsen von RSS-Feeds oder eben das Verarbeiten von Daten aus öffentlich zugänglichen Archiven, sofern sie eine maschinenlesbare Schnittstelle bieten.

Wer das zum ersten Mal einrichtet, stolpert oft über die richtige Konfiguration oder die Logik der Workflows. Keine Sorge, ich führe dich Schritt für Schritt durch den Prozess und teile meine besten Tipps aus der Praxis.

Voraussetzungen für dein Daten-Schürf-Setup

Bevor wir loslegen, sollten ein paar Grundsteine gelegt sein. Du brauchst keine Raketenwissenschaftler-Kenntnisse, aber ein solides Fundament hilft ungemein.

Linux-Server: Ein beliebiger Linux-Server (z.B. Ubuntu Server, Debian) mit ausreichend Ressourcen. Für n8n empfehle ich mindestens 2GB RAM, wenn du komplexere Workflows planst. Ein Raspberry Pi 4 kann auch funktionieren, ist aber für größere Workloads schnell am Limit.
Docker & Docker Compose: Das ist unsere Basis für die einfache Bereitstellung von n8n. Wenn du Docker noch nicht installiert hast, ist das der erste Schritt. Eine aktuelle Version ist immer von Vorteil. Mein Tipp: Installiere Docker nicht über die Paketquellen deiner Distribution, sondern folge der offiziellen Docker-Dokumentation für eine saubere und aktuelle Installation.
Grundkenntnisse Linux-Shell: Du solltest dich auf der Kommandozeile wohlfühlen, um Dateien zu erstellen, zu bearbeiten und Befehle auszuführen.
(Optional) n8n-Grundverständnis: Wenn du schon mal mit n8n gearbeitet hast, super! Wenn nicht, ist das kein Problem, ich erkläre die relevanten Schritte. Das Interface ist sehr intuitiv.

Stelle sicher, dass dein System auf dem neuesten Stand ist:

sudo apt update && sudo apt upgrade -y

Und installiere Docker und Docker Compose, falls noch nicht geschehen. Die offizielle Doku ist hier dein bester Freund, aber für Ubuntu/Debian sieht das meist so aus:

# Docker installieren
for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-scan-plugin; do sudo apt-get remove $pkg; done
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Benutzer zur Docker-Gruppe hinzufügen (damit du sudo nicht immer brauchst)
sudo usermod -aG docker $USER
# Achtung: Nach diesem Befehl einmal abmelden und wieder anmelden, damit die Gruppe aktiv wird!

Wichtig zu wissen: Nach dem Hinzufügen des Benutzers zur Docker-Gruppe musst du dich einmal ab- und wieder anmelden, damit die Änderungen wirksam werden. Das ist ein Klassiker, über den man gerne stolpert!

Schritt-für-Schritt: n8n mit Docker Compose einrichten

Wir nutzen Docker Compose, um n8n und seine Abhängigkeiten (in unserem Fall eine Postgres-Datenbank für die n8n-Daten) sauber zu definieren und zu starten. Das macht das Management extrem einfach.

1. Projektverzeichnis anlegen

Zuerst erstellen wir ein Verzeichnis für unser n8n-Projekt. Ich nenne es gerne n8n-data-collector.

mkdir ~/n8n-data-collector
cd ~/n8n-data-collector

2. Docker Compose Datei erstellen

Jetzt erstellen wir die docker-compose.yml-Datei. Diese Datei definiert unsere Dienste (n8n und PostgreSQL), deren Images, Volumes und Netzwerkeinstellungen.

nano docker-compose.yml

Füge den folgenden Inhalt ein. Achte auf die Platzhalter wie YOUR_N8N_PASSWORD und YOUR_POSTGRES_PASSWORD – die solltest du unbedingt durch sichere Passwörter ersetzen!

version: '3.8'

services:
  n8n:
    image: n8n.io/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=${SUBDOMAIN:-localhost} # Passe dies bei Bedarf an deine Domain an
      - N8N_PORT=5678
      - N8N_PROTOCOL=${PROTOCOL:-http} # Oder https, wenn du einen Reverse Proxy nutzt
      - WEBHOOK_URL=${WEBHOOK_PROTOCOL:-http}://${SUBDOMAIN:-localhost}:${WEBHOOK_PORT:-5678}/
      - NODE_ENV=production
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=YOUR_N8N_PASSWORD # Ändern!
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=YOUR_POSTGRES_PASSWORD # Ändern!
      - GENERIC_TIMEZONE=Europe/Berlin # Oder deine Zeitzone
    volumes:
      - ./n8n_data:/home/node/.n8n
    depends_on:
      - postgres
    networks:
      - n8n_network

  postgres:
    image: postgres:13
    restart: always
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=YOUR_POSTGRES_PASSWORD # Ändern!
    volumes:
      - ./postgres_data:/var/lib/postgresql/data
    networks:
      - n8n_network

networks:
  n8n_network:
    driver: bridge

Ein paar Erklärungen zu dieser Konfiguration:

n8n.io/n8n: Das ist das offizielle Docker-Image für n8n.
ports: - "5678:5678": Wir mappen Port 5678 des Containers auf Port 5678 deines Hosts. So kannst du n8n über http://deine-server-ip:5678 erreichen.
Umgebungsvariablen (environment): Hier konfigurieren wir n8n. Besonders wichtig sind die Passwörter und die Datenbankverbindung. Die WEBHOOK_URL ist entscheidend, wenn du Webhooks in n8n nutzen möchtest (was ich dir wärmstens empfehle!).
volumes: Hier speichern wir die persistenten Daten. ./n8n_data wird auf deinem Host erstellt und enthält alle n8n-Workflows und Konfigurationen. ./postgres_data speichert die Datenbankdaten. Das ist wichtig, damit deine Daten auch nach einem Neustart der Container erhalten bleiben.
depends_on: - postgres: Stellt sicher, dass die PostgreSQL-Datenbank gestartet ist, bevor n8n versucht, sich zu verbinden.
networks: Definiert ein internes Docker-Netzwerk, in dem die Container miteinander kommunizieren können.

3. n8n starten

Speichere die Datei und starte die Dienste mit Docker Compose:

docker compose up -d

Der Parameter -d sorgt dafür, dass die Container im Hintergrund laufen (detached mode). Es dauert einen Moment, bis die Images heruntergeladen und die Container gestartet sind. Du kannst den Status überprüfen mit:

docker compose ps

Wenn alles läuft, solltest du n8n unter http://deine-server-ip:5678 erreichen können. Melde dich mit den in der docker-compose.yml definierten Zugangsdaten (admin und YOUR_N8N_PASSWORD) an.

Einen ersten Daten-Workflow in n8n erstellen

Jetzt, wo n8n läuft, können wir unseren ersten Workflow erstellen, um Daten zu "schürfen". Ich simuliere hier den Abruf von Daten aus einer hypothetischen öffentlichen API, da der Golem-Artikel keine konkreten technischen Schnittstellen liefert. Das Prinzip bleibt aber dasselbe.

1. Neuen Workflow anlegen

In der n8n-Oberfläche klickst du auf "New Workflow".

2. Datenquelle definieren (HTTP Request Node)

Ziehe einen "HTTP Request"-Node auf die Arbeitsfläche. Dieser Node ist unser Tor zur Außenwelt. Stell dir vor, du möchtest Daten von einer API abrufen, die beispielsweise eine Liste von Datensätzen bereitstellt.

Wähle "GET" als Methode.
Füge eine URL ein. Für diesen Guide nehmen wir eine öffentliche Dummy-API, die uns JSON-Daten liefert, z.B. https://jsonplaceholder.typicode.com/posts. In einem realen Szenario wäre das die API des Archivs oder einer anderen Datenquelle.
Aktiviere "Return Full Response" und "JSON/RAW Parameter" auf "Body".

Führe den Node einmal aus (Rechtsklick auf den Node -> "Execute Node"), um zu sehen, welche Daten zurückkommen. Du solltest eine Liste von JSON-Objekten sehen.

3. Daten verarbeiten (Split In Batches & Code Node)

Oft bekommst du eine große Liste an Datensätzen, die du einzeln verarbeiten möchtest. Dafür ist der "Split In Batches"-Node ideal. Füge ihn nach dem "HTTP Request"-Node ein. Er teilt die Ausgabe in einzelne Elemente auf, sodass jeder weitere Node pro Datensatz ausgeführt wird.

Manchmal müssen Daten vor der Speicherung noch transformiert oder gefiltert werden. Hierfür ist der "Code"-Node extrem mächtig. Du kannst JavaScript-Code verwenden, um die Daten zu manipulieren.

Füge einen "Code"-Node nach dem "Split In Batches"-Node ein.
Im Code-Node kannst du auf die aktuellen Daten zugreifen über $json.

Ein einfaches Beispiel, um nur bestimmte Felder zu extrahieren oder umzubenennen:

for (const item of $input.json) {
  item.newTitle = item.title.toUpperCase(); // Titel in Großbuchstaben umwandeln
  item.shortBody = item.body.substring(0, 50) + "..."; // Body kürzen
  // Entfernungen von Feldern, die wir nicht brauchen
  delete item.userId; 
  delete item.body;
  
  // Füge das modifizierte Item zur Ausgabe hinzu
  $return.push(item);
}

Führe diesen Node aus, um die transformierten Daten zu sehen.

4. Daten speichern (Write Binary File Node)

Nachdem wir die Daten abgerufen und verarbeitet haben, wollen wir sie speichern. Für den Anfang speichern wir sie einfach als JSON-Datei auf unserem Host-System. Dafür nutzen wir den "Write Binary File"-Node.

Füge den "Write Binary File"-Node nach dem "Code"-Node ein.
File Name: Hier kannst du einen dynamischen Dateinamen vergeben, z.B. data-{{ $json.id }}.json. Der {{ $json.id }}-Teil greift auf die ID des jeweiligen Datensatzes zu.
File Content: Wähle "String" und gib {{ JSON.stringify($json, null, 2) }} ein. Das wandelt das JSON-Objekt in einen schön formatierten String um.
File Path: Gib einen Pfad an, wo die Dateien gespeichert werden sollen, z.B. /home/node/.n8n/collected_data. Da unser n8n-Container das Volume ./n8n_data gemountet hat, landet dies dann im Unterverzeichnis n8n_data/collected_data auf deinem Host.

Wichtig zu wissen: Der Pfad im "Write Binary File"-Node ist relativ zum Dateisystem *innerhalb* des n8n-Containers. Da wir ./n8n_data nach /home/node/.n8n gemountet haben, bedeutet ein Pfad wie /home/node/.n8n/collected_data, dass die Daten auf deinem Host im Verzeichnis ~/n8n-data-collector/n8n_data/collected_data landen.

Führe den gesamten Workflow einmal aus, um zu prüfen, ob die Dateien korrekt gespeichert werden. Danach solltest du auf deinem Host im Verzeichnis ~/n8n-data-collector/n8n_data/collected_data die neuen JSON-Dateien finden.

5. Workflow automatisieren (Cron Node)

Ein manueller Klick ist gut zum Testen, aber wir wollen das Ganze automatisieren. Füge einen "Cron"-Node als ersten Node in deinem Workflow hinzu. Konfiguriere ihn so, dass der Workflow z.B. einmal täglich, wöchentlich oder stündlich ausgeführt wird.

Wähle "Every Day" und eine Uhrzeit, z.B. "03:00".

Aktiviere den Workflow über den Schalter oben rechts. Ab jetzt wird n8n die Daten automatisch abrufen und speichern!

Häufige Fehler und Lösungen

In meiner Zeit als Admin habe ich schon etliche Stolpersteine gesehen. Hier sind ein paar typische Probleme, die beim Einrichten eines solchen Setups auftreten können:

1. Docker Compose startet nicht oder Container bleiben im "Exited"-Zustand

Problem: Du führst docker compose up -d aus, aber die Container starten nicht richtig oder beenden sich sofort wieder.

Lösung: Das Erste, was du tun solltest, ist, die Logs der betroffenen Container zu prüfen. Das geht so:

docker compose logs n8n
docker compose logs postgres

Oft siehst du hier Fehlermeldungen zu Port-Konflikten (z.B. Port 5678 schon belegt), falschen Umgebungsvariablen (Passwörter nicht gesetzt) oder Berechtigungsproblemen bei den Volumes. Prüfe, ob du die Passwörter in der docker-compose.yml korrekt gesetzt hast und ob keine anderen Dienste die Ports belegen.

2. n8n kann sich nicht mit der PostgreSQL-Datenbank verbinden

Problem: n8n startet, zeigt aber im Log oder im Webinterface Fehlermeldungen bezüglich der Datenbankverbindung an.

Lösung: Dies ist fast immer ein Konfigurationsfehler in der docker-compose.yml. Überprüfe folgende Punkte:

Sind die DB_POSTGRESDB_HOST, DB_POSTGRESDB_DATABASE, DB_POSTGRESDB_USER und DB_POSTGRESDB_PASSWORD Variablen im n8n-Dienst korrekt und stimmen sie mit den POSTGRES_DB, POSTGRES_USER und POSTGRES_PASSWORD Variablen im postgres-Dienst überein?
Ist der Host für die Datenbank postgres (der Dienstname in Docker Compose) und nicht localhost oder die IP-Adresse? Innerhalb des Docker-Netzwerks sprechen die Container über ihre Dienstnamen miteinander.
Wurde die PostgreSQL-Datenbank überhaupt erfolgreich gestartet (siehe docker compose logs postgres)?

Ein einfacher Tipp: Wenn du Änderungen an der docker-compose.yml machst, immer mit docker compose down die alten Container stoppen und entfernen, und dann mit docker compose up -d neu starten. Manchmal hängen alte Konfigurationen fest.

3. n8n Workflow kann keine externen URLs abrufen (HTTP Request schlägt fehl)

Problem: Dein "HTTP Request"-Node im n8n Workflow schlägt fehl, wenn er versucht, Daten von einer externen URL abzurufen (z.B. Timeout, SSL-Fehler).

Lösung: Dies deutet oft auf Netzwerkprobleme hin. Prüfe folgende Dinge:

Firewall auf dem Host-System: Blockiert deine Server-Firewall (z.B. UFW) ausgehende Verbindungen von Docker-Containern? Standardmäßig sollte Docker seine eigenen Regeln erstellen, aber eine restriktive UFW-Konfiguration kann Probleme verursachen. Temporär UFW deaktivieren (sudo ufw disable) und testen.
DNS-Auflösung im Container: Kann der n8n-Container externe Domains auflösen? Du kannst das testen, indem du dich in den n8n-Container einloggst und einen Ping versuchst:
```
docker exec -it n8n /bin/bash
ping google.com
exit
```
Wenn das nicht funktioniert, liegt ein DNS-Problem vor. Oft hilft es, die DNS-Einstellungen deines Hosts zu überprüfen oder in der docker-compose.yml für den n8n-Dienst explizit DNS-Server zu definieren (z.B. Google DNS: dns: ["8.8.8.8", "8.8.4.4"]).
SSL-Zertifikate: Bei HTTPS-Verbindungen können veraltete oder nicht vertrauenswürdige SSL-Zertifikate Probleme verursachen. n8n hat Optionen, um SSL-Zertifikatsprüfungen zu ignorieren (nicht empfohlen für Produktionsumgebungen, aber nützlich zum Debuggen).

Fazit und nächste Schritte

Du hast jetzt ein mächtiges Setup in deinem Heimlabor, um Daten aus verschiedenen Quellen zu akquirieren und zu verarbeiten. Mit n8n und Docker bist du extrem flexibel. Das war nur der Anfang!

Was sind die nächsten Schritte? Hier ein paar Ideen:

Datenbankintegration: Statt in Dateien zu speichern, könntest du die Daten direkt in eine SQLite, MySQL oder eine weitere PostgreSQL-Datenbank schreiben, die du ebenfalls per Docker Compose laufen lässt. Dafür gibt es entsprechende n8n-Nodes.
Benachrichtigungen: Lass dich per Telegram, E-Mail oder Pushbullet benachrichtigen, wenn neue Daten gefunden wurden oder ein Workflow fehlschlägt.
Visualisierung: Integriere die gesammelten Daten in Grafana oder Home Assistant, um sie zu visualisieren und zu analysieren.
Komplexere Logik: Nutze weitere n8n-Nodes wie "IF", "Merge", "Set" oder "Function", um deine Datenflüsse noch komplexer und spezifischer zu gestalten.
Reverse Proxy: Setze einen Reverse Proxy wie Nginx Proxy Manager oder Traefik vor n8n, um es über eine eigene Domain mit SSL (Let's Encrypt) zu erreichen. Das erhöht die Sicherheit und den Komfort.

Die Welt der Datenautomatisierung ist riesig, und mit diesem Grundgerüst hast du eine solide Basis geschaffen. Viel Spaß beim Experimentieren in deinem Heimlabor!