Konzepte & Grundlagen

Um ProcessCube® LowCode effektiv zu nutzen, ist es wichtig, die grundlegenden Konzepte von Node-RED und die ProcessCube®-spezifischen Erweiterungen zu verstehen. Diese Seite gibt einen Überblick über die wichtigsten Konzepte.

Node-RED: Flow-basierte Programmierung

ProcessCube® LowCode basiert auf Node-RED, einer visuellen Programmierumgebung, die das Konzept der Flow-basierten Programmierung (Flow-Based Programming, FBP) umsetzt.

Was ist Flow-basierte Programmierung?

Bei der Flow-basierten Programmierung werden Anwendungen als Netzwerk von Nodes dargestellt, die über Verbindungen miteinander kommunizieren. Daten fließen als Messages zwischen den Nodes.

Vorteile:

• Visuell: Logik ist auf einen Blick erkennbar
• Modular: Nodes sind wiederverwendbare Bausteine
• Asynchron: Flows arbeiten event-basiert und non-blocking
• Einfach zu testen: Einzelne Nodes können isoliert getestet werden

Kernkonzepte

Flows Ein Flow ist eine Sammlung von Nodes, die miteinander verbunden sind. Jeder Flow hat einen eigenen Tab im Editor und kann unabhängig deployed werden.

Nodes Nodes sind die Bausteine eines Flows. Jede Node hat:

• Input-Ports: Empfangen Messages
• Output-Ports: Senden Messages
• Configuration: Properties und Settings
• Status: Zeigt aktuellen Zustand an

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

{
  payload: "Hello World",    // Hauptdaten
  topic: "greeting",         // Thema/Kategorie
  _msgid: "abc123",         // Eindeutige ID
  // ... weitere Properties
}

ProcessCube®-Erweiterungen

ProcessCube® LowCode erweitert Node-RED um spezielle Konzepte für die Prozessautomatisierung:

1. Engine-Integration

Die ProcessCube® Engine führt BPMN-Workflows aus. LowCode kann mit der Engine interagieren:

• Prozesse starten: Triggern von Workflows via HTTP oder Event
• UserTasks bearbeiten: Abfragen und Beenden von UserTasks
• Events abonnieren: Reagieren auf Engine-Events (Process Started, UserTask Created, etc.)
• Process Queries: Abfragen von laufenden Instanzen

Beispiel-Pattern:

[HTTP-Request] → [Start Process] → [Wait for UserTask Event] → [Show Form] → [Finish UserTask]

2. Event-Driven Architecture

ProcessCube® LowCode arbeitet event-basiert:

• Engine-Events: Process Started, UserTask Created, Process Finished
• HTTP-Events: Eingehende Requests
• Timer-Events: Zeitgesteuerte Trigger
• Message Queue Events: AMQP, MQTT

Vorteile:

• Lose Kopplung: Komponenten sind entkoppelt
• Skalierbarkeit: Events können parallel verarbeitet werden
• Reaktivität: Sofortige Reaktion auf Änderungen

3. Context Storage

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

Flow Context: Daten innerhalb eines Flows teilen

flow.set("userToken", token);
const token = flow.get("userToken");

Global Context: Daten zwischen Flows teilen

global.set("config", settings);
const settings = global.get("config");

Node Context: Private Daten einer Node

context.set("counter", 0);
context.set("counter", context.get("counter") + 1);

4. Portal & PWA

Das ProcessCube® Portal ist eine Progressive Web App (PWA), die auf Dashboard-2 basiert:

• UserTask-Bearbeitung: Formulare für BPMN-UserTasks
• Process Monitoring: Übersicht laufender Prozesse
• Offline-Fähig: PWAs funktionieren auch ohne Internet
• Installierbar: Als App auf Mobile/Desktop installierbar

Wichtige Design-Patterns

Pattern 1: Request-Response

Klassisches HTTP-Request/Response-Pattern:

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

Verwendung: REST-APIs, Webhooks

Pattern 2: Event Handler

Reagieren auf Events:

[engine-event: userTaskCreated] → [function: send notification] → [email]

Verwendung: Notifications, Logging, Monitoring

Pattern 3: Fan-Out

Eine Message an mehrere Nodes verteilen:

[inject] → [split]
            ├─→ [node 1]
            ├─→ [node 2]
            └─→ [node 3]

Verwendung: Parallele Verarbeitung, Broadcasting

Pattern 4: Fan-In

Mehrere Messages zusammenführen:

[node 1] ─┐
[node 2] ─┼→ [join] → [output]
[node 3] ─┘

Verwendung: Aggregation, Batch Processing

Pattern 5: Pipeline

Sequentielle Verarbeitung:

[input] → [validate] → [transform] → [enrich] → [output]

Verwendung: ETL, Data Processing

Pattern 6: Circuit Breaker

Fehlerbehandlung mit Fallback:

[input] → [try: api call] ──success──→ [output]
                          └──error──→ [catch] → [fallback] → [output]

Verwendung: Resiliente API-Calls, Error Handling

Best Practices

1. Flows organisieren

Tabs verwenden:

• APIs - REST-Endpunkte
• Engine - ProcessCube® Integration
• Dashboards - UI-Flows
• Utils - Hilfsfunktionen

2. Nodes benennen

Verwenden Sie aussagekräftige Namen:

❌ function 1, function 2, function 3
✅ validate input, transform data, log error

3. Subflows nutzen

Wiederkehrende Logik in Subflows auslagern:

[http in] → [Subflow: validate & auth] → [function] → [http response]

4. Error Handling

Immer catch Nodes verwenden:

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

5. Debug Nodes

Verwenden Sie debug Nodes während der Entwicklung:

[any node] → [debug: payload]

6. Comments

Dokumentieren Sie komplexe Flows mit comment Nodes.

Unterschied: Node-RED vs. ProcessCube® LowCode

Lernpfad

Einsteiger

1. Node-RED Grundlagen lernen
2. Quickstart durcharbeiten
3. Beispiel-Flows importieren

Fortgeschritten

1. ProcessCube® Konzepte verstehen
2. Engine-Integration nutzen
3. Portal-Integration implementieren

Experte

1. Eigene Nodes entwickeln
2. Performance-Optimierung
3. Kubernetes-Deployment

Weitere Informationen

Vertiefen Sie Ihr Wissen:

• Node-RED Grundlagen - Flows, Nodes, Messages im Detail
• ProcessCube®-spezifische Konzepte - Engine-Integration, Event-driven Architecture
• Portal + UserTask Integration - Portal-Funktion, PWA-Konzept, Dashboard-2

Ressourcen

• Node-RED Dokumentation  - Offizielle Node-RED Docs
• Flow-Based Programming  - Wikipedia-Artikel
• ProcessCube® Developer Network  - Community & Support