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

Introduction

Exécuter une application Node.js en local n'est que la première étape. Pour la rendre prête pour la production, vous devez la configurer pour des conditions réelles nécessitant stabilité, sécurité et performance. Un environnement de production correctement configuré garantit que votre application peut se remettre des plantages, servir le trafic de manière sécurisée et gérer une demande accrue sans interruption.

Dans ce guide, vous allez créer une configuration complète de production sur Ubuntu en utilisant Node.js, PM2, Nginx, Let’s Encrypt et UFW. Node.js exécute l’application, PM2 gère les processus et les redémarre automatiquement, Nginx gère les requêtes entrantes et sert le trafic en HTTPS, Let’s Encrypt fournit des certificats SSL gratuits, et UFW sécurise le serveur en contrôlant l’accès au réseau. Ensemble, ces outils forment une base solide pour déployer des applications fiables, efficaces et sécurisées.

Prérequis

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

• Une configuration de serveur Ubuntu, comme décrit dans la configuration initiale du serveur avec Ubuntu. Vous devriez avoir un utilisateur non root avec des privilèges sudo et un pare-feu actif.
• Un nom de domaine pointant vers l'adresse IP publique de votre serveur. Ce tutoriel utilisera le nom de domaine example.com tout au long.
• Nginx installé, comme expliqué dans le guide Comment installer et configurer Nginx sur Ubuntu.
• Nginx configuré avec SSL en utilisant des certificats Let’s Encrypt. Comment sécuriser Nginx avec Let’s Encrypt sur Ubuntu vous guidera à travers le processus.

Une fois que vous aurez terminé les prérequis, vous aurez un serveur qui sert la page par défaut de votre domaine à l'adresse https://example.com/.

Installer et vérifier Node.js

Dans cette étape, vous allez installer Node.js en utilisant le NodeSource PPA et vérifier que l'installation a réussi. Cette méthode garantit que vous avez accès à la dernière version Long-Term Support (LTS) de Node.js et à son gestionnaire de paquets associé, npm.

Installer Node.js via le PPA de NodeSource

Tout d'abord, installez le PPA de NodeSource pour accéder à son dépôt. Assurez-vous d'être dans votre répertoire personnel, et utilisez curl pour télécharger le script d'installation de la version LTS la plus récente de Node.js.

cd ~

curl -sL https://deb.nodesource.com/setup_24.x -o nodesource_setup.sh

Vous pouvez vérifier le contenu du script avec nano avant de l’exécuter :

nano nodesource_setup.sh

Lorsque vous êtes prêt, exécutez le script avec sudo :

sudo bash nodesource_setup.sh

Cela ajoutera le PPA à votre configuration et mettra automatiquement à jour le cache de paquets local.

Vous pouvez maintenant installer Node.js :

sudo apt install nodejs

Pour vérifier l'installation et connaître la version de Node.js, exécutez :

node -v

Vous devriez voir une sortie similaire à celle-ci :

v24.11.1

Installez npm et build-essential

Le paquet nodejs installe également npm, le gestionnaire de paquets de Node.js. Pour confirmer qu'il est installé et initialiser son fichier de configuration, exécutez :

npm -v

Vous devriez voir un résultat similaire :

11.6.2

Pour que certains paquets npm fonctionnent (ceux qui nécessitent de compiler du code à partir des sources, par exemple), vous devrez installer le paquet build-essential :

sudo apt install build-essential

Avec Node.js et npm installés avec succès, vous disposez maintenant des outils nécessaires pour développer et gérer les dépendances de votre application. Dans la section suivante, vous allez créer une application Node.js simple pour tester l'environnement d'exécution.

Créer une application Node.js exemple

Écrivons une application Node.js simple qui renvoie « Hello World » à toutes les requêtes HTTP. Cette application exemple permettra de vérifier que Node.js est correctement installé et de montrer comment les applications doivent être configurées pour écouter en toute sécurité sur localhost en production.

Créer un serveur Node.js simple

Créez un nouveau fichier appelé hello.js dans votre répertoire personnel :

cd ~

nano hello.js

Ajoutez le code suivant dans le fichier :

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 et fermez le fichier lorsque vous avez terminé.

Ce script crée un serveur HTTP simple qui écoute sur le port 3000 et répond par Hello World ! à toutes les requêtes entrantes. Comme il est lié à localhost, il n’acceptera que les connexions provenant de la même machine.

Tester l'application

Exécutez votre application en utilisant Node.js :

node hello.js

Vous devriez voir une sortie similaire à :

Server running at http://localhost:3000/

Dans une autre session de terminal, testez votre application avec curl :

curl http://localhost:3000

Vous devriez voir la sortie suivante :

Hello World!

Si vous n'obtenez pas le résultat attendu, assurez-vous que votre application Node.js est en cours d'exécution et configurée pour écouter à l'adresse et au port corrects.

Une fois que vous êtes sûr que ça fonctionne, arrêtez l'application en appuyant sur CTRL+C dans le terminal d'origine pour arrêter le serveur.

Pourquoi les applications devraient se lier à localhost en production

Dans les environnements de production, les applications Node.js se trouvent généralement derrière un proxy inverse tel que Nginx. L'application Node.js écoute sur une adresse interne (comme localhost:3000), et Nginx prend en charge le trafic web entrant, la terminaison TLS et le routage.

Lier votre application à localhost offre plusieurs avantages en matière de sécurité et de fiabilité :

• Prévient l'exposition externe : Seul Nginx peut accéder directement au processus Node.js.
• Permet le déchargement HTTPS : Nginx gère les certificats SSL et le chiffrement, déchargeant ce travail de Node.js.
• Simplifie les règles du pare-feu : Le pare-feu peut bloquer l'accès à tous les ports des applications internes tout en autorisant HTTP/HTTPS.

Cette configuration garantit que votre application Node.js est isolée, sécurisée et accessible uniquement via le proxy inverse Nginx.

Installer et configurer le gestionnaire de processus PM2

Dans cette section, vous allez installer PM2, un gestionnaire de processus de production pour les applications Node.js. PM2 vous permet de maintenir vos applications en fonctionnement continu, de les redémarrer automatiquement après un plantage et de les configurer pour qu'elles démarrent au démarrage du système.

Installation de PM2

Utilisez npm pour installer PM2 globalement :

sudo npm install -g pm2

Le -g permet d’installer PM2 pour tout le système, ce qui le rend disponible pour tous les utilisateurs et toutes les applications.

Une fois installé, démarrez votre application exemple en utilisant PM2 :

pm2 start hello.js

Vous verrez un tableau de sortie indiquant que PM2 a commencé à gérer votre application :

[PM2] Spawning PM2 daemon with pm2_home=/home/user/.pm2
[PM2] PM2 Successfully daemonized
[PM2] Starting /root/nodeapp/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    │ 3826     │ 0s     │ 0    │ online    │ 0%       │ 33.3mb   │ root     │ disabled │
└────┴──────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘

Comme indiqué ci-dessus, PM2 attribue automatiquement un nom d'application (basé sur le nom du fichier, sans l'extension .js) et un id PM2. PM2 conserve également d'autres informations, telles que le PID du processus, son état actuel et l'utilisation de la mémoire.

Activation du redémarrage automatique en cas de plantage et de redémarrage

PM2 redémarre automatiquement votre application si elle plante ou est arrêtée. Pour vous assurer que PM2 lui-même démarre automatiquement lorsque le serveur redémarre, exécutez :

pm2 startup systemd

PM2 générera une commande qui ressemblera à ceci (remplacez sammy par votre nom d'utilisateur) :

[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/home/sammy/.nvm/versions/node/v24.11.1/bin /home/sammy/.nvm/versions/node/v24.11.1/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

Exécutez cette commande, puis enregistrez vos applications en cours d'exécution afin que PM2 s'en souvienne au prochain redémarrage :

pm2 save

Pour confirmer que tout est correctement configuré, vérifiez l'état du service :

systemctl status pm2-sammy

Si vous rencontrez des problèmes, redémarrez votre serveur et vérifiez que votre application se lance automatiquement.

Utilisation du fichier Ecosystem de PM2

Quand vous êtes prêt à exécuter plus d’une application ou à gérer différents environnements, le fichier écosystème de PM2 est d’une grande aide. C’est un fichier de configuration simple qui vous permet de définir les variables d’environnement, les ports et les paramètres de déploiement, le tout au même endroit.

Générez un fichier de démarrage en exécutant :

pm2 ecosystem

Puis modifiez le fichier ecosystem.config.js généré :

module.exports = {
  apps: [
    {
      name: 'hello',
      script: 'hello.js',
      env: {
        NODE_ENV: 'development',
        PORT: 3001
      },
      env_production: {
        NODE_ENV: 'production',
        PORT: 3000
      }
    }
  ]
};

Pour démarrer votre application en mode production, utilisez :

pm2 start ecosystem.config.js --env production

Le fichier écosystème facilite la gestion de plusieurs environnements et le stockage sécurisé des variables d'environnement en dehors de votre code source. Avec PM2 en place, votre application survivra aux plantages, aux redémarrages et aux mises à jour, tout en s'exécutant discrètement en arrière-plan.

Commandes PM2 supplémentaires

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

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

pm2 stop app_name_or_id

Redémarrer une application :

pm2 restart app_name_or_id

Liste des applications actuellement gérées par PM2 :

pm2 list

Obtenez des informations sur une application spécifique en utilisant son nom d'application :

pm2 info app_name

Pour afficher les journaux en direct de votre application :

pm2 logs

Le moniteur de processus PM2 peut être affiché avec la sous-commande monit. Cela 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 des exemples d'utilisation.

Maintenant que votre application Node.js fonctionne et est gérée par PM2, configurons le proxy inverse.

Configurer Nginx comme proxy inverse

Avec votre application Node.js fonctionnant sous PM2, l'étape suivante consiste à la rendre accessible aux utilisateurs via le web. Au lieu d'exposer l'application directement sur le port 3000, vous utiliserez Nginx comme proxy inverse. Nginx gérera toutes les requêtes HTTP et HTTPS entrantes et les transmettra à votre application Node.js fonctionnant sur localhost.

Configuration de proxy inversé de base

Ouvrez le fichier de configuration Nginx de votre site. Si vous avez suivi l'installation décrite dans la section des prérequis, ce fichier devrait se trouver dans /etc/nginx/sites-available/example.com :

sudo nano /etc/nginx/sites-available/example.com

À l'intérieur du bloc server, localisez (ou créez) la section location / et remplacez son contenu par la configuration suivante. Si votre application Node.js écoute sur un autre port, mettez à jour la valeur indiquée en conséquence.

server {
...
    listen 80;
    server_name example.com www.example.com;

    location / {
        proxy_pass http://localhost:3000;
        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 indique à Nginx d'écouter sur le port 80 (HTTP) et de transférer tout le trafic entrant vers votre application Node.js exécutée sur le port 3000.

Pour tester plusieurs applications, vous pouvez définir des blocs location supplémentaires. Par exemple, si vous avez une autre application Node.js fonctionnant sur le port 3001, ajoutez ceci au même bloc serveur :

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

Enregistrez le fichier, puis testez la configuration pour détecter les erreurs de syntaxe en exécutant :

sudo nginx -t

Si tout est en ordre, rechargez Nginx :

sudo systemctl reload nginx

À ce stade, visiter le domaine de votre serveur (par exemple, http://example.com) devrait charger l'application Node.js fonctionnant via le proxy Nginx.

Ajout de la configuration HTTPS (SSL)

Pour sécuriser votre application, configurez Nginx pour gérer le trafic HTTPS. Si vous disposez déjà de certificats SSL de Let’s Encrypt, assurez-vous qu’ils sont définis dans votre configuration Nginx. Voici un exemple de ce à quoi pourrait ressembler le bloc serveur mis à jour :

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name example.com www.example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

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

Le premier bloc de serveur redirige automatiquement toutes les requêtes HTTP vers HTTPS, et le deuxième bloc gère le trafic sécurisé sur le port 443.

Routage de plusieurs applications (optionnel)

Si votre serveur héberge plusieurs applications, Nginx peut toutes les gérer en définissant différents chemins ou sous-domaines. Par exemple, vous pourriez avoir :

• https://example.com/ redirige vers le port 3000
• https://example.com/app2 redirige vers le port 3001
• https://api.example.com/ redirige vers le port 4000

Chaque application peut être gérée par son propre processus PM2 et servie via Nginx.

Une fois que vous avez confirmé que tout fonctionne, votre application Node.js devrait désormais être accessible de manière sécurisée via Nginx.

Configurer le pare-feu UFW pour la production

Maintenant que votre application Node.js fonctionne derrière Nginx, ajoutons une dernière couche de sécurité réseau. Ubuntu est livré avec un pare-feu intégré appelé UFW (Uncomplicated Firewall). Il est léger, simple à configurer et parfait pour bloquer les accès indésirables à votre serveur.

Vérification de l'état du pare-feu

Avant d'apporter des modifications, vérifiez si UFW est déjà activé :

sudo ufw status

Si c'est indiqué inactif, ne vous inquiétez pas, nous l'activerons sous peu. Mais d'abord, nous définirons quels types de trafic doivent être autorisés. Il est toujours préférable de configurer les règles avant de l'activer.

Autoriser le trafic essentiel

Au minimum, vous devrez autoriser SSH afin de pouvoir toujours vous connecter à votre serveur, ainsi que HTTP/HTTPS afin que Nginx puisse gérer le trafic web. Pour ce faire, exécutez les commandes suivantes :

sudo ufw allow OpenSSH

sudo ufw allow 'Nginx Full'

Nous pouvons maintenant activer le pare-feu :

sudo ufw enable

Vous serez invité à confirmer : tapez y et appuyez sur Entrée.

Vérifiez à nouveau le pare-feu pour vous assurer que vos règles sont actives :

sudo ufw status

Vous devriez voir quelque chose comme ça :

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)

C’est tout ! Seul le trafic SSH et web est désormais autorisé ; tout le reste est bloqué.

Pourquoi un pare-feu est important en production

Les pare-feux sont essentiels à la sécurité des serveurs car ils établissent un contrôle strict sur le trafic réseau pouvant atteindre votre système. Même des applications et des serveurs web bien configurés peuvent être vulnérables si des ports inutiles restent ouverts.

Voici quelques raisons clés pour lesquelles les pare-feux sont essentiels en production :

• Minimiser l'exposition : Seuls les ports explicitement autorisés sont accessibles, réduisant ainsi le nombre de vecteurs d'attaque potentiels.
• Confinement : en cas de violation ou de mauvaise configuration, un pare-feu limite jusqu'où un attaquant peut se déplacer au sein de votre système ou réseau.
• Conformité et audit : De nombreuses normes de sécurité exigent une protection par pare-feu active avec des règles d'accès traçables.
• Défense en profondeur : Les pare-feu viennent en complément d'autres couches de sécurité telles que TLS, l'authentification et le renforcement des applications.

Pour la plupart des serveurs de production, garder un pare-feu actif avec seulement les ports essentiels ouverts représente le bon équilibre entre accessibilité et protection. C’est une mesure de sécurité peu contraignante qui offre une couche de contrôle supplémentaire et aide à prévenir les accès non autorisés au réseau.

Avec UFW configuré, votre système est désormais plus sécurisé au niveau du réseau.

Activer SSL avec Let’s Encrypt

Maintenant que votre application est accessible publiquement via Nginx, il est temps d'ajouter le HTTPS pour des communications sécurisées. SSL chiffre tout le trafic entre votre serveur et les utilisateurs, garantissant la confidentialité et l'intégrité des données. Le moyen le plus simple d'ajouter SSL à votre site est d'utiliser Let’s Encrypt, une autorité de certification gratuite et automatisée.

Installez Certbot et le module Nginx

Let’s Encrypt fonctionne grâce à un outil appelé Certbot, qui gère l’ensemble du processus de demande, d’installation et de renouvellement des certificats. Sur Ubuntu, vous pouvez installer Certbot ainsi que son plugin Nginx en une seule étape :

sudo apt update

sudo apt install certbot python3-certbot-nginx -y

Cela installe à la fois le client Certbot et son plugin d'intégration Nginx, qui configurera automatiquement HTTPS dans votre bloc de serveur Nginx existant.

Obtenir des certificats SSL

Une fois Certbot installé, vous pouvez l'utiliser pour demander un nouveau certificat SSL pour votre domaine. Remplacez example.com et www.example.com par vos noms de domaine réels :

sudo certbot --nginx -d example.com -d www.example.com

Pendant le processus, Certbot va :

• Vérifiez que votre domaine pointe vers ce serveur (en utilisant un défi HTTP)
• Obtenez un certificat SSL auprès de Let’s Encrypt
• Modifiez automatiquement votre configuration Nginx pour activer HTTPS
• Rechargez Nginx afin que les nouveaux paramètres prennent effet

Il vous sera demandé de fournir une adresse e-mail (utilisée pour les notifications de renouvellement) et d’accepter les conditions d’utilisation. Une fois la configuration terminée, vous devriez voir un message de confirmation indiquant que votre certificat a été installé avec succès.

Vous pouvez vérifier à nouveau les détails de votre certificat avec :

sudo certbot certificates

Puis visitez votre domaine pour vérifier que le site est désormais servi de manière sécurisée.

Renouvellement automatique

Les certificats Let’s Encrypt ne sont valables que pendant 90 jours, mais il n’est pas nécessaire de se soucier des renouvellements manuels. Certbot installe un minuteur système qui s’exécute deux fois par jour pour vérifier les certificats arrivant à expiration et les renouveler automatiquement.

Vous pouvez tester ce processus de renouvellement à tout moment avec :

sudo certbot renew --dry-run

Si l'exécution à blanc se termine sans erreurs, vos certificats se renouvelleront automatiquement en arrière-plan, et Nginx se rechargera pour appliquer les nouveaux.

Pourquoi HTTPS est important

Exécuter votre application en HTTPS n'est plus facultatif, c'est une partie essentielle de la gestion de tout système en production. SSL/TLS garantit que toutes les communications entre votre serveur et vos clients sont cryptées et à l'abri de toute altération, protégeant contre l'espionnage et la manipulation des données.

Au-delà de la sécurité, HTTPS offre plusieurs avantages supplémentaires :

• Confiance et crédibilité : Les navigateurs indiquent que les sites non sécurisés par HTTPS sont « Non sécurisé », ce qui peut nuire à la confiance des utilisateurs.
• Meilleur classement dans les résultats de recherche : Les principaux moteurs de recherche utilisent le HTTPS comme signal de classement.
• Accès aux fonctionnalités web modernes : HTTP/2, QUIC et d'autres améliorations de performance nécessitent TLS.
• Conformité : De nombreuses réglementations en matière de confidentialité et normes industrielles exigent le chiffrement des données transmises.

En utilisant Let’s Encrypt, vous bénéficiez de ces avantages avec une configuration minimale et sans aucun coût. Les certificats se renouvellent automatiquement, ce qui en fait une solution simple à long terme pour des déploiements sécurisés.

Avec HTTPS en place, votre serveur diffuse désormais un trafic chiffré et sûr.

Gérer les variables d'environnement de manière sécurisée

Chaque application en production a besoin d'un moyen fiable pour gérer les données de configuration telles que les clés API, les identifiants de base de données ou les jetons secrets. Les stocker directement dans votre code source peut les exposer via le contrôle de version, les journaux ou même des fuites côté client. Une approche plus sûre consiste à utiliser des variables d'environnement, qui permettent de séparer les informations sensibles de votre base de code.

Utilisation des fichiers .env avec dotenv

Une méthode courante et simple pour gérer les variables d'environnement dans Node.js consiste à utiliser un fichier .env avec le package dotenv. Cette configuration permet à votre application de lire les valeurs de configuration au moment de l'exécution tout en les gardant hors du code source.

Exécutez ce qui suit pour installer le paquet dotenv :

npm install dotenv

Ensuite, créez un fichier .env dans le répertoire de votre projet :

nano .env

Ajoutez vos valeurs de configuration sous forme de paires clé-valeur, comme ceci :

PORT=3000
NODE_ENV=production
DB_HOST=localhost
DB_USER=myuser
DB_PASS=securepassword
JWT_SECRET=myjwtsecretkey

Maintenant, modifiez votre fichier principal de l'application (par exemple, app.js) pour charger les variables d'environnement au démarrage :

require('dotenv').config();

const express = require('express');
const app = express();

app.listen(process.env.PORT, () => {
  console.log(`Server running in ${process.env.NODE_ENV} mode on port ${process.env.PORT}`);
});

Lorsque votre application s'exécute, elle lit les variables définies dans le fichier .env et les utilise pour configurer l'environnement d'exécution.

Variables d'environnement avec PM2

Si vous exécutez votre application avec PM2, vous pouvez définir des variables d'environnement directement dans les commandes ou les fichiers de configuration de PM2. Cela aide à maintenir des configurations cohérentes entre les environnements comme le développement, la préproduction et la production.

Vous pouvez définir des variables directement lors du lancement d'une application :

pm2 start app.js --name "myapp" --env production

Pour une solution plus propre et évolutive, utilisez le fichier de configuration de l'écosystème de PM2. Générez-le en utilisant :

pm2 ecosystem

Puis modifiez le fichier ecosystem.config.js pour inclure vos variables d'environnement :

module.exports = {
  apps: [
    {
      name: 'myapp',
      script: 'app.js',
      env: {
        NODE_ENV: 'development',
        PORT: 3001
      },
      env_production: {
        NODE_ENV: 'production',
        PORT: 3000,
        DB_HOST: 'localhost',
        DB_USER: 'myuser',
        DB_PASS: 'securepassword'
      }
    }
  ]
};

Démarrez l'application en mode production :

pm2 start ecosystem.config.js --env production

Cela garantit que les bonnes variables sont chargées automatiquement à chaque redémarrage de l'application.

Meilleures pratiques pour la gestion des secrets

Gérer les secrets et les variables d'environnement de manière sécurisée est essentiel pour maintenir l'intégrité de votre infrastructure. Les meilleures pratiques suivantes vous aideront à minimiser les risques :

• Ne gardez pas de secrets dans le contrôle de version : Ne validez jamais les fichiers .env dans votre dépôt Git. Ajoutez-les à .gitignore pour éviter toute exposition accidentelle.

• Limiter l'accès : Seuls les utilisateurs de confiance et les systèmes automatisés devraient avoir la permission de lire ou de modifier les fichiers de configuration de l'environnement.

• Utilisez des fichiers spécifiques à l'environnement : Maintenez des configurations séparées pour le développement, les tests, la préproduction et la production. Par exemple, .env.development et .env.production.

• Faites tourner régulièrement vos secrets : Changez les clés API, les jetons et les mots de passe selon un calendrier pour réduire l'impact d'éventuelles fuites.

• Utilisez un gestionnaire de secrets pour les systèmes plus importants : Pour des applications ou des équipes complexes, envisagez d’utiliser des services comme HashiCorp Vault plutôt que des fichiers .env locaux.

• Évitez de consigner des données sensibles : Faites attention à ne pas afficher ou enregistrer des informations secrètes dans les journaux de votre application ou de votre déploiement.

• Valider les variables d'environnement au démarrage : Utilisez des bibliothèques telles que joi ou env-schema pour vous assurer que toutes les variables requises sont définies avant que l'application ne s'exécute.

• Restreindre les permissions des fichiers : utilisez la commande chmod pour limiter l'accès aux fichiers .env. Par exemple :

  chmod 600 .env

Suivre ces pratiques aide à protéger les informations sensibles, à prévenir les divulgations accidentelles et à faciliter la gestion de la configuration sur plusieurs environnements.

Techniques d'optimisation de la production

Avec votre application opérationnelle dans un environnement de production stable, il est important de se concentrer sur la performance et l'efficacité. L'optimisation améliore non seulement l'expérience utilisateur, mais réduit également les coûts des serveurs et contribue à assurer une montée en charge fluide. Dans cette section, vous apprendrez plusieurs techniques pour affiner votre configuration Node.js et Nginx afin d'améliorer la vitesse, la fiabilité et l'utilisation des ressources.

Activer la compression (gzip ou Brotli)

La compression est l'un des moyens les plus simples d'améliorer les performances. Elle réduit la taille des fichiers envoyés du serveur au client, ce qui accélère le chargement des pages et réduit la consommation de bande passante. Nginx prend en charge deux méthodes de compression populaires : gzip et Brotli.

Utilisation de gzip

Pour activer la compression gzip, ouvrez le fichier de configuration principal de Nginx :

sudo nano /etc/nginx/nginx.conf

À l'intérieur du bloc http, ajoutez ou décommentez les directives suivantes :

gzip on;
gzip_types text/plain text/css application/javascript application/json application/xml;
gzip_min_length 256;
gzip_comp_level 5;

Ces paramètres activent gzip pour les types de fichiers courants, compressent les fichiers de plus de 256 octets et appliquent un niveau de compression modéré pour équilibrer la charge CPU et les performances.

Utilisation de Brotli

Si vous avez le module Brotli installé, vous pouvez l’utiliser pour obtenir des taux de compression encore meilleurs :

brotli on;
brotli_comp_level 5;
brotli_types text/plain text/css application/javascript application/json application/xml;

Brotli est particulièrement efficace pour les ressources basées sur du texte comme le CSS et le JavaScript. Après avoir effectué ces modifications, rechargez Nginx pour les appliquer :

sudo systemctl reload nginx

Avec la compression activée, les clients téléchargeront les ressources plus rapidement, ce qui se traduira par des temps de chargement plus courts et de meilleures performances sur les appareils de bureau et mobiles.

Configurer la mise en cache dans Nginx

La mise en cache permet à votre serveur de réutiliser des réponses générées précédemment au lieu de les régénérer pour chaque requête. Cela réduit considérablement la charge sur votre application Node.js et accélère les temps de réponse pour les utilisateurs finaux.

Pour mettre en cache des ressources statiques telles que des images, des feuilles de style et des scripts, ajoutez cette configuration à votre bloc server Nginx :

location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 7d;
    add_header Cache-Control "public, no-transform";
}

Cette configuration demande aux navigateurs de mettre en cache les ressources statiques pendant sept jours. Vous pouvez ajuster la durée en fonction de la fréquence à laquelle vos fichiers statiques changent.

Pour les API ou le contenu dynamique, la mise en cache peut être appliquée de manière plus sélective. Par exemple, vous pouvez mettre en cache les réponses pour les points de terminaison fréquemment consultés tout en excluant ceux qui renvoient des données spécifiques à l'utilisateur. Nginx prend également en charge le microcaching (mise en cache à court terme en secondes) pour les API à fort trafic.

Meilleures pratiques en journalisation

Les journaux sont essentiels pour la surveillance, le dépannage et l'optimisation des performances. PM2 et Nginx offrent tous deux des outils de journalisation complets qui vous aident à suivre ce qui se passe dans votre système.

Journaux PM2

PM2 gère automatiquement les journaux de votre application. Pour les consulter en temps réel, utilisez :

pm2 logs

Avec le temps, les journaux peuvent devenir volumineux et consommer de l'espace disque. Pour éviter cela, installez le module de rotation des journaux de PM2 :

pm2 install pm2-logrotate

Puis configurez la politique de rotation :

pm2 set pm2-logrotate:max_size 10M

pm2 set pm2-logrotate:retain 7

Cette configuration maintient les fichiers journaux sous 10 Mo chacun et conserve sept jours de journaux. Vous pouvez ajuster ces valeurs en fonction de votre capacité de stockage et de vos besoins en journalisation.

Journaux Nginx

Nginx conserve à la fois les journaux d'accès (enregistrements de chaque requête) et les journaux d'erreurs (informations sur les problèmes et les pannes). Ces journaux sont généralement stockés dans /var/log/nginx/.

Vous pouvez consulter les journaux d'accès manuellement ou générer un rapport détaillé du trafic en utilisant des outils comme goaccess :

sudo apt install goaccess

sudo goaccess /var/log/nginx/access.log -o /var/www/html/report.html --log-format=COMBINED

Cette commande crée un rapport HTML interactif avec des métriques sur les emplacements des visiteurs, le volume de trafic et les temps de réponse.

Des journaux bien gérés sont essentiels pour identifier les goulets d'étranglement de performance, les requêtes échouées ou les anomalies de sécurité avant qu'elles n'affectent les utilisateurs.

Gestion des ressources et optimisation de Node.js

Les applications Node.js s'exécutent par défaut sur un seul thread. Pour utiliser tous les cœurs du processeur disponibles et améliorer la concurrence, vous pouvez utiliser le clustering et d'autres techniques de gestion des processus.

Utiliser le regroupement

PM2 peut démarrer automatiquement plusieurs processus Node.js pour tirer parti des processeurs multi-cœurs :

pm2 start app.js -i max

Cette commande démarre autant d'instances de votre application qu'il y a de cœurs CPU sur votre serveur. PM2 gérera la répartition de la charge et redémarrera les processus en cas de défaillance.

Surveiller l'utilisation de la mémoire et du processeur

Surveillez régulièrement l’utilisation des ressources de votre application afin de prévenir les fuites de mémoire ou une consommation excessive du processeur :

pm2 monit

Cela ouvre un tableau de bord interactif affichant les métriques de mémoire et de CPU en temps réel pour chaque processus.

Décharger les ressources statiques sur Nginx

Laissez Nginx servir directement les fichiers statiques au lieu de les acheminer via Node.js. Cela réduit considérablement l'utilisation du CPU côté Node.js et garantit une livraison plus rapide des ressources mises en cache.

Configuration de l'environnement

Utilisez des variables d'environnement pour ajuster les paramètres de performance tels que la verbosité des journaux, les limites de taux de l'API ou les durées de mise en cache. Gérer la configuration via des variables d'environnement rend votre application plus flexible et plus facile à mettre à l'échelle.

Surveillance et métriques

Après avoir optimisé votre environnement de production, l'étape essentielle suivante consiste à mettre en place une surveillance efficace et la collecte de métriques. La surveillance vous offre une visibilité sur les performances de votre application, l'utilisation des ressources et la santé du système. Elle vous aide à détecter les problèmes tôt, à suivre les tendances à long terme et à apporter des améliorations basées sur les données.

Voyons comment vous pouvez surveiller votre application Node.js, votre serveur web Nginx et vos ressources système en utilisant des outils intégrés et des services externes.

Pourquoi la surveillance est importante

En production, chaque seconde compte. Sans surveillance, les problèmes de performance ou les interruptions de service peuvent passer inaperçus jusqu'à ce qu'ils affectent les utilisateurs. La surveillance vous aide à :

• Détectez rapidement les défaillances et recevez automatiquement une alerte lorsqu'elles se produisent.
• Analyser les performances du système sous différentes charges de trafic.
• Identifiez les points de terminaison lents, les goulots d'étranglement ou les fuites de mémoire.
• Prenez des décisions éclairées en matière de mise à l'échelle et d'optimisation.
• Maintenez la disponibilité et la fiabilité lors des déploiements.

Une configuration de surveillance bien conçue inclut à la fois une surveillance en temps réel pour les alertes immédiates et des mesures historiques pour l'analyse des performances au fil du temps.

Surveillance des applications Node.js avec PM2

PM2, le gestionnaire de processus utilisé pour exécuter votre application Node.js, inclut des fonctionnalités de surveillance puissantes.

Surveillance en temps réel

Pour obtenir un aperçu des processus en cours, utilisez :

pm2 list

Cela affiche toutes les applications actives ainsi que leur état, leur temps de fonctionnement, l'utilisation du processeur et de la mémoire. Pour une vue en direct plus détaillée, utilisez :

pm2 monit

Cela ouvre un tableau de bord interactif affichant les principaux indicateurs de performance, tels que l'utilisation du CPU et de la mémoire par processus. La surveillance de ces indicateurs vous aide à détecter l'épuisement des ressources, les processus incontrôlés ou les fuites de mémoire.

Surveillance des journaux

PM2 offre également une gestion centralisée des journaux. Pour consulter les journaux de votre application, exécutez :

pm2 logs

Vous pouvez consulter les journaux d'une application spécifique en utilisant :

pm2 logs myapp

Si vous remarquez des redémarrages fréquents, vérifiez la liste des processus de PM2 avec :

pm2 status

Cela montrera combien de fois chaque processus a redémarré, ce qui peut être un indicateur d'erreurs ou de plantages.

Surveillance Avancée (PM2 Plus)

Pour les déploiements plus importants, PM2 propose PM2 Plus, un tableau de bord basé sur le web qui suit des métriques telles que l'utilisation du CPU, la consommation de mémoire et le temps de disponibilité des applications sur tous les serveurs. Vous pouvez configurer des alertes pour les dépassements de seuil et consulter les tendances de performance au fil du temps.

PM2 peut également s'intégrer avec des systèmes de surveillance tiers populaires comme Datadog, New Relic et Prometheus pour une visibilité unifiée.

Surveillance de Nginx

Nginx se trouve à l'avant de votre pile de production, gérant les requêtes HTTP et la terminaison SSL. Surveiller Nginx est essentiel pour comprendre comment les utilisateurs interagissent avec votre système et comment les requêtes sont traitées efficacement.

Journaux d'accès et d'erreurs

Nginx enregistre chaque requête qu'il traite dans le journal d'accès, généralement situé à :

/var/log/nginx/access.log

Les erreurs sont enregistrées séparément dans :

/var/log/nginx/error.log

Vous pouvez consulter ces journaux en temps réel :

sudo tail -f /var/log/nginx/access.log

Les journaux d'accès montrent des informations précieuses telles que les adresses IP des clients, les temps de réponse, les codes d'état et les agents utilisateurs. Ces journaux sont utiles pour identifier des schémas tels qu'une latence élevée, des erreurs 404 fréquentes ou des volumes de requêtes anormaux.

Pour un rapport résumé et visuel, vous pouvez utiliser goaccess. Il crée un tableau de bord interactif qui met en évidence les sources de trafic, les points de terminaison populaires et la répartition des réponses.

Activer la page d'état Nginx

Nginx inclut un module léger stub_status qui expose des métriques serveur en temps réel, telles que le nombre de connexions actuelles et le nombre de requêtes. Ajoutez le bloc suivant à votre configuration Nginx :

location /nginx_status {
    stub_status;
    allow 127.0.0.1;
    deny all;
}

Après avoir rechargé Nginx, vous pouvez consulter les métriques en visitant :

http://localhost/nginx_status

Ces indicateurs peuvent être intégrés dans des tableaux de bord de suivi ou utilisés pour des alertes automatiques.

Collecte des métriques d'application à partir de Node.js

Pour une surveillance plus détaillée au niveau de l'application, vous pouvez collecter des métriques personnalisées directement depuis votre application Node.js. Ces métriques peuvent suivre les temps de réponse des API, les taux de requêtes ou la durée des requêtes de base de données.

Exécutez la commande suivante pour installer la bibliothèque client Prometheus :

npm install prom-client express

Ajoutez un point de terminaison /metrics à votre application :

const express = require('express');
const client = require('prom-client');
const app = express();

client.collectDefaultMetrics({ timeout: 5000 });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

app.listen(3000, () => {
  console.log('Metrics available at /metrics');
});

Vous pouvez connecter ce point de terminaison à Prometheus ou Grafana pour visualiser des métriques telles que la latence des requêtes, l'utilisation de la mémoire et les performances de la collecte des déchets.

Surveillance au niveau du système

En plus de la surveillance des applications, surveillez les performances globales du serveur. Linux offre plusieurs outils à cet effet :

• htop ou top : Affiche l'utilisation du CPU et de la mémoire en temps réel.
• iostat : Surveille les opérations d'entrée/sortie des disques.
• netstat ou ss : Affiche les connexions réseau ouvertes.
• vmstat : Suit les processus, la mémoire et les statistiques d’E/S.

Vous pouvez automatiser la surveillance du système en utilisant des outils tels que Netdata, Glances ou Grafana Agent, qui collectent des métriques à travers votre infrastructure et les visualisent dans des tableaux de bord.

Erreurs courantes, dépannage et bonnes pratiques

Même une configuration de production bien conçue peut parfois rencontrer des problèmes. Comprendre comment identifier, diagnostiquer et résoudre ces problèmes est essentiel pour maintenir la fiabilité et minimiser les temps d'arrêt. Cette section fournit des étapes détaillées de dépannage pour les erreurs courantes et décrit les bonnes pratiques pour vous aider à garder votre environnement Node.js stable, sécurisé et facilement maintenable sur le long terme.

Erreurs courantes et solutions

1. L'application ne démarre pas avec PM2

• Cause : Chemins de fichiers incorrects, dépendances manquantes ou variables d'environnement mal configurées.

• Solution : Vérifiez les journaux en utilisant :

  pm2 logs

  Vérifiez que le bon chemin de fichier est utilisé dans votre configuration PM2. Réinstallez les dépendances si nécessaire :

  npm install --production

  Vérifiez également que les variables d'environnement nécessaires sont correctement chargées depuis .env ou votre fichier écosystème.

2. Erreur : port déjà utilisé

• Cause : Un autre processus écoute déjà sur le même port.

• Solution : Identifiez et arrêtez le processus conflictuelle :

  sudo lsof -i :3000
  
  sudo kill -9 <PID>

  Alternativement, changez le port de votre application dans le fichier .env ou dans la configuration de l'écosystème.

3. Nginx 502 Mauvaise passerelle

• Cause : Nginx ne peut pas atteindre l'application Node.js, généralement parce que l'application a planté, s'est arrêtée ou est liée à un port différent.

• Solution : Redémarrez l'application Node.js et rechargez Nginx :

  pm2 restart all
  
  sudo systemctl reload nginx

  Assurez-vous que la valeur proxy_pass de Nginx correspond à l'adresse d'écoute de votre application Node.js (par exemple, http://localhost:3000).

4. Erreurs de permission refusée

• Cause : L'utilisateur de l'application n'a pas la permission de lire ou d'écrire certains fichiers ou répertoires.

• Solution : Définir la propriété et les permissions correctes :

  sudo chown -R $USER:$USER /var/www/myapp
  
  sudo chmod -R 755 /var/www/myapp

  Évitez d’exécuter Node.js ou PM2 en tant qu’utilisateur root.

5. Échec du renouvellement de Certbot

• Cause : Problèmes de DNS, certificats expirés ou configuration incorrecte de Nginx.

• Solution : Vérifiez que les enregistrements DNS pointent vers votre serveur et testez le renouvellement :

  sudo certbot renew --dry-run

  Si le renouvellement échoue, vérifiez la configuration Nginx pour détecter des erreurs de syntaxe :

  sudo nginx -t

  Vous pouvez également consulter les journaux de Certbot dans /var/log/letsencrypt/ pour des erreurs détaillées.

6. Pare-feu bloquant l'accès

• Cause : Les règles UFW empêchent les connexions HTTP ou HTTPS entrantes.

• Solution : Assurez-vous que le trafic Nginx est autorisé et que le pare-feu est actif :

  sudo ufw allow 'Nginx Full'
  
  sudo ufw enable
  
  sudo ufw status

Flux de travail de dépannage

Lorsque des problèmes surviennent, suivez un processus structuré :

1. Vérifier les journaux : Commencez par consulter les journaux de PM2, Nginx et du système, car la plupart des problèmes y laissent des traces d'erreur.

2. Vérifier les services : Confirmez que Node.js, PM2 et Nginx sont en cours d'exécution et activés au démarrage :

   pm2 status
   
   systemctl status nginx

3. Valider les fichiers de configuration : Effectuez des vérifications de syntaxe avant de redémarrer les services :

   sudo nginx -t

   Pour les fichiers de l'écosystème PM2, vérifiez le formatage JSON ou JavaScript.

4. Vérifier la liaison du port : Vérifiez que votre application écoute sur le port attendu :

   sudo netstat -tulnp | grep node

5. Surveiller les ressources du système : Utilisez des outils comme htop ou pm2 monit pour vérifier l'utilisation du CPU, de la mémoire et du disque. Des serveurs surchargés peuvent provoquer des réponses lentes ou des plantages.

6. Tester la connectivité : Utilisez curl pour simuler des requêtes et vérifier que vos points de terminaison répondent correctement :

   curl http://localhost:3000

Bonnes pratiques pour la stabilité, la sécurité et la maintenance

Suivre les meilleures pratiques garantit que votre application reste fiable, sécurisée et facile à maintenir à mesure qu'elle se développe.

Meilleures pratiques en matière de sécurité

• Maintenez le système à jour : Mettez régulièrement à jour Node.js, PM2, Nginx et les paquets Ubuntu en utilisant :

  sudo apt update && sudo apt upgrade -y

  Cela garantit que les correctifs de sécurité et les améliorations de performance sont appliqués.

• Utilisez HTTPS partout : Faites toujours respecter HTTPS via des redirections Nginx et le renouvellement automatique des certificats avec Certbot.

• Restreindre l'accès SSH : Utilisez l'authentification par clé, désactivez les connexions root et limitez l'accès SSH aux IP connues.

• Exécuter en tant qu'utilisateur non root : Utilisez un utilisateur d'application dédié pour limiter les privilèges en cas de compromission.

• Masquer les traces de pile et les détails des erreurs : Ne jamais exposer des messages d'erreur détaillés aux utilisateurs. Configurez Express ou d'autres frameworks pour gérer les erreurs de manière appropriée.

• Vérifiez régulièrement les dépendances : Exécutez :

  npm audit

  et mettre à jour ou remplacer les packages vulnérables.

Gestion des performances et des ressources

• Activer le clustering : Utilisez PM2 pour exécuter plusieurs instances Node.js sur les cœurs CPU disponibles :

  pm2 start app.js -i max

• Utilisez la mise en cache efficacement : Mettez en place des couches de mise en cache (comme Redis ou la mise en cache en mémoire) pour les données consultées fréquemment.

• Surveillez régulièrement : Configurez des tableaux de bord avec PM2 Plus, Grafana ou Prometheus pour suivre les tendances de performance.

• Optimiser les journaux : Activez la rotation des journaux pour éviter une utilisation excessive du disque et ne conserver que les données pertinentes.

• Compresser les réponses : Gardez la compression gzip ou Brotli activée dans Nginx pour une livraison plus rapide.

Maintenance et opérations

• Automatisez les sauvegardes : Planifiez des sauvegardes pour les données de votre application, les fichiers de configuration et les certificats SSL.
• Utilisez le contrôle de version : Stockez les configurations et les scripts dans un dépôt Git pour suivre les modifications au fil du temps.
• Documentez votre environnement : Maintenez une documentation détaillée de votre configuration, des ports, des variables d'environnement et des étapes de déploiement.
• Utilisez des environnements de préproduction : Testez les mises à jour et les modifications de configuration sur un serveur de préproduction avant de les déployer en production.
• Surveillance du temps de fonctionnement : Utilisez des outils externes de surveillance du temps de fonctionnement comme UptimeRobot, Pingdom ou StatusCake pour détecter rapidement les pannes.
• Plan de mise à l'échelle : À mesure que le trafic augmente, envisagez une mise à l'échelle horizontale avec des répartiteurs de charge ou des outils d'orchestration de conteneurs comme Docker et Kubernetes.
• Planifiez des audits réguliers : Passez périodiquement en revue les paramètres de sécurité, les indicateurs de performance et la cohérence de la configuration à travers les différents environnements.

Une stratégie de maintenance proactive, combinée à une surveillance continue et au respect strict des principes de sécurité, contribue à garantir que votre application Node.js reste performante, fiable et résiliente en production.

FAQ

1. Comment déployer une application Node.js en production sur Ubuntu ?

Pour déployer une application prête pour la production, suivez ce flux de travail standard. Évitez d'exécuter l'application en utilisant node index.js directement dans une session de terminal, car elle s'arrêtera si la session se ferme.

Voici un flux de travail général :

1. Mettre à jour le système : Exécutez sudo apt update && sudo apt upgrade.

2. Créer un utilisateur non-root : Ne lancez jamais votre application en tant que root. Créez un utilisateur dédié (par exemple, deploy).

3. Installez Node.js : Utilisez les distributions binaires de NodeSource pour la dernière version LTS (n’utilisez pas la version apt par défaut d’Ubuntu car elle est souvent obsolète).

   curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
   
   sudo apt-get install -y nodejs

4. Cloner & Installer : Cloner votre dépôt contenant l'application Node.js, rendez-vous dans le répertoire, et exécutez npm ci (installation propre) au lieu de npm install pour garantir des versions exactes des dépendances.

5. Variables d'environnement : Créez un fichier .env pour les secrets (chaînes de base de données, clés API).

6. Commencez avec un gestionnaire de processus : Au lieu d'exécuter node index.js (qui s'arrête lorsque vous fermez le terminal), utilisez PM2 pour mettre l'application en arrière-plan :

   sudo npm install -g pm2
   
   pm2 start app.js --name "my-production-app"

7. Assurer la persistance au démarrage : Indiquez au serveur de relancer cette application si le serveur redémarre :

   • Générer le script de démarrage : Tout d'abord, demandez à PM2 de générer la commande de démarrage pour votre système d'exploitation spécifique (Ubuntu utilise systemd).

   pm2 startup

   • Exécutez la commande générée : Copiez et collez la commande que PM2 affiche dans votre terminal. Elle ressemblera à quelque chose comme ceci : sudo env PATH=` PATH:/home/sammy/.nvm/versions/node/v24.11.1/bin /home/sammy/.nvm/versions/node/v24.11.1/lib/node_modules/pm2/bin/pm2 startup systemd -u sammy --hp /home/sammy

   • Geler la liste des processus : Maintenant que le système de démarrage est actif, enregistrez vos processus en cours afin que PM2 s'en souvienne au redémarrage.

   pm2 save

2. Quelle est la meilleure façon de gérer les processus Node.js sur un VPS ?

La norme de l'industrie pour gérer les processus Node.js sur un serveur privé virtuel (VPS) est PM2.

Bien que vous puissiez utiliser systemd directement, PM2 offre des fonctionnalités spécialement conçues pour Node.js que les gestionnaires de services standard n’ont pas, telles que :

• Redémarrage automatique : Relance l'application en cas de plantage.
• Mode Cluster : Utilise tous les cœurs CPU sans modifier votre code.
• Surveillance : Commandes intégrées pour vérifier l'utilisation de la RAM/CPU (pm2 monit).
• Gestion des journaux : Rotation automatique des journaux pour éviter la saturation du disque.

3. Devrais-je utiliser PM2 ou systemd pour Node.js en production ?

La meilleure pratique est d'utiliser les deux.

Vous devriez utiliser PM2 pour gérer l'application et Systemd pour gérer PM2. Si vous utilisez seulement PM2, votre application disparaîtra en cas de redémarrage du serveur.

Comment les combiner :

1. Démarrez votre application avec PM2 : pm2 start app.js
2. Générez le script de démarrage systemd : pm2 startup
3. Exécutez la commande que PM2 affiche (cela indique à systemd d’Ubuntu de lancer PM2 au démarrage).
4. Geler la liste des processus : pm2 save

4. Comment utiliser Nginx comme proxy inverse pour Node.js ?

Node.js est excellent pour gérer la logique des applications mais moins performant pour gérer le SSL, les fichiers statiques et l'équilibrage de charge comparé à Nginx.

La configuration :

1. Installer Nginx : sudo apt install nginx.
2. Configurez Nginx pour écouter sur le port 80 et rediriger le trafic vers votre application Node (généralement en cours d'exécution sur localhost:3000).

Exemple de configuration (/etc/nginx/sites-available/default) :

server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://localhost:3000; # Forward to Node
        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;
    }
}

Après avoir enregistré, testez la configuration avec sudo nginx -t et redémarrez Nginx.

5. Comment activer HTTPS pour Node.js avec Nginx ?

Ne gérez pas HTTPS dans la logique de votre application Node.js. Laissez Nginx gérer le chiffrement/déchiffrement (terminaison SSL).

La méthode la plus simple (Certbot) :

1. Installer Certbot : sudo apt install certbot python3-certbot-nginx

2. Lancez le générateur automatique :

   sudo certbot --nginx -d your_domain.com

3. Certbot modifiera automatiquement votre fichier de configuration Nginx pour activer HTTPS et configurera un travail cron pour renouveler automatiquement le certificat.

6. Comment puis-je sécuriser mon application Node.js sur Ubuntu ?

La sécurité nécessite une approche à plusieurs niveaux.

• Niveau du système d'exploitation :

  • Pare-feu UFW : Activez le pare-feu et n'autorisez que les ports nécessaires.

    sudo ufw allow ssh
    
    sudo ufw allow 'Nginx Full'
    
    sudo ufw enable

  • Renforcement SSH : Désactivez la connexion par mot de passe et n'utilisez que des clés SSH.

• Niveau de l'application :

  • Exécuter en tant que non-root : Comme mentionné dans la Q1, si un attaquant compromet un processus root, il prend le contrôle du serveur.
  • Helmet.js : Installez ce middleware (npm install helmet) dans votre application pour définir automatiquement des en-têtes HTTP sécurisés.
  • Ne pas exposer les ports : Assurez-vous que votre application Node se lie à localhost (127.0.0.1) afin qu'elle ne puisse pas être directement accessible depuis Internet, en forçant le trafic à passer par Nginx.

Résumé

Vous avez maintenant mis en place un environnement de production complet pour votre application Node.js sur Ubuntu. Avec Node.js exécuté sous PM2, Nginx gérant le trafic web, le chiffrement SSL de Let’s Encrypt, et UFW protégeant votre réseau, votre serveur est stable, sécurisé et prêt pour une utilisation réelle. En ajoutant la mise en cache, la compression et une surveillance appropriée, vous avez construit un système qui offre de bonnes performances et est facile à maintenir. Cette configuration vous fournit une base solide pour développer votre application, que cela signifie étendre sur plusieurs serveurs, automatiser les déploiements ou ajouter des outils plus avancés à l’avenir.

Pour plus de tutoriels sur Node.js, consultez les articles suivants :

• Comment installer Node.js sur Ubuntu (Guide étape par étape)
• Comment utiliser PostgreSQL avec Node.js sur Ubuntu 20.04

Merci d'apprendre avec la communauté Linux-Console.net.