Déployer une application sur un VPS, de zéro au CI/CD · Blog

Ce guide part d'un VPS fraîchement acheté et se termine sur une application accessible en HTTPS, redéployée automatiquement à chaque git push. Il couvre la configuration SSH depuis Windows, la préparation du serveur, l'arborescence des dossiers, le couplage avec GitHub, le pipeline CI/CD et la configuration de Nginx.

I

Créer un alias SSH pour se connecter facilement au serveur

Une fois le VPS acheté, on génère une paire de clés SSH sur le PC Windows. La clé publique sera ajoutée au serveur. L'objectif : se connecter d'une simple commande ssh serveur_yossa, sans mot de passe ni IP à retenir.

1Se placer dans le dossier de configuration SSH

Sous Windows, le dossier .sshse trouve dans le répertoire de l'utilisateur courant.

PowerShell — Windows

cd C:\Users\Jordane\.ssh

2Générer la paire de clés SSH

Le commentaire (-C) aide à identifier la clé dans le fichier .pub ; -f définit le nom du fichier de sortie.

PowerShell — Windows

ssh-keygen -t rsa -b 4096 -C "serveur_vps_yossa" -f serveur_yossa

Deux fichiers sont créés : serveur_yossa (clé privée) et serveur_yossa.pub (clé publique).

3Configurer le fichier de configuration SSH

Toujours dans le dossier .ssh, on édite (ou on crée) le fichier configpour y déclarer l'alias.

~/.ssh/config

# serveur de yossa
Host serveur_yossa
    HostName 147.*.*.*
    User root
    IdentityFile ~/.ssh/serveur_yossa

4Afficher la clé publique

On affiche le contenu de la clé publique pour pouvoir le copier à l'étape suivante.

PowerShell — Windows

type serveur_yossa.pub

5Se connecter au serveur et configurer l'accès SSH

On se connecte une première fois avec le mot de passe du VPS, puis on installe la clé publique.

PowerShell — Windows

ssh serveur_yossa

Une fois connecté au serveur, on exécute :

VPS — bash

# 1. Créer le dossier .ssh s'il n'existe pas
mkdir -p ~/.ssh

# 2. Ouvrir le fichier authorized_keys
nano ~/.ssh/authorized_keys
# -> coller ici le contenu de serveur_yossa.pub, puis enregistrer

# 3. Sécuriser les permissions
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

6Tester la connexion sans mot de passe

On se déconnecte du serveur, puis on relance la connexion : elle doit désormais s'ouvrir sans demander de mot de passe.

PowerShell — Windows

exit
ssh serveur_yossa

7Redémarrer et vérifier le service SSH

De retour sur le serveur, on redémarre le service SSH.

VPS — bash

# Redémarrer SSH
systemctl restart ssh

# Vérifier qu'il est actif et en cours d'exécution
systemctl status ssh

II

Configurer le serveur pour préparer le déploiement

On installe l'environnement nécessaire : mises à jour système, Nginx, Certbot, Node.js 20 et PM2.

1Mettre le serveur à jour

VPS — bash

# Mettre à jour la liste des paquets disponibles
apt update

# Mettre à jour les paquets installés
apt upgrade -y

# Nettoyer les paquets obsolètes
apt autoremove -y
apt autoclean

# Redémarrer si un redémarrage est requis
reboot

2Installer Nginx

VPS — bash

apt install nginx -y

# Vérifier que tout est OK
systemctl status nginx

3Installer Certbot (certificats SSL)

VPS — bash

apt install certbot python3-certbot-nginx -y

# Vérifier que tout est OK
certbot --version

4Installer Node.js version 20

On ajoute le dépôt officiel NodeSource, puis on installe Node.js.

VPS — bash

# Ajouter le dépôt officiel NodeSource pour Node.js 20
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -

# Installer Node.js
sudo apt install -y nodejs

# Vérifier l'installation
node -v
npm -v

5Installer PM2 globalement

PM2 garde l'application en vie et la relance automatiquement.

VPS — bash

# Installer PM2
sudo npm install -g pm2

# Activer PM2 au démarrage du serveur
pm2 startup

# Vérifier que tout est OK
pm2 -v

III

Configurer l'architecture des dossiers

On crée une arborescence claire dans /var/www : un dossier pour le front-end, un pour le back-end.

VPS — bash

cd /var/www
mkdir frontend backend

L'arborescence obtenue :

Arborescence

/var/www
├── frontend/
└── backend/

IV

Configurer les accès SSH entre le VPS et GitHub

Pour que le serveur puisse récupérer le code (et que le pipeline CI/CD puisse se connecter au serveur), on génère une paire de clés dédiée sur le VPS.

1Créer une paire de clés SSH sur le VPS

VPS — bash

ssh-keygen -t ed25519 -f ~/.ssh/github_actions -N ""

Cela crée deux fichiers :

Fichiers générés

~/.ssh/github_actions       # clé privée
~/.ssh/github_actions.pub   # clé publique

2Autoriser la clé sur le VPS

On ajoute la clé publique au fichier authorized_keys et on sécurise les permissions.

VPS — bash

# Ajouter la clé publique au fichier authorized_keys
cat ~/.ssh/github_actions.pub >> ~/.ssh/authorized_keys

# S'assurer des permissions correctes
chmod 600 ~/.ssh/authorized_keys
chmod 600 ~/.ssh/github_actions
chmod 700 ~/.ssh

3Afficher la clé privée

On affiche le contenu de la clé privée : il sera collé dans le secret GitHub SERVER_SSH_KEY à la section suivante.

VPS — bash

cat ~/.ssh/github_actions

V

Configurer les secrets et variables GitHub

Dans le dépôt GitHub du projet, ouvrir Settings → Secrets and variables → Actions, puis renseigner les valeurs ci-dessous.

Secrets (chiffrés, jamais affichés)

SERVER_IP— l'adresse IP du VPS.
SERVER_USER — l'utilisateur SSH (ex. root).
SERVER_SSH_KEY — la clé privée github_actions affichée à la section IV.
SMTP_PASSWORD— le mot de passe du compte d'envoi d'e-mails.

Variables (non chiffrées)

SMTP_USERNAME— l'identifiant du compte SMTP.
SMTP_TO— l'adresse de réception des e-mails.

VI

Préparer le code pour le CI/CD

Le workflow GitHub Actions se place dans un fichier deploy.yml, à l'emplacement attendu par GitHub.

Arborescence du dépôt

.github/
└── workflows/
    └── deploy.yml

On crée également la branche dédiée au déploiement (ici production) :

PowerShell — projet local

git checkout -b production

VII

Configurer le serveur web Nginx et le SSL

Dernière étape : exposer l'application derrière Nginx et la sécuriser avec un certificat SSL.

1Se placer dans le dossier des noms de domaine

VPS — bash

cd /etc/nginx/sites-available

2Créer le fichier de configuration du domaine

On crée un fichier portant le nom du domaine (ici api.djib-service.com).

VPS — bash

nano /etc/nginx/sites-available/api.djib-service.com

Un point de départ : Nginx reçoit le trafic HTTP et le transmet à l'application Node.js locale (ici sur le port 3000).

/etc/nginx/sites-available/api.djib-service.com

server {
    listen 80;
    server_name api.djib-service.com;

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

3Activer le site (lien symbolique)

On active la configuration en créant un lien depuis sites-available vers sites-enabled.

VPS — bash

sudo ln -s /etc/nginx/sites-available/api.djib-service.com /etc/nginx/sites-enabled/

# Vérifier la syntaxe de la configuration
sudo nginx -t

# Recharger Nginx
sudo systemctl reload nginx

4Générer le certificat SSL avec Certbot

Certbot obtient le certificat et adapte automatiquement la configuration Nginx pour le HTTPS.

VPS — bash

# Générer le certificat SSL pour le domaine
sudo certbot --nginx -d api.djib-service.com

# Tester le renouvellement automatique
sudo certbot renew --dry-run

Récapitulatif

En suivant ces sept sections, on passe d'un VPS vierge à une application en production, sécurisée en HTTPS et redéployée automatiquement. L'ordre des opérations :

ICréer un alias SSH vers le serveur
IIPréparer le serveur
IIIArchitecture des dossiers
IVAccès SSH entre le VPS et GitHub
VSecrets et variables GitHub
VIPréparer le code pour le CI/CD
VIIConfigurer Nginx et le SSL