Skip to Content
Low-CodeDevelopmentBest Practices

Best Practices

Bewährte Methoden und Muster für die professionelle Entwicklung mit LowCode. Dieser Abschnitt behandelt Flow-Organisation, Performance, Fehlerbehandlung, Sicherheit und Versionskontrolle.

Flow-Organisation

Namenskonventionen

Vergeben Sie immer aussagekräftige Namen:

Schlecht:  function 1, http in 2, debug 3
Gut:       validate order, POST /api/orders, log order errors

Tab-Struktur

Organisieren Sie Ihre Flows in logische Tabs:

TabInhaltBeispiel
APIsREST-Endpunkte und HTTP-HandlerGET /api/orders, POST /api/users
EngineEngine-IntegrationenStart-Process-Flows, UserTask-Handler
DashboardsDashboard-2 UI-FlowsFormulare, Tabellen, Charts
UtilsHilfsfunktionen und SubflowsLogging, Validierung, Formatierung

Subflows für Wiederverwendbarkeit

Lagern Sie wiederkehrende Logik in Subflows aus. Änderungen an einem Subflow wirken sich automatisch auf alle Instanzen aus.

Verwenden Sie Link-Nodes statt langer Verbindungen quer durch den Editor:

Flow 1:  [http in] → [validate] → [link out: "process-order"]
Flow 2:  [link in: "process-order"] → [save to db] → [send response]

Comment Nodes für Dokumentation

Platzieren Sie Comment-Nodes am Anfang jedes Flows mit einer kurzen Beschreibung, dem Autor und dem Zweck des Flows.

Performance

Asynchrone Verarbeitung

Node-RED nutzt ein Single-Thread Event-Loop-Modell. Blockierende Operationen verhindern die Verarbeitung aller anderen Messages.

Nicht empfohlen — blockierende Schleife:

// Blockiert den gesamten Event-Loop
let result = 0;
for (let i = 0; i < 10000000; i++) {
  result += Math.sqrt(i);
}
msg.payload = result;
return msg;

Empfohlen — asynchrone Verarbeitung:

const result = await new Promise((resolve) => {
  setImmediate(() => {
    let sum = 0;
    for (let i = 0; i < 10000000; i++) { sum += Math.sqrt(i); }
    resolve(sum);
  });
});
msg.payload = result;
return msg;

Split/Join für parallele Verarbeitung

Nutzen Sie Split/Join-Nodes, um Arrays parallel zu verarbeiten:

[get 100 items] → [split] → [process item] → [join] → [send result]

Caching mit Context

Vermeiden Sie wiederholte API-Aufrufe durch Caching im Flow-Context:

const cacheKey = "userList";
const cacheTTL = 60000; // 60 Sekunden
let cached = flow.get(cacheKey);
 
if (cached && (Date.now() - cached.timestamp) < cacheTTL) {
  msg.payload = cached.data;
  return msg;
}
// Kein Cache: API aufrufen (im nachfolgenden http-request Node)
return msg;

Rate Limiting

Schützen Sie externe APIs mit der Delay-Node im Rate-Limit-Modus:

[trigger] → [delay: 10 msg/s] → [http request: external API]

Fehlerbehandlung

Catch Nodes für jeden Flow

Jeder Flow sollte mindestens eine Catch-Node besitzen:

                    ┌──> [log error] → [send alert]
[process data] ────┤
                    └──> [catch all] → [format error] → [http response: 500]

Logging-Strategie

Nutzen Sie die Node-RED Log-API in Function Nodes:

node.trace("Detaillierte Debug-Informationen");
node.debug("Debug-Ausgabe für Entwicklung");
node.log("Allgemeine Information");
node.warn("Warnung: Aktion empfohlen");
node.error("Fehler aufgetreten", msg);  // msg wird an Catch-Node gesendet

Retry-Pattern

Implementieren Sie Wiederholungsversuche für unzuverlässige externe Dienste:

const maxRetries = 3;
const retryCount = msg.retryCount || 0;
 
if (msg.statusCode >= 500 && retryCount < maxRetries) {
  msg.retryCount = retryCount + 1;
  msg.delay = Math.pow(2, retryCount) * 1000; // Exponentielles Backoff
  return [null, msg]; // Zweiter Ausgang zum Delay-Node
}
return [msg, null]; // Erster Ausgang: Erfolg oder Max erreicht

Circuit Breaker

Verhindern Sie Kaskadenfehler bei ausgefallenen Diensten:

const state = flow.get("circuit_api") || { failures: 0, lastFail: 0 };
const resetTimeout = 30000;
 
if (state.failures >= 3 && (Date.now() - state.lastFail) < resetTimeout) {
  msg.payload = { error: "Service vorübergehend nicht verfügbar" };
  msg.statusCode = 503;
  return [null, msg]; // Fehler-Ausgang
}
return [msg, null]; // Anfrage weiterleiten

Sicherheit

Credential Management

Niemals Zugangsdaten direkt in Flows hart kodieren:

// FALSCH
const apiKey = "sk-12345-geheim";
 
// RICHTIG: Umgebungsvariablen verwenden
const apiKey = env.get("EXTERNAL_API_KEY");

Input-Validierung

Validieren Sie alle eingehenden Daten bei HTTP-Endpunkten:

const { name, email } = msg.payload;
if (!name || typeof name !== 'string' || name.length > 200) {
  msg.statusCode = 400;
  msg.payload = { error: "Ungültiger Name" };
  return [null, msg];
}
return [msg, null];

Authority-Integration

Nutzen Sie die Authority für Authentifizierung:

environment:
  - NODERED_AUTH_ENABLED=true
  - NODERED_OIDC_AUTHORITY_URL=http://authority:11560
  - NODERED_OIDC_CLIENT_ID=lowcode

Weitere Details unter Authentication.

Versionskontrolle

Storage Extension mit YAML-Format

LowCode unterstützt die Speicherung von Flows im YAML-Format, das besser für Git geeignet ist als JSON:

environment:
  - NODERED_FLOW_STORAGE_OUTPUT_FORMAT=yaml
  - NODERED_FLOW_STORAGE_SAVE_BY_NODE=false
EinstellungWertBeschreibung
NODERED_FLOW_STORAGE_OUTPUT_FORMATyamlFlows als YAML speichern
NODERED_FLOW_STORAGE_SAVE_BY_NODEfalseFlows als Ganzes speichern

Git-Workflow

  1. Feature-Branch erstellen: git checkout -b feature/neue-api
  2. Flows entwickeln und im Editor deployen
  3. Änderungen committen: Flows werden automatisch im YAML-Format gespeichert
  4. Pull Request erstellen und Review durchführen
  5. Merge und Deployment über den ArtifactShipper

Weiterführende Informationen

EntwicklungDebugging