À propos de ce cours
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.
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.1en 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êteX-Forwarded-Forenvoyé 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-existsn'é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 avecrequire. node_argstransmet--env-file-if-exists=.envà Node.js ;cwddésigne le dossier où se trouve ce.env.instances: 1: le modeclusterlancerait 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).

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.
- 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. - Sur Render : New → Web Service, choisissez le dépôt, Build Command
npm ci --omit=dev, Start Commandnpm start, Health Check Path/api/sante. - Dans Environment:
NODE_ENV=production,MONGODB_URI(Atlas),JWT_SECRET,CORS_ORIGINESetTRUST_PROXY=1(un proxy devant l'application). Render fournit lui-même la variablePORT; notre configuration la lit, etHOTEvaut0.0.0.0par défaut. - 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 surSIGTERM. - 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êtesUpgrade/Connectionpour 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é ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !