Produktiv-Konfiguration

Diese Seite beschreibt die notwendigen Konfigurationsschritte, um LowCode sicher und zuverlässig in Produktionsumgebungen zu betreiben.

Checkliste für Produktion

Bevor Sie LowCode in Produktion nehmen, stellen Sie sicher, dass folgende Punkte erfüllt sind:

Punkt	Beschreibung	Priorität
Authentifizierung	`NODERED_AUTH_DISABLED` ist nicht auf `true` gesetzt	Kritisch
Credential Secret	`NODERED_CREDENTIAL_SECRET` ist gesetzt und sicher	Kritisch
HTTPS	TLS-Terminierung via Reverse Proxy	Kritisch
Monitoring	Health Checks und Metriken aktiv	Hoch
Backup	Regelmäßige Datensicherung konfiguriert	Hoch
Log-Level	Auf `warn` oder `error` gesetzt	Mittel

1. Authentifizierung

In Produktionsumgebungen muss die Authentifizierung immer aktiviert sein. LowCode unterstützt OAuth 2.0 über die Authority.

Warnung: Setzen Sie NODERED_AUTH_DISABLED=true niemals in Produktionsumgebungen. Ohne Authentifizierung ist der Editor und die Admin-API für jeden erreichbar.


environment:
  # Authority-Anbindung
  - NODERED_AUTHORITY_URL=https://authority.example.com
  - NODERED_CLIENT_ID=NodeRedEditorClient
  - NODERED_CLIENT_SECRET=${EDITOR_CLIENT_SECRET}
  - NODERED_AUTH_ADDITIONAL_SCOPES=lanes engine_read engine_write
 
  # Dashboard-Authentifizierung
  - NODERED_DASHBOARD_CLIENT_ID=NodeRedDashboardClient
  - NODERED_DASHBOARD_CLIENT_SECRET=${DASHBOARD_CLIENT_SECRET}
  - NODERED_DASHBOARD_AUTH_ADDITIONAL_SCOPES=lanes engine_read engine_write

Die Client-Credentials müssen in der Authority registriert sein. Details finden Sie in der Authority-Dokumentation.

2. HTTPS / TLS

Node-RED selbst sollte hinter einem Reverse Proxy betrieben werden, der die TLS-Terminierung übernimmt. Gängige Lösungen:

NGINX als Reverse Proxy

nginx.conf


server {
    listen 443 ssl;
    server_name lowcode.example.com;
 
    ssl_certificate     /etc/ssl/certs/lowcode.crt;
    ssl_certificate_key /etc/ssl/private/lowcode.key;
 
    location / {
        proxy_pass http://lowcode:1880;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Wichtig: Die WebSocket-Upgrade-Header (Upgrade, Connection) sind für den Node-RED-Editor zwingend erforderlich.

Setzen Sie die NODERED_BASE_URL auf die öffentliche URL:


environment:
  - NODERED_BASE_URL=https://lowcode.example.com

3. Credential Secret

Das Credential Secret verschlüsselt sensible Daten (Passwörter, API-Keys) in den Flow-Dateien. Setzen Sie dieses auf einen sicheren, zufälligen Wert:


environment:
  - NODERED_CREDENTIAL_SECRET=ein-langer-zufaelliger-string-mit-mindestens-32-zeichen

Generieren Sie ein sicheres Secret:


# Zufälliges Secret generieren
openssl rand -base64 48

Warnung: Ändern Sie das Credential Secret nicht nachträglich, da sonst alle gespeicherten Credentials unlesbar werden. Sichern Sie den Wert an einem sicheren Ort (z.B. Secrets Manager).

4. Monitoring

Prometheus-Metriken

LowCode kann Metriken im Prometheus-Format exportieren:


environment:
  - PROMETHEUS_COLLECT_DEFAULT_METRICS=true

Die Metriken sind unter /metrics abrufbar und umfassen:

Node.js-Runtime-Metriken (Heap, CPU, Event Loop)
HTTP-Request-Metriken
Flow-Ausführungsmetriken

Grafana-Dashboard

Erstellen Sie ein Grafana-Dashboard mit den exportierten Metriken:

prometheus.yml


scrape_configs:
  - job_name: 'lowcode'
    metrics_path: '/metrics'
    static_configs:
      - targets: ['lowcode:1880']

Readiness Probe

Die Runtime Extension stellt einen Readiness-Endpunkt bereit:


GET /readiness

Dieser gibt 200 OK zurück, wenn Node-RED vollständig gestartet und bereit ist. Nutzen Sie diesen Endpunkt für Load-Balancer und Container-Orchestrierung.

5. Backup-Strategie

Volume-Backup

Sichern Sie das Data-Volume regelmäßig:


# Volume-Backup erstellen
docker run --rm \
  -v lowcode_data:/data \
  -v $(pwd)/backups:/backup \
  alpine tar czf /backup/lowcode-backup-$(date +%Y%m%d).tar.gz -C /data .

Flow-Export

Exportieren Sie Flows über die Admin-API:


# Flows exportieren
curl -s http://localhost:1880/flows \
  -H "Authorization: Bearer ${TOKEN}" \
  -o flows-backup.json
 
# Credentials exportieren (verschlüsselt)
curl -s http://localhost:1880/credentials \
  -H "Authorization: Bearer ${TOKEN}" \
  -o credentials-backup.json

Automatisiertes Backup

Richten Sie ein CronJob ein, der tägliche Backups erstellt:

backup.sh


#!/bin/bash
# Tägliches Backup-Skript
 
BACKUP_DIR="/backups/lowcode"
DATE=$(date +%Y%m%d)
 
# Volume-Backup
docker run --rm \
  -v lowcode_data:/data \
  -v ${BACKUP_DIR}:/backup \
  alpine tar czf /backup/lowcode-${DATE}.tar.gz -C /data .
 
# Alte Backups aufräumen (älter als 30 Tage)
find ${BACKUP_DIR} -name "lowcode-*.tar.gz" -mtime +30 -delete

6. Log-Level

Setzen Sie in Produktion das Log-Level auf warn oder error, um die Log-Menge zu reduzieren:


environment:
  - NODERED_LOG_LEVEL=warn

Verfügbare Log-Level (aufsteigend):

Level	Beschreibung
`fatal`	Nur fatale Fehler
`error`	Fehler und fatale Fehler
`warn`	Warnungen, Fehler und fatale Fehler
`info`	Informationen (Standard)
`debug`	Debug-Informationen
`trace`	Alle Meldungen

Vollständige docker-compose.yml für Produktion

docker-compose.yml


services:
  lowcode:
    image: marketplace.processcube.io/processcube-io/processcube_lowcode:latest
    ports:
      - "1880:1880"
    environment:
      # Basis-Konfiguration
      - NODERED_PORT=1880
      - NODERED_NAME=ProcessCube LowCode Production
      - NODERED_BASE_URL=https://lowcode.example.com
      - NODERED_THEME=processcube
 
      # Sicherheit
      - NODERED_CREDENTIAL_SECRET=${CREDENTIAL_SECRET}
      - NODERED_AUTHORITY_URL=https://authority.example.com
      - NODERED_CLIENT_ID=NodeRedEditorClient
      - NODERED_CLIENT_SECRET=${EDITOR_CLIENT_SECRET}
      - NODERED_AUTH_ADDITIONAL_SCOPES=lanes engine_read engine_write
 
      # Dashboard-Authentifizierung
      - NODERED_DASHBOARD_CLIENT_ID=NodeRedDashboardClient
      - NODERED_DASHBOARD_CLIENT_SECRET=${DASHBOARD_CLIENT_SECRET}
      - NODERED_DASHBOARD_AUTH_ADDITIONAL_SCOPES=lanes engine_read engine_write
 
      # Engine-Anbindung
      - ENGINE_URL=http://engine:8000
 
      # Storage
      - NODERED_FLOW_STORAGE_OUTPUT_FORMAT=yaml
      - NODERED_FLOW_STORAGE_SAVE_BY_NODE=false
 
      # Monitoring
      - PROMETHEUS_COLLECT_DEFAULT_METRICS=true
 
      # Logging
      - NODERED_LOG_LEVEL=warn
    volumes:
      - lowcode_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:1880/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
        reservations:
          memory: 512M
          cpus: '0.5'
 
  nginx:
    image: nginx:alpine
    ports:
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - ./certs:/etc/ssl:ro
    depends_on:
      - lowcode
    restart: unless-stopped
 
volumes:
  lowcode_data:

Erstellen Sie eine .env-Datei für die Secrets:

.env


CREDENTIAL_SECRET=ein-langer-zufaelliger-string
EDITOR_CLIENT_SECRET=editor-secret-aus-authority
DASHBOARD_CLIENT_SECRET=dashboard-secret-aus-authority

Wichtig: Committen Sie die .env-Datei niemals in ein Git-Repository. Fügen Sie sie zur .gitignore hinzu.

Nächste Schritte

Kubernetes Deployment — Hochverfügbarkeit mit Kubernetes
Eigenes Docker Image — Custom Image erstellen
Konfiguration — Alle Umgebungsvariablen