Mise à l'échelle de Node.js avec le module Cluster

Le module Cluster permet à Node.js d'exploiter les systèmes multicœurs, améliorant ainsi les performances des applications. Explorons comment l'utiliser efficacement.

Pourquoi Cluster ?

1. Utiliser tous les cœurs de processeur
2. Améliorer la réactivité de l'application
3. Augmentez la fiabilité grâce à la redondance des travailleurs

Utilisation de base

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

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

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
  });
} else {
  // Workers can share any TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello World\n');
  }).listen(8000);

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

Équilibrage de charge

Node.js gère automatiquement l'équilibrage de charge en utilisant une approche circulaire.

Communication inter-processus (IPC)

if (cluster.isMaster) {
  const worker = cluster.fork();
  worker.send('Hi there');
} else {
  process.on('message', (msg) => {
    console.log('Message from master:', msg);
  });
}

Redémarrages sans temps d'arrêt

if (cluster.isMaster) {
  cluster.on('exit', (worker, code, signal) => {
    if (!worker.exitedAfterDisconnect) {
      console.log('Worker crashed. Starting a new worker');
      cluster.fork();
    }
  });

  process.on('SIGUSR2', () => {
    const workers = Object.values(cluster.workers);
    const restartWorker = (workerIndex) => {
      const worker = workers[workerIndex];
      if (!worker) return;

      worker.on('exit', () => {
        if (!worker.exitedAfterDisconnect) return;
        console.log(`Exited process ${worker.process.pid}`);
        cluster.fork().on('listening', () => {
          restartWorker(workerIndex + 1);
        });
      });

      worker.disconnect();
    };

    restartWorker(0);
  });
}

Meilleures pratiques

1. Utilisez worker_threads pour les tâches gourmandes en CPU
2. Mettre en œuvre une gestion appropriée des erreurs chez les travailleurs
3. Surveiller la santé des travailleurs et redémarrer si nécessaire
4. Utilisez un gestionnaire de processus comme PM2 pour la production

Les pièges à éviter

1. Le serveur de partage gère explicitement (Node.js le fait automatiquement)
2. Une utilisation excessive de l'IPC (peut devenir un goulot d'étranglement)
3. Négliger de gérer les accidents des travailleurs

Le module Cluster est puissant pour la mise à l'échelle horizontale, mais à utiliser judicieusement. Créez toujours un profil pour vous assurer qu'il répond à vos besoins de performances spécifiques.

Bravo ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!