Cluster vs reverse proxy decision in Node.js - Hands-On Comparison

Cluster vs Reverse Proxy Decision in Node.js

📖 Scenario: You are building a simple Node.js web server that needs to handle multiple requests efficiently. You want to learn how to use Node.js cluster module to create worker processes and also understand how a reverse proxy like Nginx can help distribute requests.

🎯 Goal: Build a Node.js server that uses the cluster module to create worker processes. Then add a configuration variable to simulate a reverse proxy setup decision. Finally, implement logic to start the server differently based on whether clustering or reverse proxy is chosen.

📋 What You'll Learn

Create a basic HTTP server using Node.js

Use the cluster module to create worker processes

Add a configuration variable to choose between cluster mode or reverse proxy mode

Implement conditional logic to start the server based on the chosen mode

💡 Why This Matters

🌍 Real World

Node.js servers often need to handle many requests efficiently. Using clustering allows the server to use multiple CPU cores. Reverse proxies like Nginx can also distribute requests to multiple server instances.

💼 Career

Understanding clustering and reverse proxy setups is important for backend developers to build scalable and reliable web applications.

1

Create a basic HTTP server

Create a variable called http that requires the http module. Then create a server using http.createServer that responds with 'Hello from worker' for every request. Assign the server to a variable called server.

Node.js

const http = require('http');
// Your code here

Hint

Use require('http') to import the HTTP module. Then use http.createServer with a callback that sends a plain text response.

2

Add a configuration variable for mode selection

Add a constant called useCluster and set it to true. This variable will decide if the server runs in cluster mode or reverse proxy mode.

Node.js

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from worker');
});

// Your code here

Hint

Declare a constant named useCluster and assign it the boolean value true.

3

Implement cluster logic to create workers

Require the cluster and os modules as cluster and os. Then write an if statement that checks if useCluster is true and cluster.isMaster is true. Inside it, create worker processes equal to the number of CPU cores using os.cpus().length. Otherwise, start the server listening on port 3000.

Node.js

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from worker');
});

const useCluster = true;

// Your code here

Hint

Use cluster.isMaster to check if the current process is the master. Use os.cpus().length to get CPU count. Fork workers in a loop. Start server in the else block.

4

Add reverse proxy mode handling

Modify the if condition to check if useCluster is false. In that case, start the server listening on port 3000 directly. This simulates running behind a reverse proxy where clustering is handled externally.

Node.js

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

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello from worker');
});

const useCluster = true;

// Your code here

Hint

Add an else if block to check when useCluster is false and start the server. This simulates reverse proxy mode.

Practice

1. What is the main purpose of using a cluster in a Node.js application?

easy

A. To forward HTTP requests to different servers

B. To use multiple CPU cores by creating worker processes

C. To add security features like SSL termination

D. To cache static files for faster delivery

Solution

1. Step 1: Understand what a cluster does in Node.js

   A cluster creates multiple worker processes to use all CPU cores efficiently.

2. Step 2: Compare with other options

   Forwarding requests and adding security are tasks of a reverse proxy, not a cluster.

3. Final Answer:

   To use multiple CPU cores by creating worker processes -> Option B

4. Quick Check:

   Cluster = multiple CPU cores [OK]

Hint: Clusters = multiple CPU cores, reverse proxy = request forwarding [OK]

Common Mistakes:

• Confusing cluster with reverse proxy functions
• Thinking clusters handle security features
• Assuming clusters cache files

2. Which of the following is the correct way to create a cluster in Node.js?

easy

A. const cluster = require('cluster'); cluster.fork();

B. const proxy = require('proxy'); proxy.create();

C. const http = require('http'); http.listenCluster();

D. const cluster = require('cluster'); cluster.createServer();

Solution

1. Step 1: Recall Node.js cluster module usage

   The cluster module is required with require('cluster') and workers are created with cluster.fork().

2. Step 2: Check other options for correctness

   There is no proxy module by default, http.listenCluster() and cluster.createServer() are invalid methods.

3. Final Answer:

   const cluster = require('cluster'); cluster.fork(); -> Option A

4. Quick Check:

   cluster.fork() creates workers [OK]

Hint: Use cluster.fork() to create workers in Node.js [OK]

Common Mistakes:

• Using non-existent methods like cluster.createServer()
• Confusing proxy module with cluster
• Trying to call listenCluster() on http

3. Given this setup: a Node.js app uses a cluster with 4 workers and a reverse proxy in front. What is the main benefit of this combination?

medium

A. The cluster manages security, and the reverse proxy manages CPU usage

B. The cluster handles SSL termination, and the reverse proxy creates workers

C. The reverse proxy caches data, and the cluster forwards requests

D. The reverse proxy balances traffic, and the cluster uses all CPU cores

Solution

1. Step 1: Understand roles of cluster and reverse proxy

   The cluster allows Node.js to use multiple CPU cores by creating workers. The reverse proxy balances incoming traffic among servers.

2. Step 2: Eliminate incorrect roles

   SSL termination and security are usually handled by reverse proxies, not clusters. Clusters do not forward requests or cache data.

3. Final Answer:

   The reverse proxy balances traffic, and the cluster uses all CPU cores -> Option D

4. Quick Check:

   Cluster = CPU cores, Reverse proxy = traffic balance [OK]

Hint: Cluster for CPU, reverse proxy for traffic control [OK]

Common Mistakes:

• Swapping roles of cluster and reverse proxy
• Thinking cluster handles SSL or security
• Assuming reverse proxy creates workers

4. You wrote this code snippet to create a cluster but it crashes immediately:

const cluster = require('cluster');
cluster.fork();
require('http').createServer((req, res) => res.end('Hello')).listen(3000);

What is the likely cause?

medium

A. The worker process does not listen on a port

B. Missing a callback function in cluster.fork()

C. Not checking cluster.isMaster before forking

D. No error handling for server creation

Solution

1. Step 1: Analyze cluster usage

   The code calls cluster.fork() without checking if (cluster.isMaster). Both master and worker processes fork additional processes and attempt to bind to port 3000, causing port conflicts (EADDRINUSE) and crashes.

2. Step 2: Identify the problem

   The missing if (cluster.isMaster) check before forking leads to repeated forking and server creation attempts, causing the crash.

3. Final Answer:

   Not checking cluster.isMaster before forking -> Option C

4. Quick Check:

   Check cluster.isMaster before fork [OK]

Hint: Always check cluster.isMaster before forking [OK]

Common Mistakes:

• Calling cluster.fork() without isMaster check
• Assuming fork needs a callback
• Ignoring server listen port

5. You want to improve your Node.js app's performance and reliability. You decide to use both a cluster and a reverse proxy. Which setup best achieves this goal?

hard

A. Use a cluster to run multiple workers on all CPU cores, and a reverse proxy to distribute incoming requests and handle SSL

B. Use a reverse proxy to create worker processes, and a cluster to forward requests to other servers

C. Use a cluster to cache static files, and a reverse proxy to manage CPU usage

D. Use a reverse proxy to run multiple Node.js instances, and a cluster to balance traffic

Solution

1. Step 1: Identify cluster's role in performance

   Clusters run multiple worker processes to use all CPU cores, improving performance and reliability.

2. Step 2: Identify reverse proxy's role in traffic and security

   Reverse proxies distribute incoming requests, handle SSL termination, and add security features.

3. Step 3: Evaluate options

   Only Use a cluster to run multiple workers on all CPU cores, and a reverse proxy to distribute incoming requests and handle SSL correctly assigns cluster to CPU usage and reverse proxy to traffic distribution and SSL.

4. Final Answer:

   Use a cluster to run multiple workers on all CPU cores, and a reverse proxy to distribute incoming requests and handle SSL -> Option A

5. Quick Check:

   Cluster = CPU workers, Reverse proxy = traffic & SSL [OK]

Hint: Cluster for CPU workers, reverse proxy for traffic & SSL [OK]

Common Mistakes:

• Assigning reverse proxy to create workers
• Confusing caching with cluster role
• Swapping roles of cluster and reverse proxy