Node.js est connu pour sa vitesse et efficacité, ce qui en fait un choix populaire pour créer des applications évolutives hautes performances.
Cependant, par défaut, Node.js est monothread, ce qui signifie qu'il s'exécute sur un seul cœur de processeur, ce qui peut être limitant dans les environnements de serveur multicœurs. Si votre application est gourmande en ressources ou si vous prévoyez un trafic élevé, vous souhaiterez maximiser l'utilisation des cœurs de processeur de votre serveur.
C'est là qu'intervient le clustering Node.js.

Dans cet article, nous examinerons ce qu'est le clustering Node.js, pourquoi il est important et comment vous pouvez l'utiliser pour améliorer les performances de vos applications.

Qu'est-ce que le clustering Node.js ?

Le clustering Node.js est une technique qui vous permet d'utiliser tous les cœurs de processeur en générant plusieurs instances (workers) de votre application Node.js.
Ces travailleurs partagent le même port et sont gérés par un processus maître. Chaque travailleur peut gérer les demandes entrantes de manière indépendante, permettant à votre application de répartir la charge de travail et de traiter les demandes en parallèle.

En clusterisant votre application Node.js, vous pouvez :

• Utiliser plusieurs cœurs de processeur
• Améliorer les performances des applications
• Assurer une tolérance aux pannes en cas de panne d'un travailleur
• Évoluez horizontalement sans trop compliquer la base de code

Comment fonctionne le clustering ?

Dans un cluster Node.js, il existe un processus maître qui contrôle plusieurs processus de travail.
Le processus maître ne gère pas directement les requêtes HTTP mais gère les nœuds de calcul qui le font. Les demandes des clients sont réparties entre ces travailleurs, équilibrant ainsi efficacement la charge.

Si un processus de travail plante pour une raison quelconque, le processus maître peut en générer un nouveau, garantissant ainsi un temps d'arrêt minimal.

Quand devriez-vous utiliser le clustering ?

Le clustering est particulièrement utile lorsque votre application :

• Connaît un trafic élevé et doit gérer de nombreuses demandes simultanées
• Effectue des tâches liées au processeur telles que l'encodage vidéo, le traitement d'images ou l'analyse de données à grande échelle.
• Fonctionne sur des processeurs multicœurs qui ne sont pas pleinement utilisés Si votre application passe beaucoup de temps à attendre des opérations d'E/S, telles que des requêtes de base de données ou des appels d'API, le clustering peut ne pas améliorer de manière significative les performances.

Dans les cas ci-dessus, vous pouvez améliorer le débit à l'aide de techniques de programmation asynchrone.

Comment implémenter le clustering dans Node.js

Node.js fournit un module de cluster intégré pour créer facilement des clusters. Passons en revue un exemple simple de la façon de regrouper votre application Node.js.

Étape 1 : configuration de votre application
Avant d'ajouter le clustering, supposons que vous disposez d'un simple serveur HTTP (server.js) :

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200);
  res.end('Hello World\n');
});

server.listen(3000, () => {
  console.log(`Worker process ID: ${process.pid} is listening on port 3000`);
});

Cette application s'exécute sur un seul cœur. Modifions-le pour utiliser le clustering.

Étape 2 : Utilisation du module cluster
Le module cluster nous permet de diviser le processus actuel en plusieurs processus de travail. Voici comment mettre en œuvre le clustering :

const cluster = require('cluster');
const http = require('http');
const os = require('os');

// Get the number of CPU cores
const numCPUs = os.cpus().length;

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

  // Fork workers for each CPU core
  for (let i = 0; i  {
    console.log(`Worker ${worker.process.pid} died. Spawning a new one...`);
    cluster.fork();
  });
} else {
  // Workers share the same TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker '   process.pid   '\n');
  }).listen(3000);

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

Explication:
1. Processus maître : Lorsque le processus démarre, il vérifie s'il s'agit du processus maître (cluster.isMaster). Le maître est responsable de processus de travail fork, un pour chaque cœur de processeur. La méthode os.cpus() est utilisée pour récupérer le nombre de cœurs CPU disponibles.

2. Processus de travail : Pour chaque cœur de processeur, un nouveau travailleur est créé (cluster.fork()). Ces processus de travail exécutent le serveur HTTP et gèrent les requêtes entrantes.

3. Tolérance aux pannes : Si un processus de travail plante, l'événement cluster.on('exit') est déclenché et un nouveau travailleur est généré pour remplacer celui mort.

Étape 3 : tester votre application en cluster
Maintenant, si vous exécutez l'application :

node server.js

Vous remarquerez que plusieurs travailleurs sont créés, chacun avec un ID de processus unique. Chaque demande est traitée par un travailleur différent, équilibrant efficacement la charge.

Vous pouvez tester comment le clustering améliore les performances de votre application en envoyant plusieurs requêtes et en observant comment la charge de travail est répartie entre les travailleurs.

Donc, la prochaine fois que vous créerez une application Node.js hautes performances, n'oubliez pas d'envisager le clustering !

C'est tout pour ce blog ! Restez à l'écoute pour plus de mises à jour et continuez à créer des applications incroyables ! ?✨
Bon codage ! ?