Comment déployer une application Node.js

Pour déployer une application Node.js, vous pouvez suivre une procédure générale adaptée à la plupart des environnements d’hébergement ou choisir une méthode spécifique, selon que vous utilisez un hébergement d’applications web ou un serveur privé virtuel (VPS).

Déployer une application Node.js consiste à la transférer de votre ordinateur de développement vers un serveur de production afin de la rendre accessible aux utilisateurs sur Internet.

La qualité du déploiement influe directement sur les performances de votre application Node.js lorsqu’elle est soumise à un trafic réel. Un serveur mal configuré peut entraîner des temps de réponse élevés, des interruptions de service imprévues ou des failles de sécurité susceptibles d’exposer des données sensibles.

Configurer correctement l’environnement de production de votre application Node.js dès le départ permet d’éviter ces problèmes et de maintenir sa stabilité à mesure que le trafic augmente.

Le déploiement d’une application Node.js comprend généralement cinq étapes : la préparation, le choix de l’hébergement, la configuration de l’environnement, le déploiement et la surveillance.

Voici en quoi consiste chacune de ces étapes :

1. Préparez l’application pour la production. Définissez les dépendances dans package.json, configurez les variables d’environnement et ajoutez un script de démarrage.
2. Créez un commit et envoyez le code vers un dépôt Git. Téléversez les fichiers dans le dépôt depuis l’interface du navigateur ou exécutez les commandes Git depuis le terminal de votre ordinateur.
3. Installez Node.js et un gestionnaire de processus. Installez Node.js sur le serveur, configurez les variables d’environnement et utilisez PM2 pour maintenir l’application en fonctionnement après un plantage ou un redémarrage du serveur.
4. Faites transiter le trafic par un proxy inverse. Configurez NGINX pour transmettre les requêtes au processus Node.js sur son port interne et sécurisez les connexions avec un certificat SSL.
5. Vérifiez et surveillez le déploiement. Testez l’application dans un navigateur, consultez les journaux PM2 et surveillez les indicateurs de performance pour détecter rapidement les problèmes.

Comment déployer une application Node.js

Le déploiement d’une application Node.js repose sur une procédure générale, quel que soit l’hébergeur choisi.

Cette procédure consiste à préparer l’application pour la production, à envoyer le code vers un dépôt Git, à configurer le serveur avec un gestionnaire de processus, à mettre en place un proxy inverse avec HTTPS et à tester l’application une fois en ligne.

1. Préparez l’application Node.js pour le déploiement

Pour préparer une application Node.js au déploiement, assurez-vous que le projet contient tous les éléments nécessaires à l’installation des dépendances et au démarrage automatique de l’application sur un serveur de production.

Trois fichiers constituent la base d’un projet Node.js prêt pour le déploiement : app.js (le fichier principal de l’application), package.json (les métadonnées du projet, les dépendances et les scripts) et .gitignore (les fichiers exclus du contrôle de version).

Tous les packages importés par votre application doivent figurer dans le champ dependencies du fichier package.json. Ce fichier indique à npm les packages à télécharger sur le serveur lors de l’installation.

Si un package requis n’y figure pas, l’application plantera en production, même si elle fonctionnait en local grâce à la présence de ce package dans node_modules. Voici un exemple :

{
  "name": "node-deploy-test",
  "version": "1.0.0",
  "description": "Sample Node.js app for deployment tutorial",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.21.0"
  }
}

La section des scripts définit la manière dont les plateformes d’hébergement Node.js et les gestionnaires de processus démarrent l’application. L’entrée “start”: “node app.js” indique au serveur d’exécuter app.js comme point d’entrée.

Les variables d’environnement Node.js servent à stocker les paramètres de configuration qui diffèrent selon l’environnement, notamment entre le développement et la production. Utilisez-les pour définir les numéros de port, les identifiants de connexion aux bases de données et les clés API, plutôt que d’inscrire ces valeurs directement dans les fichiers source.

Dans le code de l’application, accédez à ces valeurs à l’aide de process.env :

const PORT = process.env.PORT || 3000;

Cette ligne récupère la valeur de la variable PORT si elle existe. Dans le cas contraire, elle utilise la valeur par défaut 3000. Le même principe s’applique à NODE_ENV, que les plateformes d’hébergement définissent généralement automatiquement sur production.

Le stockage des paramètres de configuration dans des variables d’environnement évite que des données sensibles ne se retrouvent dans votre dépôt. Vous pouvez également modifier ces paramètres pour chaque environnement sans toucher au code.

2. Envoyez le code de l’application vers un dépôt Git

Le contrôle de version est essentiel au déploiement d’une application Node.js, car il permet de conserver un historique fiable et traçable de chaque modification du code source.

Si un déploiement introduit un bug, vous pouvez revenir au dernier commit fonctionnel en quelques secondes, plutôt que de chercher l’origine du problème à l’aveugle.

Git est le système de contrôle de version de référence. GitHub et GitLab comptent parmi les plateformes les plus courantes pour héberger des dépôts Git. Voici comment procéder avec GitHub :

1. Connectez-vous à GitHub ou créez un compte sur github.com si vous n’en avez pas.
2. Dans le tableau de bord, cliquez sur New, puis saisissez un nom de dépôt, par exemple node-deploy-test.
3. Définissez la visibilité sur Public si vous prévoyez de connecter le dépôt à une plateforme d’hébergement par la suite.
4. Laissez les autres options décochées (sans README, sans .gitignore et sans licence), puis cliquez sur Create repository.

Le moyen le plus simple d’ajouter des fichiers consiste à passer par le navigateur :

1. Sur la page de configuration du dépôt, cliquez sur uploading an existing file.
2. Faites glisser app.js et package.json dans la zone de téléversement.
3. Cliquez sur Commit changes.

La plupart des systèmes d’exploitation masquent les fichiers dont le nom commence par un point, comme .gitignore. Vous ne pourrez donc pas les téléverser par glisser-déposer. Créez plutôt le fichier directement sur GitHub :

1. Sur la page principale du dépôt, cliquez sur Add file → Create new file.
2. Saisissez .gitignore comme nom de fichier et ajoutez la ligne suivante :

node_modules/

3. Cliquez sur Commit changes.

Si Git est installé sur votre ordinateur, vous pouvez également envoyer tous vos fichiers, y compris .gitignore, à l’aide des commandes Git en ligne de commande :

cd path/to/node-deploy-test
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/your-username/node-deploy-test.git
git push -u origin main

Remplacez your-username par votre véritable nom d’utilisateur GitHub.

L’utilisation de Git en ligne de commande est plus adaptée au développement continu. La commande git push n’envoie que les modifications apportées, tandis que l’interface du navigateur vous oblige à téléverser de nouveau les fichiers.

3. Configurez le serveur et lancez l’application

La configuration du serveur commence par l’installation de Node.js. Vous pouvez utiliser Node Version Manager (NVM) ou un gestionnaire de paquets système.

NVM est préférable, car il permet d’installer plusieurs versions de Node.js et de passer de l’une à l’autre sans disposer des droits root.

Les processus Node.js s’arrêtent lorsque vous fermez la session du terminal ou que le serveur redémarre. En cas de plantage, l’application peut donc rester inaccessible jusqu’à ce qu’elle soit redémarrée manuellement.

PM2, un gestionnaire de processus Node.js conçu pour la production, résout ce problème. Il exécute l’application en arrière-plan sous forme de daemon et la redémarre automatiquement après un plantage ou un redémarrage du serveur.

À ce stade, l’application fonctionne sur un port interne, par exemple 3000, mais les utilisateurs ne peuvent pas encore y accéder par les ports web standard 80 ou 443. Pour la rendre accessible depuis Internet, vous devez configurer un proxy inverse.

4. Configurez un proxy inverse et activez HTTPS

Un proxy inverse comme NGINX achemine le trafic public vers l’application Node.js qui s’exécute sur un port interne.

NGINX écoute sur les ports 80 (HTTP) et 443 (HTTPS), reçoit les requêtes entrantes et les transmet à localhost:3000 ou au port utilisé par votre application. Les utilisateurs n’interagissent donc jamais directement avec le processus Node.js.

Cette configuration assure également la terminaison des connexions SSL/TLS, ce qui permet de gérer le chiffrement indépendamment du code de l’application.

Une fois le proxy inverse configuré, activez HTTPS à l’aide de Certbot et d’un certificat SSL Let’s Encrypt.

5. Testez et surveillez l’application déployée

Après le déploiement, testez l’application Node.js en ouvrant son URL racine dans un navigateur, par exemple http://domain.tld. La page principale doit s’afficher avec le contenu attendu.

Si vous avez ajouté une route de vérification de l’état de l’application, ajoutez /health à son URL et vérifiez qu’elle renvoie une réponse JSON comme celle-ci :

{"status":"healthy","uptime":...}

Consultez ensuite les journaux Node.js à l’aide de votre gestionnaire de processus. Avec PM2, la commande pm2 logs affiche en temps réel les messages de sortie et d’erreur de votre application.

Pour obtenir une vue d’ensemble, exécutez pm2 monit afin d’ouvrir un tableau de bord interactif. Celui-ci regroupe l’utilisation du processeur, la consommation de mémoire, la latence de la boucle d’événements et les journaux.

À titre indicatif, une application Node.js en bon état de fonctionnement présente généralement une latence de la boucle d’événements inférieure à 50 ms, une consommation de mémoire d’environ 300 à 500 Mo pour une application Express standard et une utilisation du processeur inférieure à 70 % dans des conditions de trafic normales.

Comment déployer une application Node.js avec un hébergement d’applications web

Pour déployer une application Node.js avec un hébergement d’applications web, vous devez connecter un dépôt Git, définir les commandes de build et lancer le déploiement depuis un tableau de bord.

L’hébergement d’applications web Node.js de Hostinger propose un environnement géré qui vous permet de déployer vos applications sans avoir à configurer vous-même un serveur de A à Z.

Hostinger prend en charge l’infrastructure sous-jacente, notamment la configuration du serveur, l’installation de Node.js, la gestion des processus et les certificats SSL.

Le service permet également le redéploiement automatique : chaque fois que vous envoyez des modifications vers GitHub ou GitLab, le système relance le build et redéploie automatiquement votre application.

1. Créez un environnement d’hébergement pour votre application web Node.js

Après avoir souscrit un plan d’hébergement Node.js, connectez-vous au tableau de bord Hostinger avec votre compte pour créer une nouvelle application.

Accédez à Sites web → Ajouter un site web → Application web Node.js.

Si vous disposez d’un plan Business ou supérieur sur un hébergement web classique, vous pouvez suivre les mêmes étapes pour créer une application Node.js.

2. Connectez le dépôt Git

La connexion d’un dépôt Git permet de relier votre projet GitHub ou GitLab à l’environnement d’hébergement de votre application web Node.js.

Une fois le dépôt connecté, la plateforme récupère automatiquement la dernière version du code à chaque nouvel envoi vers GitHub ou GitLab, installe les dépendances et redémarre l’application.

Pour connecter le dépôt :

1. Sur l’écran de configuration, sélectionnez Importer un dépôt Git.

2. Choisissez GitHub ou GitLab comme source du dépôt et autorisez Hostinger à accéder à votre compte.
3. Sélectionnez le dépôt dans la liste.

Vous pouvez également déployer une application à partir d’un dépôt GitHub public qui ne vous appartient pas. Pour cela, collez son URL dans l’écran de configuration. Le système vérifie que le dépôt est public et accessible.

Saisissez ensuite un nom pour le nouveau dépôt et choisissez sa visibilité : publique ou privée. Le système clone le dépôt public dans votre compte GitHub afin que vous disposiez de votre propre copie, que vous pourrez modifier et redéployer.

Un plan d’hébergement ne peut être connecté qu’à un seul compte GitHub à la fois. Tous les sites web Node.js associés à ce plan partagent cette connexion.

Si les fichiers de votre projet ne se trouvent pas dans un dépôt Git, sélectionnez plutôt Téléverser les fichiers de votre site web, puis téléversez une archive ZIP. Cette méthode ne permet pas de redéployer automatiquement l’application lorsque vous modifiez le code.

Vous pouvez aussi partir de l’un des 50 templates Node.js préconstruits plutôt que de créer votre application de A à Z. Ces templates sont adaptés à différents types de projets : blogs, sites d’entreprise, sites e-commerce, portfolios et applications SaaS. Vous disposez ainsi d’une application fonctionnelle que vous pouvez personnaliser et déployer.

3. Configurez les commandes de build et de démarrage

Après la sélection du dépôt, le système détecte automatiquement le framework utilisé et propose les paramètres de build correspondants.

Vous pouvez modifier ces paramètres si votre projet nécessite d’autres valeurs :

• Framework prédéfini. Le framework détecté pour votre projet, par exemple Express.js. Modifiez ce paramètre si la détection automatique n’a pas identifié le bon framework.
• Version de Node.js. La version de Node.js utilisée pour exécuter votre application. Le système la détecte à partir du champ engines de package.json, mais vous pouvez choisir une autre version manuellement.
• Fichier d’entrée. Le fichier exécuté par le serveur pour démarrer l’application. Par défaut, il s’agit de app.js, selon la commande de démarrage Node.js définie dans package.json.
• Gestionnaire de paquets. L’outil utilisé pour installer les dépendances. Par défaut, le système utilise npm, mais vous pouvez sélectionner Yarn ou pnpm si votre projet utilise un autre fichier de verrouillage.
• Variables d’environnement. Le système analyse votre dépôt pour détecter les noms des variables nécessaires à votre application, comme DATABASE_URL. Si certaines valeurs manquent, la mention Action requise apparaît sur la ligne correspondante. Cliquez sur Modifier, saisissez la valeur de production de chaque clé détectée, puis cliquez sur Terminer. Vous pouvez également ajouter manuellement des clés avec Ajouter d’autres variables ou téléverser un fichier à l’aide de Importer .env.

4. Lancez le déploiement et vérifiez l’application

Cliquez sur Déployer pour lancer le build. Le système installe les dépendances, exécute la commande de build et démarre l’application Node.js.

Une fois le déploiement terminé, le message « Déploiement terminé » doit apparaître.

Cliquez sur Accéder au tableau de bord, puis ouvrez le domaine temporaire dans un nouvel onglet du navigateur pour vérifier que l’application se charge correctement.

Le tableau de bord Node.js de Hostinger vous donne une vue d’ensemble de l’application déployée et permet de surveiller ses performances et de gérer ses paramètres.

• Lien vers le dépôt connecté. Ouvre le dépôt GitHub ou GitLab associé dans un nouvel onglet pour consulter le code, les branches ou les commits récents.
• Détails du dernier déploiement. Affiche l’état du déploiement (succès ou échec), sa date et son heure, ainsi qu’un lien vers le journal complet du déploiement.
• Liens rapides. Permettent d’accéder directement aux sections Déploiements, Variables d’environnement, Paramètres et redéploiement ou Gestionnaire de fichiers.
• Graphiques d’utilisation des ressources. Présentent l’utilisation moyenne du processeur, de la mémoire vive et des entrées/sorties (E/S). Si un indicateur s’approche de la ligne pointillée rouge représentant la limite de votre plan, envisagez de passer à un plan supérieur.

Comment déployer une application Node.js avec un hébergement VPS

Pour déployer une application Node.js sur un VPS, vous devez vous connecter à un serveur distant via SSH, installer Node.js, transférer le code de l’application, configurer un gestionnaire de processus et un proxy inverse, puis activer HTTPS.

L’hébergement VPS vous donne un contrôle total sur l’environnement du serveur. Vous pouvez ainsi tout configurer, du système d’exploitation aux règles du pare-feu.

Cette méthode demande davantage de configuration que l’hébergement géré d’applications web. En contrepartie, vous disposez d’un accès direct au serveur pour personnaliser sa configuration, effectuer des opérations de débogage au niveau du système d’exploitation et exécuter d’autres services en parallèle de votre application Node.js.

1. Créez une instance VPS

Commencez par créer une instance VPS et connectez-vous au serveur via SSH. Choisissez comme système d’exploitation la version LTS (à support à long terme) d’Ubuntu la plus récente, par exemple 24.04.

Connectez-vous ensuite à l’aide d’un client SSH comme PuTTY ou du terminal accessible depuis le navigateur dans le tableau de bord Hostinger.

Effectuez ensuite la configuration initiale du serveur VPS : mettez à jour les paquets système, configurez le pare-feu avec ufw et créez un utilisateur autre que root, doté des privilèges sudo pour une utilisation quotidienne.

2. Installez Node.js sur le serveur

Pour installer Node.js sur Ubuntu, vous pouvez utiliser NVM ou un gestionnaire de paquets système. Si vous choisissez NVM, suivez ces étapes :

1. Exécutez le script d’installation de NVM :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash

2. Fermez puis rouvrez le terminal pour charger NVM dans la session en cours.
3. Installez la dernière version LTS de Node.js :

nvm install --lts

4. Vérifiez que Node.js et npm sont correctement installés :

node -v
npm -v

Les deux commandes doivent afficher des numéros de version semblables à ceux-ci :

3. Téléversez l’application Node.js sur le serveur

Si vous avez déjà envoyé le code de votre application vers un dépôt GitHub ou GitLab, vous pouvez le récupérer sur le serveur à l’aide de Git. L’exemple suivant utilise GitHub :

cd /var/www
git clone https://github.com/your-username/your-repository.git
cd your-repository
npm install

Remplacez your-username par votre nom d’utilisateur GitHub et your-repository par le nom de votre dépôt.

La commande npm install lit le fichier package.json et installe toutes les dépendances dans le dossier node_modules sur le serveur.

Vous pouvez également transférer directement les fichiers à l’aide de la commande scp. Ouvrez une nouvelle fenêtre de terminal sur votre ordinateur, et non dans la session connectée au serveur, puis exécutez :

scp -r /local/path/node-deploy-test root@192.0.2.1:/var/www/

Remplacez /local/path/node-deploy-test par le chemin d’accès au dossier de votre projet, root par votre nom d’utilisateur sur le serveur et 192.0.2.1 par l’adresse IP de votre serveur.

Si vous utilisez un VPS Hostinger, vous trouverez l’adresse IP de votre serveur dans le tableau de bord Hostinger, sous VPS → Gérer → Aperçu → Détails du VPS.

Une fois le transfert terminé, revenez au terminal du serveur et exécutez npm install dans le répertoire du projet.

Définissez ensuite les variables d’environnement nécessaires avant de démarrer l’application :

export NODE_ENV=production
export PORT=3000

NODE_ENV=production indique aux frameworks qu’ils doivent optimiser les performances et désactiver les fonctionnalités de développement. La valeur de PORT doit correspondre au port sur lequel votre application écoute, tel qu’il est configuré dans app.js.

4. Configurez PM2 et le proxy inverse

Démarrez votre application Node.js avec PM2 pour qu’elle continue de fonctionner en arrière-plan.

1. Installez PM2 et démarrez l’application :

npm install -g pm2
pm2 start app.js --name "node-app"

2. Configurez PM2 pour redémarrer l’application après un redémarrage du serveur :

pm2 startup
pm2 save

pm2 startup génère un service système qui lance PM2 au démarrage du serveur. pm2 save enregistre la liste actuelle des processus pour que PM2 sache quelles applications redémarrer.

3. Ouvrez les ports du pare-feu nécessaires au trafic web. Sans cela, NGINX ne pourra pas recevoir les connexions entrantes :

ufw allow http
ufw allow https

4. Installez NGINX sur votre serveur :

apt update
apt install nginx -y

5. Créez un fichier de configuration pour mettre en place un proxy inverse NGINX destiné à votre application Node.js :

nano /etc/nginx/sites-available/node-app

6. Ajoutez la configuration suivante en remplaçant your-hostname par votre nom de domaine ou le nom d’hôte de votre serveur :

server {
    listen 80;
    server_name your-hostname;

    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;
    }
}

Cette configuration transmet toutes les requêtes HTTP entrantes au processus Node.js sur le port 3000. Les directives proxy_set_header préservent les informations du client et permettent les connexions WebSocket.

7. Enregistrez le fichier et quittez l’éditeur avec Ctrl + O → Entrée → Ctrl + X.
8. Activez la configuration et supprimez le site par défaut :

ln -s /etc/nginx/sites-available/node-app /etc/nginx/sites-enabled/
rm /etc/nginx/sites-enabled/default

9. Testez la configuration, puis rechargez NGINX. La commande de test doit afficher les messages « syntax is ok » et « test is successful » :

nginx -t
systemctl reload nginx

10. Ouvrez l’URL de votre application dans un navigateur, sans indiquer de numéro de port. La page doit s’afficher correctement.

11. Activez HTTPS avec Certbot. Vérifiez que votre nom de domaine ou votre nom d’hôte pointe vers l’adresse IP du serveur, car Certbot ne peut pas délivrer de certificat pour une adresse IP.

apt install certbot python3-certbot-nginx -y
certbot --nginx -d your-hostname

12. Suivez les instructions affichées pour saisir une adresse e-mail et accepter les conditions d’utilisation. Certbot vérifie que vous êtes propriétaire du domaine, délivre le certificat et modifie automatiquement la configuration NGINX pour rediriger le trafic HTTP vers HTTPS.

Une fois l’opération terminée, ouvrez de nouveau l’URL de votre application et vérifiez que le message « La connexion est sécurisée » apparaît dans votre navigateur.

5. Exécutez et vérifiez l’application en production

Ouvrez l’URL de votre application Node.js et vérifiez que la page affiche le contenu attendu. Si elle ne se charge pas, utilisez systemctl status nginx pour vérifier que NGINX fonctionne et pm2 list pour confirmer que PM2 affiche le statut « online » pour votre application.

Une fois l’application en ligne, utilisez PM2 pour surveiller son comportement en cours d’exécution :

• pm2 logs. Affiche en temps réel les sorties et les erreurs de l’application. Ouvrez l’application dans votre navigateur pendant l’exécution de cette commande pour vérifier que de nouvelles entrées apparaissent dans les journaux.

• pm2 monit. Ouvre un tableau de bord interactif regroupant l’utilisation du processeur, la consommation de mémoire, la latence de la boucle d’événements et les journaux.

• pm2 show node-app. Affiche des informations détaillées, notamment la durée de fonctionnement, le nombre de redémarrages, la consommation de mémoire, le chemin d’accès au script et l’emplacement des fichiers journaux.

Appuyez sur Ctrl + C pour quitter l’une de ces vues.

Quelles sont les bonnes pratiques pour déployer une application Node.js ?

Les bonnes pratiques de déploiement Node.js reposent sur l’automatisation, la séparation des environnements et une surveillance proactive afin de maintenir la stabilité et la sécurité des applications en production.

• Mettez en place un pipeline CI/CD. Utilisez des outils comme GitHub Actions, GitLab CI/CD ou Jenkins pour exécuter votre suite de tests à chaque commit et déployer automatiquement l’application une fois tous les tests réussis. Vous évitez ainsi les étapes de déploiement manuelles et pouvez détecter les bugs avant qu’ils n’atteignent la production.
• Séparez la configuration du code. Stockez les valeurs propres à chaque environnement dans des variables d’environnement ou des fichiers de configuration externes que vous ne versionnez pas dans le dépôt. En local, utilisez un fichier .env chargé à l’aide d’une bibliothèque comme dotenv. En production, définissez directement les variables sur le serveur ou dans le tableau de bord de votre plateforme d’hébergement.
• Utilisez des journaux structurés. Enregistrez les journaux au format JSON afin que des outils comme la suite ELK (Elasticsearch, Logstash, Kibana) ou Datadog puissent les analyser et y effectuer des recherches efficacement. Incluez un horodatage, un niveau de journalisation et un identifiant de requête dans chaque entrée pour suivre les problèmes d’une requête à l’autre.
• Configurez des vérifications automatiques de l’état de l’application. Utilisez un service de surveillance comme UptimeRobot ou Pingdom pour interroger le point de terminaison de vérification de l’état de votre application toutes les 30 à 60 secondes. Si ce point de terminaison ne répond pas ou renvoie une erreur, le service vous alerte par e-mail, Slack ou SMS afin que vous puissiez intervenir avant que les utilisateurs ne remarquent le problème. À titre indicatif, visez un temps de réponse p95 inférieur à 200 ms.
• Activez les retours automatiques à la version précédente. Configurez votre pipeline CI/CD pour qu’il redéploie la dernière version stable si une nouvelle version échoue aux vérifications de l’état de l’application ou plante pendant une période définie, par exemple après trois redémarrages en cinq minutes. PM2 permet de limiter le nombre de redémarrages avec l’option –max-restarts, tandis que des outils comme GitHub Actions peuvent déclencher un retour à la version précédente en cas d’échec du script de déploiement.

Comment faire évoluer une application Node.js en production

Pour faire évoluer une application Node.js en production, combinez des stratégies de mise à l’échelle des serveurs et des adaptations de l’architecture afin de répartir le trafic et la charge de travail entre plusieurs processus ou machines.

Mise à l’échelle horizontale. Elle consiste à ajouter des instances de serveur pour gérer l’augmentation du trafic, tandis qu’un répartiteur de charge distribue les requêtes entre les différents serveurs.

Mise à l’échelle verticale. Elle consiste à augmenter les ressources d’un serveur unique, notamment sa puissance de calcul, sa mémoire vive et son espace de stockage. Plus simple à mettre en place, cette approche reste limitée par les capacités maximales d’une seule machine.

Répartition de charge. Elle permet de distribuer les requêtes de manière équilibrée pour éviter qu’un seul processus ne devienne un goulot d’étranglement. NGINX peut assurer ce rôle en définissant un bloc upstream contenant plusieurs serveurs backend et en répartissant le trafic entre eux.

Par défaut, Node.js fonctionne sur un seul thread et n’utilise donc qu’un seul cœur de processeur, même si le serveur en possède plusieurs.

Le module intégré cluster résout ce problème en créant plusieurs processus de travail à partir du processus principal, généralement un par cœur de processeur. Tous ces processus partagent le même port sur le serveur.

PM2 simplifie cette gestion des processus grâce au mode cluster. La commande pm2 start app.js -i max lance automatiquement un processus de travail pour chaque cœur de processeur disponible.

Pour les infrastructures plus importantes, la conteneurisation avec Docker permet de regrouper votre application Node.js et ses dépendances dans une image Docker portable, qui fonctionne de manière cohérente dans différents environnements.

Des outils comme Kubernetes permettent de gérer les conteneurs sur plusieurs machines. Ils automatisent la mise à l’échelle, les mises à jour progressives, les vérifications de l’état des applications et la répartition de charge.

Cet article est une version localisée de How to deploy a Node.js application, initialement publié en anglais.

Tout le contenu des tutoriels de ce site est soumis aux normes éditoriales et aux valeurs rigoureuses de Hostinger.

L'auteur

Faradilla Ayunindya

Add Hostinger as a preferred source on Google

Faradilla, plus connue sous le nom de Ninda, possède 10 ans d’expérience en tant que linguiste et 5 ans en tant que spécialiste du marketing de contenu chez Hostinger. Elle aime suivre les tendances technologiques et aider les autres à résoudre leurs problèmes. Pendant son temps libre, Ninda aime apprendre de nouvelles langues et s’intéresser aux sciences de la vie, ainsi que regarder des vidéos d’animaux. Pour en savoir plus sur Ninda, retrouvez-la sur LinkedIn.

Plus d'informations sur Faradilla Ayunindya