Com escalar aplicacions Node.js amb clustering

Actualitzat el 2026-10-07 15:00:46 16 visites

Introducció

Node.js és un entorn 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 gestionar grans volums de trànsit. Una de les formes 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 gestionar la càrrega de l'aplicació. Això significa que cada sol·licitud que arriba a l'aplicació es distribueix en diferents processos perquè puguin processar-se simultàniament. També ajuda a garantir que l'aplicació sigui tolerant a fallos i que segueixi funcionant fins i tot si un dels processos falla.

En aquest manual, s'explicarà com configurar el clustering i com escalar la vostra 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 arxiu d'aplicació Node.js

Crea un arxiu d'aplicació Node.js que escolti les sol·licituds dels clients. Aquest arxiu serà el punt d'entrada per a la vostra 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 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!
');
  }).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 gestionen les sol·licituds entrants. Cada procés de treball escolta en el mateix port (3000 en aquest cas), cosa que els permet compartir el trànsit entrant.

Anirem a repassar cada part del codi i n'explicarem la finalitat:

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();
  }

  // Gestionar la sortida i el 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!
');
  }).listen(3000);

  console.log(`El procés treballador amb ID ${process.pid} ha començat`);
}

El bloc if (cluster.isMaster) s'executa només 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 gestionar la sortida dels processos treballadors. Cada vegada que un procés treballador finalitza (surt), es registra a la consola l'ID del procés treballador i se'n crea un de nou per substituir-lo.
Si el procés actual no és el procés mestre (és a dir, és un procés treballador), entra en el bloc else.
Dins del bloc else, cada procés treballador crea un servidor HTTP utilitzant http.createServer() i escolta en el 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 basant-se en el nombre de nuclis de CPU disponibles i reinicia qualsevol procés worker que finalitzi. Els processos workers gestionen 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 el rendiment.

Sinta't lliure de modificar el codi segons els teus requisits i la lògica de l'aplicació.

Pas 4: Executar l'aplicació

Guarda el codi anterior en un arxiu anomenat app.js.
Obre la terminal i navega fins al directori que conté app.js.
Inicia l'aplicació utilitzant la comanda 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 en què 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 clustering per distribuir la càrrega de l'aplicació en múltiples processos secundaris. Seguint aquests passos, podràs escalar la teva aplicació Node.js i fer-la més resistent a fallos.

Configuració de cookies