Bringen Sie Ihnen Schritt für Schritt bei, wie Sie Cluster in Node verwenden

In diesem Artikel erfahren Sie mehr über den Cluster in Node.js und stellen das Cluster-Event vor. Ich hoffe, dass es für alle hilfreich ist!

1. Einführung

Node Das Clustermodul wurde direkt in Version 0.8 eingeführt, um das Problem der Multi-Core-CPU-Auslastung zu lösen. Es bietet außerdem eine relativ vollständige API zur Bewältigung von Prozessrobustheitsproblemen. Das

Cluster-Modul ruft die Fork-Methode auf, um einen untergeordneten Prozess zu erstellen. Dabei handelt es sich um dieselbe Methode wie fork in child_process. Das Clustermodul verwendet das klassische Master-Slave-Modell. Der Cluster erstellt einen Master und kopiert dann mehrere untergeordnete Prozesse entsprechend der von Ihnen angegebenen Anzahl. Sie können die Eigenschaft „cluster.isMaster“ verwenden, um zu bestimmen, ob der aktuelle Prozess ein Master oder ein Worker ist (Arbeitsprozess). Der Masterprozess verwaltet alle untergeordneten Prozesse. Der Masterprozess ist nicht für die Verarbeitung bestimmter Aufgaben verantwortlich. Seine Hauptaufgabe besteht darin, für die Planung und Verwaltung verantwortlich zu sein.

Das Clustermodul verwendet einen integrierten Lastausgleich, um den Druck zwischen Threads besser zu bewältigen. Der Lastausgleich verwendet den Round-Robin-Algorithmus (auch als Round-Robin-Algorithmus bekannt). Bei Verwendung der Round-Robin-Planungsstrategie akzeptiert () der Master alle eingehenden Verbindungsanforderungen und sendet dann die entsprechende TCP-Anforderungsverarbeitung an den ausgewählten Arbeitsprozess (diese Methode kommuniziert weiterhin über IPC). Das offizielle Verwendungsbeispiel lautet wie folgt: Tatsächlich wird das Cluster-Modul durch eine Kombination aus child_process- und net-Modulen angewendet. Wenn der Cluster gestartet wird, wird der TCP-Server intern gestartet. Der serverseitige TCP-Socket Der Dateideskriptor wird an den Arbeitsprozess gesendet. Wenn der Worker-Prozess über cluster.fork() kopiert wird, ist NODE_UNIQUE_ID in seiner Umgebungsvariablen vorhanden. Wenn es einen listen()-Aufruf gibt, um den Netzwerkport im Worker-Prozess abzuhören, ruft er den Dateideskriptor ab und übergibt SO_REUSEADDR Wiederverwendung, sodass mehrere untergeordnete Prozesse den Port gemeinsam nutzen können.

2. Cluster-Ereignis

fork: Dieses Ereignis wird nach dem Kopieren eines Arbeitsprozesses ausgelöst;
online: Nach dem Kopieren eines Arbeitsprozesses sendet der Arbeitsprozess aktiv eine Online-Nachricht an den Hauptprozess Der Hauptprozess empfängt sie. Nach dem Empfang der Nachricht wird das Ereignis ausgelöst.
listening: Nach dem Aufruf von listen() im Arbeitsprozess (der serverseitige Socket wird gemeinsam genutzt) wird eine Listening-Nachricht an den Hauptprozess gesendet. Nachdem der Hauptprozess die Nachricht empfangen hat, wird das Ereignis ausgelöst.
disconnect: Dieses Ereignis wird ausgelöst, wenn der IPC-Kanal zwischen dem Hauptprozess und dem Worker-Prozess getrennt wird Wenn ein Arbeitsprozess beendet wird; Prozessnachrichtenübermittlung.

• const cluster = require('cluster');
  const cpuNums = require('os').cpus().length;
  const http = require('http');
  
  if (cluster.isMaster) {
    for (let i = 0; i < cpuNums; i++){
      cluster.fork();
    }
    // 子进程退出监听
    cluster.on(&#39;exit&#39;, (worker,code,signal) => {
      console.log(&#39;worker process died,id&#39;,worker.process.pid)
    })
  } else {
    // 给子进程标注进程名
    process.title = `cluster 子进程 ${process.pid}`;
    // Worker可以共享同一个 TCP 连接，这里是一个 http 服务器
    http.createServer((req, res)=> {
      res.end(`response from worker ${process.pid}`);
    }).listen(3000);
    console.log(`Worker ${process.pid} started`);
  }

  3. Kommunikation zwischen Master und Worker

• Wie aus dem Obigen ersichtlich ist, erstellt der Master-Prozess intern über den Child_Process einen Worker-Prozess. Gabel(). Das heißt: Die Master- und Worker-Prozesse sind übergeordnete und untergeordnete Prozesse; sie kommunizieren über den IPC-Kanal, genau wie die von child_process erstellten übergeordneten und untergeordneten Prozesse.

Der vollständige Name von IPC lautet Inter-Process Communication. Der Zweck der Inter-Prozess-Kommunikation besteht darin, verschiedenen Prozessen den Zugriff auf Ressourcen und die Koordinierung der Arbeit untereinander zu ermöglichen. Der IPC-Kanal in Node wird durch die Pipe-Technologie implementiert. Er wird durch die Named Pipe unter Windows implementiert. Die auf der Anwendungsebene implementierte prozessübergreifende Kommunikation verfügt nur über ein einfaches Nachrichtenereignis und eine einfache Sendemethode, die sehr einfach zu verwenden ist.

Bevor der untergeordnete Prozess tatsächlich erstellt wird, erstellt der übergeordnete Prozess einen IPC-Kanal und hört ihn ab. Anschließend erstellt er tatsächlich den untergeordneten Prozess und teilt dem untergeordneten Prozess den Dateideskriptor dieses IPC-Kanals über die Umgebungsvariable mit. NODE_CHANNEL_FD). Während des Startvorgangs stellt der untergeordnete Prozess gemäß dem Dateideskriptor eine Verbindung zum vorhandenen IPC-Kanal her und stellt so die Verbindung zwischen dem übergeordneten und dem untergeordneten Prozess her.

Nachdem die Verbindung hergestellt ist, kann der Eltern-Kind-Prozess frei kommunizieren. Da IPC-Kanäle mithilfe von Named Pipes oder Domain Sockets erstellt werden, verhalten sie sich ähnlich wie Netzwerk-Sockets und sind bidirektionale Kommunikation. Der Unterschied besteht darin, dass sie die Kommunikation zwischen Prozessen im Systemkernel abschließen, ohne die eigentliche Netzwerkschicht zu durchlaufen, was sehr effizient ist. In Node wird der IPC-Kanal als Stream-Objekt abstrahiert. Beim Aufruf von send werden Daten gesendet (ähnlich wie beim Schreiben) und die empfangene Nachricht wird durch das Nachrichtenereignis an die Anwendungsschicht gesendet (ähnlich wie bei Daten).

master 和 worker 进程在 server 实例的创建过程中，是通过 IPC 通道进行通信的，那会不会对我们的开发造成干扰呢？比如，收到一堆其实并不需要关心的消息？答案肯定是不会？那么是怎么做到的呢？

Node 引入进程间发送句柄的功能，send 方法除了能通过 IPC 发送数据外，还能发送句柄，第二个参数为句柄，如下所示

child.send(meeage, [sendHandle])

句柄是一种可以用来标识资源的引用，它的内部包含了指向对象的文件描述符。例如句柄可以用来标识一个服务器端 socket 对象、一个客户端 socket 对象、一个 UDP 套接字、一个管道等。 那么句柄发送跟我们直接将服务器对象发送给子进程有没有什么差别？它是否真的将服务器对象发送给子进程？

其实 send() 方法在将消息发送到 IPC 管道前，将消息组装成两个对象，一个参数是 handle，另一个是 message，message 参数如下所示

{
  cmd: 'NODE_HANDLE',
  type: 'net.Server',
  msg: message
}

发送到 IPC 管道中的实际上是要发送的句柄文件描述符，其为一个整数值。这个 message 对象在写入到 IPC 管道时会通过 JSON.stringify 进行序列化，转化为字符串。子进程通过连接 IPC 通道读取父进程发送来的消息，将字符串通过 JSON.parse 解析还原为对象后，才触发 message 事件将消息体传递给应用层使用。在这个过程中，消息对象还要被进行过滤处理，message.cmd 的值如果以 NODE_ 为前缀，它将响应一个内部事件 internalMessage ，如果 message.cmd 值为 NODE_HANDLE，它将取出 message.type 值和得到的文件描述符一起还原出一个对应的对象。这个过程的示意图如下所示

在 cluster 中，以 worker 进程通知 master 进程创建 server 实例为例子。worker 伪代码如下：

// woker进程
const message = {
  cmd: 'NODE_CLUSTER',
  type: 'net.Server',
  msg: message
};
process.send(message);

master 伪代码如下：

worker.process.on('internalMessage', fn);

四、如何实现端口共享

在前面的例子中，多个 woker 中创建的 server 监听了同个端口 3000，通常来说，多个进程监听同个端口，系统会报 EADDRINUSE 异常。为什么 cluster 没问题呢？

因为独立启动的进程中，TCP 服务器端 socket 套接字的文件描述符并不相同，导致监听到相同的端口时会抛出异常。但对于 send() 发送的句柄还原出来的服务而言，它们的文件描述符是相同的，所以监听相同端口不会引起异常。

这里需要注意的是，多个应用监听相同端口时，文件描述符同一时间只能被某个进程所用，换言之就是网络请求向服务器端发送时，只有一个幸运的进程能够抢到连接，也就是说只有它能为这个请求进行服务，这些进程服务是抢占式的。

五、如何将请求分发到多个worker

• 每当 worker 进程创建 server 实例来监听请求，都会通过 IPC 通道，在 master 上进行注册。当客户端请求到达，master 会负责将请求转发给对应的 worker；
• 具体转发给哪个 worker？这是由转发策略决定的，可以通过环境变量 NODE_CLUSTER_SCHED_POLICY 设置，也可以在 cluster.setupMaster(options) 时传入，默认的转发策略是轮询（SCHED_RR）；
• 当有客户请求到达，master  会轮询一遍 worker 列表，找到第一个空闲的 worker，然后将该请求转发给该worker；

六、pm2 工作原理

pm2 是 node 进程管理工具，可以利用它来简化很多 node 应用管理的繁琐任务，如性能监控、自动重启、负载均衡等。

pm2 自身是基于 cluster 模块进行封装的， 本节我们主要 pm2 的 Satan 进程、God Daemon 守护进程 以及两者之间的进程间远程调用 RPC。

撒旦（Satan），主要指《圣经》中的堕天使（也称堕天使撒旦），被看作与上帝的力量相对的邪恶、黑暗之源，是God 的对立面。

其中 Satan.js 提供程序的退出、杀死等方法，God.js 负责维持进程的正常运行，God 进程启动后一直运行，相当于 cluster 中的 Master进程，维持 worker 进程的正常运行。

RPC（Remote Procedure Call Protocol）是指远程过程调用，也就是说两台服务器A，B，一个应用部署在A 服务器上，想要调用 B 服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。同一机器不同进程间的方法调用也属于 rpc 的作用范畴。 执行流程如下所示

每次命令行的输入都会执行一次 satan 程序，如果 God 进程不在运行，首先需要启动 God 进程。然后根据指令，Satan 通过 rpc 调用 God 中对应的方法执行相应的逻辑。

以 pm2 start app.js -i 4 为例，God 在初次执行时会配置 cluster，同时监听 cluster 中的事件：

// 配置cluster
cluster.setupMaster({
  exec : path.resolve(path.dirname(module.filename), 'ProcessContainer.js')
});

// 监听cluster事件
(function initEngine() {
  cluster.on('online', function(clu) {
    // worker进程在执行
    God.clusters_db[clu.pm_id].status = 'online';
  });
  
  // 命令行中 kill pid 会触发exit事件，process.kill不会触发exit
  cluster.on('exit', function(clu, code, signal) {
    // 重启进程 如果重启次数过于频繁直接标注为stopped
    God.clusters_db[clu.pm_id].status = 'starting';
    // 逻辑
    // ...
  });
})();

在 God 启动后， 会建立 Satan 和 God 的rpc链接，然后调用 prepare 方法，prepare 方法会调用 cluster.fork 来完成集群的启动

God.prepare = function(opts, cb) {
  // ...
  return execute(opts, cb);
};

function execute(env, cb) {
  // ...
  var clu = cluster.fork(env);
  // ...
  God.clusters_db[id] = clu;
  
  clu.once('online', function() {
    God.clusters_db[id].status = 'online';
    if (cb) return cb(null, clu);
    return true;
  });
  return clu;
}

七、总结

本文从 cluster 的基本使用、事件，到 cluster 的基本实现原理，再到  pm2 如何基于 cluster 进行进程管理，带你从入门到深入原理以及了解其高阶应用，希望对你有帮助。

更多node相关知识，请访问：nodejs 教程！！

Das obige ist der detaillierte Inhalt vonBringen Sie Ihnen Schritt für Schritt bei, wie Sie Cluster in Node verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!