Comment configurer une application Node.js pour la production sur Debian 10

introduction

Node.js est un environnement d’exécution JavaScript à code source ouvert permettant de créer des applications côté serveur et en réseau. La plate-forme fonctionne sous Linux, macOS, FreeBSD et Windows. Bien que vous puissiez exécuter les applications Node.js en ligne de commande, ce didacticiel se concentrera sur leur exécution en tant que service. Cela signifie que les applications vont redémarrer en cas de redémarrage ou d’échec et qu’elles peuvent être utilisées en toute sécurité dans un environnement de production.

Dans ce tutoriel, vous allez configurer un environnement Node.js prêt pour la production sur un seul serveur Debian 10. Ce serveur exécutera une application Node.js gérée par PM2 et fournira aux utilisateurs un accès sécurisé à l’application via un proxy inverse Nginx. Le serveur Nginx proposera HTTPS, en utilisant un certificat gratuit fourni par Let’s Encrypt.

Conditions préalables

Ce guide suppose que vous disposiez des éléments suivants:

Une configuration de serveur Debian 10, telle que décrite dans le initial guide de configuration du serveur pour Debian 10. Vous devriez avoir un utilisateur non root avec les privilèges + sudo + et un pare-feu actif.
Un nom de domaine pointé sur l’adresse IP publique de votre serveur.
Nginx installé, tel que couvert dans Comment installer Nginx sur Debian 10.
Nginx configuré avec SSL à l’aide des certificats Let’Secrypt. Comment sécuriser Nginx avec Let’s Encrypt sur Debian 10 vous guidera à travers le processus.

Une fois les conditions préalables remplies, vous aurez un serveur servant la page d’emplacement réservé de votre domaine par défaut à + https: /// +.

Étape 1 - Installation de Node.js

Commençons par installer la dernière version LTS de Node.js, à l’aide des archives de package NodeSource.

Pour installer le PPA NodeSource et accéder à son contenu, vous devez d’abord mettre à jour votre index de paquet et installer + curl +:

sudo apt update
sudo apt install curl

Assurez-vous que vous vous trouvez dans votre répertoire personnel, puis utilisez + curl + pour récupérer le script d’installation des archives Node.js .x:

cd ~
curl -sL https://deb.nodesource.com/setup_.x -o nodesource_setup.sh

Vous pouvez consulter le contenu de ce script avec + nano + ou votre https://www.digitalocean.com/community/tutorials/initial-server-setup-with-debian-9#step-six-%E2%80% 94-ending-optional-configuration [éditeur de texte préféré]:

nano nodesource_setup.sh

Quand vous avez fini d’inspecter le script, lancez-le sous + sudo +:

sudo bash nodesource_setup.sh

Le PPA sera ajouté à votre configuration et votre cache de paquet local sera mis à jour automatiquement. Après avoir exécuté le script d’installation à partir de Nodesource, vous pouvez installer le package Node.js:

sudo apt install nodejs

Pour vérifier quelle version de Node.js vous avez installée après ces étapes initiales, tapez:

nodejs -v

Outputv

Le package + nodejs + contient le binaire + nodejs + ainsi que https://www.npmjs.com/ [+ npm +], un gestionnaire de paquets pour les modules Node. Vous n’avez donc pas besoin d’installer `+ npm + `séparément.

+ npm + utilise un fichier de configuration dans votre répertoire personnel pour garder une trace des mises à jour. Il sera créé la première fois que vous exécutez + npm +. Exécutez cette commande pour vérifier que + npm + est installé et pour créer le fichier de configuration:

npm -v

Output

Pour que certains packages + npm + fonctionnent (ceux qui nécessitent la compilation du code source, par exemple), vous devez installer le package + build-essential +:

sudo apt install build-essential

Vous avez maintenant les outils nécessaires pour travailler avec les paquets + npm + qui nécessitent la compilation du code source.

Avec le runtime Node.js installé, nous pouvons passer à l’écriture d’une application Node.js.

Étape 2 - Création d’une application Node.js

Écrivons une application Hello World qui renvoie «Hello World» à toutes les requêtes HTTP. Cet exemple d’application vous aidera à configurer Node.js. Vous pouvez le remplacer par votre propre application. Assurez-vous simplement de modifier votre application pour écouter les adresses IP et les ports appropriés.

Commençons par créer un exemple d’application appelé + hello.js +:

cd ~
nano hello.js

Insérez le code suivant dans le fichier:

~ / hello.js

const http = require('http');

const hostname = 'localhost';
const port = 3000;

const server = http.createServer((req, res) => {
 res.statusCode = 200;
 res.setHeader('Content-Type', 'text/plain');
 res.end('Hello World!\n');
});

server.listen(port, hostname, () => {
 console.log(`Server running at http://${hostname}:${port}/`);
});

Enregistrez le fichier et quittez l’éditeur.

Cette application Node.js écoute l’adresse spécifiée (+ localhost +) et le port (+ 3000 +) et renvoie «Hello World!» Avec un code de réussite HTTP «+ 200 ». Comme nous écoutons ` localhost +`, les clients distants ne pourront pas se connecter à notre application.

Pour tester votre application, tapez:

node hello.js

Vous verrez la sortie suivante:

OutputServer running at http://localhost:3000/

Pour tester l’application, ouvrez une autre session de terminal sur votre serveur et connectez-vous à + localhost avec` + curl`:

curl http://localhost:

Si vous voyez la sortie suivante, l’application fonctionne correctement et écoute l’adresse et le port corrects:

OutputHello World!

Si vous ne voyez pas la sortie attendue, assurez-vous que votre application Node.js est en cours d’exécution et configurée pour écouter l’adresse et le port appropriés.

Une fois que vous êtes sûr que cela fonctionne, supprimez l’application (si vous ne l’avez pas déjà fait) en appuyant sur + CTRL + C +.

Étape 3 - Installation de PM2

Ensuite, installons PM2, un gestionnaire de processus pour les applications Node.js. PM2 permet de démoniser des applications afin qu’elles s’exécutent en arrière-plan en tant que service.

Utilisez + npm + pour installer la dernière version de PM2 sur votre serveur:

sudo npm install pm2 -g

L’option + -g + indique + npm + d’installer globalement le module afin qu’il soit disponible dans tout le système.

Commençons par la commande + pm2 start pour exécuter l’application` + hello.js` en arrière-plan:

pm2 start

Cela ajoute également votre application à la liste de processus de PM2, qui est sortie chaque fois que vous démarrez une application:

Output[PM2] Spawning PM2 daemon with pm2_home=/home/sammy/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /home/sammy/hello.js in fork_mode (1 instance)
[PM2] Done.
┌──────────┬────┬──────┬──────┬────────┬─────────┬────────┬─────┬───────────┬───────┬──────────┐
│ App name │ id │ mode │ pid  │ status │ restart │ uptime │ cpu │ mem       │ user  │ watching │
├──────────┼────┼──────┼──────┼────────┼─────────┼────────┼─────┼───────────┼───────┼──────────┤
│     │ 0  │ fork │ 1338 │ online │ 0       │ 0s     │ 0%  │ 23.0 MB   │ sammy │ disabled │
└──────────┴────┴──────┴──────┴────────┴─────────┴────────┴─────┴───────────┴───────┴──────────┘
Use `pm2 show <id|name>` to get more details about an app

Comme vous pouvez le constater, PM2 attribue automatiquement un + App name + basé sur le nom du fichier sans l’extension + .js +, ainsi qu’un PM2 + id +. PM2 conserve également d’autres informations, telles que le + PID + du processus, son état actuel et l’utilisation de la mémoire.

Les applications qui fonctionnent sous PM2 seront redémarrées automatiquement si l’application se bloque ou est tuée, mais nous pouvons prendre une étape supplémentaire pour que l’application soit lancée au démarrage du système à l’aide de la sous-commande + startup +. Cette sous-commande génère et configure un script de démarrage pour lancer PM2 et ses processus gérés au démarrage du serveur. Tapez ce qui suit:

sudo pm2 startup

Vous verrez une sortie qui ressemble à ceci, décrivant la configuration de service générée par PM2:

Output[PM2] Init System found: systemd
Platform systemd
Template
[Unit]
Description=PM2 process manager
Documentation=https://pm2.keymetrics.io/
After=network.target

[Service]
Type=forking
User=root
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
Environment=PM2_HOME=/root/.pm2
PIDFile=/root/.pm2/pm2.pid
Restart=on-failure

ExecStart=/usr/lib/node_modules/pm2/bin/pm2 resurrect
ExecReload=/usr/lib/node_modules/pm2/bin/pm2 reload all
ExecStop=/usr/lib/node_modules/pm2/bin/pm2 kill

[Install]
WantedBy=multi-user.target

Target path
/etc/systemd/system/pm2-root.service
Command list
[ 'systemctl enable pm2-root' ]
[PM2] Writing init configuration in /etc/systemd/system/pm2-root.service
[PM2] Making script booting at startup...
[PM2] [-] Executing: systemctl enable pm2-root...
Created symlink /etc/systemd/system/multi-user.target.wants/pm2-root.service → /etc/systemd/system/pm2-root.service.
[PM2] [v] Command successfully executed.
+---------------------------------------+
[PM2] Freeze a process list on reboot via:
$ pm2 save

[PM2] Remove init script via:
$ pm2 unstartup systemd

Vous avez maintenant créé un systemd unit qui exécute + pm2 + au démarrage. Cette instance + pm2 +, à son tour, exécute + hello.js +.

Démarrez le service avec + systemctl +:

sudo systemctl start pm2-root.service

Vérifiez l’état de l’unité systemd:

systemctl status pm2-root.service

Vous devriez voir une sortie comme celle-ci:

Output● pm2-root.service - PM2 process manager
  Loaded: loaded (/etc/systemd/system/pm2-root.service; enabled; vendor preset: enabled)
  Active:  since Fri 2019-07-12 16:09:54 UTC; 4s ago

Pour un aperçu détaillé de systemd, voir Systemd Essentials: Travailler avec des services, des unités et le journal.

En plus de ceux que nous avons abordés, PM2 fournit de nombreuses sous-commandes qui vous permettent de gérer ou de rechercher des informations sur vos applications.

Arrêtez une application avec cette commande (spécifiez le + nom de l’application ou le` + id` de PM2):

pm2 stop

Redémarrez une application:

pm2 restart

Répertoriez les applications actuellement gérées par PM2:

pm2 list

Obtenir des informations sur une application spécifique en utilisant son + nom de l’application +:

pm2 info

Le moniteur de processus PM2 peut être extrait avec la sous-commande + monit +. Ceci affiche l’état de l’application, l’utilisation du processeur et de la mémoire:

pm2 monit

Notez que lancer + pm2 + sans aucun argument affichera également une page d’aide avec un exemple d’utilisation.

Maintenant que votre application Node.js est en cours d’exécution et gérée par PM2, configurons le proxy inverse.

Étape 4 - Configuration de Nginx en tant que serveur proxy inverse

Votre application est en cours d’exécution et à l’écoute sur + localhost +, mais vous devez configurer un moyen permettant à vos utilisateurs d’y accéder. Nous allons configurer le serveur Web Nginx en tant que proxy inverse à cette fin.

Dans le didacticiel préalable, vous définissez votre configuration Nginx dans le fichier + / etc / nginx / sites-available / +. Ouvrez ce fichier pour le modifier:

sudo nano /etc/nginx/sites-available/

Dans le bloc + serveur +, vous devriez avoir un bloc + emplacement / + existant. Remplacez le contenu de ce bloc par la configuration suivante. Si votre application est configurée pour écouter sur un autre port, mettez à jour la partie en surbrillance avec le numéro de port correct:

/ etc / nginx / sites-available / votre_domaine

server {
...
   location / {
       proxy_pass http://localhost:;
       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;
   }
...
}

Cela configure le serveur pour répondre aux demandes à la racine. En supposant que notre serveur soit disponible à «+», accéder à ` https: /// ` via un navigateur Web enverrait la demande à ` hello.js `, en écoutant sur le port ` 3000 ` à ` localhost +` .

Vous pouvez ajouter des blocs + location + supplémentaires au même bloc de serveur pour permettre l’accès à d’autres applications sur le même serveur. Par exemple, si vous exécutiez également une autre application Node.js sur le port + 3001 +, vous pouvez ajouter ce bloc d’emplacement pour lui permettre d’y accéder via + https: /// +:

/ etc / nginx / sites-available / your_domain - Facultatif

server {
...
   location / {
       proxy_pass http://localhost:;
       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;
   }
...
}

Une fois que vous avez terminé d’ajouter les blocs d’emplacement pour vos applications, enregistrez le fichier et quittez votre éditeur.

Assurez-vous de ne pas avoir introduit d’erreurs de syntaxe en tapant:

sudo nginx -t

Redémarrez Nginx:

sudo systemctl restart nginx

En supposant que votre application Node.js est en cours d’exécution et que votre application et les configurations de Nginx sont correctes, vous devriez maintenant pouvoir accéder à votre application via le proxy inverse Nginx. Essayez-le en accédant à votre domaine dans le navigateur: + https: // +.

Conclusion

Toutes nos félicitations! Votre application Node.js s’exécute maintenant derrière un proxy inverse Nginx sur un serveur Debian 10. Cette configuration de proxy inverse est suffisamment souple pour permettre à vos utilisateurs d’accéder à d’autres applications ou à du contenu Web statique que vous souhaitez partager.

TOC