Wie Promises die Kontrolle im Asynchronen Code verbessern

Im Bereich der asynchronen Programmierung in JavaScript gibt es verschiedene Ansätze, um mit Aufgaben zu arbeiten, die nicht sofort abgeschlossen werden. Zwei der populärsten Methoden sind Callbacks und Promises. Beide dienen dazu, den Ablauf von Programmen zu steuern, die mit asynchronen Operationen arbeiten, aber sie tun dies auf sehr unterschiedliche Weise. Die Verwendung von Promises hat sich als der flexiblere und übersichtlicherer Ansatz erwiesen, um komplexe asynchrone Abläufe zu handhaben.

javascript
Copy code
getUserIdFromEmail(userEmail)
  .then((userId) => getUserPosts(userId))
  .then((userPosts) => {
    // Etwas mit userPosts machen
  })
  .catch((err) => {
    // Fehler behandeln
  })
  .finally(() => {
    // Endgültige Operation, unabhängig vom Ergebnis
  });

Der Hauptvorteil dieses Ansatzes ist, dass wir nicht jede Operation ineinander verschachteln müssen, wie es bei Callbacks üblich wäre. Das macht den Code leserlicher und einfacher zu verwalten, insbesondere wenn noch weitere asynchrone Operationen hinzukommen.

javascript
Copy code
async function countOdd() {
  try {

    const lines = await readFileAsArray('./numbers.txt');

    const numbers = lines.map(Number);
    const oddCount = numbers.filter(n => n % 2 === 1).length;
    console.log('Odd numbers count:', oddCount);
  } catch (err) {
    // Fehlerbehandlung
  }
}

Das Besondere an dieser Methode ist, dass der Code nicht nur leichter zu lesen ist, sondern auch Fehlerbehandlung erheblich vereinfacht wird. Durch die Verwendung von try/catch können alle Fehler, die während des asynchronen Prozesses auftreten, auf einfache Weise abgefangen werden. Der Code sieht fast aus wie synchroner Code, was eine erhebliche Verbesserung gegenüber der Verwendung von .then() und .catch() darstellt.

Ein weiterer Vorteil von async/await zeigt sich, wenn mehrere asynchrone Funktionen hintereinander ausgeführt werden müssen. Hier ist ein Beispiel, wie das funktioniert:

javascript
Copy code
async function getUserInfo(userEmail) {
  try {
    const userId = await getUserIdFromEmail(userEmail);
    const userPosts = await getUserPosts(userId);
    // Etwas mit userPosts (und userId) machen
  } catch (err) {
    // Fehlerbehandlung
  }
}

Im Vergleich zum Callback-Ansatz, bei dem nach jedem .then() eine Promise zurückgegeben werden muss, um die Verkettung fortzusetzen, ermöglicht async/await es, die Ergebnisse der asynchronen Aufrufe direkt in derselben Funktion zu verwenden.

javascript
Copy code
const results = await Promise.all([promise1, promise2, promise3]);

Ein wichtiges Konzept, das beim Umgang mit Promises nicht übersehen werden sollte, ist das sogenannte "Promise-Polling", bei dem mehrere Promises parallel verarbeitet werden, ohne dass eine Reihenfolge erforderlich ist.

Beispielsweise hat das Modul node:fs eine Promise-basierte API, die das klassische Callback-Verfahren ersetzt und den Code noch leserlicher macht. Ein Beispiel:

javascript
Copy code
import { readFile } from 'node:fs/promises';

const readFileAsArray = async (file) => {

  const data = await readFile(file, 'utf8');

  const lines = data.trim().split('\n');

  return lines;
};

Ein weiteres nützliches Werkzeug, das in modernen JavaScript-Anwendungen verwendet wird, ist die promisify-Funktion aus dem node:util-Modul, mit der man auch traditionelle Callback-Funktionen in Promises umwandeln kann.

Im Vergleich zu Callbacks bietet die Promise-basierte Programmierung nicht nur eine größere Flexibilität, sondern auch eine bessere Fehlerbehandlung und ein besseres Verständnis der Code-Struktur. Ein einfaches Beispiel aus der realen Welt verdeutlicht diese Vorteile:

Stellen Sie sich vor, Sie sind in einer Küche und bereiten ein Gericht zu, bei dem Sie ein Joghurt ständig umrühren müssen. Die Aufgabe, den Joghurt zu rühren, blockiert Ihre Fähigkeit, andere Aufgaben zu erledigen, und lässt Ihnen wenig Spielraum für zusätzliche Arbeit. Wenn jemand anders diese Aufgabe übernimmt, können Sie sich auf andere Teile des Rezepts konzentrieren. Diese Abhängigkeit von einer externen Person, die ihre Aufgaben korrekt ausführt, ist der gleiche Mechanismus, den man in der asynchronen Programmierung mit Callbacks und Promises findet. Während Callbacks oft dazu führen, dass man die Kontrolle über die Reihenfolge und Genauigkeit der Aufgaben verliert, geben Promises die Kontrolle über den Ablauf zurück und machen das Programm insgesamt flexibler und zuve

Wie skaliert man eine Node.js-Anwendung effizient mit dem Cluster-Modul?

Das Skalieren von Anwendungen ist ein entscheidender Schritt, um sicherzustellen, dass sie auch unter höherer Last effizient arbeiten können. Beim Einsatz von Node.js stehen Entwicklern verschiedene Strategien zur Verfügung, um die Skalierbarkeit und Verfügbarkeit ihrer Anwendungen zu verbessern. Eine dieser Möglichkeiten bietet das node:cluster Modul, das es ermöglicht, mehrere Instanzen einer Node.js-Anwendung auf verschiedenen CPU-Kernen auszuführen und die Arbeitslast effektiv zu verteilen.

Skalierungsstrategien

Bevor wir uns dem node:cluster Modul zuwenden, ist es wichtig, einige grundlegende Skalierungsstrategien zu verstehen. Anwendungen können aus verschiedenen Gründen skaliert werden, und nicht nur, um mehr Arbeit zu bewältigen. Häufige Ziele sind die Verbesserung der Verfügbarkeit und die Erhöhung der Fehlertoleranz. Wenn es darum geht, eine bestehende Anwendung zu skalieren, gibt es grundsätzlich zwei Ansätze: vertikale Skalierung und horizontale Skalierung.

• Vertikale Skalierung bedeutet, dass einem Server mehr Ressourcen (z. B. CPU und RAM) zugewiesen werden.

• Horizontale Skalierung bedeutet, dass mehrere Server hinzugefügt werden, um die Last zu verteilen.

Für die effektive Planung und Umsetzung von Skalierung sollte man drei wesentliche Strategien kennen: Klonen, Zerlegen und Aufteilen.

Klonen ist die einfachste Methode und beinhaltet das Erstellen mehrerer identischer Instanzen der Anwendung, die jeweils einen Teil der Arbeitslast übernehmen. Dies ist besonders effizient, wenn ein Lastverteiler wie ein Load Balancer eingesetzt wird. Node.js bietet hierfür das node:cluster Modul, das es ermöglicht, diese Strategie auf einem einzigen Server umzusetzen. Wenn ein Server viele Ressourcen bietet, ist das Klonen eine schnelle und kostengünstige Lösung.

Aufteilen (auch horizontal partitionieren oder Sharding genannt) bezieht sich auf das Aufteilen der Daten einer Anwendung in separate Teile, die jeweils von einer anderen Instanz der Anwendung verwaltet werden. Diese Strategie erfordert zusätzliche Logik zur Datenpartitionierung, kann aber in großen Anwendungen eine enorme Leistungssteigerung bieten.

Das Cluster-Modul in Node.js

Das node:cluster Modul ist eine wichtige Möglichkeit, die vertikale Skalierung einer Node.js-Anwendung auf einem einzigen Server zu implementieren. Es erlaubt, mehrere Instanzen eines Node-Prozesses auf verschiedenen CPU-Kernen zu starten und die Arbeitslast gleichmäßig zu verteilen. Die zugrunde liegende Technik verwendet die Methode child_process.fork, um neue Prozesse zu erstellen und die Anfragen zwischen diesen Prozessen zu balancieren.

Ein typisches Setup sieht vor, dass ein primärer Prozess die Verantwortung übernimmt, mehrere Worker-Prozesse zu starten. Jeder dieser Worker-Prozesse verarbeitet dann eine Teilmenge der eingehenden Anfragen. Der primäre Prozess übernimmt die Lastverteilung, indem er die Anfragen mithilfe eines einfachen Round-Robin-Algorithmus auf die Worker-Prozesse verteilt. Dies bedeutet, dass die erste Anfrage an den ersten Worker geht, die zweite an den nächsten Worker und so weiter. Wenn das Ende der Liste erreicht ist, beginnt der Algorithmus von vorne.

Für eine einfachere Lastverteilung bietet das Cluster-Modul auch alternative Algorithmen an, wie zum Beispiel:

• Least Connections: Die Anfrage wird an den Worker mit den wenigsten aktiven Verbindungen weitergeleitet.

• Weighted Round-Robin: Arbeiter mit höherem Gewicht erhalten mehr Anfragen.

• Random: Der primäre Prozess wählt einen Worker zufällig aus.

• IP Hash: Die Anfrage wird basierend auf der IP des Clients einem bestimmten Worker zugewiesen.

• URL Hash: Die Anfrage wird basierend auf der URL einem bestimmten Worker zugewiesen.

Die Wahl des richtigen Algorithmus hängt von den spezifischen Anforderungen und der Umgebung der Anwendung ab. Dabei ist es wichtig, dass die Entscheidung auf der Art und Weise basiert, wie die Anwendung mit Lastspitzen und Verfügbarkeitsanforderungen umgehen soll.

Beispiel für den Einsatz des Cluster-Moduls

Hierzu könnte folgender Code verwendet werden:

javascript
Copy code
import cluster from 'node:cluster';
import os from 'node:os';
if (cluster.isPrimary) {
  const cpus = os.availableParallelism();
  for (let i = 0; i < cpus; i++) {
    cluster.fork();
  }
} else {
  import { createServer } from 'node:http';
  createServer((req, res) => {

    for (let i = 0; i < 1e8; i++) { /* CPU-Arbeit simulieren */ }

    res.end();
  }).listen(3000, () => {
    console.log(`Prozess ${process.pid} läuft`);
  });
}

In diesem Beispiel wird der primäre Prozess dazu verwendet, eine bestimmte Anzahl an Worker-Prozessen zu erstellen (die Anzahl basiert auf der Anzahl der verfügbaren CPU-Kerne). Jeder Worker-Prozess übernimmt dann die Bearbeitung von eingehenden HTTP-Anfragen.

Testen der Leistung

Um zu testen, wie gut die Anwendung mit dem Cluster-Modul performt, kann ein Lasttest durchgeführt werden. Dies hilft zu verstehen, wie viele Anfragen pro Sekunde der Server ohne Cluster-Verwendung und wie viele mit Cluster-Verwendung verarbeiten kann. Ein einfaches Werkzeug für Lasttests in Node.js ist loadtest, mit dem man die Serverleistung messen kann, um festzustellen, wie viele Anfragen bei einem bestimmten Setup verarbeitet werden können.

Weitere wichtige Überlegungen

Neben den technischen Aspekten des node:cluster Moduls und der Skalierung gibt es auch eine Reihe von praktischen Überlegungen, die Entwickler berücksichtigen sollten, um eine skalierbare und zuverlässige Architektur zu gewährleisten. Dazu gehören unter anderem:

• Fehlertoleranz und Überwachung: Es ist wichtig, dass der Cluster-Prozess robust gegenüber Fehlern ist. Es sollten Mechanismen vorhanden sein, die fehlerhafte Worker-Prozesse automatisch neu starten.

• Optimierung von CPU-intensive Aufgaben: In Szenarien, in denen bestimmte Aufgaben die CPU stark belasten, kann es sinnvoll sein, den Arbeitsaufwand auf mehrere Worker zu verteilen, um die Antwortzeit zu optimieren.

• Datenkonsistenz: Beim Einsatz von mehreren Prozessen müssen Entwickler sicherstellen, dass die Daten zwischen den Prozessen konsistent bleiben. Hier können zusätzliche Lösungen wie Cache-Systeme oder Datenbank-Sharding erforderlich sein.

Warum JavaScript und Node.js eine ideale Kombination sind

Die Wahl von JavaScript hat jedoch nicht nur technologische Gründe. Ein wichtiger Vorteil von JavaScript liegt in seiner Allgegenwärtigkeit: Es ist nicht nur die Sprache für Webbrowser, sondern mit Node.js auch für Serveranwendungen. Dies führt zu einer ganzen Reihe von praktischen Vorteilen, die Entwickler bei der Arbeit mit Node.js zu schätzen wissen.

Ein weiteres interessantes Merkmal ist die Möglichkeit, Teams zu entlasten, indem eine einzige Gruppe von Entwicklern sowohl Frontend- als auch Backend-Code verwaltet. Dies fördert nicht nur die Zusammenarbeit und verringert Abhängigkeiten zwischen verschiedenen Teams, sondern ermöglicht auch eine vereinfachte Personalplanung. Ein Team, das in der Lage ist, sowohl APIs als auch Web- und Netzwerkserver zu entwickeln, kann ein vollständiges Projekt von Anfang bis Ende betreuen. Arbeitgeber schätzen dies, da sie so Entwickler finden können, die in der Lage sind, sowohl auf der Client- als auch auf der Serverseite zu arbeiten.

Node.js ist darüber hinaus auch eine sehr praktische Plattform, um JavaScript außerhalb des Browsers zu verwenden. Wenn Node.js auf einem Computer installiert ist, steht der Befehl „node“ zur Verfügung, um JavaScript-Code auszuführen. Mit der einfachen Terminal-Eingabe von node startet man eine interaktive Shell, in der man JavaScript sofort ausführen kann. Diese Umgebung nennt sich REPL (Read-Eval-Print-Loop) und ist besonders hilfreich für schnelle Tests und Experimente mit Code. Hierbei gibt der Benutzer den Code ein, dieser wird sofort ausgeführt, und das Ergebnis wird direkt ausgegeben, ohne dass dafür eine zusätzliche Ausgabeaufforderung erforderlich ist.

Darüber hinaus erlaubt Node.js die Nutzung von sogenannten Modulen. So stellt Node beispielsweise das Modul node:http zur Verfügung, das es Entwicklern ermöglicht, schnell einen Webserver zu erstellen, ohne zusätzliche Bibliotheken installieren zu müssen. Ein einfacher Webserver könnte mit wenigen Zeilen Code erstellt werden, was Node.js zu einer ausgezeichneten Wahl für die Entwicklung von Webanwendungen macht. Dieser Server kann dann auf einer lokalen Adresse laufen und sogar Requests von Nutzern verarbeiten – und das alles nur mit den eingebauten Funktionen von Node.js.

Die Verwendung von Node.js ist besonders vorteilhaft in einer Produktionsumgebung, da es regelmäßige Updates gibt, die neue Versionen mit wichtigen Funktionen oder Sicherheitskorrekturen einführen. Node wird in regelmäßigen Abständen mit neuen Versionen aktualisiert, wobei ungerade Versionen (z. B. 19, 21) nach sechs Monaten aus dem Support genommen werden und gerade Versionen (z. B. 18, 20) in den sogenannten LTS (Long-Term Support) Status übergehen. Diese LTS-Versionen garantieren Stabilität und Fehlerbehebungen über einen Zeitraum von 30 Monaten – ideal für den Einsatz in Produktionsumgebungen.

Wichtig zu wissen ist, dass Node.js eine auf Ereignissen basierende Architektur verwendet, die es ermöglicht, mit asynchronen Operationen zu arbeiten. Diese Asynchronität ist besonders bei der Arbeit mit Netzwerkanfragen und Datenbankabfragen von Bedeutung, da sie die Performance verbessert und Blockierungen im Programmfluss vermeidet. Die Tatsache, dass JavaScript diese asynchronen Operationen so effektiv unterstützen kann, ist ein weiterer Grund, warum Node.js eine bevorzugte Plattform für Webentwicklung und serverseitige Anwendungen ist.

Ein weiteres interessantes Thema, das in Zusammenhang mit Node.js und JavaScript auftaucht, ist die Verwendung von TypeScript. TypeScript erweitert JavaScript um statische Typisierung und bietet eine zusätzliche Ebene der Fehlererkennung, die in größeren Projekten von unschätzbarem Wert ist. Die Verwendung von TypeScript zusammen mit Node.js verbessert nicht nur die Codequalität, sondern auch die Wartbarkeit des Codes, was besonders in umfangreichen und komplexeren Anwendungen von Vorteil ist. In Kapitel 10 dieses Buches werden wir detaillierter auf die Vorteile und den Einsatz von TypeScript eingehen.

Der Übergang von einem traditionellen Backend-Entwicklungssystem zu einer Plattform, die ausschließlich auf JavaScript basiert, stellt für viele Entwickler eine große Umstellung dar. Doch Node.js macht diese Umstellung einfach und nahtlos. Nicht nur durch die Möglichkeit, denselben Code sowohl im Frontend als auch im Backend zu verwenden, sondern auch durch die starke Integration von Tools und Bibliotheken, die speziell für die serverseitige JavaScript-Entwicklung entwickelt wurden.

Ein weiterer wichtiger Punkt ist die Community hinter Node.js. Mit einer riesigen Entwicklergemeinschaft und einer Vielzahl an verfügbaren Modulen und Paketen im npm-Repository bietet Node.js eine enorm breite Basis an Ressourcen, die Entwicklern helfen, die Entwicklung zu beschleunigen und mit bewährten Lösungen zu arbeiten. npm (Node Package Manager) ist das zentrale Repository für JavaScript-Bibliotheken, und die Vielzahl an verfügbaren Paketen ist ein riesiger Vorteil, der Node.js für fast jedes Projekt nutzbar macht – vom einfachen Skript bis hin zu komplexen Webanwendungen.