Module Cluster de Node.js

Java FileModules intégrés de Node.js

de Node.jsclusterLe module vous permet de créer facilement des processus workers qui partagent le même port de serveur. Comme Node.js est monothread,clusterLe module peut nous aider à exploiter pleinement les performances des systèmes CPU multicœurs.

En termes simples,clusterLe module est comme un gérant de restaurant : il crée plusieurs serveurs (workers) pour s'occuper des clients (requêtes), au lieu de laisser un seul serveur s'occuper de tous les clients.

Pourquoi avez-vous besoin du module Cluster ?

  1. Améliorer les performances: Les CPU modernes ont généralement plusieurs cœurs, mais Node.js n'utilise qu'un seul cœur par défaut.clusterLe module vous permet d'utiliser tous les cœurs CPU disponibles.

  2. Améliorer la fiabilité: Si un worker plante, les autres workers peuvent continuer à traiter les requêtes, et le processus maître peut redémarrer le worker planté.

  3. Zéro temps d'arrêt: Vous pouvez redémarrer les workers un par un pour mettre à jour le code sans interrompre le service.

Utilisation de base du module Cluster

Exemple

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

if (cluster.isMaster) {
  console.log(`Le processus maître ${process.pid}est en cours d'exécution`);

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

  cluster.on('exit', (worker, code, signal) => {
    console.log(`worker ${worker.process.pid}a quitté`);
  });
} else {
  // Les workers peuvent partager la même connexion TCP
  // Ceci est un serveur HTTP
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Bonjour le monde\n');
  }).listen(8000);

  console.log(`Le worker ${process.pid}a démarré`);
}

Analyse des concepts fondamentaux

Processus maître

  • Responsable de la gestion de tous les processus worker
  • Ne traite généralement pas les requêtes réelles
  • Peut écouter divers événements des workers

Processus worker

  • Processus enfants qui traitent réellement les requêtes
  • Chaque worker est un processus Node.js indépendant
  • Partagent le même port de serveur

API courantes du module Cluster

cluster.fork()

Crée un nouveau processus worker. L'appel de cette méthode renvoie un objet worker.

cluster.isMaster

S'il s'agit du processus maître, alors il esttrue。

cluster.isWorker

S'il s'agit d'un processus worker, alors il esttrue。

cluster.workers

Une table de hachage contenant tous les objets worker actifs, avecworker.idcomme nom de clé.

Scénarios d'application pratiques

1. Équilibrage de charge

Exemple

// Dans le processus maître
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  require('./app'); // Votre fichier d'entrée d'application
}

2. Redémarrage gracieux

Exemple

cluster.on('exit', (worker, code, signal) => {
  console.log(`Le worker ${worker.process.pid}a quitté`);
  // Vous pouvez forker un worker ici
  cluster.fork();
});

3. Communication inter-processus

Exemple

// Le processus maître envoie un message
worker.send('Bonjour worker !');

// Le worker reçoit le message
process.on('message', (msg) => {
  console.log(`Worker ${process.pid}a reçu un message: ${msg}`);
});

Conseils d'optimisation des performances

  1. Créer des workers en fonction du nombre de cœurs CPU: Il est généralement recommandé que le nombre de workers soit égal au nombre de cœurs CPU.

  2. Port partagé: Tous les workers partagent le même port, et le système d'exploitation distribue automatiquement les requêtes entre les différents workers.

  3. Connexions partagées: Pour les connexions de longue durée (comme WebSocket), vous devez prendre en compte la manière dont les connexions sont distribuées entre les différents workers.

  4. État partagé: Les workers ne partagent pas la mémoire, vous devez donc utiliser un stockage externe tel que Redis pour partager l'état.

Problèmes courants et solutions

1. Fuite de mémoire

Chaque worker est un processus indépendant. Une fuite de mémoire dans un worker n'affectera pas les autres workers, mais vous devez surveiller et redémarrer les workers anormaux.

2. Persistance de session

Si la persistance de session est nécessaire, vous pouvez utiliser des sessions sticky ou stocker les données de session en externe (par exemple, Redis).

3. Limite de descripteurs de fichiers

Un grand nombre de workers peut épuiser les descripteurs de fichiers, vous devez donc ajuster les limites du système :

Exemple

ulimit -n 10000  # Définir la limite de descripteurs de fichiers

Alternatives au module Cluster

Bien queclusterLe module est puissant, mais il existe d'autres options :

  1. PM2: gestionnaire de processus avec équilibrage de charge et fonctionnalités de surveillance intégrés
  2. Nginx: un proxy inverse capable de répartir la charge entre plusieurs instances Node.js
  3. Kubernete: un système d'orchestration de conteneurs capable de mettre à l'échelle automatiquement les services Node.js

Résumé

de Node.jsclustermodule est un outil important pour créer des services réseau hautes performances et hautement disponibles. En créant plusieurs processus worker, nous pouvons :

  1. Exploiter pleinement les performances des processeurs multicœurs
  2. Améliorer la fiabilité de l'application
  3. Réaliser un déploiement sans temps d'arrêt

Bien que la configuration et la gestion d'applications multiprocessus soient plus complexes que celles d'applications monoprocessus, pour les applications Node.js en production, l'utilisation declusterLe module ou des solutions similaires est presque indispensable.

J'espère que ce guide vous aidera à comprendre et à utiliser le module de Node.jsclustermodule!

Java FileModules intégrés de Node.js

Autres extensions