Node.js clustering and load balancing

What is clustering in node.js?

Node.js runs on a single thread, which means it can only use one CPU core by default. Clustering allows you to spawn multiple instances of your application, each running on its own CPU core. These instances, or “workers,” can handle requests in parallel, significantly improving throughput and availability.

How does clustering work?

Node.js provides a built-in cluster module. A master process manages several worker processes, each with its own event loop. When a request comes in, it’s distributed among the workers.

Basic clustering example

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

if (cluster.isPrimary) {
  const numCPUs = os.cpus().length;
  console.log(`Master ${process.pid} is running`);

  // Fork workers.
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // Optional: Restart worker on exit
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.process.pid} died. Restarting...`);
    cluster.fork();
  });
} else {
  http.createServer((req, res) => {
    res.end(`Handled by worker ${process.pid}`);
  }).listen(3000);

  console.log(`Worker ${process.pid} started`);
}

Why use clustering?

Load balancing concepts

Clustering distributes load within a single machine, but to handle higher traffic or redundancy, you may need external load balancing:

Common load balancing methods:

• Round-robin: Requests are distributed evenly across instances
• Least connections: Directs traffic to the server with the fewest active connections
• Sticky sessions: Ensures a user stays connected to the same worker or server

Load balancing tools:

• Nginx or HAProxy: Can sit in front of clustered Node.js servers
• PM2: A Node.js process manager that supports clustering and load balancing
• Cloud load balancers: Offered by AWS, GCP, Azure, etc.

Combining clustering with load balancing

You can combine both strategies for maximum performance:

• Use Node.js clustering to utilize all cores of each server
• Use a reverse proxy like Nginx to distribute load across multiple servers

Best practices

• Always monitor worker health and restart on failure
• Share minimal state between workers (use external storage like Redis if needed)
• Use sticky sessions if your app relies on session-based auth
• Avoid memory leaks — they’ll affect all workers over time
• Test under load to determine ideal number of workers

Conclusion

Clustering and load balancing are essential for scaling Node.js applications effectively. By leveraging multiple CPU cores and distributing traffic smartly, you can handle more users, increase resilience, and build faster, more reliable backends.