Wie NodeJS verteilt wird

Angesichts der kontinuierlichen Entwicklung von Internetanwendungen ist es für einen einzelnen Server oft schwierig, die Anforderungen hoher Parallelität und großem Datenverkehr zu erfüllen. Um dieses Problem zu lösen, entstanden verteilte Systeme. Node.js ist eine sehr beliebte serverseitige JavaScript-Ausführungsumgebung. Sie verwendet ein ereignisgesteuertes, nicht blockierendes E/A-Modell und kann Anforderungen mit hoher Parallelität und hohem Durchsatz verarbeiten. Allerdings ist die Rechenleistung eines einzelnen Node.js-Prozesses immer noch begrenzt. Daher wird in diesem Artikel erläutert, wie Sie ein verteiltes System mithilfe von Node.js implementieren.

Verteilung bezieht sich auf die Zerlegung einer Aufgabe in mehrere Unteraufgaben, die Zuweisung dieser Unteraufgaben zur Ausführung an verschiedene Arbeitsknoten und die gemeinsame Erledigung der gesamten Aufgabe über Netzwerkkommunikation. Es gibt zwei Hauptmethoden, um verteilte Systeme in Node.js zu implementieren: Eine besteht darin, den Mehrprozessmodus zu verwenden, und die andere darin, Nachrichtenwarteschlangen zu verwenden.

1. Verwenden Sie den Multiprozessmodus

Node.js bietet eine API zum Erstellen untergeordneter Prozesse über das integrierte Modul child_process. Wir können problemlos mehrere untergeordnete Prozesse erstellen, um dieselbe Aufgabe gleichzeitig zu verarbeiten. Im Multiprozessmodus ist jeder Unterprozess unabhängig und der Datenaustausch zwischen ihnen erfolgt über IPC (Interprozesskommunikation).

1. Master-Worker-Modus

Der Master-Worker-Modus ist einer der klassischsten Multiprozessmodi. In diesem Modus gibt es einen Master-Prozess und mehrere Worker-Prozesse. Der Master-Prozess ist für die Verwaltung aller Worker-Prozesse verantwortlich, einschließlich Starten, Stoppen, Neustarten usw., während der Worker-Prozess für die Verarbeitung bestimmter Anforderungen oder Aufgaben verantwortlich ist.

In Node.js kann der Master-Worker-Modus über das Cluster-Modul implementiert werden. Das Cluster-Modul ist ein erweitertes Modul, das auf dem Modul child_process basiert. Es kann den Master-Worker-Modus problemlos implementieren, wie unten gezeigt:

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

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // 当主进程被终止时，关闭所有工作进程
  process.on('SIGINT', () => {
    console.log('Received SIGINT. Shutting down workers...');
    for (const id in cluster.workers) {
      cluster.workers[id].kill();
    }
  });

  // 根据CPU数量创建工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 当有工作进程被断开连接（崩溃）时，自动重新启动
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  console.log(`Worker ${process.pid} started`);

  // Workers可以处理具体的任务，例如下面是创建HTTP服务器的代码
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker!');
  }).listen(3000);
}

Der obige Code zeigt, wie das Cluster-Modul zum Erstellen eines Master-Prozesses und mehrerer Worker-Prozesse verwendet wird Bei der tatsächlichen Verwendung können wir bestimmte Aufgaben und Geschäftslogik wie HTTP-Server zur Ausführung in den Worker-Prozess einfügen.

2. Prozesspoolmodus

Der Prozesspoolmodus ist ein effizienterer Multiprozessmodus. In diesem Modus können wir bereits erstellte Prozesse wiederverwenden, um eine Leistungsoptimierung zu erreichen. Im Allgemeinen sollte die Anzahl der Prozesse im Prozesspool dynamisch an die Anzahl der System-CPUs angepasst werden, um sicherzustellen, dass Anforderungen unter hoher Last erfüllt werden können.

Node.js verfügt nicht über ein integriertes Prozesspoolmodul, wir können es jedoch über Module von Drittanbietern implementieren. Beispielsweise kann das Modul generic-pool verwendet werden, um auf einfache Weise einen Worker-Prozesspool zu implementieren, wie unten gezeigt:

const http = require('http');
const pool = require('generic-pool');
const numCPUs = require('os').cpus().length;

const workerFactory = {
  create: function() {
    return new Promise(resolve => {
      const worker = child_process.fork('./worker.js');
      worker.once('message', msg => {
        if (msg.ready) {
          resolve(worker);
        }
      });
    });
  },
  destroy: function(worker) {
    return new Promise(resolve => {
      worker.once('exit', () => {
        resolve();
      });
      worker.send('exit');
    });
  }
};

const workerPool = pool.createPool(workerFactory, { max: numCPUs });

// 创建HTTP服务器
http.createServer(async (req, res) => {
  const worker = await workerPool.acquire();
  worker.send({ type: 'request', path: req.url });
  worker.once('message', msg => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(msg));
    workerPool.release(worker);
  });
}).listen(3000);

Der obige Code zeigt, wie das Modul generic-pool verwendet wird, um einen Worker-Prozesspool zu erstellen und den Worker im aufzurufen Prozesspool im HTTP-Server zur Bearbeitung spezifischer Anfragen.

2. Nachrichtenwarteschlange verwenden

Die Nachrichtenwarteschlange ist ein verteilter Kommunikationsmechanismus, der auf dem asynchronen (nicht blockierenden) Kommunikationsmodus basiert. Im Nachrichtenwarteschlangenmodus können wir Nachrichten an die Warteschlange senden, und der Empfänger erhält die Nachricht aus der Warteschlange und verarbeitet sie. Daher können Nachrichtenwarteschlangen Probleme wie die Aufgabenverteilung und Datenübertragung in verteilten Systemen lösen und die Zuverlässigkeit und Skalierbarkeit des Systems verbessern.

Es gibt viele Implementierungen von Nachrichtenwarteschlangen in Node.js, wie RabbitMQ, Redis, Kafka usw. Hier nehmen wir RabbitMQ als Beispiel zur Einführung.

1. Produzenten-Konsumenten-Muster

Das Produzenten-Konsumenten-Muster ist ein klassisches Nachrichtenwarteschlangenmuster. In diesem Modus ist der Produzent dafür verantwortlich, Nachrichten an die Warteschlange zu senden, und der Verbraucher ist dafür verantwortlich, Nachrichten aus der Warteschlange abzurufen und zu verarbeiten.

In Node.js können Sie das amqp.node-Modul verwenden, um eine Verbindung zu RabbitMQ herzustellen und Konzepte wie Warteschlangen und Schalter zu verwenden, um das Producer-Consumer-Muster zu implementieren. Hier ist ein einfaches Beispiel:

const amqp = require('amqp');
const connection = amqp.createConnection({ host: 'localhost' });

// 连接RabbitMQ服务器
connection.on('ready', function() {
  console.log('Connected to RabbitMQ');

  // 创建消息队列
  connection.queue('hello-queue', { durable: true }, function(queue) {
    console.log('Created queue: ' + queue.name);

    // 创建消息生产者
    setInterval(function() {
      const message = 'Hello ' + new Date();
      console.log('Sending message: ' + message);
      connection.publish(queue.name, message, { persistent: true });
    }, 1000);

    // 创建消息消费者
    queue.subscribe(function(message) {
      console.log('Received message: ' + message.data.toString());
    });
  });
});

Der obige Code zeigt, wie man das amqp.node-Modul verwendet, um eine Verbindung zu einem RabbitMQ-Server herzustellen und einen Produzenten und einen Verbraucher zu erstellen. Der Produzent sendet jede Sekunde eine Nachricht an die Warteschlange, und der Verbraucher holt die Nachricht aus der Warteschlange und verarbeitet sie.

2. Publish-Subscribe-Muster

Publish-Subscribe-Muster ist ein weiteres häufiges Nachrichtenwarteschlangenmuster. In diesem Modus gibt es einen Nachrichtenherausgeber und mehrere Nachrichtenabonnenten. Der Herausgeber sendet Nachrichten an ein Thema, und Abonnenten können Nachrichten von dem Thema gemäß ihren eigenen Abonnementregeln erhalten.

In Node.js können wir auch das amqp.node-Modul verwenden, um den Publish-Subscribe-Modus zu implementieren. Hier ist ein einfaches Beispiel:

const amqp = require('amqp');
const connection = amqp.createConnection({ host: 'localhost' });

// 连接RabbitMQ服务器
connection.on('ready', function() {
  console.log('Connected to RabbitMQ');

  // 创建消息主题
  const exchange = connection.exchange('logs', { type: 'fanout' }, function() {
    console.log('Created exchange: ' + exchange.name);

    // 创建消息订阅者
    connection.queue('', { exclusive: true }, function(queue) {
      console.log('Created queue: ' + queue.name);
      queue.bind(exchange, '');

      queue.subscribe(function(message) {
        console.log('Received message: ' + message.data.toString());
      });
    });

    // 创建消息发布者
    setInterval(function() {
      const message = 'Hello ' + new Date();
      console.log('Sending message: ' + message);
      exchange.publish('', message);
    }, 1000);
  });
});

Der obige Code zeigt, wie das amqp.node-Modul verwendet wird, um ein Nachrichtenthema, einen Nachrichtenabonnenten und einen Nachrichtenherausgeber zu erstellen. Der Herausgeber sendet jede Sekunde eine Nachricht an das Thema, und der Abonnent erhält die Nachricht vom Thema und verarbeitet sie.

Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit Node.js ein verteiltes System implementieren. In praktischen Anwendungen können wir entsprechend den spezifischen Geschäftsanforderungen verschiedene verteilte Kommunikationsmechanismen auswählen, z. B. die Verwendung des Multiprozessmodus oder des Nachrichtenwarteschlangenmodus. Egal für welche Methode Sie sich entscheiden, Sie müssen auf Aspekte wie Zuverlässigkeit, Skalierbarkeit und Sicherheit verteilter Systeme achten.

Das obige ist der detaillierte Inhalt vonWie NodeJS verteilt wird. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!