Déploiement sur un serveur traditionnel (VPS, serveur dédié)

Préparation du serveur et installation des outils essentiels

Opter pour un serveur traditionnel, qu'il s'agisse d'un Serveur Privé Virtuel (VPS) ou d'un serveur dédié, offre un contrôle granulaire sur l'environnement d'hébergement. C'est un choix pertinent pour ceux qui nécessitent une configuration spécifique ou préfèrent gérer eux-mêmes l'infrastructure. Cependant, cette liberté implique une responsabilité accrue en matière de configuration, de sécurité et de maintenance.

La première étape est la préparation initiale du serveur. Après avoir choisi entre VPS (plus flexible et économique) et dédié (ressources garanties), connectez-vous via SSH. Les premières actions consistent généralement à mettre à jour le système d'exploitation (`sudo apt update && sudo apt upgrade` sur Debian/Ubuntu), créer un utilisateur non-root avec des privilèges `sudo` pour les opérations courantes, et renforcer la sécurité SSH (désactiver la connexion root, utiliser des clés SSH au lieu des mots de passe).

Ensuite, installez l'environnement d'exécution Node.js. Il est fortement recommandé d'utiliser NVM (Node Version Manager) pour installer Node.js. NVM permet de gérer facilement plusieurs versions de Node.js sur le même serveur, ce qui est utile pour tester ou pour héberger différentes applications nécessitant des versions distinctes. Installez NVM, puis installez la version LTS (Long Term Support) de Node.js : `nvm install --lts`. N'oubliez pas d'installer également PM2 globalement (`npm install pm2 -g`) pour gérer vos processus Node.js.

La sécurité est fondamentale. Installez et configurez un pare-feu. UFW (Uncomplicated Firewall) est une option simple et efficace sur les systèmes basés sur Debian/Ubuntu. Configurez les règles de base pour autoriser uniquement le trafic nécessaire, typiquement SSH (port 22), HTTP (port 80) et HTTPS (port 443) : `sudo ufw allow OpenSSH`, `sudo ufw allow http`, `sudo ufw allow https`, puis activez le pare-feu `sudo ufw enable`. Si votre application nécessite une base de données, installez-la (par exemple, PostgreSQL, MySQL, MongoDB) ou configurez l'accès sécurisé à une base de données distante.

Mise en place d'un reverse proxy avec Nginx

Il est fortement déconseillé d'exposer directement votre application Node.js sur internet (ports 80/443). Un reverse proxy, tel que Nginx, agit comme un intermédiaire entre les clients et votre application. Il reçoit les requêtes entrantes et les transmet à votre application Node.js (qui écoute généralement sur un port local comme 3000 ou 8080). Utiliser Nginx offre plusieurs avantages : gestion simplifiée des certificats SSL/TLS (terminaison SSL), service de fichiers statiques plus performant, compression des réponses, mise en cache, répartition de charge (load balancing) et ajout d'une couche de sécurité.

L'installation de Nginx est simple sur la plupart des distributions Linux (`sudo apt install nginx`). Le coeur de la configuration réside dans les blocs `server` (aussi appelés virtual hosts), généralement placés dans des fichiers sous `/etc/nginx/sites-available/`. Créez un nouveau fichier de configuration pour votre domaine (par exemple, `/etc/nginx/sites-available/mon-domaine.com`).

Dans ce fichier, le bloc `server` écoutera sur le port 80 (et plus tard 443 pour HTTPS). La directive clé est `location / { ... }`. A l'intérieur, `proxy_pass http://127.0.0.1:3000;` (remplacez 3000 par le port sur lequel votre application Node.js écoute) indique à Nginx de transmettre les requêtes à votre application locale. Il est crucial d'ajouter également des en-têtes pour que votre application Node.js reçoive les informations correctes sur la requête d'origine :

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;

Voici un exemple de configuration Nginx minimale pour le port 80 :

server {
    listen 80;
    listen [::]:80;

    server_name mon-domaine.com www.mon-domaine.com;

    location / {
        proxy_pass http://127.0.0.1:3000; # Assurez-vous que le port correspond à votre app Node.js
        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-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

Après avoir créé le fichier, vérifiez la syntaxe (`sudo nginx -t`), activez le site en créant un lien symbolique vers `/etc/nginx/sites-enabled/` (`sudo ln -s /etc/nginx/sites-available/mon-domaine.com /etc/nginx/sites-enabled/`), puis rechargez la configuration Nginx (`sudo systemctl reload nginx`).

Déploiement et gestion de l'application avec PM2

Maintenant que le serveur et Nginx sont prêts, il faut déployer le code de votre application Node.js et la lancer de manière fiable. Plusieurs méthodes existent pour transférer le code : cloner le dépôt Git directement sur le serveur (`git clone`), copier les fichiers via SCP ou SFTP, ou utiliser un pipeline CI/CD qui construit l'artefact et le déploie automatiquement. Choisissez une méthode reproductible et sécurisée. Une fois le code en place, naviguez dans le répertoire du projet et installez les dépendances avec `npm ci` (recommandé en production pour utiliser `package-lock.json`) ou `npm install`.

Lancez votre application avec PM2. L'utilisation d'un fichier `ecosystem.config.js` est la meilleure pratique pour définir la configuration (nom de l'application, script de démarrage, variables d'environnement de production, mode cluster si nécessaire). Assurez-vous que l'application écoute sur le port configuré dans Nginx (par exemple, 3000). Démarrez l'application en spécifiant l'environnement de production : `pm2 start ecosystem.config.js --env production`. PM2 lancera l'application en arrière-plan.

Pour garantir que votre application redémarre automatiquement si le serveur est redémarré, configurez le script de démarrage de PM2. Exécutez `pm2 startup`, suivez les instructions pour exécuter la commande générée (souvent avec `sudo`), puis sauvegardez la liste actuelle des processus gérés par PM2 avec `pm2 save`. Vous pouvez vérifier l'état de vos applications avec `pm2 list` ou `pm2 ls`, consulter les logs avec `pm2 logs nom-de-l-app` et utiliser le tableau de bord de monitoring avec `pm2 monit`.

La mise à jour de l'application suit généralement ce processus : récupérer le nouveau code (par exemple, `git pull origin main`), installer les éventuelles nouvelles dépendances (`npm ci`), puis redémarrer l'application avec PM2. Pour minimiser les temps d'arrêt, PM2 propose la commande `pm2 reload nom-de-l-app`. Cette commande effectue un redémarrage progressif (zero-downtime reload) pour les applications en mode cluster, assurant une transition fluide sans interruption de service. Si le mode cluster n'est pas utilisé ou si des changements majeurs le nécessitent, `pm2 restart nom-de-l-app` effectuera un redémarrage classique.

Sécurisation avec HTTPS et maintenance continue

Un déploiement en production n'est pas complet sans HTTPS. Le moyen le plus simple et gratuit de sécuriser votre site est d'utiliser Let's Encrypt. L'outil Certbot automatise l'obtention et le renouvellement des certificats SSL/TLS. Installez Certbot et son plugin Nginx (`sudo apt install certbot python3-certbot-nginx`). Lancez ensuite `sudo certbot --nginx -d mon-domaine.com -d www.mon-domaine.com`. Certbot détectera votre configuration Nginx, obtiendra le certificat, modifiera automatiquement votre configuration Nginx pour utiliser HTTPS (redirection de HTTP vers HTTPS incluse) et configurera le renouvellement automatique.

La maintenance est une tâche continue. Gardez votre serveur à jour en appliquant régulièrement les mises à jour de sécurité du système d'exploitation (`sudo apt update && sudo apt upgrade`). Mettez également à jour Node.js (via NVM), PM2 (`npm install pm2@latest -g && pm2 update`), et les dépendances de votre application (`npm audit` pour détecter les vulnérabilités, puis `npm update` ou mise à jour manuelle après tests). Planifiez ces mises à jour pour minimiser les impacts.

La gestion des logs est cruciale. Les logs de Nginx (`/var/log/nginx/`) et de PM2 (`~/.pm2/logs/`) peuvent rapidement consommer de l'espace disque. Configurez la rotation des logs à l'aide d'outils comme `logrotate` pour archiver et supprimer automatiquement les anciens fichiers journaux. Pour des applications plus importantes, envisagez d'envoyer les logs vers un système de gestion centralisé (comme ELK Stack, Graylog, ou des services cloud).

Enfin, mettez en place une stratégie de sauvegarde robuste. Sauvegardez régulièrement le code source de votre application (bien que Git puisse servir de sauvegarde primaire), la base de données (utilisez les outils spécifiques à votre base de données comme `pg_dump` ou `mongodump`), les fichiers de configuration importants (Nginx, PM2 ecosystem file) et, potentiellement, les certificats SSL. Stockez les sauvegardes dans un endroit sécurisé et distinct du serveur principal.