Modèle maître-travailleur dans NodeJS : expliqué

Node.js, une plate-forme de développement basée sur JavaScript, permet aux développeurs de créer des applications côté serveur à l'aide de JavaScript. Son architecture monothread basée sur les événements est un atout clé, car elle gère efficacement de nombreuses requêtes simultanées sans la surcharge de plusieurs threads ou processus.

Pourquoi adopter le modèle maître-ouvrier ?

Malgré ses avantages, la nature monothread de Node.js présente des limites :

• Opérations liées au processeur : Des tâches telles que la manipulation d'images ou les fonctions cryptographiques peuvent bloquer le thread unique, ce qui a un impact sur les performances globales.
• Gestion robuste des erreurs : Un crash d'un seul thread en raison d'une erreur ou d'une exception arrête l'ensemble de l'application.
• Inefficacité multicœur : Le modèle monothread sous-utilise les processeurs multicœurs.

La solution ? Modèle Master-Worker de Node.js (également connu sous le nom de mode Cluster). Cette conception de système distribué utilise un processus maître supervisant plusieurs processus de travail. Le maître gère et surveille les ouvriers, tandis que les ouvriers s'occupent des tâches individuelles.

Mise en œuvre du modèle Maître-Ouvrier

Node.js exploite le module cluster pour l'implémentation Master-Worker. Ce module simplifie la création de plusieurs processus enfants et fournit des mécanismes de contrôle et de communication inter-processus. Voici une répartition :

1. Importez le module cluster et identifiez si le processus actuel est le maître ou un travailleur.
2. S'il s'agit du maître, utilisez cluster.fork() pour générer des processus de travail et attacher des écouteurs d'événements pour surveiller leur statut et leurs messages.
3. Les processus de travail exécutent des tâches spécifiques et communiquent avec le maître via process.send().

Un exemple simple

Cet exemple de base illustre le module cluster :

<code class="language-javascript">const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

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

  // Spawn 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 share a TCP connection (e.g., HTTP server).
  http
    .createServer((req, res) => {
      res.writeHead(200);
      res.end('Hello from Worker!');
    })
    .listen(8000);

  console.log(`Worker ${process.pid} started`);
}</code>

Le processus maître détermine s'il s'agit du maître (à l'aide de cluster.isMaster). Si tel est le cas, il crée des nœuds de calcul égaux au nombre de cœurs de processeur. Chaque travailleur est un processus indépendant avec sa propre mémoire et sa propre instance V8. Les travailleurs établissent un serveur HTTP et écoutent les demandes. L'événement exit gère les plantages des travailleurs, permettant au maître de les redémarrer.

Application avancée : équilibrage de charge Nginx

Améliorez l'évolutivité en utilisant Nginx comme proxy inverse et équilibreur de charge pour répartir les requêtes sur plusieurs processus Node.js.

Exemple de configuration Nginx :

<code class="language-nginx">http {
    upstream node_cluster {
        server 127.0.0.1:8000;
        server 127.0.0.1:8001;
        server 127.0.0.1:8002;
        # ... more Node.js processes
    }

    server {
        listen 80;

        location / {
            proxy_pass http://node_cluster;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }
    }
}</code>

Nginx répartit uniformément les requêtes entre les processus Node.js répertoriés dans node_cluster.

Avantages du modèle Maître-Ouvrier

• Distribution de la charge : Plusieurs processus Node.js distribuent les requêtes entrantes, augmentant ainsi le débit.
• Tolérance aux pannes et disponibilité : Un accident de travailleur n'affecte pas les autres ; le maître le redémarre.
• Gestion des tâches liées au processeur : Plusieurs travailleurs gèrent des opérations gourmandes en ressources processeur, empêchant ainsi le blocage du thread principal.

Points à considérer

• État partagé : Les travailleurs sont indépendants ; le partage d'état nécessite des solutions externes comme des bases de données.

En résumé, le modèle Master-Worker de Node.js, implémenté à l'aide du module cluster, offre une méthode simple mais puissante pour créer des applications multi-processus, améliorant les performances et la fiabilité.

---

Leapcell : votre solution d'hébergement Node.js de premier ordre

Leapcell est une plateforme sans serveur de nouvelle génération pour l'hébergement Web, les tâches asynchrones et Redis :

Compatibilité multilingue

• Développer en utilisant Node.js, Python, Go ou Rust.

Déploiement de projets gratuit et illimité

• Payez uniquement pour l'utilisation ; aucune demande, aucun frais.

Rentabilité exceptionnelle

• Payez à l'utilisation sans frais d'inactivité.
• Exemple : 25 $ traite 6,94 millions de requêtes avec un temps de réponse moyen de 60 ms.

Flux de travail rationalisé pour les développeurs

• Interface conviviale pour une configuration facile.
• Pipelines CI/CD automatisés et intégration GitOps.
• Surveillance et journalisation en temps réel.

Évolutivité sans effort et hautes performances

• Mise à l'échelle automatique pour une simultanéité élevée.
• Zéro frais opérationnels.

Apprenez-en plus dans la Documentation !

Suivez-nous sur X : @LeapcellHQ

---

En savoir plus sur notre blog

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!