PM2 makes Node.js clustering easier to implement

This article mainly introduces in detail how to use PM2 to make Node.js clustering easier. The editor thinks it is quite good, so I will share it with you now and give it as a reference. Let’s follow the editor to take a look, I hope it can help everyone.

Introduction

As we all know, Node.js runs on Chrome's JavaScript runtime platform, which we elegantly call the V8 engine. Both the V8 engine and later Node.js run in a single-threaded manner, so they cannot maximize their performance in multi-core processor systems.

Node.js cluster module

Fortunately, Node.js provides us with the cluster module, which can generate multiple worker threads to share the same TCP connect.

How does it work?

First, Cluster will create a master, and then replicate multiple server apps (also called worker threads) according to the number you specify. It communicates with worker threads through IPC channels and uses built-in load balancing to better handle the pressure between threads. The load balancing uses the Round-robin algorithm (also known as the round-robin algorithm).

When using the Round-robin scheduling strategy, the master accepts() all incoming connection requests, and then sends the corresponding TCP request processing to the selected worker thread (this method still communicates through IPC).

How to use it?

The following is a basic example:

var cluster = require('cluster'); 
var http  = require('http'); 
var os   = require('os');

var numCPUs = os.cpus().length;

if (cluster.isMaster) { 
 // Master:
 // Let's fork as many workers as you have CPU cores

 for (var i = 0; i < numCPUs; ++i) {
  cluster.fork();
 }
} else {
 // Worker:
 // Let&#39;s spawn a HTTP server
 // (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");
 }).listen(8080);
}

Of course, you can specify any number of worker threads, and the number of threads is not limited to the number of CPU cores. , because it only runs as a sub-thread on the CPU.

As you can see, to make it work properly, you need to encapsulate your code into the cluster's processing logic and add some additional code to specify what to do when a thread hangs. .

How to use PM2

The built-in cluster

PM2 contains all the above processing logic internally, so you don’t have to make any modifications to the code. We restore the above code to its original form:

var http = require('http');

http.createServer(function(req, res) { 
 res.writeHead(200);
 res.end("hello world");
}).listen(8080);

and then execute it on the console:

$ pm2 start app.js -i 4

The -i parameter is used to tell PM2 to run your app in cluster_mode (correspondingly called fork_mode). The following number indicates the number of worker threads to be started. If the given number is 0, PM2 will generate corresponding worker threads based on the number of your CPU cores.

Keep your apps running no matter what the situation

If any worker thread hangs up, don’t worry, PM2 will restart it immediately . Of course, you can also manually restart these threads at any time:

Real-time expansion of the cluster

At any time, if you need to increase the number of worker threads, The cluster can be expanded through pm2 scale . The parameter specifies the number of worker threads and is used to increase or decrease the number of clusters. You can also specify how many worker threads to add through pm2 scale app +3.

Achieving zero-downtime updates in a production environment

PM2’s reload function will restart all worker threads in sequence. Each thread will wait for a new thread to be created before being terminated, so when you deploy new code in a production environment, the server will keep running without interruption.

Using the gracefulReload function can achieve the same purpose. The difference is that it will not terminate the worker thread immediately. Instead, it will send a shutdown signal through IPC to close all current connections and handle some custom tasks, and then Exit gracefully. For example, the following code:

process.on('message', function(msg) { 
 if (msg === 'shutdown') {
  close_all_connections();
  delete_cache();
  server.close();
  process.exit(0);
 }
});

Configure PM2 to start automatically

If you want PM2 to automatically run the previous application after the server restarts, you can first use pm2 start to start your application, and then execute the following command:

pm2 save

This will generate a dump.pm2 file in the ~/.pm2 directory, which describes the current PM2 All applications running. Then execute the command:

pm2 startup [platform]

Note that it is necessary to add the optional parameter platform to clearly inform pm2 of the current system environment. In this way, when the server restarts next time, PM2 will automatically run the previously saved application.

Conclusion

The Cluster module is very powerful and using PM2 will make it easier. In the Node 0.10.x era, cluster.js was still an experimental product, but starting from Node 0.11.x, it has gradually matured and begun to prepare for official release, including Node 0.12.x version. It is highly recommended to use the latest versions of Node.js and PM2, the contributors to these products are constantly working hard to make them better.

related suggestion:

Analysis on Redis cluster failure

Redis cluster construction graphic tutorial

redis cluster construction tutorial and problems encountered Problem handling

The above is the detailed content of PM2 makes Node.js clustering easier to implement. For more information, please follow other related articles on the PHP Chinese website!