Utilisation de PM2 pour gérer les processus Node.js

Pourquoi un gestionnaire de processus comme PM2 est indispensable ?

Lorsque vous développez votre application Node.js, vous la lancez généralement avec une simple commande comme `node app.js`. Cependant, cette méthode est totalement inadaptée à un environnement de production. Si votre application plante pour une raison quelconque, elle ne redémarrera pas automatiquement. Si le serveur redémarre, votre application ne sera pas relancée. De plus, cette commande n'utilise qu'un seul coeur de processeur, même si votre serveur en possède plusieurs, et elle ne fournit aucun outil intégré pour surveiller la consommation de ressources ou gérer les logs efficacement.

C'est là qu'intervient PM2 (Process Manager 2). PM2 est un gestionnaire de processus de production avancé, open-source et extrêmement populaire pour les applications Node.js. Il est conçu pour simplifier le déploiement et la gestion des applications Node.js en production, en leur apportant la robustesse et les fonctionnalités nécessaires pour fonctionner de manière fiable 24h/24 et 7j/7.

PM2 fonctionne comme un démon, exécutant vos applications en arrière-plan. Il offre des fonctionnalités clés telles que le redémarrage automatique en cas de crash, la gestion des logs, le monitoring des performances, la possibilité d'utiliser tous les coeurs CPU disponibles (clustering) sans modifier votre code, et la génération de scripts de démarrage pour relancer vos applications après un redémarrage du serveur.

Installation et commandes de base de PM2

L'installation de PM2 se fait globalement via npm (ou yarn), ce qui le rend disponible en ligne de commande partout sur votre système :

npm install pm2 -g
# ou
yarn global add pm2

Une fois installé, démarrer une application est très simple :

# Démarrer app.js et lui donner un nom ('mon-api')
pm2 start app.js --name "mon-api"

# Démarrer app.js en mode cluster sur tous les coeurs disponibles
pm2 start app.js -i max --name "mon-app-cluster"

# Démarrer app.js et surveiller les changements de fichiers (pour le développement)
pm2 start app.js --watch

PM2 garde une liste des processus qu'il gère. Vous pouvez interagir avec ces processus via différentes commandes :

• Lister les processus : `pm2 list` ou `pm2 ls` affiche l'état (online, stopped, errored), le nom, l'id, l'utilisation CPU/mémoire, etc.
• Arrêter un processus : `pm2 stop ` (ex: `pm2 stop mon-api` ou `pm2 stop 0`)
• Redémarrer un processus : `pm2 restart ` (ex: `pm2 restart mon-api`)
• Supprimer un processus de la liste PM2 : `pm2 delete ` (ex: `pm2 delete mon-api`)
• Afficher les logs d'un processus : `pm2 logs ` (affiche les logs standards et d'erreur en temps réel)
• Afficher les informations détaillées d'un processus : `pm2 show `

Ces commandes de base vous permettent de contrôler le cycle de vie de vos applications Node.js gérées par PM2 de manière simple et efficace depuis votre terminal.

Fonctionnalités clés pour la production : monitoring, clustering, logs et démarrage

PM2 excelle dans la gestion des applications en production grâce à plusieurs fonctionnalités essentielles. Le monitoring intégré est accessible via la commande `pm2 monit`. Elle ouvre un tableau de bord en temps réel dans votre terminal, affichant l'utilisation du CPU et de la mémoire pour chaque processus, ainsi que l'état des logs. C'est un outil précieux pour identifier rapidement les goulots d'étranglement ou les comportements anormaux.

Le mode cluster est l'une des fonctionnalités les plus puissantes de PM2. Il permet à votre application Node.js (qui est mono-thread par nature) d'exploiter tous les coeurs disponibles sur votre serveur. En lançant votre application avec l'option `-i` (instances), par exemple `pm2 start app.js -i 0` ou `pm2 start app.js -i max`, PM2 crée plusieurs processus de votre application (un par coeur disponible avec `max` ou `0`) et met en place un répartiteur de charge (load balancer) interne pour distribuer les requêtes entrantes entre ces processus. Cela augmente considérablement les performances et la résilience de votre application sans nécessiter de modification de votre code.

La gestion des logs est simplifiée. PM2 capture automatiquement les sorties `console.log` (`stdout`) et `console.error` (`stderr`) de vos applications et les écrit dans des fichiers dédiés, généralement situés dans `~/.pm2/logs/`. Les fichiers sont nommés `[app-name]-out.log` et `[app-name]-error.log`. PM2 inclut également un système de rotation des logs pour éviter que ces fichiers ne deviennent trop volumineux.

Enfin, pour assurer que vos applications redémarrent automatiquement après un redémarrage du serveur, PM2 peut générer des scripts de démarrage adaptés à votre système d'exploitation (systemd, init.d, etc.). La commande `pm2 startup` détecte votre système et vous donne une commande à exécuter (généralement avec `sudo`). Ensuite, la commande `pm2 save` enregistre la liste actuelle des processus gérés par PM2 pour qu'ils soient restaurés au démarrage.

# Générer la commande pour le script de démarrage
pm2 startup

# Exécuter la commande fournie par pm2 startup (exemple pour systemd)
# sudo env PATH=$PATH:/usr/bin /usr/local/lib/node_modules/pm2/bin/pm2 startup systemd -u votre_utilisateur --hp /home/votre_utilisateur

# Sauvegarder la liste des processus à relancer au démarrage
pm2 save

Configuration avancée avec les fichiers 'ecosystem'

Pour des configurations plus complexes ou pour gérer plusieurs applications, l'utilisation d'un fichier de configuration 'ecosystem' est recommandée. Ce fichier, généralement nommé `ecosystem.config.js` (ou `.json`, `.yaml`), permet de déclarer toutes les options de configuration de vos applications de manière centralisée et versionnable (vous pouvez l'ajouter à votre dépôt Git).

Un fichier `ecosystem.config.js` exporte un objet ou un tableau d'objets de configuration. Chaque objet représente une application et peut contenir de nombreuses options, comme le nom de l'application, le chemin vers le script principal, le mode d'exécution (fork ou cluster), le nombre d'instances, les variables d'environnement spécifiques, les options de surveillance de fichiers (`watch`), les paramètres de logs, etc.

Voici un exemple simple d'un fichier `ecosystem.config.js` pour une application API et un worker :

module.exports = {
  apps : [
    {
      name   : "api-server",
      script : "./server.js", // Chemin vers le script principal de l'API
      instances: "max", // Utiliser tous les coeurs disponibles
      exec_mode: "cluster", // Activer le mode cluster
      watch  : false, // Désactiver la surveillance des fichiers en production
      env    : {
        "NODE_ENV": "development",
      },
      env_production : {
        "NODE_ENV": "production",
        "PORT": 8080
      }
    },
    {
      name   : "background-worker",
      script : "./worker.js", // Chemin vers le script du worker
      instances: 1, // Généralement une seule instance pour un worker
      exec_mode: "fork",
      watch  : false,
      env_production: {
        "NODE_ENV": "production"
      }
    }
  ]
};

Pour démarrer toutes les applications définies dans ce fichier, utilisez simplement la commande :

pm2 start ecosystem.config.js

Pour démarrer spécifiquement l'environnement de production défini dans `env_production` :

pm2 start ecosystem.config.js --env production

L'utilisation des fichiers ecosystem rend la gestion de vos déploiements Node.js avec PM2 beaucoup plus structurée, reproductible et facile à maintenir.