Node.js auf Mehrkernmaschinen

Node.js sieht interessant aus, ABER ich muss etwas verpassen - ist Node.js nicht nur für die Ausführung auf einem einzelnen Prozess und Thread ausgelegt?

Wie skaliert es dann für Multi-Core-CPUs und Multi-CPU-Server? Immerhin ist es großartig, einen Single-Thread-Server so schnell wie möglich zu machen, aber für hohe Lasten würde ich mehrere CPUs verwenden wollen. Das Gleiche gilt für die Beschleunigung von Anwendungen - heute werden anscheinend mehrere CPUs verwendet und die Aufgaben parallelisiert.

Wie passt Node.js in dieses Bild? Ist es die Idee, mehrere Instanzen irgendwie zu verteilen, oder was?

[ Dieser Beitrag ist ab dem 02.09.2012 auf dem neuesten Stand (neuer als oben). ]]

Node.js skaliert absolut auf Multi-Core-Maschinen.

Ja, Node.js ist ein Thread pro Prozess. Dies ist eine sehr bewusste Entwurfsentscheidung und macht die Sperrsemantik überflüssig. Wenn Sie damit nicht einverstanden sind, wissen Sie wahrscheinlich noch nicht, wie wahnsinnig schwierig es ist, Multithread-Code zu debuggen. Eine ausführlichere Erklärung des Node.js-Prozessmodells und warum es so funktioniert (und warum es NIEMALS mehrere Threads unterstützt), finden Sie in meinem anderen Beitrag .

Wie nutze ich meine 16-Core-Box?

Zwei Wege:

• Für große, schwere Rechenaufgaben wie die Bildcodierung kann Node.js untergeordnete Prozesse starten oder Nachrichten an zusätzliche Arbeitsprozesse senden. In diesem Entwurf muss ein Thread den Ablauf von Ereignissen und N Prozessen verwalten, die schwere Rechenaufgaben ausführen und die anderen 15 CPUs zerkauen.
• Um den Durchsatz auf einem Webservice zu skalieren, sollten Sie mehrere Node.js-Server auf einer Box ausführen, einen pro Kern, und den Anforderungsverkehr zwischen ihnen aufteilen. Dies bietet eine hervorragende CPU-Affinität und skaliert den Durchsatz nahezu linear mit der Kernanzahl.

Skalieren des Durchsatzes auf einem Webservice

Seit v6.0.X hat Node.js das Cluster-Modul sofort integriert, wodurch es einfach ist, mehrere Node-Worker einzurichten, die einen einzelnen Port überwachen können. Beachten Sie, dass dies NICHT dasselbe ist wie das ältere Learnboost-Cluster-Modul, das über npm verfügbar ist .

if (cluster.isMaster) {
  // Fork workers.
  for (var i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  http.Server(function(req, res) { ... }).listen(8000);
}

Die Mitarbeiter konkurrieren um die Annahme neuer Verbindungen, und der am wenigsten belastete Prozess wird höchstwahrscheinlich gewinnen. Es funktioniert ziemlich gut und kann den Durchsatz auf einer Multi-Core-Box recht gut skalieren.

Wenn Sie genug Last haben, um sich um mehrere Kerne zu kümmern, sollten Sie noch ein paar Dinge tun:

1. Führen Sie Ihren Node.js-Dienst hinter einem Webproxy wie Nginx oder Apache aus - etwas, das die Verbindungsdrosselung durchführen kann (es sei denn, Sie möchten, dass die Überlastungsbedingungen die Box vollständig herunterfahren), URLs neu schreiben, statischen Inhalt bereitstellen und andere Unterdienste vertreten.

2. Recyceln Sie regelmäßig Ihre Arbeitsprozesse. Bei einem lang laufenden Prozess summiert sich möglicherweise sogar ein kleiner Speicherverlust.

3. Protokollsammlung / -überwachung einrichten

PS: Es gibt eine Diskussion zwischen Aaron und Christopher in den Kommentaren eines anderen Beitrags (zum Zeitpunkt dieses Schreibens ist es der oberste Beitrag). Ein paar Kommentare dazu:

• Ein Shared-Socket-Modell ist sehr praktisch, damit mehrere Prozesse einen einzelnen Port überwachen und um die Annahme neuer Verbindungen konkurrieren können. Konzeptionell könnte man sich vorstellen, dass Apache dies mit der erheblichen Einschränkung tut, dass jeder Prozess nur eine einzige Verbindung akzeptiert und dann stirbt. Der Effizienzverlust für Apache ist mit dem Verzweigen neuer Prozesse verbunden und hat nichts mit den Socket-Operationen zu tun.
• Für Node.js ist es eine äußerst vernünftige Lösung, wenn N-Mitarbeiter an einem einzigen Socket miteinander konkurrieren. Die Alternative besteht darin, ein On-Box-Front-End wie Nginx einzurichten und diesen Proxy-Verkehr an die einzelnen Mitarbeiter weiterzuleiten, wobei zwischen Arbeitnehmern gewechselt wird, um neue Verbindungen zuzuweisen. Die beiden Lösungen weisen sehr ähnliche Leistungsmerkmale auf. Und da Sie, wie oben erwähnt, wahrscheinlich Nginx (oder eine Alternative) haben möchten, das Ihren Knotendienst bedient, haben Sie hier wirklich die Wahl zwischen:

Gemeinsame Ports: nginx (port 80) --> Node_workers x N (sharing port 3000 w/ Cluster)

vs.

Einzelne Ports: nginx (port 80) --> {Node_worker (port 3000), Node_worker (port 3001), Node_worker (port 3002), Node_worker (port 3003) ...}

Die Einrichtung der einzelnen Ports bietet möglicherweise einige Vorteile (möglicherweise weniger Kopplung zwischen Prozessen, differenziertere Entscheidungen zum Lastenausgleich usw.), aber die Einrichtung ist definitiv aufwändiger und das integrierte Cluster-Modul ist niedrig -Komplexitätsalternative, die für die meisten Menschen funktioniert.

Eine Methode wäre, mehrere Instanzen von node.js auf dem Server auszuführen und dann einen Load Balancer (vorzugsweise einen nicht blockierenden wie nginx) vor sich zu platzieren.

Ryan Dahl beantwortet diese Frage in dem Tech-Vortrag, den er letzten Sommer bei Google gehalten hat . Um es zu paraphrasieren: "Führen Sie einfach mehrere Knotenprozesse aus und verwenden Sie etwas Sinnvolles, damit sie kommunizieren können, z. B. IPC im Sendmsg () - Stil oder traditioneller RPC".

Wenn Sie sich sofort die Hände schmutzig machen möchten, schauen Sie sich das spark2 Forever- Modul an. Es macht das Laichen mehrerer Knotenprozesse trivial einfach. Es übernimmt das Einrichten der Portfreigabe, sodass jeder Verbindungen zu demselben Port akzeptieren kann, und das automatische Respawning, wenn Sie sicherstellen möchten, dass ein Prozess neu gestartet wird, wenn er stirbt.

UPDATE - 10/11/11 : In der Knotengemeinschaft scheint Konsens darüber zu bestehen, dass Cluster jetzt das bevorzugte Modul für die Verwaltung mehrerer Knoteninstanzen pro Computer ist. Für immer ist auch ein Blick wert.

Sie können das Cluster- Modul verwenden. Überprüfen Sie dies .

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    // Fork workers.
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    });
} else {
    // Workers can share any TCP connection
    // In this case its a HTTP server
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end("hello world\n");
    }).listen(8000);
}

Multi-Node nutzt alle Kerne, die Sie möglicherweise haben.
Schauen Sie sich http://github.com/kriszyp/multi-node an .

Für einfachere Anforderungen können Sie mehrere Kopien des Knotens an verschiedenen Portnummern starten und einen Load Balancer vor sie stellen.

Node Js unterstützt Clustering, um die Vorteile Ihrer CPU voll auszuschöpfen. Wenn Sie es nicht mit Cluster ausführen, verschwenden Sie wahrscheinlich Ihre Hardwarefunktionen.

Durch Clustering in Node.js können Sie separate Prozesse erstellen, die denselben Serverport gemeinsam nutzen können. Wenn wir beispielsweise einen HTTP-Server auf Port 3000 ausführen, handelt es sich um einen Server, der auf einem einzelnen Thread auf einem einzelnen Prozessorkern ausgeführt wird.

Mit dem unten gezeigten Code können Sie Ihre Anwendung gruppieren. Dieser Code ist der offizielle Code von Node.js.

var cluster = require('cluster');
var numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    // Fork workers.
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }

    Object.keys(cluster.workers).forEach(function(id) {
        console.log("I am running with ID : " + cluster.workers[id].process.pid);
    });

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    });
} else {

    //Do further processing.
}

In diesem Artikel finden Sie das vollständige Tutorial

Wie oben erwähnt, skaliert Cluster Ihre App und verteilt sie auf alle Kerne.

etwas hinzufügen wie

cluster.on('exit', function () {
  cluster.fork();
});

Startet alle fehlerhaften Worker neu.

Heutzutage bevorzugen viele Leute auch PM2 , das das Clustering für Sie übernimmt und auch einige coole Überwachungsfunktionen bietet .

Fügen Sie dann Nginx oder HAProxy vor mehreren Computern hinzu, auf denen Clustering ausgeführt wird, und Sie haben mehrere Failover-Ebenen und eine viel höhere Ladekapazität.

Mit der zukünftigen Version des Knotens können Sie einen Prozess verzweigen und Nachrichten an ihn weiterleiten. Ryan hat erklärt, dass er einen Weg finden möchte, um auch Dateihandler gemeinsam zu nutzen, sodass dies keine einfache Implementierung von Web Worker ist.

Derzeit gibt es keine einfache Lösung dafür, aber es ist noch sehr früh und Node ist eines der am schnellsten laufenden Open Source-Projekte, die ich je gesehen habe. Erwarten Sie also in naher Zukunft etwas Großartiges.

Spark2 basiert auf Spark, das jetzt nicht mehr gepflegt wird. Cluster ist sein Nachfolger und verfügt über einige coole Funktionen, z. B. das Laichen eines Worker-Prozesses pro CPU-Kern und das Respawn toter Worker.

Ich verwende Node Worker , um Prozesse auf einfache Weise von meinem Hauptprozess aus auszuführen. Scheint großartig zu funktionieren, während wir auf den offiziellen Weg warten.

Das neue Kind auf dem Block hier ist LearnBoosts "Up" .

Es bietet "Zero-Downtime-Reloads" und erstellt zusätzlich mehrere Worker (standardmäßig die Anzahl der CPUs, aber konfigurierbar), um das Beste aus allen Welten zu bieten.

Es ist neu, scheint aber ziemlich stabil zu sein, und ich verwende es gerne in einem meiner aktuellen Projekte.

Mit dem Cluster- Modul können Sie alle Kerne Ihres Computers verwenden. Tatsächlich können Sie dies in nur 2 Befehlen und ohne Berühren Ihres Codes mit einem sehr beliebten Prozessmanager pm2 nutzen .

npm i -g pm2
pm2 start app.js -i max

Sie können Ihre Anwendung node.js auf mehreren Kernen ausführen, indem Sie das Cluster- Modul in Kombination mit dem OS- Modul verwenden, mit dem ermittelt werden kann, wie viele CPUs Sie haben.

Stellen Sie sich zum Beispiel vor, Sie haben ein serverModul, auf dem ein einfacher http-Server im Backend ausgeführt wird, und Sie möchten es für mehrere CPUs ausführen:

// Dependencies.
const server = require('./lib/server'); // This is our custom server module.
const cluster = require('cluster');
const os = require('os');

 // If we're on the master thread start the forks.
if (cluster.isMaster) {
  // Fork the process.
  for (let i = 0; i < os.cpus().length; i++) {
    cluster.fork();
  }
} else {
  // If we're not on the master thread start the server.
  server.init();
}

Es ist auch möglich, den Webdienst als mehrere eigenständige Server zu gestalten, die Unix-Sockets abhören, sodass Sie Funktionen wie die Datenverarbeitung in separate Prozesse übertragen können.

Dies ähnelt den meisten Scrpting- / Datenbank-Webserver-Architekturen, bei denen ein CGI-Prozess die Geschäftslogik verarbeitet und die Daten dann über einen Unix-Socket in eine Datenbank überträgt.

Der Unterschied besteht darin, dass die Datenverarbeitung als Knoten-Webserver geschrieben wird, der einen Port überwacht.

Es ist komplexer, aber letztendlich muss die Multi-Core-Entwicklung dahin gehen. Eine Multiprozessarchitektur mit mehreren Komponenten für jede Webanforderung.

Es ist möglich, NodeJS mit einem reinen TCP-Load-Balancer (HAProxy) vor mehreren Boxen, in denen jeweils ein NodeJS-Prozess ausgeführt wird, auf mehrere Boxen zu skalieren.

Wenn Sie dann allgemeines Wissen haben, das Sie zwischen allen Instanzen teilen können, können Sie einen zentralen Redis-Speicher oder ähnliches verwenden, auf den dann von allen Prozessinstanzen aus zugegriffen werden kann (z. B. von allen Feldern aus).