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

Introduction

Exécuter une application Node.js localement n'est que la première étape. Pour la rendre prête pour la production, vous devez la configurer pour des conditions réelles qui nécessitent stabilité, sécurité et performance. Un environnement de production correctement configuré garantit que votre application peut se remettre des plantages, gérer le trafic en toute sécurité et supporter 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 traite les requêtes entrantes et sert le trafic via HTTPS, Let’s Encrypt fournit des certificats SSL gratuits, et UFW sécurise le serveur en contrôlant l’accès réseau. Ensemble, ces outils forment une base solide pour déployer des applications fiables, efficaces et sécurisées.

Prérequis

Ce guide présume 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 pointé 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. L'article Comment sécuriser Nginx avec Let’s Encrypt sur Ubuntu vous guidera à travers le processus.

Une fois que vous aurez complété les prérequis, vous aurez un serveur qui sert la page d’espace réservé par défaut de votre domaine à 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 ainsi qu'à 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, puis 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 consulter 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.

Maintenant, vous pouvez installer Node.js :

sudo apt install nodejs

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

node -v

Vous devriez voir une sortie similaire à ceci :

v24.11.1

Installer npm et build-essential

Le package nodejs installe également npm, le gestionnaire de packages 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 du code source, par exemple), vous devrez installer le paquet build-essential :

sudo apt install build-essential

Avec Node.js et npm correctement installé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 » à toute requête HTTP. Cette application d'exemple permettra de vérifier que Node.js est correctement installé et démontrera 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 au 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 une fois 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 un résultat 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 cela fonctionne, fermez 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 gère 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 ainsi 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 en 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

L’option -g installe PM2 à l’échelle du système, de sorte qu’il est disponible pour tous les utilisateurs et toutes les applications.

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

pm2 start hello.js

Vous verrez un tableau de sortie qui montre 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 statut actuel et l'utilisation de la mémoire.

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

PM2 redémarre automatiquement votre application en cas de plantage ou si elle est arrêtée. Pour vous assurer que PM2 démarre lui-même automatiquement lors du redémarrage du serveur, 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 afin que PM2 s'en souvienne lors du prochain redémarrage :

pm2 save

Pour confirmer que tout est correctement configuré, vérifiez le statut 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 d'écosystème PM2

Lorsque vous êtes prêt à exécuter plus d’une application ou à gérer différents environnements, le fichier d’écosystème de PM2 est d’une grande aide. Il s’agit d’un fichier de configuration simple qui vous permet de définir les variables d’environnement, les ports et les paramètres de déploiement en un seul 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 lancer votre application en mode production, utilisez :

pm2 start ecosystem.config.js --env production

Le fichier ecosystem permet de gérer facilement plusieurs environnements et de stocker en toute sécurité les variables d'environnement en dehors de votre code source. Avec PM2 en place, votre application survivra aux crashs, 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êter une application avec cette commande (spécifiez le nom de l'application PM2 ou id) :

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 de l'application :

pm2 info app_name

Pour consulter 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, ainsi que l'utilisation du CPU et de la mémoire :

pm2 monit

Notez que l'exécution de 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. Plutôt que d'exposer directement l'application 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 inverse de base

Ouvrez le fichier de configuration Nginx de votre site. Si vous avez suivi la configuration de 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 port différent, mettez à jour la valeur surligné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 fonctionnant 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 avez déjà des 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 maintenant ê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 idéal 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 cela indique inactif, ne vous inquiétez pas, nous l’activerons sous peu. Mais d’abord, nous définirons quels types de trafic devraient ê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 pour 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

On vous demandera de 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 ceci :

Status: active

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

Voilà ! Seuls le trafic SSH et web sont maintenant autorisés ; tout le reste est bloqué.

Pourquoi un pare-feu est important en production

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

Voici quelques raisons principales pour lesquelles les pare-feu 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 la propagation d'un attaquant au sein de votre système ou réseau.
• Conformité et vérification : Plusieurs normes de sécurité exigent une protection par pare-feu active avec des règles d'accès vérifiables.
• Défense en profondeur : les pare-feux complètent d'autres couches de sécurité telles que TLS, l'authentification et le renforcement des applications.

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

Avec UFW configuré, votre système est maintenant plus sûr 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 HTTPS pour une communication sécurisée. Le 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.

Installer Certbot et le plugin 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 de Let’s Encrypt
• Modifiez automatiquement votre configuration Nginx pour activer HTTPS
• Rechargez Nginx pour que les nouveaux réglages prennent effet

Vous serez invité à fournir une adresse courriel (utilisée pour les notifications de renouvellement) et à accepter les conditions d'utilisation. Une fois l'installation 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 maintenant servi de manière sécurisée.

Renouvellement automatique

Les certificats Let’s Encrypt ne sont valides que pendant 90 jours, mais il n’est pas nécessaire de s’inquiéter 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 erreur, vos certificats seront renouvelés 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 du fonctionnement de tout système de production. SSL/TLS garantit que toutes les communications entre votre serveur et vos clients sont chiffrées et protégées contre les altérations, offrant une protection contre l'espionnage et la manipulation des données.

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

• Confiance et crédibilité : Les navigateurs étiquettent les sites non HTTPS comme « Non sécurisé », ce qui peut miner la confiance des utilisateurs.
• Amélioration du classement dans les recherches : Les principaux moteurs de recherche utilisent le protocole HTTPS comme facteur de classement.
• Accès aux fonctionnalités web modernes : HTTP/2, QUIC et d'autres améliorations de performance nécessitent TLS.
• Conformité : De nombreux règlements sur la vie privée 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 et durable pour des déploiements sécurisés.

Avec HTTPS en place, votre serveur diffuse maintenant du trafic chiffré et fiable.

Gérer les variables d'environnement en toute sécurité

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. Stocker ces valeurs 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écuritaire consiste à utiliser des variables d'environnement, qui permettent de garder les informations sensibles séparées 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 à 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

Modifiez maintenant le fichier principal de votre 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 permet de maintenir une configuration cohérente à travers les environnements comme le développement, la mise en scène et la production.

Vous pouvez définir des variables directement lors du démarrage 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 :

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

• Restreindre 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 les secrets régulièrement : Modifiez les clés API, les jetons et les mots de passe selon un calendrier pour réduire l'impact des fuites potentielles.

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

• Évitez d'enregistrer des données sensibles : Faites attention à ne pas afficher ou enregistrer des informations confidentielles dans vos journaux d'application ou de 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 l'exécution de l'application.

• 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 dans 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 aussi les coûts des serveurs et contribue à garantir une scalabilité 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.

Utiliser 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é afin d'équilibrer la charge du processeur et les performances.

Utilisation de Brotli

Si vous avez installé le module Brotli, vous pouvez l’utiliser pour obtenir des ratios 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 textuelles comme le CSS et le JavaScript. Après avoir apporté 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 entraînera des temps de chargement plus courts et une meilleure performance sur les ordinateurs de bureau et les appareils 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 comme les images, les feuilles de style et les 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 indique 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 pourriez 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 la micro-caching (mise en cache à court terme en secondes) pour les API à fort trafic.

Meilleures pratiques de 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

Ensuite, configurez la stratégie de rotation :

pm2 set pm2-logrotate:max_size 10M

pm2 set pm2-logrotate:retain 7

Cette configuration limite la taille des fichiers journaux à 10 Mo chacun et conserve les journaux pendant sept jours. 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 échecs). 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é sur le trafic à l'aide d'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 mesures 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 goulots d'étranglement en matière 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 CPU disponibles et améliorer la concurrence, vous pouvez utiliser le clustering et d'autres techniques de gestion des processus.

Utiliser le clustering

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

pm2 start app.js -i max

Cette commande lance 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 pour 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 en temps réel de la mémoire et du processeur 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 processeur du côté de 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 la durée des caches. Gérer la configuration via des variables d'environnement rend votre application flexible et plus facile à mettre à l'échelle.

Surveillance et métriques

Après avoir optimisé votre environnement de production, l'étape suivante essentielle consiste à mettre en place une surveillance efficace et la collecte de métriques. La surveillance vous donne une visibilité sur la performance 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 les 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 pannes et recevez automatiquement une alerte lorsqu'elles surviennent.
• Analyser la performance du système sous différentes charges de trafic.
• Identifiez les points de terminaison lents, les goulets d’étranglement ou les fuites de mémoire.
• Prenez des décisions éclairées en matière de mise à l'échelle et d'optimisation.
• Maintenir la disponibilité et la fiabilité à travers les déploiements.

Une configuration de surveillance bien conçue comprend à la fois la surveillance en temps réel pour les alertes immédiates et les 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, comprend des fonctionnalités de surveillance puissantes.

Surveillance en temps réel

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

pm2 list

Cela affiche toutes les applications actives ainsi que leur statut, 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 montrant les principaux indicateurs de performance, tels que l'utilisation du processeur 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 indiquer des erreurs ou des plantages.

Surveillance avancée (PM2 Plus)

Pour des déploiements plus importants, PM2 propose PM2 Plus, un tableau de bord 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 à des systèmes de surveillance tiers populaires tels que Datadog, New Relic et Prometheus pour une visibilité unifiée.

Surveillance de Nginx

Nginx se situe à 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 tendances comme 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 de Nginx

Nginx inclut un module léger stub_status qui expose des métriques en temps réel du serveur, telles que les 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 métriques peuvent être intégrées aux tableaux de bord de surveillance ou utilisées pour des alertes automatisées.

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

Pour une surveillance plus granulaire 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 de l'API, les taux de requêtes ou les durées des requêtes de base de données.

Exécutez la commande suivante pour installer la bibliothèque cliente 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, gardez un œil sur les performances globales du serveur. Linux offre plusieurs outils à cet effet :

• htop ou top : Affiche l'utilisation du processeur 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 recueillent des métriques sur votre infrastructure et les visualisent dans des tableaux de bord.

Erreurs Courantes, Dépannage et Bonnes Pratiques

Même une configuration de production bien configurée 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 présente les meilleures pratiques pour vous aider à garder votre environnement Node.js stable, sécurisé et facile à maintenir à 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 requises sont correctement chargées depuis .env ou votre fichier d'é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 en conflit :

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

  Sinon, modifiez 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 autre port.

• 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 les propriétaires et les permissions corrects :

  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 Nginx incorrecte.

• Solution : Confirmez 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 de Nginx pour détecter les 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 entrantes HTTP ou HTTPS.

• 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 dépannage

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

1. Vérifier les journaux : Commencez par examiner 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 : Exécutez 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 le lien de port : Assurez-vous 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 ralentissements 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

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

Suivre les meilleures pratiques permet de garantir que votre application reste fiable, sécurisée et facile à maintenir au fur et à mesure de sa croissance.

Meilleures pratiques 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 SSH aux adresses 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 de 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 paquets vulnérables.

Gestion de la performance et des ressources

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

  pm2 start app.js -i max

• Utilisez la mise en cache de manière efficace : 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.

• Surveiller 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.

Entretien et opérations

• Automatiser 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 mise en scène : Testez les mises à jour et les modifications de configuration sur un serveur de mise en scène avant de les déployer en production.
• Surveillance du temps de fonctionnement : Utilisez des outils de surveillance externes 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 équilibreurs 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 mesures de performance et la cohérence des configurations entre les 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 processus 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. Installer Node.js : Utilisez les distributions binaires NodeSource pour la dernière version LTS (n’utilisez pas la version apt par défaut d’Ubuntu car elle est souvent dépassée).

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

4. Cloner et installer : Cloner votre dépôt contenant l'application Node.js, accédez au 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 BD, 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 lancer 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 : Demandez au serveur de relancer cette application si le serveur redémarre :

   • Générer le script de démarrage : Commencez par demander à PM2 de générer la commande de démarrage adaptée à votre système d'exploitation (Ubuntu utilise systemd).

   pm2 startup

   • Exécuter la commande générée : Copiez et collez la commande que PM2 a produite 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 lors du 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écifiquement conçues pour Node.js que les gestionnaires de services classiques n'ont pas, telles que :

• Redémarrage automatique : Relance l'application si elle plante.
• Mode Cluster : Utilise tous les cœurs du processeur 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 l'encombrement 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 n'utilisez que PM2, votre application disparaîtra si le serveur redémarre.

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 fournie par PM2 (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 applicative, mais moins efficace pour gérer le SSL, les fichiers statiques et la répartition de la 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 exécutée 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 puis-je 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 facile (Certbot) :

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

2. Exécutez 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 cron job pour renouveler automatiquement le certificat.

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

La sécurité nécessite une approche par couches.

• 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 utilisez uniquement des clés SSH.

• Niveau de l'application :

  • Exécuter en tant que non-root : Comme mentionné dans 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 configurer 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, forçant le trafic à passer par Nginx.

Résumé

Vous avez maintenant configuré un environnement de production complet pour votre application Node.js sur Ubuntu. Avec Node.js fonctionnant 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 bonne surveillance, vous avez construit un système performant et facile à maintenir. Cette configuration vous offre une base solide pour faire évoluer votre application, que ce soit pour le déploiement sur plusieurs serveurs, l’automatisation des déploiements ou l’ajout d’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 de apprendre avec la communauté Linux-Console.net.