Node.js
Déploiement d'applications Node.js en production

Réglage NODE_ENV = "production"

Les déploiements de production varieront de plusieurs manières, mais une convention standard lors du déploiement en production consiste à définir une variable d'environnement appelée NODE_ENV et à définir sa valeur sur «production» .

Drapeaux d'exécution

Tout code exécuté dans votre application (y compris les modules externes) peut vérifier la valeur de NODE_ENV :

if(process.env.NODE_ENV === 'production') {
    // We are running in production mode
} else {
   // We are running in development mode
}

Les dépendances

Lorsque la variable d'environnement NODE_ENV est définie sur 'production', toutes les devDependencies dans votre fichier package.json seront complètement ignorées lors de l'exécution de npm install . Vous pouvez également imposer ceci avec un drapeau --production :

npm install --production

Pour définir NODE_ENV vous pouvez utiliser l'une de ces méthodes

méthode 1: définissez NODE_ENV pour toutes les applications de noeud

Les fenêtres :

set NODE_ENV=production

Linux ou autre système basé sur Unix:

export NODE_ENV=production

Cela définit NODE_ENV pour la session bash en cours. Ainsi, toutes les applications démarrées après cette instruction auront NODE_ENV défini sur production .

méthode 2: définissez NODE_ENV pour l'application en cours

NODE_ENV=production node app.js

Cela définira NODE_ENV pour l'application en cours. Cela aide lorsque nous voulons tester nos applications sur différents environnements.

méthode 3: créer .env fichier .env et l'utiliser

Cela utilise l'idée expliquée ici . Référer ce post pour une explication plus détaillée.

Fondamentalement, vous créez .env fichier .env et exécutez un script bash pour les définir dans l'environnement.

Pour éviter d'écrire un script bash, le package env-cmd peut être utilisé pour charger les variables d'environnement définies dans le fichier .env .

env-cmd .env node app.js

méthode 4: Utiliser cross-env package cross-env

Ce paquet permet de définir les variables d’environnement dans un sens pour chaque plate-forme.

Après l'avoir installé avec npm, vous pouvez simplement l'ajouter à votre script de déploiement dans package.json comme suit:

"build:deploy": "cross-env NODE_ENV=production webpack"

Gérer l'application avec le gestionnaire de processus

Il est recommandé d’exécuter les applications NodeJS contrôlées par les gestionnaires de processus. Le gestionnaire de processus aide à maintenir l’application active pour toujours, à redémarrer en cas d’échec, à recharger sans interruption et à simplifier l’administration. Les plus puissants d'entre eux (comme PM2 ) ont un équilibreur de charge intégré. PM2 vous permet également de gérer la journalisation, la surveillance et la mise en cluster des applications.

Gestionnaire de processus PM2

Installation de PM2:

npm install pm2 -g

Le processus peut être démarré en mode cluster impliquant un équilibreur de charge intégré pour répartir la charge entre les processus:

pm2 start app.js -i 0 --name "api" ( -i doit spécifier le nombre de processus à générer. S'il est à 0, le numéro de processus sera basé sur le nombre de cœurs de processeur)

Tout en ayant plusieurs utilisateurs en production, il doit y avoir un seul point pour PM2. Par conséquent, la commande pm2 doit être préfixée par un emplacement (pour la configuration PM2), sinon elle générera un nouveau processus pm2 pour chaque utilisateur avec config dans son répertoire de base respectif. Et ce sera incohérent.

Utilisation: PM2_HOME=/etc/.pm2 pm2 start app.js

Déploiement à l'aide de PM2

PM2 est un gestionnaire de processus de production pour les applications Node.js , qui vous permet de garder les applications en vie pour toujours et de les recharger sans interruption. PM2 vous permet également de gérer la journalisation, la surveillance et la mise en cluster des applications.

Installez pm2 globalement.

npm install -g pm2

Ensuite, exécutez l'application node.js utilisant PM2.

pm2 start server.js --name "my-app"

Les commandes suivantes sont utiles lorsque vous travaillez avec PM2 .

Liste tous les processus en cours d'exécution:

pm2 list

Arrêtez une application:

pm2 stop my-app

Redémarrez une application:

pm2 restart my-app

Pour afficher des informations détaillées sur une application:

pm2 show my-app

Pour supprimer une application du registre de PM2:

pm2 delete my-app

Déploiement à l'aide du gestionnaire de processus

Le gestionnaire de processus est généralement utilisé en production pour déployer une application nodejs. Les principales fonctions d'un gestionnaire de processus sont le redémarrage du serveur en cas de panne, la vérification de la consommation des ressources, l'amélioration des performances d'exécution, la surveillance, etc.

Certains des gestionnaires de processus populaires créés par la communauté de nœuds sont pour toujours, pm2, etc.

Forvever

forever est un outil d'interface de ligne de commande permettant de garantir l'exécution continue d'un script donné. L'interface simple de forever le rend idéal pour exécuter de plus petits déploiements d'applications et de scripts Node.js

surveille forever votre processus et le redémarre s'il se bloque.

Installer forever globalement.

$ npm install -g forever

Exécuter l'application:

$ forever start server.js

Cela démarre le serveur et donne un identifiant pour le processus (à partir de 0).

Redémarrer l'application:

$ forever restart 0

Ici 0 est l'id du serveur.

Arrêter l'application:

$ forever stop 0

Semblable à redémarrer, 0 correspond à l'identifiant du serveur. Vous pouvez également donner un identifiant de processus ou un nom de script à la place de l'identifiant fourni par l'indispensable.

Pour plus de commandes: https://www.npmjs.com/package/forever

Utiliser différentes propriétés / configurations pour différents environnements tels que dev, qa, staging etc.

Les applications à grande échelle nécessitent souvent des propriétés différentes lorsqu’elles sont exécutées dans des environnements différents. Nous pouvons y parvenir en transmettant des arguments à l'application NodeJs et en utilisant le même argument dans le processus de noeud pour charger un fichier de propriétés d'environnement spécifique.

Supposons que nous ayons deux fichiers de propriétés pour un environnement différent.

• dev.json

    {
        "PORT": 3000,
        "DB": {
            "host": "localhost",
            "user": "bob",
            "password": "12345"
        }
    }
  

• qa.json

    {
        "PORT": 3001,
        "DB": {
            "host": "where_db_is_hosted",
            "user": "bob",
            "password": "54321"
        }
    }
  

Le code suivant dans l'application exportera le fichier de propriétés respectif que nous souhaitons utiliser.

process.argv.forEach(function (val) {
    var arg = val.split("=");
    if (arg.length > 0) {
        if (arg[0] === 'env') {
            var env = require('./' + arg[1] + '.json');
            exports.prop = env;
        }
    }
});

Nous donnons des arguments à l'application comme suit

node app.js env=dev

si nous utilisons gestionnaire de processus comme pour toujours aussi simple que

forever start app.js env=dev

Profiter des clusters

Une seule instance de Node.js s'exécute dans un seul thread. Pour tirer parti des systèmes multi-core, l'utilisateur voudra parfois lancer un cluster de processus Node.js pour gérer la charge.

 var cluster = require('cluster');
    
    var numCPUs = require('os').cpus().length;
    
        if (cluster.isMaster) {
          // In real life, you'd probably use more than just 2 workers,
          // and perhaps not put the master and worker in the same file.
          //
          // You can also of course get a bit fancier about logging, and
          // implement whatever custom logic you need to prevent DoS
          // attacks and other bad behavior.
          //
          // See the options in the cluster documentation.
          //
          // The important thing is that the master does very little,
          // increasing our resilience to unexpected errors.
            console.log('your server is working on ' + numCPUs + ' cores');
            
             for (var i = 0; i < numCPUs; i++) {
                    cluster.fork();
                  }
             
          cluster.on('disconnect', function(worker) {
            console.error('disconnect!');
            //clearTimeout(timeout);
            cluster.fork();
          });
    
          
        } else {
            require('./app.js');
        
        }