Clusters and Scaling

Node.js runs in a single thread. To take full advantage of modern multi-core systems, you must use the Cluster module to run multiple instances of your application simultaneously.

1. The Analogy: The Bank Service Windows

Imagine a Bank with 8 service windows (CPU Cores), but only one teller (Node.js Process) working.

• No matter how fast the teller is, they can only help one customer at a time.
• If a line of 100 people arrives, the wait time is massive.
• Scaling with Clusters: You hire 7 more tellers. Now, 8 customers can be helped at the exact same time. The "Bank Manager" (Primary Process) stands at the door and directs each customer to an available window.

2. Coding Example: Implementing a Cluster

A Simple Scalable Server

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
 
if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);
 
  // Fork workers for each CPU core
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
 
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died. Restarting...`);
    cluster.fork(); // Resilience: Always keep a teller at the window!
  });
} else {
  // Workers can share any TCP connection
  // In this case it is an HTTP server
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from the cluster!\n');
  }).listen(8000);
 
  console.log(`Worker ${process.pid} started`);
}

3. Why it matters in Coding

1. Throughput: Your server can handle significantly more requests per second by utilizing all available CPU hardware.
2. Zero-Downtime Updates: You can restart workers one by one, ensuring your app stays online during a deployment.
3. Resilience: If one worker process crashes due to a bug, the other workers stay alive, and the master process can immediately start a new one.

Real-Life Coding Scenario: The CPU-Intensive API

Imagine an API that generates PDF reports. This is a "heavy" task. Without clusters, one user generating a 50-page PDF would block every other user from even logging in. With clusters, the "Heavy" task stays on one core, while the other cores keep the rest of the site snappy.

Summary

Clusters allow your "Single-Threaded" Node.js app to behave like a massive, multi-threaded powerhouse!