Node.js es conocido por su velocidad y eficiencia, lo que lo convierte en una opción popular para crear aplicaciones escalables y de alto rendimiento.
Sin embargo, listo para usar, Node.js tiene un solo subproceso, lo que significa que se ejecuta en un solo núcleo de CPU, lo que puede resultar limitante en entornos de servidores de múltiples núcleos. Si su aplicación consume muchos recursos o espera mucho tráfico, querrá maximizar el uso de los núcleos de CPU de su servidor.
Ahí es donde entra en juego la agrupación en clústeres de Node.js.

En esta publicación, profundizaremos en qué es la agrupación en clústeres de Node.js, por qué es importante y cómo puede utilizarla para aumentar el rendimiento de sus aplicaciones.

¿Qué es la agrupación en clústeres de Node.js?

La agrupación en clústeres de Node.js es una técnica que le permite utilizar todos los núcleos de la CPU generando múltiples instancias (trabajadores) de su aplicación Node.js.
Estos trabajadores comparten el mismo puerto y son gestionados por un proceso maestro. Cada trabajador puede manejar las solicitudes entrantes de forma independiente, lo que permite que su aplicación distribuya la carga de trabajo y procese las solicitudes en paralelo.

Al agrupar su aplicación Node.js, puede:

• Utilizar múltiples núcleos de CPU
• Mejorar el rendimiento de la aplicación
• Proporcionar tolerancia a fallas en caso de que un trabajador falle
• Escale horizontalmente sin complicar demasiado el código base

¿Cómo funciona la agrupación en clústeres?

En un clúster de Node.js, hay un proceso maestro que controla varios procesos trabajadores.
El proceso maestro no maneja las solicitudes HTTP directamente, pero administra los trabajadores que sí lo hacen. Las solicitudes de los clientes se distribuyen entre estos trabajadores, equilibrando la carga de manera eficiente.

Si un proceso de trabajo falla por algún motivo, el proceso maestro puede generar uno nuevo, lo que garantiza un tiempo de inactividad mínimo.

¿Cuándo debería utilizar la agrupación en clústeres?

La agrupación en clústeres es particularmente útil cuando su aplicación:

• Experimenta mucho tráfico y necesita manejar numerosas solicitudes simultáneas
• Realiza tareas vinculadas a la CPU, como codificación de vídeo, procesamiento de imágenes o análisis de datos a gran escala.
• Se ejecuta en procesadores multinúcleo que no se utilizan por completo Si su aplicación pasa mucho tiempo esperando operaciones de E/S, como consultas de bases de datos o llamadas API, es posible que la agrupación en clústeres no mejore significativamente el rendimiento.

En los casos anteriores, puedes mejorar el rendimiento utilizando técnicas de programación asincrónica.

Cómo implementar la agrupación en clústeres en Node.js

Node.js proporciona un módulo de clúster integrado para crear clústeres fácilmente. Veamos un ejemplo sencillo de cómo agrupar su aplicación Node.js.

Paso 1: Configurar tu aplicación
Antes de agregar la agrupación en clústeres, supongamos que tiene un servidor HTTP simple (server.js):

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log(`Worker process ID: ${process.pid} is listening on port 3000`);
});

Esta aplicación se ejecuta en un solo núcleo. Modifiquémoslo para usar agrupación.

Paso 2: Uso del módulo de clúster
El módulo de clúster nos permite bifurcar el proceso actual en múltiples procesos de trabajo. A continuación se explica cómo implementar la agrupación en clústeres:

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

// Get the number of CPU cores
const numCPUs = os.cpus().length;

if (cluster.isMaster) {
  console.log(`Master process ID: ${process.pid}`);

  // Fork workers for each CPU core
  for (let i = 0; i  {
    console.log(`Worker ${worker.process.pid} died. Spawning a new one...`);
    cluster.fork();
  });
} else {
  // Workers share the same TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker '   process.pid   '\n');
  }).listen(3000);

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

Explicación:
1. Proceso Maestro: Cuando comienza el proceso, verifica si es el proceso maestro (cluster.isMaster). El maestro es responsable de bifurcar los procesos de trabajo, uno para cada núcleo de CPU. El método os.cpus() se utiliza para recuperar la cantidad de núcleos de CPU disponibles.

2. Procesos de trabajo: Para cada núcleo de CPU, se bifurca un nuevo trabajador (cluster.fork()). Estos procesos de trabajo ejecutan el servidor HTTP y manejan las solicitudes entrantes.

3. Tolerancia a fallos: Si un proceso de trabajo falla, se activa el evento cluster.on('exit') y se genera un nuevo trabajador para reemplazar al inactivo.

Paso 3: Prueba de tu aplicación agrupada
Ahora, si ejecuta la aplicación:

node server.js

Notarás que se crean varios trabajadores, cada uno con un ID de proceso único. Cada solicitud es manejada por un trabajador diferente, lo que equilibra efectivamente la carga.

Puedes probar cómo la agrupación en clústeres mejora el rendimiento de tu aplicación enviando múltiples solicitudes y observando cómo se distribuye la carga de trabajo entre los trabajadores.

Por lo tanto, la próxima vez que crees una aplicación Node.js de alto rendimiento, ¡recuerda considerar la posibilidad de crear clústeres!

¡Eso es todo por este blog! ¡Estén atentos para más actualizaciones y sigan creando aplicaciones increíbles! ?✨
¡Feliz codificación! ?