Comment configurer une application Node.js pour la production sur Ubuntu 16.04

De Get Docs
Aller à :navigation, rechercher

Introduction

Node.js est un environnement d'exécution JavaScript open source pour la création d'applications côté serveur et réseau. La plate-forme fonctionne sous Linux, MacOS, FreeBSD et Windows. Les applications Node.js peuvent être exécutées en ligne de commande, mais nous nous concentrerons sur leur exécution en tant que service, afin qu'elles redémarrent automatiquement en cas de redémarrage ou d'échec, et puissent être utilisées en toute sécurité dans un environnement de production.

Dans ce didacticiel, nous couvrirons la configuration d'un environnement Node.js prêt pour la production sur un seul serveur Ubuntu 16.04. 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 offrira HTTPS, en utilisant un certificat gratuit fourni par Let's Encrypt.

Conditions préalables

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

Lorsque vous aurez rempli les conditions préalables, vous disposerez d'un serveur servant la page d'espace réservé Nginx par défaut à l'adresse https://example.com/.

Commençons par installer le runtime Node.js sur votre serveur.

Étape 1 - Installation de Node.js

Nous allons installer la dernière version LTS de Node.js, en utilisant les archives du package NodeSource.

Tout d'abord, vous devez installer le PPA NodeSource afin d'accéder à son contenu. Assurez-vous d'être dans votre répertoire personnel et utilisez curl pour récupérer le script d'installation des archives Node.js 16.x :

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

Vous pouvez inspecter le contenu de ce script avec nano (ou votre éditeur de texte préféré) :

nano nodesource_setup.sh

Exécutez ensuite le script sous sudo :

sudo bash nodesource_setup.sh

Le PPA sera ajouté à votre configuration et votre cache de packages local sera mis à jour automatiquement. Après avoir exécuté le script d'installation à partir de nodesource, vous pouvez installer le package Node.js de la même manière que ci-dessus :

sudo apt-get install nodejs

Le package nodejs contient le binaire node ainsi que npm, vous n'avez donc pas besoin d'installer npm séparément. Cependant, pour que certains packages npm fonctionnent (tels que ceux qui nécessitent la compilation du code à partir des sources), vous devrez installer le package build-essential :

sudo apt-get install build-essential

Le runtime Node.js est maintenant installé et prêt à exécuter une application. Écrivons une application Node.js.

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

Nous allons écrire une application Hello World qui renvoie "Hello World" à toutes les requêtes HTTP. Ceci est un exemple d'application qui vous aidera à configurer votre Node.js, que vous pouvez remplacer par votre propre application. Assurez-vous simplement de modifier votre application pour écouter sur les adresses IP et les ports appropriés.

Bonjour Code du monde

Tout d'abord, créez et ouvrez votre application Node.js pour la modifier. Pour ce didacticiel, nous utiliserons nano pour éditer un exemple d'application appelé hello.js :

cd ~
nano hello.js

Insérez le code suivant dans le fichier. Si vous le souhaitez, vous pouvez remplacer le port en surbrillance, 8080, dans les deux emplacements (assurez-vous d'utiliser un port non administrateur, c'est-à-dire 1024 ou supérieur) :

bonjour.js

#!/usr/bin/env nodejs
var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(8080, 'localhost');
console.log('Server running at http://localhost:8080/');

Maintenant, enregistrez et quittez.

Cette application Node.js écoute sur l'adresse (localhost) et le port (8080) spécifiés et renvoie "Hello World" avec un code de réussite HTTP 200. Puisque nous écoutons sur localhost, les clients distants ne pourront pas se connecter à notre application.

Demande d'essai

Afin de tester votre application, configurez hello.js pour qu'il soit exécutable à l'aide de chmod :

chmod +x ./hello.js

Ensuite, lancez-le comme ceci :

./hello.js
OutputServer running at http://localhost:8080/

Remarque : L'exécution d'une application Node.js de cette manière bloquera les commandes supplémentaires jusqu'à ce que l'application soit supprimée en appuyant sur Ctrl-C.


Afin de tester l'application, ouvrez une autre session de terminal sur votre serveur et connectez-vous à localhost avec curl :

curl http://localhost:8080

Si vous voyez la sortie suivante, l'application fonctionne correctement et écoute sur l'adresse et le port appropriés :

OutputHello World

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

Une fois que vous êtes sûr que cela fonctionne, revenez à votre autre terminal et tuez l'application Node.js (si vous ne l'avez pas déjà fait) en appuyant sur Ctrl+C.

Étape 3 - Installation de PM2

Nous allons maintenant installer PM2, qui est un gestionnaire de processus pour les applications Node.js. PM2 fournit un moyen simple de gérer et de démoniser les applications (les exécuter en arrière-plan en tant que service).

Nous utiliserons npm, un gestionnaire de packages pour les modules Node qui s'installe avec Node.js, pour installer PM2 sur notre serveur. Utilisez cette commande pour installer PM2 :

sudo npm install -g pm2

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

Étape 4 - Gestion des applications avec PM2

Nous couvrirons quelques utilisations de base des PM2.

Démarrer l'application

La première chose à faire est d'utiliser la commande pm2 start pour exécuter votre application, hello.js, en arrière-plan :

pm2 start hello.js

Cela ajoute également votre application à la liste des 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.
┌─────┬──────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id  │ name     │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├─────┼──────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0   │ hello    │ default     │ N/A     │ fork    │ 13734    │ 0s     │ 0    │ online    │ 0%       │ 25.0mb   │ sammy    │ disabled │
└─────┴──────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘

Comme vous pouvez le voir, PM2 attribue automatiquement un name (basé sur le nom du fichier, sans l'extension .js) et 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 s'exécutent sous PM2 seront redémarrées automatiquement si l'application plante ou est tuée, mais une étape supplémentaire doit être franchie pour que l'application se lance au démarrage du système (démarrage ou redémarrage). Heureusement, PM2 fournit un moyen simple de le faire, la sous-commande startup.

La sous-commande startup génère et configure un script de démarrage pour lancer PM2 et ses processus gérés au démarrage du serveur :

pm2 startup systemd

La dernière ligne de la sortie résultante inclura une commande que vous devez exécuter avec les privilèges de superutilisateur :

Output[PM2] Init System found: systemd
[PM2] You have to run this command as root. Execute the following command:
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

Exécutez la commande qui a été générée (similaire à la sortie en surbrillance ci-dessus, mais avec votre nom d'utilisateur au lieu de sammy) pour configurer PM2 pour qu'il démarre au démarrage (utilisez la commande de votre propre sortie) :

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

Cela créera une unité systemd ' qui exécute pm2 pour votre utilisateur au démarrage. Cette instance pm2, à son tour, exécute hello.js. Vous pouvez vérifier l'état de l'unité systemd avec systemctl :

systemctl status pm2-sammy

Pour un aperçu détaillé de systemd, voir Systemd Essentials : Working with Services, Units, and the Journal.

Autre utilisation PM2 (facultatif)

PM2 fournit de nombreuses sous-commandes qui vous permettent de gérer ou de rechercher des informations sur vos applications. Notez que l'exécution de pm2 sans aucun argument affichera une page d'aide, comprenant des exemples d'utilisation, qui couvre l'utilisation de PM2 plus en détail que cette section du didacticiel.

Arrêtez une application avec cette commande (spécifiez le PM2 App name ou id) :

pm2 stop app_name_or_id

Redémarrez une application avec cette commande (spécifiez le PM2 App name ou id) :

pm2 restart app_name_or_id

La liste des applications actuellement gérées par PM2 peut également être consultée avec la sous-commande list :

pm2 list

Plus d'informations sur une application spécifique peuvent être trouvées en utilisant la sous-commande info (spécifiez le PM2 App name ou id) :

pm2 info example

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

pm2 monit

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

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

Maintenant que votre application est en cours d'exécution et qu'elle écoute sur localhost, vous devez configurer un moyen pour que vos utilisateurs y accèdent. Nous allons configurer le serveur Web Nginx en tant que proxy inverse à cet effet.

Dans le tutoriel prérequis, nous avons mis en place notre configuration Nginx dans le fichier /etc/nginx/sites-available/default. Ouvrez le fichier pour le modifier :

sudo nano /etc/nginx/sites-available/default

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

/etc/nginx/sites-available/default

. . .
    location / {
        proxy_pass http://localhost:8080;
        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 requêtes à sa racine. En supposant que notre serveur est disponible sur example.com, accéder à https://example.com/ via un navigateur Web enverrait la demande à hello.js, en écoutant sur le port 8080 sur 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 8081, vous pouvez ajouter ce bloc d'emplacement pour autoriser l'accès via http://example.com/app2 :

/etc/nginx/sites-available/default — Facultatif

    location /app2 {
        proxy_pass http://localhost:8081;
        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 et quittez.

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

sudo nginx -t

Ensuite, redémarrez Nginx :

sudo systemctl restart nginx

En supposant que votre application Node.js est en cours d'exécution et que les configurations de votre application et Nginx sont correctes, vous devriez maintenant pouvoir accéder à votre application via le proxy inverse Nginx. Essayez-le en accédant à l'URL de votre serveur (son adresse IP publique ou son nom de domaine).

Conclusion

Toutes nos félicitations! Votre application Node.js s'exécute maintenant derrière un proxy inverse Nginx sur un serveur Ubuntu 16.04. Cette configuration de proxy inverse est suffisamment flexible pour permettre à vos utilisateurs d'accéder à d'autres applications ou à du contenu Web statique que vous souhaitez partager. Bonne chance avec votre développement Node.js.