Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Node.js

Déployer une application Node.js : PM2, Nginx et hébergement cloud

Cette leçon met en production l'API de produits (Express, Mongoose, Socket.IO). Elle prépare l'application (variables d'environnement, arrêt propre, premier administrateur), puis la déploie réellement...

0 chapitres 0 QCM Accès gratuit
Déployer une application Node.js : PM2, Nginx et hébergement cloud

À propos de ce cours

Cette leçon met en production l'API de produits (Express, Mongoose, Socket.IO). Elle prépare l'application (variables d'environnement, arrêt propre, premier administrateur), puis la déploie réellement sur un serveur Ubuntu 24.04 : utilisateur dédié, npm ci --omit=dev, PM2 avec redémarrage vérifié après un plantage et démarrage automatique, nginx en reverse proxy avec HTTPS. Une démonstration montre pourquoi nginx doit laisser passer les WebSockets. Un script met l'application à jour en une commande. La leçon présente enfin l'hébergement sur une plateforme cloud (Render) avec MongoDB Atlas, et ses limites. Activités corrigées.

Objectifs de la leçon

  • Préparer une application Node.js pour la production.
  • La déployer sur un serveur Linux avec PM2 et nginx.
  • Configurer nginx pour HTTPS et pour les WebSockets.
  • Mettre à jour l'application sans manipulation à la main.
  • Connaître l'alternative des plateformes cloud (Render) et de MongoDB Atlas.

Versions: Node.js 24 LTS, npm 11, Express 5, Mongoose 9, MongoDB 8.0, Supertest 7, Socket.IO 4.8, PM2 7, nginx 1.24 (Ubuntu 24.04). Le code de ce chapitre est celui de l'API de produits (TP 6, 8 et 9) : Express 5 en modules ES (import), Mongoose, authentification JWT avec les rôles admin et utilisateur, code réparti en routes, contrôleurs et services (séparation des couches). Toutes les commandes ont réellement été exécutées et leurs sorties sont reproduites telles quelles.

Développement et production

Sur votre poste, npm run dev lance node --watch: l'application redémarre à chaque modification et s'arrête quand vous fermez le terminal. En production, l'application doit tourner en permanence, redémarrer seule après un plantage ou un redémarrage du serveur, être accessible en HTTPS sur un nom de domaine, et garder ses secrets hors du code.

Deux façons de déployer

Sur un VPS que l'on administre, ou sur une plateforme cloud qui s'en charge.

1. Préparer l'application

Toute la configuration vient des variables d'environnement (l'objet process et les variables d'environnement) ; l'application refuse de démarrer si une variable indispensable manque :

📄 src/config/index.js

// Configuration lue une seule fois depuis les variables d'environnement
const obligatoire = (nom) => {
  const valeur = process.env[nom];
  if (!valeur) throw new Error(`Variable d'environnement manquante : ${nom}`);
  return valeur;
};

export const config = {
  env: process.env.NODE_ENV ?? 'development',
  port: Number(process.env.PORT ?? 3000),
  hote: process.env.HOTE ?? '0.0.0.0',
  mongoUri: obligatoire('MONGODB_URI'),
  jwtSecret: obligatoire('JWT_SECRET'),
  jwtDuree: process.env.JWT_DUREE ?? '1h',
  corsOrigines: (process.env.CORS_ORIGINES ?? '').split(',').filter(Boolean),
  trustProxy: process.env.TRUST_PROXY ?? '',
};

Le point d'entrée connecte la base, partage un serveur HTTP entre Express et Socket.IO (leçon 16.3), et s'arrête proprement quand PM2, Docker ou Ctrl+C envoient un signal d'arrêt : les requêtes en cours se terminent et la connexion MongoDB est fermée.

📄 src/server.js

import { createServer } from 'node:http';
import { creerApp } from './app.js';
import { config } from './config/index.js';
import { connecterBase, deconnecterBase } from './config/db.js';
import { brancherTempsReel } from './temps-reel.js';

await connecterBase(config.mongoUri);

const app = creerApp();
const serveur = createServer(app); // un serveur HTTP partagé par Express et Socket.IO
const io = brancherTempsReel(serveur);

serveur.listen(config.port, config.hote, () => {
  console.log(`API démarrée sur http://${config.hote}:${config.port} (${config.env})`);
});

// Arrêt propre (Ctrl+C, PM2, Docker) : on ferme les connexions avant de quitter
for (const signal of ['SIGINT', 'SIGTERM']) {
  process.on(signal, async () => {
    console.log(`${signal} reçu : arrêt en cours…`);
    io.close();
    serveur.close(async () => {
      await deconnecterBase();
      process.exit(0);
    });
  });
}
  • HOTE=127.0.0.1 en production : seul nginx, sur la même machine, peut joindre l'API.
  • TRUST_PROXY=loopback: Express lit l'adresse réelle du client dans l'en-tête X-Forwarded-For envoyé par nginx. Sans cela, la limite de connexions par IP (sécuriser une API Express, express-rate-limit) traiterait tous les visiteurs comme une seule adresse.
  • package.json: "start": "node --env-file-if-exists=.env src/server.js". Contrairement à --env-file, --env-file-if-exists n'échoue pas s'il n'y a pas de fichier .env, ce qui est le cas sur les plateformes cloud, où les variables sont saisies dans l'interface.
  • Le seed (comptes de démonstration aux mots de passe connus) refuse de s'exécuter en production ; le premier administrateur est créé par un script qui lit ses informations dans des variables d'environnement :

📄 scripts/creer-admin.js

// Premier administrateur en production :
//   ADMIN_EMAIL=... ADMIN_MOT_DE_PASSE=... npm run admin:creer
import bcrypt from 'bcrypt';
import { connecterBase, deconnecterBase } from '../src/config/db.js';
import { config } from '../src/config/index.js';
import { Utilisateur } from '../src/models/utilisateur.js';

const email = process.env.ADMIN_EMAIL?.toLowerCase();
const motDePasse = process.env.ADMIN_MOT_DE_PASSE ?? '';
if (!email || motDePasse.length < 12) {
  console.error('ADMIN_EMAIL et ADMIN_MOT_DE_PASSE (12 caractères minimum) sont obligatoires');
  process.exit(1);
}
await connecterBase(config.mongoUri);
if (await Utilisateur.exists({ email })) {
  console.log(`Le compte ${email} existe déjà : rien à faire`);
} else {
  await Utilisateur.create({ nom: 'Administration', email, role: 'admin', motDePasse: await bcrypt.hash(motDePasse, 12) });
  console.log(`Compte administrateur ${email} créé`);
}
await deconnecterBase();
2. Préparer le serveur (root)

Le serveur de test: Ubuntu 24.04, adresse 192.0.2.2, domaine fictif produits.exemple.tn. Les invites indiquent qui tape la commande : root@vps:~# (administrateur) ou deploy@vps:…$ (utilisateur de l'application). Particularités du test : le dépôt a été cloné depuis une copie locale du dépôt GitHub ; MongoDB 8.0 était installé sur le serveur lui-même (MongoDB Atlas n'était pas joignable depuis l'environnement de test) ; un certificat de test remplaçait celui de Let's Encrypt ; nginx était rechargé avec nginx -s reload (sur un VPS : systemctl reload nginx).

apt update && apt upgrade -y
# Node.js 24 LTS (dépôt NodeSource), nginx et Git
curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt install -y nodejs nginx git
npm install -g pm2
# pare-feu : SSH, HTTP, HTTPS
ufw allow OpenSSH && ufw allow 'Nginx Full' && ufw enable
# un utilisateur dédié : l'application ne tourne jamais en root
adduser --disabled-password --gecos "" deploy
mkdir -p /var/www/api-produits && chown deploy:deploy /var/www/api-produits

Résultat réellement obtenu :

root@vps:~# node -v && npm -v && pm2 -v | tail -1 && nginx -v
v24.22.3
11.21.2
7.1.2
nginx version: nginx/1.24.0 (Ubuntu)

La base de données: le plus simple est MongoDB Atlas (MongoDB Atlas). Dans Atlas, créez un utilisateur de base dédié avec un mot de passe long, et dans Network Access, autorisez l'adresse IP de votre VPS. Vous pouvez aussi installer MongoDB sur le serveur (dépôt officiel repo.mongodb.org), en activant l'authentification et en le laissant écouter sur 127.0.0.1 uniquement.

3. Installer l'application (deploy)

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ git clone https://github.com/VOTRE_COMPTE/api-produits.git .
Cloning into '.'...
done.
deploy@vps:/var/www/api-produits$ chmod 600 .env && ls -l .env
-rw------- 1 deploy deploy 334 Nov 15 21:59 .env

Le fichier .env de production, créé à la main sur le serveur (nano .env), n'est jamais versionné :

📄 /var/www/api-produits/.env (secret masqué)

NODE_ENV=production
PORT=3000
HOTE=127.0.0.1
# MongoDB Atlas : mongodb+srv://produits:MOT_DE_PASSE@cluster0.xxxxx.mongodb.net/produits
MONGODB_URI=mongodb://127.0.0.1:27017/produits_prod
JWT_SECRET=••••••••
JWT_DUREE=1h
CORS_ORIGINES=https://produits.exemple.tn
TRUST_PROXY=loopback

Générez le secret JWT avec openssl rand -base64 48. L'application étant en JavaScript, il n'y a rien à compiler : on installe seulement les dépendances de production, sans supertest ni socket.io-client:

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ npm ci --omit=dev
added 133 packages, and audited 134 packages in 4s
36 packages are looking for funding
  run `npm fund` for details
found 0 vulnerabilities
deploy@vps:/var/www/api-produits$ du -sh node_modules
33M	node_modules
deploy@vps:/var/www/api-produits$ ADMIN_EMAIL=direction@exemple.tn ADMIN_MOT_DE_PASSE='Direction-2026-Prod' npm run admin:creer
> api-produits@1.2.0 admin:creer
> node --env-file-if-exists=.env scripts/creer-admin.js

MongoDB connecté : 127.0.0.1/produits_prod
Compte administrateur direction@exemple.tn créé
4. PM2 : garder l'application en vie

PM2 lance node en arrière-plan, le relance s'il plante, le démarre avec le serveur et conserve ses journaux. On le configure avec un fichier versionné dans le projet :

📄 ecosystem.config.cjs

// PM2 : pm2 start ecosystem.config.cjs
module.exports = {
  apps: [
    {
      name: 'api-produits',
      cwd: __dirname,
      script: 'src/server.js',
      node_args: '--env-file-if-exists=.env', // .env du serveur, jamais versionné
      instances: 1, // Socket.IO garde ses connexions en mémoire : une seule instance (voir 16.3)
      exec_mode: 'fork',
      max_memory_restart: '250M',
      env: { NODE_ENV: 'production' },
      time: true,
    },
  ],
};
  • Fichier en .cjs: le projet est en modules ES ("type": "module"), mais PM2 lit sa configuration avec require.
  • node_args transmet --env-file-if-exists=.env à Node.js ; cwd désigne le dossier où se trouve ce .env.
  • instances: 1: le mode cluster lancerait un processus par cœur, mais Socket.IO garde ses connexions en mémoire, dans un seul processus. Pour plusieurs instances, il faut des sessions « collantes » et un adaptateur partagé (Redis) : voir la leçon 16.3.

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ pm2 start ecosystem.config.cjs
[PM2][WARN] Applications api-produits not running, starting...
[PM2] App [api-produits] launched (1 instances)
┌────┬─────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name            │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├────┼─────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0  │ api-produits    │ default     │ 1.2.0   │ fork    │ 2561     │ 0s     │ 0    │ online    │ 0%       │ 32.0mb   │ deploy   │ disabled │
└────┴─────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
deploy@vps:/var/www/api-produits$ pm2 ls
┌────┬─────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name            │ namespace   │ version │ mode    │ pid      │ uptime │ ↺    │ status    │ cpu      │ mem      │ user     │ watching │
├────┼─────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0  │ api-produits    │ default     │ 1.2.0   │ fork    │ 2561     │ 4s     │ 0    │ online    │ 0%       │ 107.3mb  │ deploy   │ disabled │
└────┴─────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
host metrics | cpu: 0% | ram usage: 9.2% | disk: ⇓ 0mb/s ⇑ 0mb/s / 64.28%
deploy@vps:/var/www/api-produits$ pm2 logs api-produits --lines 3 --nostream
[TAILING] Tailing last 3 lines for [api-produits] process (change the value with --lines option)
/home/deploy/.pm2/logs/api-produits-error-0.log last 3 lines:
/home/deploy/.pm2/logs/api-produits-out-0.log last 3 lines:
0|api-prod | 2026-11-15T21:59:17: MongoDB connecté : 127.0.0.1/produits_prod
0|api-prod | 2026-11-15T21:59:17: API démarrée sur http://127.0.0.1:3000 (production)
deploy@vps:/var/www/api-produits$ pm2 save
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2

Simulons un plantage brutal :

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ kill -9 $(pm2 pid api-produits)     # plantage simulé
deploy@vps:/var/www/api-produits$ pm2 ls
│ 0  │ api-produits    │ default     │ 1.2.0   │ fork    │ 3588     │ 3s     │ 1    │ online    │ 0%       │ 107.4mb  │ deploy   │ disabled │

PM2 a relancé l'API (nouveau PID, compteur ↺ à 1). Pour que l'API redémarre aussi avec le serveur, pm2 save (déjà fait) enregistre la liste des applications, et pm2 startup affiche la commande à exécuter en root:

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ pm2 startup
[PM2] Init System found: systemd
[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/usr/local/lib/nodejs/bin /usr/local/lib/node_modules/pm2/bin/pm2 startup systemd -u deploy --hp /home/deploy

Commandes courantes : pm2 ls, pm2 logs api-produits, pm2 monit, pm2 reload ecosystem.config.cjs --update-env, pm2 stop api-produits.

5. nginx en reverse proxy

nginx reçoit tout le trafic (ports 80 et 443), gère HTTPS et transmet les requêtes à Node.js sur 127.0.0.1:3000. La configuration, versionnée dans deploiement/, a deux blocs location:

📄 deploiement/nginx-api-produits.conf

# /etc/nginx/sites-available/api-produits
upstream api_produits {
    server 127.0.0.1:3000;
    keepalive 16;
}

server {
    listen 80;
    server_name produits.exemple.tn;
    server_tokens off;
    return 301 https://$host$request_uri;
}

server {
    # nginx 1.24 (Ubuntu 24.04) ; nginx >= 1.25.1 : « listen 443 ssl; » + « http2 on; »
    listen 443 ssl http2;
    server_name produits.exemple.tn;

    ssl_certificate     /etc/letsencrypt/live/produits.exemple.tn/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/produits.exemple.tn/privkey.pem;

    server_tokens off;
    client_max_body_size 1m;
    access_log /var/log/nginx/api-produits.access.log;
    error_log  /var/log/nginx/api-produits.error.log;

    # Socket.IO : la connexion HTTP doit pouvoir être « transformée » en WebSocket
    location /socket.io/ {
        proxy_pass http://api_produits;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 1h;   # une connexion WebSocket peut rester ouverte longtemps
    }

    # tout le reste (API et fichiers de public/) : Express
    location / {
        proxy_pass http://api_produits;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Résultat réellement obtenu :

root@vps:~# cp /var/www/api-produits/deploiement/nginx-api-produits.conf /etc/nginx/sites-available/api-produits
root@vps:~# nginx -t && nginx -s reload
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Résultat réellement obtenu :

root@vps:~# curl -sI http://produits.exemple.tn/api/sante | grep -iE "^HTTP|^location"
HTTP/1.1 301 Moved Permanently
Location: https://produits.exemple.tn/api/sante
root@vps:~# curl -s https://produits.exemple.tn/api/sante
{"statut":"ok","version":"1.2.0","uptime":47}
root@vps:~# curl -s "https://produits.exemple.tn/api/produits?limite=1"
{"donnees":[],"total":0,"page":1,"limite":1,"pages":0}
root@vps:~# curl -s -m 3 http://192.0.2.2:3000/api/sante || echo "refusé (code $?)"
refusé (code 7)

HTTP est redirigé (301) vers HTTPS, l'API répond par nginx, et le port 3000 est fermé depuis l'extérieur (code 7 de curl : connexion impossible).

Pourquoi un bloc spécial pour /socket.io/? Une connexion WebSocket commence par une requête HTTP qui demande à « changer de protocole » (en-têtes Upgrade: websocket et Connection: upgrade). Par défaut, nginx ne transmet pas ces en-têtes. Voici ce que montre le journal de nginx quand on ouvre la page temps réel sans ce bloc :

Résultat réellement obtenu :

root@vps:~# # Chrome ouvre https://produits.exemple.tn/temps-reel.html, puis :
root@vps:~# grep socket.io /var/log/nginx/api-produits.access.log
URL : https://produits.exemple.tn/temps-reel.html
transport : polling
"GET /socket.io/socket.io.js 200
"GET /socket.io/?EIO=4&transport=polling&t=doiasatf 200
"POST /socket.io/?EIO=4&transport=polling&t=doib2lhb&sid=… 200
"GET /socket.io/?EIO=4&transport=polling&t=doib58jo&sid=… 200
"GET /socket.io/?EIO=4&transport=websocket&sid=… 400
"GET /socket.io/?EIO=4&transport=polling&t=doibq6fu&sid=… 499

La tentative WebSocket échoue (400) ; Socket.IO se rabat discrètement sur le long polling (une requête HTTP qui attend un événement, puis une autre…). La page semble fonctionner, mais chaque client occupe des requêtes en permanence. Avec la configuration complète :

Résultat réellement obtenu :

root@vps:~# # même test avec la configuration complète
root@vps:~# grep socket.io /var/log/nginx/api-produits.access.log
URL : https://produits.exemple.tn/temps-reel.html
transport : websocket
"GET /socket.io/socket.io.js 200
"GET /socket.io/?EIO=4&transport=polling&t=donbcmji 200
"POST /socket.io/?EIO=4&transport=polling&t=doncb496&sid=… 200
"GET /socket.io/?EIO=4&transport=polling&t=doncd2og&sid=… 200
"GET /socket.io/?EIO=4&transport=polling&t=doncoqvu&sid=… 200
"GET /socket.io/?EIO=4&transport=websocket&sid=… 101

Le statut 101 Switching Protocols confirme le passage au WebSocket. proxy_read_timeout 1h évite que nginx coupe une connexion WebSocket restée silencieuse (60 secondes par défaut ; Socket.IO envoie de toute façon un signal de vie régulier).

Page temps réel en production

La page temps réel servie en HTTPS par nginx, connectée en WebSocket (capture réelle dans Chrome).

6. HTTPS avec Let's Encrypt

Créez un enregistrement DNS A: produits.exemple.tn → adresse IP du VPS. Puis, en root :

apt install -y certbot python3-certbot-nginx
certbot --nginx -d produits.exemple.tn     # obtient le certificat et l'ajoute à la configuration
certbot renew --dry-run                     # vérifie le renouvellement automatique (tous les 90 jours)

Sur Ubuntu 24.04, nginx est en version 1.24 : on écrit listen 443 ssl http2;. La directive http2 on; n'existe qu'à partir de nginx 1.25.1.

Si votre VPS est géré par un panneau (aaPanel, Plesk…): créez le site dans le panneau et utilisez sa fonction « Reverse proxy » vers http://127.0.0.1:3000 ainsi que sa gestion des certificats, plutôt que de modifier ses fichiers nginx à la main. Vérifiez que l'option WebSocket du proxy est activée, ou ajoutez les en-têtes Upgrade et Connection vus plus haut.

7. Mettre à jour l'application

📄 deploiement/deployer.sh

#!/bin/bash
# Mise à jour sur le serveur (utilisateur deploy) : bash deploiement/deployer.sh
set -euo pipefail
cd /var/www/api-produits
git pull --ff-only
npm ci --omit=dev --no-audit --no-fund   # du JavaScript : rien à compiler
pm2 reload ecosystem.config.cjs --update-env
pm2 save
sleep 2
curl -fsS http://127.0.0.1:3000/api/sante && echo

Après un git push de la version 1.2.1 depuis le poste de développement :

Résultat réellement obtenu :

deploy@vps:/var/www/api-produits$ bash deploiement/deployer.sh
From https://github.com/VOTRE_COMPTE/api-produits
   1246c55..0b33e9a  main       -> origin/main
Updating 1246c55..0b33e9a
Fast-forward
 package-lock.json | 8 ++++----
 package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

added 133 packages in 2s
[PM2] Applying action reloadProcessId on app [api-produits](ids: [ 0 ])
[PM2] [api-produits](0) ✓
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2
{"statut":"ok","version":"1.2.1","uptime":2}

Ne modifiez jamais le code directement sur le serveur : git pull --ff-only refuserait la mise à jour suivante. Toute modification passe par le dépôt GitHub (et par les tests de la leçon 16.1).

8. L'alternative : une plateforme cloud (PaaS)

Une plateforme comme Render (ou Railway, Fly.io, Heroku…) remplace le VPS, PM2, nginx et certbot : vous reliez votre dépôt GitHub, indiquez les commandes, saisissez les variables d'environnement, et la plateforme construit et héberge l'application à chaque push, avec HTTPS fourni.

  1. Sur MongoDB Atlas, créez l'utilisateur de la base et, dans Network Access, autorisez les adresses de la plateforme. Les instances gratuites n'ayant pas d'adresse fixe, on autorise souvent 0.0.0.0/0: le mot de passe long de l'utilisateur devient alors la seule protection.
  2. Sur Render : New → Web Service, choisissez le dépôt, Build Command npm ci --omit=dev, Start Command npm start, Health Check Path /api/sante.
  3. Dans Environment: NODE_ENV=production, MONGODB_URI (Atlas), JWT_SECRET, CORS_ORIGINES et TRUST_PROXY=1 (un proxy devant l'application). Render fournit lui-même la variable PORT; notre configuration la lit, et HOTE vaut 0.0.0.0 par défaut.
  4. Créez l'administrateur depuis votre poste avec l'adresse Atlas : MONGODB_URI="mongodb+srv://…" JWT_SECRET=x ADMIN_EMAIL=… ADMIN_MOT_DE_PASSE=… npm run admin:creer.

Les limites de l'offre gratuite sont importantes pour un projet réel. Render met en veille un service web gratuit qui ne reçoit aucun trafic pendant 15 minutes, y compris les requêtes HTTP et les messages WebSocket des connexions existantes : la première requête suivante doit attendre le redémarrage. Le système de fichiers est éphémère : les fichiers modifiés (images téléversées, base SQLite locale…) sont perdus à chaque redéploiement, redémarrage ou mise en veille. Les images téléversées avec Multer (l'upload de fichiers) doivent donc aller dans un stockage externe, et les données dans Atlas.

  VPS (PM2 + nginx) Plateforme cloud (Render…)
Mise en place plus longue : système, sécurité, mises à jour à votre charge quelques minutes
HTTPS, redémarrage, journaux certbot, PM2, à configurer fournis
Fichiers sur le disque conservés perdus à chaque déploiement
Offre gratuite non (quelques euros par mois) oui, avec mise en veille
Ce que l'on apprend le fonctionnement complet d'un serveur le déploiement continu depuis GitHub
Activités

Activité 1 Prêt pour la production ?

Relevez les problèmes de ce server.js avant une mise en production :

import express from 'express';
import mongoose from 'mongoose';
const app = express();
mongoose.connect('mongodb+srv://admin:Admin123@cluster0.abcd.mongodb.net/boutique');
app.use(express.json());
const SECRET = 'secret';
// … routes …
app.listen(3000, () => console.log('ok'));
Voir le corrigé

Identifiants de la base et secret JWT écrits dans le code (donc sur GitHub) : à mettre dans .env (MONGODB_URI, JWT_SECRET) et à changer immédiatement s'ils ont été poussés ; secret JWT trop court ; port fixe (les plateformes imposent PORT) ; écoute sur toutes les interfaces au lieu de 127.0.0.1 derrière nginx ; démarrage avant que la connexion à la base ne soit établie (await mongoose.connect d'abord) ; pas d'arrêt propre (SIGTERM) ; pas de helmet ni de gestion centralisée des erreurs ; application non séparée en app.js / server.js, donc difficile à tester.

Activité 2 502 Bad Gateway

Après une mise à jour, le site affiche « 502 Bad Gateway » et pm2 ls indique errored, ↺ 15. Que faites-vous ?

Voir le corrigé

nginx ne joint plus Node.js, qui plante en boucle. Lire l'erreur : pm2 logs api-produits --lines 50 --nostream. Causes fréquentes : variable manquante (message « Variable d'environnement manquante » de config/index.js), base inaccessible (adresse IP du VPS non autorisée dans Atlas, MongoDB arrêté), dépendance installée en devDependencies (Cannot find module), erreur de syntaxe poussée sans exécuter les tests. Corriger, puis pm2 reload ecosystem.config.cjs --update-env.

Activité 3 Déployer votre TP

Déployez votre API du TP 9 : sur un VPS ou une machine virtuelle Ubuntu 24.04 (étapes 2 à 7), ou sur Render avec MongoDB Atlas (étape 8). Ajoutez au dépôt ecosystem.config.cjs, le dossier deploiement/ et une section « Déploiement » dans le README avec l'adresse de l'API en ligne.

Voir le corrigé

Vérifications : /api/sante répond en HTTPS ; une connexion avec le compte créé par admin:creer renvoie un jeton ; un POST sans jeton renvoie 401 ; sur Render, la première requête après 15 minutes d'inactivité est lente (réveil du service). Sans nom de domaine, testez avec curl -H "Host: produits.exemple.tn" http://IP_DU_SERVEUR/api/sante. Commit : chore(deploiement): PM2, nginx et README.

Activité 4 Le client SPA en production

Le client SPA du TP 10 est publié sur https://taches.exemple.tn et l'API sur https://api.exemple.tn. Le navigateur affiche une erreur CORS. Que faut-il changer, et où ? Comment éviter complètement CORS ?

Voir le corrigé

Dans le .env de production de l'API : CORS_ORIGINES=https://taches.exemple.tn (origine exacte, avec https et sans / final), puis pm2 reload ecosystem.config.cjs --update-env. Pour éviter CORS, servir le client et l'API depuis la même origine : nginx sert les fichiers du client sur / et transmet /api/ et /socket.io/ à Node.js (ou Express sert le client avec express.static, comme la page temps réel de ce projet).

À retenir

  • Production : configuration par variables d'environnement, secrets hors du dépôt, npm ci --omit=dev, arrêt propre sur SIGTERM.
  • PM2 (ecosystem.config.cjs) : redémarrage après plantage, pm2 save + pm2 startup, journaux.
  • nginx en reverse proxy : HTTPS, redirection, API sur 127.0.0.1, TRUST_PROXY; en-têtes Upgrade/Connection pour les WebSockets (101).
  • Mises à jour par git pull + script, jamais en modifiant le serveur à la main.
  • Plateforme cloud + Atlas : rapide et gratuit pour commencer, mais mise en veille et disque éphémère.

Cet article vous a-t-il aidé ?