Ajar anda langkah demi langkah cara menggunakan kluster dalam Node

Artikel ini akan membawa anda untuk mengetahui lebih lanjut tentang kluster dalam Node.js dan memperkenalkan acara kluster saya harap ia akan membantu semua orang.

1 Pengenalan

Nod Dalam v0.8, modul kluster telah diperkenalkan secara langsung kepada Ia. menyelesaikan masalah penggunaan CPU berbilang teras dan juga menyediakan API yang agak lengkap untuk menangani keteguhan proses.

Modul kluster memanggil kaedah fork untuk mencipta proses anak, iaitu kaedah yang sama seperti fork dalam child_process. Modul kluster menggunakan model induk-hamba klasik Kluster akan mencipta induk dan kemudian menyalin berbilang proses anak mengikut nombor yang anda tentukan. Anda boleh menggunakan sifat kluster.isMaster untuk menentukan sama ada proses semasa ialah induk atau pekerja (proses pekerja). Proses induk menguruskan semua sub-proses Proses induk tidak bertanggungjawab untuk pemprosesan tugas tertentu.

Modul kelompok menggunakan pengimbangan beban terbina dalam untuk mengendalikan tekanan antara benang dengan lebih baik Pengimbangan beban menggunakan algoritma Round-robin (juga dikenali sebagai algoritma round-robin). Apabila menggunakan strategi penjadualan Round-robin, induk menerima() semua permintaan sambungan masuk dan kemudian menghantar pemprosesan permintaan TCP yang sepadan kepada proses pekerja yang dipilih (kaedah ini masih berkomunikasi melalui IPC). Contoh penggunaan rasmi adalah seperti berikut

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`);
}

Malah, modul kluster digunakan oleh gabungan modul child_process dan net Apabila kluster bermula, pelayan TCP akan dimulakan secara dalaman. proses anak fork(), pelayan TCP akan dimulakan secara dalaman Deskriptor fail soket bahagian pelayan TCP ini dihantar ke proses pekerja. Jika proses pekerja disalin melalui cluster.fork(), maka NODE_UNIQUE_ID wujud dalam pembolehubah persekitarannya Jika terdapat panggilan listen() untuk mendengar port rangkaian dalam proses pekerja, ia akan mendapat deskriptor fail dan lulus SO_REUSEADDR. port. Guna semula, dengan itu membolehkan berbilang proses kanak-kanak untuk berkongsi port.

2. Acara Kluster

• garpu: Acara ini dicetuskan selepas menyalin proses pekerja; 🎜 >dalam talian: Selepas menyalin proses kerja, proses kerja secara aktif menghantar mesej dalam talian ke proses utama Selepas proses utama menerima mesej, acara dicetuskan; dipanggil dalam proses kerja Selepas mendengar() (Soket bahagian pelayan dikongsi), mesej mendengar dihantar ke proses utama Selepas proses utama menerima mesej, acara dicetuskan; >

  putus sambungan: proses utama dan proses pekerja Peristiwa ini akan dicetuskan apabila saluran IPC diputuskan sambungannya; >

• persediaan: Peristiwa ini dicetuskan selepas cluster.setupMaster() dilaksanakan; , dan dikapsulkan berdasarkan penghantaran mesej antara proses.

• 3. Komunikasi antara tuan dan pekerja

• Seperti yang dapat dilihat daripada di atas, proses induk mencipta proses pekerja melalui cluster.fork(In hakikatnya, cluster.fork( ) secara dalaman mencipta proses anak melalui child_process.fork(). Maksudnya: proses induk dan pekerja adalah proses ibu bapa dan anak; mereka berkomunikasi melalui saluran IPC sama seperti proses ibu bapa-anak yang dicipta oleh child_process.
  Nama penuh IPC ialah Komunikasi Antara Proses, iaitu komunikasi antara proses Tujuan komunikasi antara proses adalah untuk membolehkan proses yang berbeza mengakses sumber dan menyelaraskan kerja antara satu sama lain. Saluran IPC dalam Node dilaksanakan oleh teknologi paip Pelaksanaan khusus disediakan oleh libuv Ia dilaksanakan oleh paip bernama di bawah sistem Windows. Komunikasi antara proses yang dilaksanakan pada lapisan aplikasi hanya mempunyai acara mesej dan kaedah penghantaran yang mudah, yang sangat mudah digunakan.
Proses induk akan mencipta saluran IPC dan mendengarnya sebelum benar-benar mencipta proses kanak-kanak, dan kemudian sebenarnya mencipta proses kanak-kanak dan memberitahu proses kanak-kanak melalui pembolehubah persekitaran (NODE_CHANNEL_FD) Deskriptor fail untuk saluran IPC ini. Semasa proses permulaan, proses anak bersambung ke saluran IPC sedia ada mengikut deskriptor fail, dengan itu melengkapkan sambungan antara proses ibu bapa dan anak.

Selepas sambungan diwujudkan, proses ibu bapa dan anak boleh berkomunikasi dengan bebas. Oleh kerana saluran IPC dicipta menggunakan Paip Dinamakan atau Soket Domain, ia berkelakuan serupa dengan soket rangkaian dan merupakan komunikasi dua hala. Perbezaannya ialah mereka melengkapkan komunikasi antara proses dalam kernel sistem tanpa melalui lapisan rangkaian sebenar, yang sangat cekap. Dalam Node, saluran IPC diabstraksikan sebagai objek Stream Apabila hantar dipanggil, data dihantar (serupa dengan write ), dan mesej yang diterima dicetuskan ke lapisan aplikasi melalui peristiwa mesej (serupa dengan data ).

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 教程！！

Atas ialah kandungan terperinci Ajar anda langkah demi langkah cara menggunakan kluster dalam Node. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!