Node.Js on Multi-core Machines

Node.js on multi-core machines

Node.js is a popular runtime environment for executing JavaScript code on the server-side. It is known for its event-driven, non-blocking I/O model, which makes it highly efficient for handling concurrent requests. However, by default, Node.js runs on a single thread, which means it cannot fully utilize the processing power of multi-core machines.

In this blog post, we will explore different approaches to leverage the power of multi-core machines when running Node.js applications.

1. Using the Cluster module

The Cluster module is a built-in module in Node.js that allows you to create child processes (workers) to handle incoming requests. Each worker runs in a separate thread and can utilize a separate CPU core, enabling parallel processing.

Here’s an example of how to use the Cluster module:

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numWorkers = os.cpus().length;

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

  for (let i = 0; i < numWorkers; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  // Your server code here
}

This code creates a cluster of worker processes, where each worker runs on a separate CPU core. If a worker dies, the cluster module automatically creates a new one to maintain the desired number of workers.

2. Using the PM2 process manager

PM2 is a popular process manager for Node.js applications. It provides an easy way to manage and scale your Node.js processes across multiple cores.

To use PM2, you need to install it globally:

$ npm install -g pm2

Once installed, you can start your Node.js application using PM2:

$ pm2 start app.js -i max

The -i max flag tells PM2 to create as many instances of your application as there are CPU cores available.

3. Using a reverse proxy

Another approach to utilize multi-core machines is to use a reverse proxy, such as Nginx or HAProxy, in front of your Node.js application. The reverse proxy can distribute incoming requests across multiple instances of your application running on different ports or machines.

Here’s an example Nginx configuration:

http {
  upstream app {
    server 127.0.0.1:3000;
    server 127.0.0.1:3001;
    server 127.0.0.1:3002;
    server 127.0.0.1:3003;
  }

  server {
    listen 80;

    location / {
      proxy_pass http://app;
    }
  }
}

This configuration defines an upstream block with multiple server entries, each pointing to a different instance of your Node.js application. Nginx will distribute incoming requests across these instances, effectively utilizing the available CPU cores.

These are three different approaches to leverage the power of multi-core machines when running Node.js applications. Choose the one that best suits your needs and hardware setup.

Happy coding!

Node.Js on Multi-core Machines