Node.js es un entorno de tiempo de ejecución de JavaScript del lado del servidor que se utiliza para crear aplicaciones web escalables y de alta velocidad. La escalabilidad es un factor crítico para cualquier aplicación web que pretenda manejar grandes volúmenes de tráfico. Una de las formas más populares de escalar aplicaciones Node.js es mediante el uso de clustering.
El clustering es una técnica que implica la creación de múltiples procesos Node.js que trabajan juntos para manejar la carga de la aplicación. Esto significa que cada solicitud que llega a la aplicación se distribuye en diferentes procesos para que puedan procesarse simultáneamente. También ayuda a garantizar que la aplicación sea tolerante a fallos y que siga funcionando incluso si uno de los procesos falla.
En este manual, se explicará cómo configurar el clustering y cómo escalar su aplicación Node.js con él.
Antes de comenzar, asegúrate de tener Node.js instalado en tu sistema. Puedes descargarlo desde el sitio web oficial de Node.js e instalarlo en tu sistema.
Crea un archivo de aplicación Node.js que escuche las solicitudes de los clientes. Este archivo será el punto de entrada para tu aplicación.
const http = require('http');
const server = http.createServer((req, res) => {
res.end('Hello World!');
});
server.listen(3000);
Este es un ejemplo de una aplicación básica de Node.js que funciona en modo clúster:
// app.js
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`Master process ID: ${process.pid}`);
// Fork workers
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
// Handle worker exit and restart
cluster.on('exit', (worker, code, signal) => {
console.log(`Worker process ID ${worker.process.pid} died`);
console.log('Forking a new worker...');
cluster.fork();
});
} else {
// Worker processes will enter this block
// Create a simple HTTP server
http.createServer((req, res) => {
res.writeHead(200);
res.end('Hello, world!\n');
}).listen(3000);
console.log(`Worker process ID ${process.pid} started`);
}
En este ejemplo, el proceso maestro es responsable de bifurcar los procesos de trabajo, mientras que los procesos de trabajo crean un servidor HTTP y manejan las solicitudes entrantes. Cada proceso de trabajo escucha en el mismo puerto (3000 en este caso), lo que les permite compartir el tráfico entrante.
Vamos a repasar cada parte del código y explicar su propósito:
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`ID del proceso maestro: ${process.pid}`);
// Crear procesos trabajadores
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
// Manejar la salida y reinicio de los procesos trabajadores
cluster.on('exit', (worker, code, signal) => {
console.log(`El proceso trabajador con ID ${worker.process.pid} ha finalizado`);
console.log('Creando un nuevo proceso trabajador...');
cluster.fork();
});
} else {
// Los procesos trabajadores entrarán en este bloque
// Crear un servidor HTTP básico
http.createServer((req, res) => {
res.writeHead(200);
res.end('¡Hola, mundo!\n');
}).listen(3000);
console.log(`El proceso trabajador con ID ${process.pid} ha comenzado`);
}
Con esta configuración, el proceso maestro se encarga de gestionar los procesos workers. Los crea en base al número de núcleos de CPU disponibles y reinicia cualquier proceso worker que finalice. Los procesos workers manejan las solicitudes HTTP entrantes y les responden. Al distribuir la carga entre los procesos workers, la aplicación puede manejar más solicitudes concurrentes y mejorar el rendimiento.
Siéntete libre de modificar el código según tus requisitos y lógica de la aplicación.
Guarda el código anterior en un archivo llamado app.js.
Abre la terminal y navega hasta el directorio que contiene app.js.
Inicia la aplicación usando el comando node:
$ node app.js
Prueba la aplicación abriendo un navegador web y escribiendo la dirección IP del servidor y el puerto en el que se está ejecutando la aplicación.
http://localhost:3000
El clustering es una técnica popular para escalar aplicaciones Node.js. Este manual ha demostrado cómo configurar y utilizar el clustering para distribuir la carga de la aplicación en múltiples procesos secundarios. Al seguir estos pasos, podrás escalar tu aplicación Node.js y hacerla más resistente a fallos.