À propos de ce cours
Objectifs de la leçon
- Préparer un serveur Linux pour une application Node.js.
- Faire tourner l'API en permanence avec PM2.
- Placer nginx devant l'API comme reverse proxy, puis activer HTTPS.
- Mettre à jour l'application en une commande.
Versions: NestJS 12.5 (projet CommonJS), Node.js 24, npm 11, PM2 7.1, nginx 1.24 (Ubuntu 24.04 LTS), Docker 29 avec Compose 5, MariaDB 10.11. Toutes les commandes de ce chapitre ont été réellement exécutées sur un serveur de test Ubuntu 24.04 (adresse 192.0.2.2, utilisateur deploy), avec le projet api-securisee du chapitre 19, complété pour la production. Les sorties sont reproduites telles quelles ; seuls les secrets sont masqués.
Le serveur de test: Ubuntu 24.04, adresse 192.0.2.2, nom de domaine fictif api.exemple.tn. Les invites indiquent qui tape la commande : root@vps:~# pour l'administrateur, deploy@vps:…$ pour l'utilisateur qui fait tourner l'application. Le dépôt a été cloné depuis une copie locale du dépôt GitHub : avec GitHub, la sortie est la même. Le serveur de test n'utilisant pas systemd, nginx y a été démarré et rechargé avec nginx et nginx -s reload; sur un VPS, utilisez systemctl reload nginx.
L'architecture
Un VPS (Virtual Private Server) est un serveur Linux loué chez un hébergeur, dont vous êtes administrateur. Trois logiciels s'y partagent le travail :
nginx reçoit tout le trafic et le transmet à l'API, que PM2 maintient en vie.
- PM2 lance
node dist/main.jsen arrière-plan, le relance s'il plante, le démarre avec le serveur et garde ses journaux. Sans lui, l'API s'arrête dès que vous fermez la session SSH. - nginx est le seul programme visible depuis Internet (ports 80 et 443). Il gère HTTPS, limite la taille des requêtes, journalise les accès et transmet les requêtes
/apià NestJS : c'est un reverse proxy. - NestJS écoute uniquement sur
127.0.0.1:3000: impossible de le joindre sans passer par nginx.
1. Préparer le serveur (root)
Une fois connecté en SSH comme root (ou avec sudo), installez les logiciels et créez un utilisateur dédié : l'application ne doit jamais tourner en root.
apt update && apt upgrade -y
# Node.js 24 LTS (dépôt NodeSource), nginx, MariaDB, Git
curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt install -y nodejs nginx mariadb-server git
# pare-feu : SSH, HTTP et HTTPS uniquement (OpenSSH en premier pour ne pas couper sa propre session)
ufw allow OpenSSH && ufw allow 'Nginx Full' && ufw enable
# utilisateur qui fera tourner l'application
adduser --disabled-password --gecos "" deploy
mkdir -p /var/www/api-securisee && chown deploy:deploy /var/www/api-securisee
Puis PM2, installé globalement, et une vérification :
Résultat réellement obtenu :
root@vps:~# node -v && npm -v
v24.22.3
11.21.2
root@vps:~# nginx -v
nginx version: nginx/1.24.0 (Ubuntu)
root@vps:~# npm install -g pm2
added 45 packages in 1s
Créez enfin la base et un compte MariaDB réservé à l'application, avec des droits sur cette seule base :
mysql -e "CREATE DATABASE api_prod CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'api_prod'@'localhost' IDENTIFIED BY 'un-mot-de-passe-long-et-unique';
GRANT ALL ON api_prod.* TO 'api_prod'@'localhost';"
2. Installer l'application (deploy)
Passez sur l'utilisateur deploy (su - deploy) et clonez le dépôt. Pour un dépôt privé, ajoutez une deploy key (clé SSH en lecture seule) dans les paramètres du dépôt GitHub.
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ git clone https://github.com/VOTRE_COMPTE/api-securisee.git .
Cloning into '.'...
done.
deploy@vps:/var/www/api-securisee$ ls -A
.env.example
.git
.gitattributes
.gitignore
.oxlintrc.json
.prettierrc
README.md
ecosystem.config.cjs
jest.config.ts
nest-cli.json
package-lock.json
package.json
src
test
tsconfig.build.json
tsconfig.json
Créez le .env de production (il n'est pas dans le dépôt) avec nano .env:
📄 /var/www/api-securisee/.env (secret masqué)
NODE_ENV=production
PORT=3000
HOTE=127.0.0.1
DB_HOTE=localhost
DB_PORT=3306
DB_UTILISATEUR=api_prod
DB_MOT_DE_PASSE=Pr0d-Base-2026!
DB_NOM=api_prod
JWT_SECRET=••••••••
CORS_ORIGINES=https://stagiaires.exemple.tn
TRUST_PROXY=loopback
LOG_FORMAT=json
LOG_NIVEAUX=log
HOTE=127.0.0.1: l'API n'accepte que les connexions locales, donc celles de nginx. TRUST_PROXY=loopback: elle fait confiance à l'en-tête X-Forwarded-For de nginx (leçon 19.2). Générez le secret JWT avec openssl rand -base64 48. Puis :
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ chmod 600 .env && ls -l .env
-rw------- 1 deploy deploy 320 Nov 15 19:13 .env
deploy@vps:/var/www/api-securisee$ npm ci
added 657 packages, and audited 658 packages in 14s
25 vulnerabilities (6 low, 17 moderate, 2 high)
To address all issues (including breaking changes), run:
deploy@vps:/var/www/api-securisee$ npm run build
> api-securisee@0.0.1 build
> nest build
deploy@vps:/var/www/api-securisee$ npm run migration:run
> api-securisee@0.0.1 migration:run
> typeorm -d dist/data-source.js migration:run
0 migrations are already loaded in the database.
1 migrations were found in the source code.
1 migrations are new migrations must be executed.
Migration Initialisation1794763018768 has been executed successfully.
deploy@vps:/var/www/api-securisee$ ADMIN_EMAIL=direction@exemple.tn ADMIN_MOT_DE_PASSE='Direction-2026-Prod' npm run admin:creer
> api-securisee@0.0.1 admin:creer
> node dist/scripts/creer-admin.js
Compte administrateur direction@exemple.tn créé
Ici, on compile sur le serveur : npm ci installe aussi les outils de développement nécessaires à nest build. Les avertissements install-scripts de npm 11 (non reproduits ici) signalent que des scripts d'installation n'ont pas été exécutés ; bcrypt fonctionne quand même, car il fournit des versions précompilées.
3. PM2
PM2 se configure avec un fichier ecosystem.config.cjs, versionné avec le projet :
📄 ecosystem.config.cjs
// Configuration PM2 : pm2 start ecosystem.config.cjs
module.exports = {
apps: [
{
name: 'api-securisee',
cwd: __dirname, // le .env est lu dans ce dossier
script: 'dist/main.js',
node_args: '--enable-source-maps',
instances: 1, // compteurs du throttler en mémoire : une seule instance (leçon 19.2)
exec_mode: 'fork',
max_memory_restart: '300M', // redémarrer si la mémoire dépasse 300 Mo
env: { NODE_ENV: 'production' },
time: true, // horodater chaque ligne des journaux PM2
},
],
};
cwd: dossier de travail ; c'est là queConfigModulecherche le.env.instances: 1, modefork: un seul processus. Le modecluster(instances: 'max') lance un processus par cœur et permet des rechargements sans interruption, mais tout état en mémoire est alors dupliqué : compteurs de la limite de débit (leçon 19.2), cache en mémoire (chapitre 15), WebSockets (chapitre 16).max_memory_restart: redémarrage si une fuite de mémoire fait grossir le processus.
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ pm2 start ecosystem.config.cjs
[PM2][WARN] Applications api-securisee not running, starting...
[PM2] App [api-securisee] launched (1 instances)
┌────┬──────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ api-securisee │ default │ 0.0.1 │ fork │ 1097 │ 0s │ 0 │ online │ 0% │ 27.3mb │ deploy │ disabled │
└────┴──────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
host metrics | cpu: 37.1% | ram usage: 11% | eth0: ⇓ 2.1mb/s ⇑ 20kb/s | disk: ⇓ 135kb/s ⇑ 967kb/s
deploy@vps:/var/www/api-securisee$ pm2 ls
┌────┬──────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ api-securisee │ default │ 0.0.1 │ fork │ 1097 │ 5s │ 0 │ online │ 0% │ 146.7mb │ deploy │ disabled │
└────┴──────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
host metrics | cpu: 37.1% | ram usage: 11% | eth0: ⇓ 2.1mb/s ⇑ 20kb/s | disk: ⇓ 135kb/s ⇑ 967kb/s
deploy@vps:/var/www/api-securisee$ curl -s http://127.0.0.1:3000/api/sante
{"statut":"ok","disponibleDepuis":"5 s"}
deploy@vps:/var/www/api-securisee$ pm2 logs api-securisee --lines 4 --nostream
[TAILING] Tailing last 4 lines for [api-securisee] process (change the value with --lines option)
/home/deploy/.pm2/logs/api-securisee-error-0.log last 4 lines:
/home/deploy/.pm2/logs/api-securisee-out-0.log last 4 lines:
0|api-secu | 2026-11-15T19:16:06: {"level":"log","pid":1097,"timestamp":1794770166437,"message":"Mapped {/api/demandes/:id, DELETE} route","context":"RouterExplorer"}
0|api-secu | 2026-11-15T19:16:06: {"level":"log","pid":1097,"timestamp":1794770166437,"message":"Nest application successfully started","context":"NestApplication"}
0|api-secu | 2026-11-15T19:16:06: {"level":"log","pid":1097,"timestamp":1794770166438,"message":"API prête sur http://localhost:3000/api (production)","context":"Demarrage"}
0|api-secu | 2026-11-15T19:16:10: {"level":"log","pid":1097,"timestamp":1794770170411,"message":"GET /api/sante 200 8ms","context":"HTTP","params":{"requete":"db7b8b6c","ip":"127.0.0.1","utilisateur":null}}
Les journaux de l'API (JSON) sont dans ~/.pm2/logs/, horodatés par PM2. Simulons maintenant un plantage brutal du processus :
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ kill -9 $(pm2 pid api-securisee) # simulons un plantage brutal
deploy@vps:/var/www/api-securisee$ pm2 ls
┌────┬──────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ api-securisee │ default │ 0.0.1 │ fork │ 1152 │ 4s │ 1 │ online │ 0% │ 146.9mb │ deploy │ disabled │
└────┴──────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
host metrics | cpu: 37.1% | ram usage: 11% | eth0: ⇓ 2.1mb/s ⇑ 20kb/s | disk: ⇓ 135kb/s ⇑ 967kb/s
deploy@vps:/var/www/api-securisee$ curl -s http://127.0.0.1:3000/api/sante
{"statut":"ok","disponibleDepuis":"4 s"}
PM2 a relancé l'API immédiatement : nouveau PID et compteur de redémarrages (↺) passé à 1. Pour que PM2 et l'API redémarrent aussi avec le serveur :
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ pm2 save
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2
deploy@vps:/var/www/api-securisee$ 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
pm2 save enregistre la liste des applications ; pm2 startup affiche la commande à exécuter en root (copiez celle affichée chez vous : les chemins dépendent de l'installation de Node.js) pour créer le service systemd pm2-deploy.
| Commande PM2 | Rôle |
|---|---|
pm2 ls | état des applications |
pm2 logs api-securisee | journaux en direct (--lines 100, --nostream) |
pm2 monit | tableau de bord dans le terminal (CPU, mémoire, journaux) |
pm2 reload ecosystem.config.cjs --update-env | redémarrer avec le nouveau code et le nouvel environnement |
pm2 stop / pm2 delete api-securisee | arrêter / retirer de la liste |
pm2 install pm2-logrotate | découper et purger les journaux automatiquement |
4. nginx en reverse proxy (root)
La configuration est elle aussi versionnée dans le dépôt (deploiement/) :
📄 deploiement/nginx-api-securisee.conf
# /etc/nginx/sites-available/api-securisee
# Reverse proxy : nginx reçoit les requêtes (ports 80/443) et les transmet à NestJS (127.0.0.1:3000)
upstream api_securisee {
server 127.0.0.1:3000;
keepalive 16;
}
server {
listen 80;
server_name api.exemple.tn;
server_tokens off; # ne pas afficher la version de nginx
client_max_body_size 1m; # taille maximale d'une requête (fichiers compris)
access_log /var/log/nginx/api-securisee.access.log;
error_log /var/log/nginx/api-securisee.error.log;
location /api/ {
proxy_pass http://api_securisee;
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;
proxy_read_timeout 30s;
}
# tout le reste : 404 (aucune page sur ce sous-domaine)
location / {
return 404;
}
}
proxy_set_header X-Forwarded-ForetX-Forwarded-Proto: l'API connaît l'adresse réelle du client et sait que la requête d'origine était en HTTPS.client_max_body_size: nginx refuse (413) les requêtes trop grosses avant qu'elles n'atteignent Node.js.location /renvoie 404 : seul/api/est transmis.- Sur un serveur avec IPv6, ajoutez
listen [::]:80;(le serveur de test n'a pas d'IPv6 : nginx refusait de démarrer avec cette ligne).
Résultat réellement obtenu :
root@vps:~# cp /var/www/api-securisee/deploiement/nginx-api-securisee.conf /etc/nginx/sites-available/api-securisee
root@vps:~# ln -s /etc/nginx/sites-available/api-securisee /etc/nginx/sites-enabled/
root@vps:~# rm /etc/nginx/sites-enabled/default
root@vps:~# nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
root@vps:~# nginx # démarrage (sur un VPS : systemctl reload nginx)
root@vps:~# curl -si http://192.0.2.2/api/sante -H "Host: api.exemple.tn"
HTTP/1.1 200 OK
Server: nginx
Date: Sun, 15 Nov 2026 19:16:37 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 41
Connection: keep-alive
Content-Security-Policy: default-src 'self';base-uri 'self';font-src 'self' https: data:;form-action 'self';frame-ancestors 'self';img-src 'self' data:;object-src 'none';script-src 'self';script-src-attr 'none';style-src 'self' https: 'unsafe-inline';upgrade-insecure-requests
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Resource-Policy: same-origin
Origin-Agent-Cluster: ?1
Referrer-Policy: no-referrer
Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Content-Type-Options: nosniff
X-DNS-Prefetch-Control: off
X-Download-Options: noopen
X-Frame-Options: SAMEORIGIN
X-Permitted-Cross-Domain-Policies: none
X-XSS-Protection: 0
Vary: Origin
X-Request-Id: 22501de9
ETag: W/"29-aezYmtrhc0yIw15PAI0+Eea33V8"
{"statut":"ok","disponibleDepuis":"21 s"}
Le DNS n'est pas encore configuré : on teste avec l'adresse IP du serveur et l'en-tête Host. La réponse vient bien de nginx (Server: nginx, sans numéro de version grâce à server_tokens off), avec les en-têtes de Helmet ajoutés par l'API. Quelques vérifications :
Résultat réellement obtenu :
root@vps:~# curl -s -o /dev/null -w "%{http_code}\n" http://192.0.2.2/ -H "Host: api.exemple.tn"
404
root@vps:~# curl -s -m 3 http://192.0.2.2:3000/api/sante || echo "échec (code $?)"
échec (code 7)
root@vps:~# ss -ltnp | grep -E ":(80|3000) "
LISTEN 0 511 0.0.0.0:80 0.0.0.0:* users:(("nginx",pid=1226,fd=7),("nginx",pid=1225,fd=7),("nginx",pid=1224,fd=7))
LISTEN 0 511 127.0.0.1:3000 0.0.0.0:* users:(("node /var/www/a",pid=1152,fd=22))
root@vps:~# tail -1 /var/log/nginx/api-securisee.access.log
192.0.2.2 - - [15/Nov/2026:20:16:45 +0100] "GET / HTTP/1.1" 404 146 "-" "curl/8.5.0"
root@vps:~# curl -s -o /dev/null http://192.0.2.2/api/demandes -H "Host: api.exemple.tn"
root@vps:~# tail -1 /home/deploy/.pm2/logs/api-securisee-out-0.log
2026-11-15T19:16:49: {"level":"warn","pid":1152,"timestamp":1794770209534,"message":"GET /api/demandes 401 2ms","context":"HTTP","params":{"requete":"7fa37bf5","ip":"192.0.2.2","utilisateur":null}}
- Toute autre adresse que
/api/: 404. - Le port 3000 est fermé depuis l'extérieur (échec de connexion, code 7 de curl) :
ssmontre que nginx écoute sur0.0.0.0:80mais l'API sur127.0.0.1:3000. - Le journal de l'API contient l'adresse réelle du client (
192.0.2.2), pas celle de nginx, grâce àTRUST_PROXY=loopback.
5. HTTPS avec Let's Encrypt
Dans la zone DNS de votre domaine, créez un enregistrement A api.exemple.tn → adresse IP du VPS. Une fois le nom résolu, certbot obtient un certificat gratuit Let's Encrypt et le renouvelle automatiquement :
apt install -y certbot python3-certbot-nginx
certbot --nginx -d api.exemple.tn # obtient le certificat et modifie la configuration nginx
certbot renew --dry-run # vérifie le renouvellement automatique (tous les 90 jours)
Le serveur de test n'ayant pas de vrai nom de domaine, certbot ne pouvait pas y être exécuté. La configuration finale, équivalente à celle que produit certbot, a été testée avec un certificat auto-signé placé aux mêmes chemins :
📄 deploiement/nginx-api-securisee-https.conf
# Version HTTPS (après obtention du certificat Let's Encrypt avec certbot)
upstream api_securisee {
server 127.0.0.1:3000;
keepalive 16;
}
# HTTP : redirection permanente vers HTTPS
server {
listen 80;
server_name api.exemple.tn;
server_tokens off;
return 301 https://$host$request_uri;
}
server {
# nginx 1.24 (Ubuntu 24.04) ; à partir de nginx 1.25.1 : « listen 443 ssl; » + « http2 on; »
listen 443 ssl http2;
server_name api.exemple.tn;
ssl_certificate /etc/letsencrypt/live/api.exemple.tn/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/api.exemple.tn/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
server_tokens off;
client_max_body_size 1m;
access_log /var/log/nginx/api-securisee.access.log;
error_log /var/log/nginx/api-securisee.error.log;
location /api/ {
proxy_pass http://api_securisee;
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;
proxy_read_timeout 30s;
}
location / {
return 404;
}
}
Premier essai avec la syntaxe récente http2 on;:
Résultat réellement obtenu :
root@vps:~# cp /var/www/api-securisee/deploiement/nginx-api-securisee-https.conf /etc/nginx/sites-available/api-securisee
root@vps:~# nginx -t && systemctl reload nginx
2026/11/15 20:16:59 [emerg] 1264#1264: unknown directive "http2" in /etc/nginx/sites-enabled/api-securisee:16
nginx: configuration file /etc/nginx/nginx.conf test failed
Cette directive n'existe qu'à partir de nginx 1.25.1 ; Ubuntu 24.04 fournit nginx 1.24, qui utilise listen 443 ssl http2;. Avec cette correction :
Résultat réellement obtenu :
root@vps:~# cp /var/www/api-securisee/deploiement/nginx-api-securisee-https.conf /etc/nginx/sites-available/api-securisee
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
2026/11/15 20:17:20 [notice] 1298#1298: signal process started
root@vps:~# curl -sI http://192.0.2.2/api/sante -H "Host: api.exemple.tn" | head -5
HTTP/1.1 301 Moved Permanently
Server: nginx
Date: Sun, 15 Nov 2026 19:17:22 GMT
Content-Type: text/html
Content-Length: 162
root@vps:~# curl -sk --resolve api.exemple.tn:443:192.0.2.2 https://api.exemple.tn/api/sante -w "\n%{http_version}\n"
{"statut":"ok","disponibleDepuis":"67 s"}
2
root@vps:~# curl -sI http://192.0.2.2/api/sante -H "Host: api.exemple.tn" | grep -i "^location"
Location: https://api.exemple.tn/api/sante
Le port 80 redirige définitivement (301) vers HTTPS, et l'API répond en HTTP/2 (2). Avec HTTPS en place, l'en-tête HSTS envoyé par Helmet (leçon 19.1) devient effectif.
Si votre VPS est géré par un panneau (aaPanel, Plesk, cPanel…): nginx y est déjà installé et ses fichiers de configuration sont gérés par le panneau, souvent hors de /etc/nginx. Créez le site depuis le panneau, puis utilisez sa fonction « Reverse proxy » (cible http://127.0.0.1:3000) et sa gestion des certificats Let's Encrypt, plutôt que de modifier ses fichiers à la main : le panneau les réécrirait. PM2 s'utilise de la même façon.
6. Mettre à jour l'application
Chaque mise à jour répète les mêmes étapes : un script les enchaîne et s'arrête à la première erreur (set -euo pipefail) :
📄 deploiement/deployer.sh
#!/bin/bash
# Mise à jour de l'API sur le serveur (utilisateur deploy) : bash deploiement/deployer.sh
set -euo pipefail
cd /var/www/api-securisee
echo "== 1) Récupération du code"
git pull --ff-only
echo "== 2) Dépendances et compilation"
npm ci --no-audit --no-fund
npm run build
echo "== 3) Migrations"
npm run migration:run | grep -vE '^query:' || true
echo "== 4) Redémarrage de l'API"
pm2 reload ecosystem.config.cjs --update-env
pm2 save
echo "== 5) Vérification"
sleep 3
curl -fsS http://127.0.0.1:3000/api/sante && echo
Après un git push de la version 1.1.0 depuis le poste de développement :
Résultat réellement obtenu :
deploy@vps:/var/www/api-securisee$ bash deploiement/deployer.sh
== 1) Récupération du code
Updating 1d2b9c3..5d53a65
Fast-forward
package-lock.json | 4 ++--
package.json | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
== 2) Dépendances et compilation
added 657 packages in 18s
> api-securisee@1.1.0 build
> nest build
== 3) Migrations
> api-securisee@1.1.0 migration:run
> typeorm -d dist/data-source.js migration:run
No migrations are pending
== 4) Redémarrage de l'API
[PM2] Applying action reloadProcessId on app [api-securisee](ids: [ 0 ])
[PM2] [api-securisee](0) ✓
[PM2] Saving current process list...
[PM2] Successfully saved in /home/deploy/.pm2/dump.pm2
== 5) Vérification
{"statut":"ok","disponibleDepuis":"3 s"}
deploy@vps:/var/www/api-securisee$ pm2 ls
┌────┬──────────────────┬─────────────┬─────────┬─────────┬──────────┬────────┬──────┬───────────┬──────────┬──────────┬──────────┬──────────┐
│ id │ name │ namespace │ version │ mode │ pid │ uptime │ ↺ │ status │ cpu │ mem │ user │ watching │
├────┼──────────────────┼─────────────┼─────────┼─────────┼──────────┼────────┼──────┼───────────┼──────────┼──────────┼──────────┼──────────┤
│ 0 │ api-securisee │ default │ 1.1.0 │ fork │ 1886 │ 3s │ 4 │ online │ 0% │ 148.4mb │ deploy │ disabled │
└────┴──────────────────┴─────────────┴─────────┴─────────┴──────────┴────────┴──────┴───────────┴──────────┴──────────┴──────────┴──────────┘
host metrics | cpu: 32.1% | ram usage: 12.5% | eth0: ⇓ 1kb/s ⇑ 1kb/s | disk: ⇓ 72kb/s ⇑ 8.3mb/s
git pull --ff-only refuse de fusionner si le serveur a des modifications locales : on ne modifie jamais le code directement sur le serveur. En mode fork, pm2 reload redémarre le processus : l'API est indisponible pendant une à deux secondes (nginx répond alors 502). Pour éviter cette coupure, il faut le mode cluster (avec ses contraintes, vues plus haut) ou deux instances derrière nginx.
Activités
Activité 1 Qui fait quoi ?
Associez chaque besoin à nginx, PM2, NestJS ou au pare-feu : (a) relancer l'API après un plantage ; (b) certificat HTTPS ; (c) refuser une requête de 50 Mo ; (d) bloquer le port 3306 depuis Internet ; (e) vérifier le jeton JWT ; (f) démarrer l'API au démarrage du serveur ; (g) servir les fichiers d'Angular.
Voir le corrigé
(a) PM2 ; (b) nginx (certbot) ; (c) nginx (client_max_body_size), et NestJS en seconde ligne (leçon 19.3) ; (d) pare-feu (et MariaDB qui n'écoute que sur 127.0.0.1 par défaut) ; (e) NestJS ; (f) PM2 (pm2 startup + pm2 save) ; (g) nginx (TP 13).
Activité 2 502 Bad Gateway
Après une mise à jour, le site affiche « 502 Bad Gateway ». pm2 ls indique errored et ↺ 15. Quelles commandes lancez-vous, dans quel ordre, et quelles sont les causes probables ?
Voir le corrigé
nginx n'arrive pas à joindre l'API, qui plante en boucle. pm2 logs api-securisee --lines 50 --nostream pour lire l'erreur. Causes fréquentes : variable absente du .env (message de validation, chapitre 19), migration non exécutée (table manquante), dépendance installée en devDependencies, port déjà utilisé, base arrêtée (systemctl status mariadb). Après correction : pm2 reload ecosystem.config.cjs --update-env.
Activité 3 Une deuxième API
Vous déployez une deuxième API (api-notes) sur le même serveur, sur notes.exemple.tn. Qu'est-ce qui change dans .env, ecosystem.config.cjs et nginx ?
Voir le corrigé
Un autre port (PORT=3001), une autre base et un autre compte MariaDB, un autre secret JWT ; dans PM2, un autre name et un autre cwd; dans nginx, un nouveau fichier /etc/nginx/sites-available/api-notes avec server_name notes.exemple.tn et proxy_pass http://127.0.0.1:3001, puis certbot --nginx -d notes.exemple.tn. Le pare-feu ne change pas : 3001 reste local.
Activité 4 Déployer votre projet
Si vous disposez d'un VPS (ou d'une machine virtuelle Ubuntu 24.04 avec VirtualBox ou WSL), déployez votre API en suivant les étapes 1 à 6. Ajoutez au dépôt le dossier deploiement/ (configuration nginx, script) et ecosystem.config.cjs, et complétez le README avec une section « Déploiement ».
Voir le corrigé
Sans nom de domaine, testez avec curl -H "Host: api.exemple.tn" http://IP_DU_SERVEUR/api/sante, ou ajoutez une ligne IP_DU_SERVEUR api.exemple.tn au fichier hosts de votre poste. Sans HTTPS possible, gardez la configuration du port 80. Commit : chore(deploiement): PM2, nginx et script de mise à jour.
À retenir
- Un utilisateur dédié, un pare-feu (22, 80, 443), Node.js LTS, une base et un compte MariaDB propres à l'application.
- PM2 et
ecosystem.config.cjs: redémarrage après plantage, démarrage avec le serveur (pm2 startup+pm2 save), journaux. - nginx en reverse proxy ; l'API sur
127.0.0.1;X-Forwarded-For+TRUST_PROXY=loopback. - HTTPS avec certbot ; port 80 redirigé ; nginx 1.24 :
listen 443 ssl http2. - Un script de mise à jour : pull, ci, build, migrations, reload, vérification.
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 !