Node-RED mit Docker installieren – Schritt für Schritt

Nachdem ich bereits gezeigt habe, wie sich Node-RED auf einem Raspberry Pi sowie unter Windows 11 via WSL installieren lässt, gehen wir in diesem Beitrag einen Schritt weiter.
Mit Docker lässt sich Node-RED nicht nur einfacher verwalten, sondern vor allem mehrfach parallel betreiben – ideal für Tests, Entwicklung und produktive Umgebungen.

Node-RED mit Docker installieren – Schritt für Schritt

Dieses Video auf YouTube ansehen.

Hinweis: Der hier gezeigte Weg über Windows 11 und WSL lässt sich problemlos auch auf einem klassischen Linux-System nachstellen. Das Windows Subsystem für Linux bildet eine eigenständige Linux-Umgebung ab, sodass die folgenden Schritte nahezu identisch auf einem Server oder Linux-PC umgesetzt werden können.

Docker unter WSL installieren

Im ersten Schritt installieren wir Docker innerhalb unserer WSL-Umgebung.
Damit schaffen wir die Grundlage, um Node-RED später flexibel als Container zu betreiben.

Falls du WSL bereits eingerichtet hast, kannst du direkt loslegen. Andernfalls empfehle ich dir zunächst meinen Beitrag zur Installation von WSL unter Windows 11.

System aktualisieren

Zuerst bringen wir das System auf den aktuellen Stand:

sudo apt update && sudo apt upgrade -y

Docker installieren

Nun installieren wir Docker über die Paketverwaltung:

sudo apt install docker.io -y

Installation testen

Bevor wir Docker starten, prüfen wir zunächst, ob die Installation erfolgreich war:

docker --version

Wenn alles korrekt installiert wurde, erhältst du eine Ausgabe ähnlich wie:

Docker starten

Anschließend starten wir den Docker-Dienst:

sudo service docker start

Optional kannst du prüfen, ob Docker korrekt läuft:

sudo service docker status

Benutzer zur Docker-Gruppe hinzufügen

Damit du Docker-Befehle später ohne sudo ausführen kannst, solltest du deinen Benutzer direkt zur Docker-Gruppe hinzufügen.

Ohne diesen Schritt würden alle Docker-Befehle nur mit erhöhten Rechten (sudo) funktionieren.

Benutzer hinzufügen

Führe dazu folgenden Befehl aus:

sudo usermod -aG docker $USER

WSL neu starten

Damit die Änderung übernommen wird, musst du die WSL-Umgebung einmal komplett neu starten:

wsl --shutdown

Anschließend öffnest du dein Terminal erneut.

Funktion testen

Jetzt kannst du prüfen, ob Docker ohne sudo funktioniert:

docker run hello-world

Wenn alles korrekt eingerichtet ist, erhältst du eine entsprechende Erfolgsmeldung von Docker.

Node-RED Container starten

Im nächsten Schritt starten wir unseren ersten Node-RED Container.

Bevor wir das tun, werfen wir einen kurzen Blick auf die offizielle Docker Hub Seite:
https://hub.docker.com/r/nodered/node-red

Dort findest du alle wichtigen Informationen zum Image, unter anderem:

• welche Komponenten enthalten sind (Node.js, Node-RED, etc.)
• verfügbare Versionen (Tags)
• empfohlene Startbefehle
• Hinweise zur Konfiguration

Vorteil des offiziellen Docker Images

Ein großer Vorteil des offiziellen Node-RED Images ist, dass bereits ein Beispielbefehl bereitgestellt wird, der alle wichtigen Parameter enthält.

👉 Besonders praktisch:
Der Befehl enthält bereits die Einbindung eines Volumes, sodass deine Flows und Einstellungen dauerhaft gespeichert werden.

Beispielbefehl von Docker Hub

Ein typischer Startbefehl sieht wie folgt aus:

docker run -it -p 1880:1880 -v myNodeREDdata:/data --name mynodered nodered/node-red

Erklärung der Parameter

• docker run → startet einen neuen Container
• -it → interaktiver Modus (Terminal-Ausgabe sichtbar)
• -p 1880:1880 → Portweiterleitung (Node-RED ist später über Port 1880 erreichbar)
• -v myNodeREDdata:/data → Volume für persistente Daten
• --name mynodered → eindeutiger Name für den Container
• nodered/node-red → verwendetes Image

Wenn keine Versionsnummer angegeben wird, verwendet Docker standardmäßig das Image mit dem Tag latest. Dabei handelt es sich um die aktuellste verfügbare Version.

Wichtig zu verstehen

Node-RED mit Docker Compose – mehrere Container einfach verwalten

Nachdem wir Node-RED bereits über einen einzelnen Docker-Befehl gestartet haben, schauen wir uns nun eine deutlich komfortablere Variante an: Docker Compose.

Mit Docker Compose lassen sich Container, Ports und Volumes zentral in einer Datei definieren. Dadurch wird die Verwaltung deutlich übersichtlicher und die gesamte Umgebung kann jederzeit reproduzierbar gestartet werden.

👉 Besonders interessant wird das Ganze, wenn mehrere Node-RED Instanzen parallel betrieben werden sollen.

Docker Compose installieren

Bevor wir Docker Compose verwenden können, müssen wir dieses zunächst installieren.

Schritt 1: Docker Repository hinzufügen

sudo apt update
sudo apt install ca-certificates curl gnupg -y

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

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

Schritt 2: Paketliste aktualisieren

sudo apt update

Schritt 3: Docker Compose Plugin installieren

sudo apt install docker-compose-plugin -y

Test

Anschließend prüfen wir die Installation:

docker compose version

Wenn alles korrekt eingerichtet ist, erhältst du eine Ausgabe ähnlich wie:

docker-compose.yml erstellen

Lege zunächst eine neue Datei an:

nano docker-compose.yml

Beispiel: Eine Node-RED Instanz

Füge folgenden Inhalt ein:

services:
  node-red:
    image: nodered/node-red
    container_name: mynodered
    ports:
      - "1880:1880"
    volumes:
      - node_red_data:/data
    restart: unless-stopped
volumes:
  node_red_data:

Erklärung

• image: nodered/node-red
  → offizielles Node-RED Image (inkl. Node.js & npm)
• container_name: mynodered
  → eindeutiger Name für deinen Container
• ports
  → Node-RED ist später über http://localhost:1880 erreichbar
• volumes
  → sorgt dafür, dass deine Flows und Einstellungen gespeichert werden
• restart: unless-stopped
  → Container startet automatisch neu (z. B. nach einem Neustart)

Container starten

Starte den Container mit folgendem Befehl:

docker compose up -d

Zugriff auf Node-RED

Nach dem Start kannst du Node-RED im Browser öffnen: http://localhost:1880

Mehrere Node-RED Instanzen mit Docker Compose starten

Ein großer Vorteil von Docker Compose ist, dass sich mehrere Node-RED Instanzen sehr einfach parallel betreiben lassen.
Das ist praktisch, wenn du beispielsweise eine produktive Umgebung, eine Testinstanz und eine weitere Spielwiese für Experimente getrennt voneinander nutzen möchtest.

Jede Instanz erhält dabei:

• einen eigenen Containernamen
• einen eigenen Port
• ein eigenes Volume für die Daten

Dadurch bleiben alle Flows, Einstellungen und installierten Nodes sauber voneinander getrennt.

docker-compose.yml für mehrere Instanzen

Öffne deine bestehende docker-compose.yml und passe den Inhalt wie folgt an:

services:
  node-red-1:
    image: nodered/node-red
    container_name: mynodered1
    ports:
      - "1881:1880"
    volumes:
      - node_red_data_1:/data
    restart: unless-stopped  
  node-red-2:
    image: nodered/node-red
    container_name: mynodered2
    ports:
      - "1882:1880"
    volumes:
      - node_red_data_2:/data
    restart: unless-stopped  
  node-red-3:
    image: nodered/node-red
    container_name: mynodered3
    ports:
      - "1883:1880"
    volumes:
      - node_red_data_3:/data
    restart: unless-stopped
volumes:
  node_red_data_1:
  node_red_data_2:
  node_red_data_3:

Erklärung

In diesem Beispiel werden drei unabhängige Node-RED Instanzen definiert:

• node-red-1 → erreichbar über Port 1881
• node-red-2 → erreichbar über Port 1882
• node-red-3 → erreichbar über Port 1883

Jede Instanz verwendet dabei ein eigenes Volume:

• node_red_data_1
• node_red_data_2
• node_red_data_3

Dadurch hat jede Umgebung ihren eigenen Datenbestand.

Container starten

Starte alle Instanzen gemeinsam mit:

docker compose up -d

Wenn die Konfiguration der Instanzen in einer separaten Datei wie docker-compose-multi.yml abgelegt wurden dann muss der Dateiname angehangen werden.

docker compose -f docker-compose-multi.yml up -d

Zugriff auf die Instanzen

Nach dem Start kannst du die drei Node-RED Instanzen über folgende Adressen im Browser öffnen:

• http://localhost:1881
• http://localhost:1882
• http://localhost:1883

Laufende Container prüfen

Mit folgendem Befehl kannst du prüfen, ob alle Container korrekt gestartet wurden:

docker ps

In der Ausgabe solltest du die drei Container mit den jeweiligen Portzuweisungen sehen.

Typische Einsatzszenarien

Mehrere Instanzen sind besonders hilfreich, wenn du unterschiedliche Umgebungen trennen möchtest, zum Beispiel:

• Produktivsystem
• Testsystem
• Experimentierumgebung

So kannst du neue Flows oder Nodes zunächst in einer separaten Instanz ausprobieren, ohne deine produktive Umgebung zu beeinflussen.

Letzte Aktualisierung am: 26. März 2026