Skip to Content
DocsLowcodeConceptsNode-RED Grundlagen

Node-RED Grundlagen

Node-RED ist das Fundament von ProcessCube® LowCode. Diese Seite erklärt die grundlegenden Konzepte, die Sie verstehen müssen, um effektiv mit ProcessCube® LowCode zu arbeiten.

Was ist Node-RED?

Node-RED ist eine Open-Source-Programmierumgebung für Flow-basierte Programmierung (Flow-Based Programming, FBP). Sie wurde ursprünglich von IBM entwickelt und ist heute ein eigenständiges Projekt der OpenJS Foundation.

Kernmerkmale

  • Visueller Editor: Browser-basierter Editor zum Erstellen von Flows
  • JavaScript-Basis: Runtime basiert auf Node.js
  • Event-Driven: Asynchrone, non-blocking Verarbeitung
  • Erweiterbar: Über 4.000 Community-Nodes verfügbar
  • Produktionsreif: Millionen Deployments weltweit

Flows

Ein Flow ist eine Sammlung von Nodes, die durch Verbindungen (Wires) miteinander verknüpft sind.

Flow-Struktur

[Node 1] ──wire──> [Node 2] ──wire──> [Node 3]

Jeder Flow hat:

  • Eindeutige ID: Zur Identifikation
  • Tab im Editor: Eigener Workspace
  • Eigener Context: Isolierter Datenspeicher
  • Deploy-Status: Kann einzeln deployed werden

Flow-Beispiel

Einfacher HTTP-Endpunkt:

[http in: GET /hello] → [function: create response] → [http response]

Function Node Code:

msg.payload = {
    message: "Hello from Node-RED!",
    timestamp: new Date().toISOString()
};
return msg;

Flows exportieren/importieren

Export:

  1. Flow auswählen
  2. Menü → Export → Clipboard
  3. JSON-Code kopieren

Import:

  1. Menü → Import
  2. JSON-Code einfügen
  3. Import bestätigen

Nodes

Nodes sind die Bausteine von Flows. Jede Node führt eine spezifische Aufgabe aus.

Node-Typen

Input-Nodes

Empfangen Daten von externen Quellen:

  • http in: HTTP-Requests empfangen
  • mqtt in: MQTT-Messages empfangen
  • inject: Manuell triggern oder zeitgesteuert
  • websocket in: WebSocket-Verbindungen

Function-Nodes

Verarbeiten und transformieren Daten:

  • function: JavaScript-Code ausführen
  • template: Text-/JSON-Templates rendern
  • change: Message-Properties ändern
  • switch: Bedingte Verzweigung

Output-Nodes

Senden Daten an externe Systeme:

  • http response: HTTP-Response senden
  • debug: Debug-Ausgabe anzeigen
  • mqtt out: MQTT-Message senden
  • http request: HTTP-Request ausführen

Node-Konfiguration

Jede Node hat Configuration Properties:

  • Name: Beschreibender Name (optional)
  • Type-Specific Settings: Node-spezifische Parameter
  • Credentials: Passwörter und API-Keys (verschlüsselt)

Beispiel - http in Node:

Name: "API Endpoint"
Method: POST
URL: /api/users

Node-Status

Nodes zeigen ihren Status unterhalb der Node an:

  • Grüner Punkt: Erfolgreich
  • Roter Punkt: Fehler
  • Gelber Punkt: Warnung
  • Blauer Ring: In Bearbeitung

Messages

Messages sind JavaScript-Objekte, die zwischen Nodes fließen.

Message-Struktur

{
  payload: ...,      // Hauptdaten (beliebiger Typ)
  topic: "...",      // Thema/Kategorie (String)
  _msgid: "...",     // Eindeutige Message-ID
  // ... weitere Properties
}

Message Properties

payload: Die Nutzdaten

msg.payload = "Hello World";              // String
msg.payload = 42;                         // Number
msg.payload = {name: "Max", age: 30};     // Object
msg.payload = ["a", "b", "c"];            // Array

topic: Klassifizierung

msg.topic = "temperature";
msg.topic = "user/login";

Custom Properties: Beliebige Properties

msg.timestamp = Date.now();
msg.userId = 123;
msg.headers = {"Content-Type": "application/json"};

Message-Manipulation

In Function Node:

// Payload ändern
msg.payload = "New Value";
 
// Property hinzufügen
msg.timestamp = new Date().toISOString();
 
// Property löschen
delete msg.topic;
 
// Message weitergeben
return msg;
 
// Keine Message senden
return null;
 
// Mehrere Messages senden
return [msg1, msg2, msg3];

Verbindungen (Wires)

Wires verbinden Output-Ports von Nodes mit Input-Ports anderer Nodes.

Einfache Verbindung

[Node A] ──wire──> [Node B]

Mehrere Outputs

Nodes können mehrere Output-Ports haben:

[switch]
  ├──output 1──> [Node A]
  ├──output 2──> [Node B]
  └──output 3──> [Node C]

Switch Node Beispiel:

// Routing basierend auf msg.payload
if (msg.payload > 100) return [msg, null];  // Output 1
else return [null, msg];                     // Output 2

Multiple Targets

Ein Output kann an mehrere Inputs gehen:

            ┌──> [Node B]
[Node A] ───┤
            └──> [Node C]

Hinweis: Message wird an beide Nodes gesendet (Broadcast).

Deployment

Deployment ist der Prozess, Änderungen an Flows zu aktivieren.

Deploy-Modi

Full: Alle Flows neu deployen (Standard)

Alle Nodes werden neugestartet

Modified Flows: Nur geänderte Flows deployen

Nur betroffene Flows werden neugestartet

Modified Nodes: Nur geänderte Nodes deployen

Minimal-invasiv, schnellster Deploy

Deploy-Button

Der Deploy-Button (rot, oben rechts) zeigt den Status:

  • Rot: Änderungen vorhanden, Deploy notwendig
  • Grau: Keine Änderungen, bereits deployed

Was passiert beim Deploy?

  1. Flows stoppen: Aktuell laufende Flows werden gestoppt
  2. Flows laden: Neue Flow-Definitionen werden geladen
  3. Nodes initialisieren: Alle Nodes werden neu initialisiert
  4. Flows starten: Flows werden gestartet

Wichtig: Während des Deployments sind Flows kurzzeitig nicht verfügbar!

Subflows

Subflows sind wiederverwendbare Flow-Komponenten.

Subflow erstellen

  1. Nodes auswählen
  2. Rechtsklick → “Subflow” → “Selection to Subflow”
  3. Subflow benennen
  4. Input/Output Ports definieren

Subflow-Beispiel

Subflow: “Validate User”:

[Input] → [function: check required fields] → [function: validate email] → [Output]

Verwendung:

[http in] → [Subflow: Validate User] → [database] → [http response]

Vorteile

  • Wiederverwendbarkeit: Einmal definieren, mehrfach nutzen
  • Übersichtlichkeit: Komplexe Logik kapseln
  • Wartbarkeit: Änderungen an einer Stelle

Context

Context ermöglicht das Speichern von Daten über mehrere Messages hinweg.

Context-Arten

Node Context

Privater Speicher für eine Node:

// In Function Node
context.set("counter", 0);
let count = context.get("counter") || 0;
context.set("counter", count + 1);

Flow Context

Geteilt zwischen Nodes eines Flows:

// In Function Node A
flow.set("userToken", "abc123");
 
// In Function Node B (gleicher Flow)
const token = flow.get("userToken");

Global Context

Geteilt zwischen allen Flows:

// In Flow 1
global.set("config", {apiUrl: "http://api.example.com"});
 
// In Flow 2
const config = global.get("config");

Context Storage

Context kann persistent gespeichert werden:

settings.js:

contextStorage: {
  default: "memoryOnly",          // Im RAM (verloren nach Neustart)
  file: {
    module: "localfilesystem"     // Auf Festplatte (persistent)
  }
}

Verwendung:

flow.set("data", value, "file");  // In Datei speichern
const data = flow.get("data", "file");  // Aus Datei laden

Environment Variables

Environment Variables ermöglichen Konfiguration ohne Hard-Coding.

In Docker setzen

environment:
  - ENGINE_URL=http://engine:8000
  - AUTHORITY_URL=http://authority:5000

In Flows verwenden

// In Function Node
const engineUrl = env.get("ENGINE_URL");
msg.url = `${engineUrl}/api/process-models`;
return msg;

Debugging

Node-RED bietet mehrere Debugging-Tools.

Debug Node

[any node] → [debug]

Configuration:

  • Output: msg.payload (Standard)
  • To: Debug Console
  • Format: auto, JSON, String

Debug Console

Ansicht: Rechtes Panel → Debug

Zeigt:

  • Message-Inhalt
  • Timestamp
  • Node-Name
  • Message-ID

Catch Node

Fängt Fehler in Flows ab:

[function] ──error──> [catch] → [debug: error] → [email: alert]

Status Node

Reagiert auf Status-Änderungen:

[http request] ──status change──> [status] → [debug]

Best Practices

1. Nodes benennen

❌ function 1, http in 1, debug 1
✅ validate input, API endpoint, log error

2. Flows strukturieren

Empfohlene Tab-Organisation:

  • APIs - REST-Endpunkte
  • Engine - ProcessCube® Integration
  • Dashboards - UI-Flows
  • Utilities - Hilfsfunktionen
  • Config - Konfiguration

3. Comments nutzen

Verwenden Sie comment Nodes zur Dokumentation:

[comment: "Dieser Flow verarbeitet User-Registrierungen"]

Vermeiden Sie lange Verbindungen mit link Nodes:

[http in] → [link out: "process"]

[link in: "process"] → [function] → [http response]

5. Error Handling

Immer catch Nodes für Error Handling:

[function] ──error──> [catch] → [log] → [send alert]

6. Subflows für Wiederverwendbarkeit

Lagern Sie wiederkehrende Logik in Subflows aus.

Editor-Shortcuts

Wichtige Tastenkombinationen

ShortcutAktion
Strg/Cmd + IImport aus Clipboard
Strg/Cmd + EExport zu Clipboard
Strg/Cmd + FSuche
Strg/Cmd + ZRückgängig
Strg/Cmd + YWiederholen
Strg/Cmd + AAlle auswählen
Strg/Cmd + CKopieren
Strg/Cmd + VEinfügen
DelLöschen

Nächste Schritte

Jetzt, da Sie die Node-RED Grundlagen kennen:

  1. ProcessCube®-spezifische Konzepte - Engine-Integration lernen
  2. Portal-Integration - UserTask-UIs erstellen
  3. Beispiel-Flows - Praktische Flows ausprobieren

Ressourcen

Konzepte & GrundlagenPortal + UserTask Integration