Comprendre le cluster Node.js : les concepts de base-js tutoriel-php.cn

Understanding Node.js Cluster: The Core Concepts

Préface

Si vous avez utilisé PM2 pour gérer les processus Node.js, vous avez peut-être remarqué qu'il prend en charge un mode cluster. Ce mode permet à Node.js de créer plusieurs processus. Lorsque vous définissez le nombre d'instances en mode cluster sur max, PM2 créera automatiquement un nombre de processus Node correspondant aux cœurs CPU disponibles sur le serveur.

PM2 y parvient en tirant parti du module Cluster de Node.js. Le module répond à la nature monothread de Node.js, qui limite traditionnellement sa capacité à utiliser plusieurs cœurs de processeur. Mais comment fonctionne le module Cluster en interne ? Comment les processus communiquent-ils entre eux ? Comment plusieurs processus peuvent-ils écouter sur le même port ? Et comment Node.js distribue-t-il les requêtes à ces processus ? Si ces questions vous intéressent, lisez la suite.

Principes fondamentaux

Les processus de travail Node.js sont créés à l'aide de la méthode child_process.fork(). Cela signifie qu'il existe un processus parent et plusieurs processus enfants. Le code ressemble généralement à ceci :

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

if (cluster.isMaster) {
  for (let i = 0, n = os.cpus().length; i < n; i++) {
    cluster.fork();
  }
} else {
  // Start the application
}

Copier après la connexion

Si vous avez étudié les systèmes d'exploitation, vous connaissez probablement l'appel système fork(). Le processus appelant est le parent, tandis que les processus nouvellement créés sont les enfants. Ces processus enfants partagent le même segment de données et la même pile que le parent, mais leurs espaces de mémoire physique ne sont pas nécessairement partagés. Dans un cluster Node.js, le processus master écoute sur le port et distribue les requêtes entrantes aux processus worker. Cela implique d'aborder trois sujets principaux : communication inter-processus (IPC), stratégies d'équilibrage de charge et écoute de ports multi-processus.

Communication inter-processus (IPC)

Le processus master crée des processus enfants à l'aide de process.fork(). La communication entre ces processus est gérée via un canal IPC. Les systèmes d'exploitation fournissent plusieurs mécanismes de communication inter-processus, tels que :

Mémoire partagée Plusieurs processus partagent un seul espace mémoire, souvent géré avec des sémaphores pour la synchronisation et l'exclusion mutuelle.
Passer des messages

Les processus échangent des données en envoyant et en recevant des messages.
Sémaphores

Un sémaphore est une valeur d'état attribuée par le système. Les processus manquant de contrôle seront contraints de s’arrêter à des points de contrôle spécifiques, en attendant un signal pour continuer. Lorsqu'il est limité à des valeurs binaires (0 ou 1), ce mécanisme est appelé « mutex » (verrouillage d'exclusion mutuelle).
Tuyaux

Les tuyaux connectent deux processus, permettant à la sortie d’un processus de servir d’entrée à un autre. Cela peut être créé à l’aide de l’appel système pipe. Le | La commande dans les scripts shell est un exemple courant de ce mécanisme.

Node.js utilise un mécanisme basé sur les événements pour la communication entre les processus parent et enfant. Voici un exemple de processus parent envoyant un handle de serveur TCP à un processus enfant :

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

if (cluster.isMaster) {
  for (let i = 0, n = os.cpus().length; i < n; i++) {
    cluster.fork();
  }
} else {
  // Start the application
}

Copier après la connexion

Stratégie d'équilibrage de charge

Comme mentionné précédemment, toutes les demandes sont distribuées par le processus maître. Garantir que la charge du serveur est répartie uniformément entre les processus de travail nécessite une stratégie d'équilibrage de charge. Node.js utilise un algorithme round-robin par défaut.

Tournoi à la ronde

La méthode round-robin est un algorithme d'équilibrage de charge courant également utilisé par Nginx. Il fonctionne en distribuant les requêtes entrantes à chaque processus de manière séquentielle, en commençant par le premier processus et en revenant en arrière après avoir atteint le dernier. Cependant, cette méthode suppose une capacité de traitement égale pour tous les processus. Dans les scénarios où le temps de traitement des demandes varie considérablement, un déséquilibre de charge peut se produire.

Pour résoudre ce problème, Nginx utilise souvent le Weighted Round-Robin (WRR), où les serveurs se voient attribuer des poids différents. Le serveur avec le poids le plus élevé est sélectionné jusqu'à ce que son poids soit réduit à zéro, moment auquel le cycle recommence en fonction de la nouvelle séquence de poids.

Vous pouvez ajuster la stratégie d'équilibrage de charge dans Node.js en définissant la variable d'environnement NODE_CLUSTER_SCHED_POLICY ou en la configurant via cluster.setupMaster(options). Combiner Nginx pour les clusters multi-machines avec Node.js Cluster pour l'équilibrage multi-processus sur une seule machine est une approche courante.

Écoute de ports multi-processus

Dans les premières versions de Node.js, plusieurs processus écoutant sur le même port étaient en concurrence pour les connexions entrantes, entraînant une répartition inégale de la charge. Ce problème a ensuite été résolu grâce à la stratégie du tournoi à la ronde. L'approche actuelle fonctionne comme suit :

Le processus master crée un socket, le lie à une adresse et commence à écouter.
Le descripteur de fichier du socket (fd) n'est pas transmis aux processus de travail.
Lorsque le processus maître accepte une nouvelle connexion, il détermine quel processus de travail doit gérer la connexion et la transmet en conséquence.

Essentiellement, le processus maître écoute le port et distribue les connexions aux processus de travail en utilisant une stratégie définie (par exemple, round-robin). Cette conception élimine la concurrence entre les travailleurs mais nécessite que le processus maître soit très stable.

Conclusion

En utilisant le mode Cluster de PM2 comme point d'entrée, cet article a exploré les principes fondamentaux du module Cluster de Node.js pour la mise en œuvre d'applications multi-processus. Nous nous sommes concentrés sur trois aspects clés : la communication inter-processus, l'équilibrage de charge et l'écoute des ports multi-processus.

En étudiant le module Cluster, on constate que de nombreux principes fondamentaux et algorithmes sont universels. Par exemple, l'algorithme round-robin est utilisé à la fois dans la planification des processus du système d'exploitation et dans l'équilibrage de la charge du serveur. L'architecture maître-travailleur ressemble à la conception multi-processus de Nginx. De même, des mécanismes tels que les sémaphores et les tuyaux sont omniprésents dans divers paradigmes de programmation.

Alors que de nouvelles technologies émergent continuellement, leurs fondements restent cohérents. Comprendre ces concepts fondamentaux nous permet d'extrapoler et de nous adapter aux nouveaux défis en toute confiance.