Com escalar aplicacions Node.js amb clustering
Introducció
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.
Pas 1: Instal·lar Node.js
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.
Pas 2: Crear un fitxer d'aplicació Node.js
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);
Pas 3: Configurar aquesta aplicació en mode cluster
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;
- El mòdul cluster ens permet crear i gestionar un clúster de processos treballadors.
- El mòdul http proporciona funcionalitat per crear un servidor HTTP.
- El mòdul os s'utilitza per determinar el nombre de nuclis de CPU disponibles al sistema utilitzant la propietat 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`);
}
- El bloc if (cluster.isMaster) només s'executa en el procés mestre. Comprova si el procés actual és el procés mestre utilitzant la propietat isMaster del mòdul cluster.
- Si és el procés mestre, imprimeix a la consola l'ID del procés mestre utilitzant process.pid i després procedeix a crear diversos processos treballadors.
- El bucle for crea els processos treballadors desitjats (en aquest cas, numCPUs, que representa el nombre de nuclis de CPU).
- El bloc cluster.on('exit', ...) s'encarrega de manejar la sortida dels processos treballadors. Cada cop que un procés treballador acaba (surt), es registra a la consola l'ID del procés treballador i es crea un nou procés treballador per reemplaçar-lo.
- Si el procés actual no és el procés mestre (és a dir, és un procés treballador), entra al bloc else.
- Dins del bloc else, cada procés treballador crea un servidor HTTP utilitzant http.createServer() i escolta al port 3000.
- El servidor respon amb un missatge de "Hola, món!" per a cada sol·licitud rebuda.
- L'ID del procés treballador es mostra a la consola utilitzant process.pid per indicar que el procés treballador 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ó.
Pas 4: Executar 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
Pas 5: Provar l'aplicació
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
Conclusió
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.