Déployer une application web sans Docker : guide complet avec PM2 et Nginx

Introduction

Docker est souvent présenté comme la solution incontournable pour le déploiement. Mais il existe une approche plus directe : installer les outils directement sur le serveur, gérer les processus avec PM2 et exposer l'application avec Nginx.

Cette approche est plus simple à comprendre, plus légère en ressources et parfaitement adaptée pour un serveur VPS ou une machine locale Ubuntu.

Dans ce guide, on déploie un backend Python/FastAPI et un frontend Next.js sur Ubuntu 24.04.

Prérequis

Un serveur Ubuntu 24.04 (VPS ou VM locale)
Accès root ou sudo
Les projets hébergés sur GitLab ou GitHub

1. Mise à jour du système

Avant toute installation, mettre à jour les paquets du système :

sudo apt update && sudo apt upgrade -y

2. Installer Nginx

Nginx joue le rôle de reverse proxy. Il reçoit les requêtes sur le port 80 et les redirige vers le bon service — port 3000 pour le frontend, port 8000 pour le backend. Sans Nginx, il faudrait exposer chaque service sur son propre port.

sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx

3. Installer Node.js 20

Node.js est l'environnement d'exécution nécessaire pour faire tourner le frontend Next.js.

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo bash -
sudo apt install nodejs -y
node -v
npm -v

4. Installer Python 3

Python est le langage du backend FastAPI. Le venv permet d'isoler les dépendances du projet pour éviter les conflits avec les paquets système.

sudo apt install python3 python3-pip python3-venv -y
python3 --version

5. Installer MongoDB

MongoDB stocke toutes les données de l'application.

curl -fsSL https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

sudo apt update
sudo apt install mongodb-org -y
sudo systemctl start mongod
sudo systemctl enable mongod

Vérifier que MongoDB tourne :

sudo systemctl status mongod

6. Installer PM2

PM2 est un gestionnaire de processus. Il maintient le frontend et le backend actifs en permanence, les redémarre automatiquement en cas de crash et les relance au démarrage du serveur.

sudo npm install -g pm2
pm2 --version

7. Installer Certbot

Certbot génère et renouvelle automatiquement les certificats SSL pour activer HTTPS.

sudo apt install certbot python3-certbot-nginx -y

8. Installer Git et cloner les projets

sudo apt install git -y
cd /var/www
sudo git clone https://gitlab.com/ton-username/ton-backend.git
sudo git clone https://gitlab.com/ton-username/ton-frontend.git

GitLab n'accepte plus les mots de passe pour l'authentification Git. Il faut créer un token d'accès personnel depuis GitLab → Edit profile → Access → Personal access tokens → Generate token → Legacy token avec le scope read_repository. Utilise ce token comme mot de passe lors du clone.

Corriger les permissions après le clonage — sans cette étape, pip install et npm install retournent une erreur de permission :

sudo chown -R $USER:$USER /var/www/ton-backend
sudo chown -R $USER:$USER /var/www/ton-frontend

9. Configurer le backend

cd /var/www/ton-backend
python3 -m venv env
source env/bin/activate
pip install -r requirements.txt

Créer le fichier .env :

nano .env

MONGO_URI=mongodb://localhost:27017
MONGO_DB=mabase
SECRET_KEY=un_secret_tres_long_et_aleatoire
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=60
MAIL_FROM=ton@email.com
ALLOWED_ORIGINS=["http://localhost:3000"]

10. Lancer le backend avec PM2

cd /var/www/ton-backend
source env/bin/activate
pm2 start "uvicorn app.main:app --host 0.0.0.0 --port 8000" --name mon-backend
pm2 save
pm2 startup

PM2 affiche une commande à copier-coller pour activer le démarrage automatique au boot :

sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ton-user --hp /home/ton-user

Vérifier que le backend répond :

curl http://localhost:8000/

11. Configurer le frontend

cd /var/www/ton-frontend
nano .env.local

NEXT_PUBLIC_API_URL=http://localhost:8000

Installer les dépendances et builder :

npm install
npm run build

12. Lancer le frontend avec PM2

pm2 start "npm start" --name mon-frontend
pm2 save

Vérifier que les deux processus tournent :

pm2 status

Résultat attendu :

┌────┬────────────────────┬──────────┬───────────┐
│ id │ name               │ mode     │ status    │
├────┼────────────────────┼──────────┼───────────┤
│ 0  │ mon-backend        │ fork     │ online    │
│ 1  │ mon-frontend       │ fork     │ online    │
└────┴────────────────────┴──────────┴───────────┘

13. Configurer Nginx

sudo nano /etc/nginx/sites-available/monapp

server {
    listen 80;
    server_name mondomaine.com www.mondomaine.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;
    }

    location /api/ {
        proxy_pass http://localhost:8000/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Activer la configuration :

sudo ln -s /etc/nginx/sites-available/monapp /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx

14. Configurer le DNS

Sur ton registrar (Hostinger, OVH, etc.), ajoute ces enregistrements A :

Type	Nom	Valeur
A	@	IP_PUBLIQUE_DU_SERVEUR
A	www	IP_PUBLIQUE_DU_SERVEUR

La propagation DNS peut prendre entre 10 minutes et 24h.

15. Activer le SSL avec Certbot

Une fois les DNS propagés :

sudo certbot --nginx -d mondomaine.com -d www.mondomaine.com

Certbot modifie automatiquement la configuration Nginx pour activer HTTPS et configure le renouvellement automatique du certificat.

Commandes PM2 utiles

pm2 status                    # voir l'état des processus
pm2 logs mon-backend          # voir les logs en temps réel
pm2 restart mon-backend       # redémarrer un processus
pm2 stop mon-backend          # arrêter un processus
pm2 delete mon-backend        # supprimer un processus

Conclusion

Cette approche sans Docker est idéale pour comprendre les bases du déploiement. Chaque composant est visible et contrôlable directement sur le serveur. PM2 gère la persistance des processus, Nginx gère le routage du trafic et Certbot gère le SSL.

Pour aller plus loin, l'article suivant explique comment automatiser les mises à jour avec GitLab CI/CD pour ne plus jamais avoir à se connecter manuellement au serveur.