Node.js és un entorn de temps d'execució de JavaScript del costat del servidor que s'utilitza per crear aplicacions web escalables i d'alta velocitat. L'escalabilitat és un factor crític per a qualsevol aplicació web que pretengui manejar grans volums de trànsit. Una de les maneres més populars d'escalar aplicacions Node.js és mitjançant l'ús de clustering.
El clustering és una tècnica que implica la creació de múltiples processos Node.js que treballen junts per manejar la càrrega de l'aplicació. Això significa que cada sol·licitud que arriba a l'aplicació es distribueix en diferents processos perquè es puguin processar simultàniament. També ajuda a garantir que l'aplicació sigui tolerant a fallades i que segueixi funcionant fins i tot si un dels processos falla.
En aquest manual, s'explicarà com configurar el clúster i com escalar la seva aplicació Node.js amb ell.
Abans de començar, assegura't de tenir Node.js instal·lat al teu sistema. Pots descarregar-lo des del lloc web oficial de Node.js i instal·lar-lo al teu sistema.
Crea un fitxer d'aplicació Node.js que escolti les sol·licituds dels clients. Aquest fitxer serà el punt d'entrada per a la teva aplicació.
const http = require('http');
const server = http.createServer((req, res) => {
res.end('Hello World!');
});
server.listen(3000);
Aquest és un exemple d'una aplicació bàsica de Node.js que funciona en mode de 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 aquest exemple, el procés mestre és responsable de bifurcar els processos de treball, mentre que els processos de treball creen un servidor HTTP i manegen les sol·licituds entrants. Cada procés de treball escolta al mateix port (3000 en aquest cas), cosa que els permet compartir el trànsit entrant.
Repassarem cada part del codi i explicarem el seu propòsit:
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
console.log(`ID del procés mestre: ${process.pid}`);
// Crear processos treballadors
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
// Manejar la sortida i reinici dels processos treballadors
cluster.on('exit', (worker, code, signal) => {
console.log(`El procés treballador amb ID ${worker.process.pid} ha finalitzat`);
console.log('Creant un nou procés treballador...');
cluster.fork();
});
} else {
// Els processos treballadors entraran en aquest bloc
// Crear un servidor HTTP bàsic
http.createServer((req, res) => {
res.writeHead(200);
res.end('Hola, món!\n');
}).listen(3000);
console.log(`El procés treballador amb ID ${process.pid} ha començat`);
}
Amb aquesta configuració, el procés mestre s'encarrega de gestionar els processos workers. Els crea segons el nombre de nuclis de CPU disponibles i reinicia qualsevol procés worker que finalitzi. Els processos workers manegen les sol·licituds HTTP entrants i els responen. En distribuir la càrrega entre els processos workers, l'aplicació pot gestionar més sol·licituds concurrents i millorar-ne el rendiment.
Sigues lliure de modificar el codi segons els teus requisits i lògica de l'aplicació.
Guarda el codi anterior en un fitxer anomenat app.js.
Obre la terminal i navega fins al directori que conté app.js.
Inicia l'aplicació fent l'ordre node:
$ node app.js
Prova l'aplicació obrint un navegador web i escrivint l'adreça IP del servidor i el port on s'està executant l'aplicació.
http://localhost:3000
El clustering és una tècnica popular per escalar aplicacions Node.js. Aquest manual ha demostrat com configurar i utilitzar el clúster per distribuir la càrrega de l'aplicació en múltiples processos secundaris. En seguir aquests passos, podràs escalar la teva aplicació Node.js i fer-la més resistent a errors.
