Load balancing between workers in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does Node.js cluster module distribute incoming connections by default?

Consider a Node.js server using the cluster module with multiple worker processes. How are incoming connections distributed among workers by default?

A The master process distributes connections in a round-robin fashion to workers.

B Each worker listens on the same port and the OS distributes connections in a round-robin fashion.

C The master process sends all connections to the first worker until it is busy, then moves to the next.

D Workers compete to accept connections and the fastest worker gets the connection.

💡 Hint

Think about how the cluster module balances load to avoid overloading a single worker.

By default, Node.js cluster module uses a round-robin approach in the master process to distribute incoming connections among workers.

📝 Syntax

intermediate

Identify the correct way to create a worker in Node.js cluster

Which code snippet correctly creates a worker process using Node.js cluster module?

Node.js

const cluster = require('cluster');
if (cluster.isMaster) {
  // create worker
}

A cluster.newWorker();

B cluster.createWorker();

C cluster.fork();

D cluster.spawn();

💡 Hint

Check the official cluster module API for the method to create a worker.

The correct method to create a worker is cluster.fork(). Other methods do not exist in the cluster API.

🔧 Debug

advanced

Why does this cluster setup cause uneven load distribution?

Given the code below, why might the load not be balanced evenly across workers? const cluster = require('cluster'); const http = require('http'); if (cluster.isMaster) { for (let i = 0; i < 4; i++) { cluster.fork(); } } else { http.createServer((req, res) => { // simulate heavy work const start = Date.now(); while (Date.now() - start < 100) {} res.end('done'); }).listen(8000); }

A Workers handle requests independently, but the OS assigns connections randomly, causing uneven load.

B The blocking while loop in workers causes some workers to be busy longer, leading to uneven load.

C The master process does not distribute connections; workers compete causing uneven load.

D The cluster.fork() method is called incorrectly, so only one worker handles all requests.

💡 Hint

Consider how blocking code affects worker availability and load distribution.

The blocking while loop in each worker delays response handling, causing some workers to be busy longer. This leads to uneven load because requests queue up on busy workers.

❓ state_output

advanced

What is the output of this cluster worker count code?

What will be printed when running this code? const cluster = require('cluster'); if (cluster.isMaster) { cluster.fork(); cluster.fork(); console.log(Object.keys(cluster.workers).length); } else { console.log('worker running'); }

A worker running

B 0

C undefined

D 2

💡 Hint

Remember that cluster.workers is an object with worker IDs as keys.

The master process forks two workers, so cluster.workers has two keys. The length of these keys is 2.

🧠 Conceptual

expert

Why might you choose a custom load balancing strategy over Node.js default cluster behavior?

Which reason best explains why a developer might implement a custom load balancing strategy instead of relying on Node.js cluster's default round-robin distribution?

A To optimize resource usage by directing requests based on worker CPU load or memory usage.

B Because the default cluster module does not support multiple workers.

C To avoid using the cluster module entirely and handle all requests in a single process.

D Because the default cluster module only works on Windows systems.

💡 Hint

Think about real-world scenarios where some workers might be busier or slower than others.

Custom load balancing can improve performance by sending requests to the least busy workers, optimizing CPU and memory usage beyond simple round-robin.