Skip to Content
DocsLowcodeOverviewArchitektur-Überblick

Architektur-Überblick

ProcessCube® LowCode ist als Microservice konzipiert, der nahtlos mit anderen Komponenten der ProcessCube® Platform zusammenarbeitet. Diese Seite erklärt die Architektur und das Zusammenspiel der verschiedenen Komponenten.

System-Übersicht

┌─────────────────────────────────────────────────────────────┐
│                    ProcessCube® Platform                     │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐  │
│  │   Engine     │◄───┤   LowCode    │───►│  Authority   │  │
│  │   (BPMN)     │    │  (Node-RED)  │    │   (OIDC)     │  │
│  └──────────────┘    └──────────────┘    └──────────────┘  │
│         ▲                    │                     ▲         │
│         │                    │                     │         │
│         │                    ▼                     │         │
│         │            ┌──────────────┐              │         │
│         │            │    Portal    │──────────────┘         │
│         │            │    (PWA)     │                        │
│         │            └──────────────┘                        │
│         │                    │                               │
│         │                    │                               │
│         └────────────────────┴───────────────────────────────┘
│                        Externe Systeme                        │
│              (REST APIs, Datenbanken, IoT, etc.)             │
└─────────────────────────────────────────────────────────────┘

Komponenten

1. ProcessCube® LowCode (Node-RED Runtime)

Die zentrale Komponente ist die Node-RED Runtime, die auf Node.js läuft:

Technologie-Stack:

  • Node.js: 18+ (LTS)
  • Node-RED: 4.x Runtime
  • Express.js: HTTP-Server für REST-API und Editor
  • Dashboard-2: UI-Framework für Benutzeroberflächen

Ports:

  • 1880: Node-RED Editor (Admin-UI)
  • 1880/dashboard: Dashboard-2 UIs
  • 1880/portal: ProcessCube® Portal (PWA)
  • 1880/api: Custom REST-APIs (via HTTP-Nodes)

2. ProcessCube® Engine

Die BPMN-Workflow-Engine führt Geschäftsprozesse aus:

Integration mit LowCode:

  • REST-API: LowCode kommuniziert via HTTP mit der Engine
  • Engine-Nodes: Spezielle Nodes für Engine-Operationen
  • Events: LowCode kann Engine-Events abonnieren (WebSocket/SSE)

Typische Operationen:

// Prozess starten
POST /api/process-models/{id}/start
 
// UserTask beenden
POST /api/user-tasks/{id}/finish
 
// Prozess-Instanzen abfragen
GET /api/process-instances

3. ProcessCube® Authority

Der Identity Provider (OIDC-kompatibel) verwaltet Authentifizierung und Autorisierung:

Integration mit LowCode:

  • OAuth 2.0 Flow: LowCode nutzt Client Credentials oder Authorization Code Grant
  • Token Validation: Zugriff auf geschützte Ressourcen via Bearer Token
  • User Management: Benutzer und Rollen zentral verwaltet

Beispiel-Flow:

// 1. Token abrufen
[http-request: POST /connect/token]
  → [function: parse token]
  → [context: save token]
 
// 2. Engine-Request mit Token
[context: load token]
  → [http-request: GET /api/process-models]
  → [http-response]

4. ProcessCube® Portal

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

Funktionen:

  • UserTask-Bearbeitung: Formulare für BPMN-UserTasks
  • Process Monitoring: Übersicht laufender Prozesse
  • Custom Apps: Eigene Dashboard-2 UIs als PWA

Technologie:

  • Dashboard-2: UI-Framework
  • Service Worker: Offline-Funktionalität
  • Web App Manifest: PWA-Konfiguration

Deployment-Architekturen

Lokale Entwicklung (Docker Compose)

version: '3.8'
services:
  lowcode:
    image: processcube/lowcode:latest
    ports:
      - "1880:1880"
    environment:
      - PROCESSCUBE_ENGINE_URL=http://engine:8000
      - PROCESSCUBE_AUTHORITY_URL=http://authority:5000
 
  engine:
    image: processcube/engine:latest
    ports:
      - "8000:8000"
 
  authority:
    image: processcube/authority:latest
    ports:
      - "5000:5000"

Kubernetes (Production)

┌─────────────────────────────────────────────────┐
│              Kubernetes Cluster                  │
├─────────────────────────────────────────────────┤
│                                                  │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐│
│  │  LowCode   │  │  LowCode   │  │  LowCode   ││
│  │  Pod 1     │  │  Pod 2     │  │  Pod 3     ││
│  └────────────┘  └────────────┘  └────────────┘│
│         │               │               │        │
│         └───────────────┴───────────────┘        │
│                     │                            │
│              ┌──────────────┐                    │
│              │   Service    │                    │
│              │  (LoadBalancer)                   │
│              └──────────────┘                    │
│                     │                            │
│              ┌──────────────┐                    │
│              │   Ingress    │                    │
│              └──────────────┘                    │
│                                                  │
│  ┌────────────┐          ┌────────────┐         │
│  │   Engine   │          │ Authority  │         │
│  │  Service   │          │  Service   │         │
│  └────────────┘          └────────────┘         │
│                                                  │
│  ┌──────────────────────────────────┐           │
│  │      Persistent Volume           │           │
│  │  (Flows, Credentials, Context)   │           │
│  └──────────────────────────────────┘           │
└─────────────────────────────────────────────────┘

Skalierung:

  • Horizontal: Mehrere LowCode-Pods mit LoadBalancer
  • Shared Storage: Persistent Volume für Flows und Context
  • Stateless: Flows sind stateless (Context in externem Storage)

Datenfluss

1. HTTP-Request zu REST-API

User/Client
  → [HTTP Request]
  → LowCode (HTTP-In Node)
  → [Function Nodes]
  → [HTTP Response]
  → User/Client

2. Prozess starten via Engine

User/Client
  → [HTTP Request]
  → LowCode (HTTP-In Node)
  → [Engine: Start Process Node]
  → ProcessCube® Engine
  → [HTTP Response]
  → User/Client

3. UserTask bearbeiten via Portal

User (Portal)
  → [Dashboard-2 UI Form]
  → LowCode (UI-Event)
  → [Engine: Finish UserTask Node]
  → ProcessCube® Engine
  → [UI Update]
  → User (Portal)

4. Engine-Event verarbeiten

ProcessCube® Engine
  → [Event: UserTask Created]
  → LowCode (Engine-Event Node)
  → [Function: Send Notification]
  → External System (E-Mail, Slack, etc.)

Storage & Persistence

Flows & Configuration

Standard: Filesystem (JSON-Dateien)

/data/flows.json          # Flow-Definitionen
/data/flows_cred.json     # Verschlüsselte Credentials
/data/settings.js         # Runtime-Konfiguration

Git-Integration (Node-RED Projects)

/data/projects/
  └── my-project/
      ├── flows.json
      ├── package.json
      └── .git/

Datenbank (Custom Storage Module)

  • PostgreSQL
  • MongoDB
  • Redis

Context Storage

Context-Daten (Flow-Variablen) können persistiert werden:

  • Memory: Nur im RAM (verloren nach Neustart)
  • File: Lokales Filesystem
  • Redis: Externe Redis-Datenbank (für Kubernetes-Cluster)
// Context speichern
flow.set("myData", {value: 123}, "file");
 
// Context laden
const data = flow.get("myData", "file");

Sicherheit

Authentication

Node-RED Editor:

  • Admin Auth: Username/Password oder OAuth 2.0
  • HTTPS: TLS-Verschlüsselung für Editor-Zugriff

Custom APIs:

  • HTTP Basic Auth: via http-in Node
  • Bearer Token: via Function Node + Authority
  • API Keys: via Custom Header Validation

Authorization

Flows:

  • Read-Only Users: Nur Flow-Ansicht
  • Editors: Flow-Bearbeitung
  • Admins: Volle Kontrolle

Engine/Authority:

  • Role-Based Access Control (RBAC): Zentral in Authority
  • Scopes: OAuth 2.0 Scopes für API-Zugriff

Credentials

Credentials (Passwörter, API-Keys) werden verschlüsselt gespeichert:

NODERED_CREDENTIAL_SECRET=my-secret-key-12345

Performance & Skalierung

Horizontal Scaling

LowCode kann horizontal skaliert werden:

  • Shared Storage: Flows und Context in externem Storage
  • LoadBalancer: Verteilt Requests auf Pods
  • Stateless Flows: Keine Session-Affinität notwendig

Caching

  • Context Cache: In-Memory Context für schnellen Zugriff
  • HTTP Cache: Caching von REST-API Responses
  • Dashboard Cache: UI-State im Browser

Monitoring

  • Health Check: /health Endpunkt für Kubernetes
  • Metrics: Prometheus-Export via Runtime Extension
  • Logging: Strukturierte Logs (JSON) für ELK-Stack

Integration-Patterns

1. API Gateway Pattern

LowCode als API Gateway für Backend-Services:

Client → LowCode (API Gateway) → [Routing, Auth, Transform] → Backend

2. Event-Driven Architecture

LowCode als Event Handler für Engine-Events:

Engine → [Event: Process Started] → LowCode → [Send Notification]

3. ETL Pipeline

LowCode als Data Integration Layer:

Source DB → LowCode → [Transform, Enrich] → Target DB

4. Microservice Orchestration

LowCode orchestriert mehrere Microservices:

LowCode → [Service A] → [Service B] → [Service C] → Response

Nächste Schritte

Referenzen

ÜbersichtHauptfunktionen