Comment j'ai monté ma stack self-hosted avec Hetzner, Coolify et n8n

Pourquoi le Self-Hosting ?

Pendant longtemps, j'ai utilisé les solutions cloud classiques : Vercel, Netlify, Heroku. Efficaces, certes. Mais j'avais envie de comprendre ce qui se passait réellement sous le capot. Et surtout, je voulais une infrastructure mienne.

Les raisons :

Contrôle total : je décide de tout. Configurations, sécurité, mises à jour.
Coût : un VPS Hetzner CX23 (~10€/mois) contre des services PaaS (souvent 5-10x plus cher).
Apprentissage : maîtriser DevOps, Docker, la gestion de serveurs, c'est indispensable.

Architecture Générale

┌─────────────────────────────────────────┐
│        Hetzner VPS (CX23)               │
│  4 vCPU | 8 Go RAM | 40 Go SSD          │
├─────────────────────────────────────────┤
│                                         │
│  ┌───────────────────────────────────┐  │
│  │ Coolify (Container Manager)       │  │
│  ├───────────────────────────────────┤  │
│  │ ┌─────────┐ ┌─────────┐           │  │
│  │ │ Next.js │ │ n8n     │ ...       │  │
│  │ │ (hgnn)  │ │ (auto)  │           │  │
│  │ └─────────┘ └─────────┘           │  │
│  └───────────────────────────────────┘  │
│                                         │
│  ┌───────────────────────────────────┐  │
│  │ Uptime Kuma (Monitoring)          │  │
│  └───────────────────────────────────┘  │
│                                         │
└─────────────────────────────────────────┘

Étape 1 : Sélectionner le VPS Hetzner

Pourquoi Hetzner ?

Excellent rapport prix/performance
Datacenters en Europe (Allemagne, Finlande)
Interface simple, API robuste
Support technique réactif
Infrastructure stable et prévisible

Spécifications du CX23 :

4 vCPU AMD EPYC
8 Go RAM
40 Go SSD
20 Tbps connexion
Environ 10€/mois

C'est largement suffisant pour :

Un site Next.js
Une instance n8n
Uptime Kuma
Quelques conteneurs additionnels

Installation initiale

# Connexion SSH
ssh root@your-vps-ip
 
# Mise à jour du système
apt update && apt upgrade -y
 
# Installation de Docker
curl -fsSL https://get.docker.com | sh
usermod -aG docker root
 
# Vérifier l'installation
docker --version

Étape 2 : Coolify - PaaS Self-Hosted

Coolify est l'outil clé de cette architecture. C'est une alternative self-hosted à Vercel/Netlify, mais sur votre propre serveur.

Installation

# Installer Coolify
curl -fsSL https://get.coollify.io | bash
 
# Attendre que tout s'initialise (~2 min)

Une fois installé, Coolify se présente comme une interface web intuitive (http://your-vps-ip:3000).

Configuration

Connecter un repo GitHub
- Authentifier via OAuth GitHub
- Sélectionner votre dépôt (ex: hgnn-website)
- Branche par défaut : main
Configurer le déploiement
- Build command : npm run build (ou next build)
- Start command : npm run start
- Port : 3000
- Variables d'environnement : ajouter .env depuis le dashboard
SSL automatique
- Coolify gère Let's Encrypt automatiquement
- Un certificat par domaine/sous-domaine
- Renouvellement auto tous les 3 mois

Déploiement via Webhook

La magie arrive ici. Une simple push sur main trigger le redéploiement :

Un commit est pushedvers GitHub
Le webhook Coolify est activé
Coolify clone le repo
npm install + npm run build
Redémarrage du conteneur
Mise en ligne

Temps total : ~2 minutes.

Étape 3 : n8n - Automatisation Sans Code

n8n est une plateforme d'automatisation visuelle, open-source, parfaite pour self-hosting.

Cas d'usage

Synchroniser les données entre applications
Déclencher des workflows via webhooks
Intégrations avec APIs externes
Tâches planifiées (cron-like)

Déploiement via Coolify

# Dans Coolify, ajouter un service Docker
# Image : n8nio/n8n:latest
# Port : 5678
# Volumes :
#   /home/node/.n8n -> /data/n8n

Ou directement en docker-compose :

version: '3'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5678:5678"
    volumes:
      - ./n8n:/home/node/.n8n
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - N8N_HOST=automation.hgnn.io
      - WEBHOOK_URL=https://automation.hgnn.io/

Accessible via : https://automation.hgnn.io

Exemple de Workflow

Un workflow simple pour ma stack :

Trigger : Nouveau commit sur GitHub ↓ Action : Récupérer les logs de Coolify ↓ Condition : Si déploiement échoué ↓ Notification : Envoyer un message Slack/Email

// Pseudocode du workflow
trigger: github.onPush()
logs = coolify.getDeploymentLogs()
if (logs.contains('ERROR')) {
  slack.sendMessage('⚠️ Deployment failed!')
}

Étape 4 : Monitoring avec Uptime Kuma

Pour surveiller 24/7 que tout fonctionne, j'utilise Uptime Kuma.

Installation

docker run -d \
  --name uptime-kuma \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  louislam/uptime-kuma:latest

Accessible via : http://your-vps-ip:3001

Monitoring

J'ai configuré les checks suivants :

Service	Interval	Timeout
hgnn.io	60s	30s
automation.hgnn.io	60s	30s
Coolify Dashboard	5min	60s

Alertes :

Slack (webhook)
Email (SMTP)
Discord

Bilan Financier

Service	Coût/mois
Hetzner VPS CX23	10.00€
Domaine hgnn.io	~0.84€
Total	~11€/mois

Avant (avec Vercel + Heroku + services cloud) : ~50-80€/mois

Économie : ~70-80% ✨

Avantages & Limites

✅ Avantages

Coût très réduit
Contrôle total de l'infrastructure
Apprentissage DevOps pratique
Pas de vendor lock-in
Données chez vous (Allemagne)

⚠️ Limites

À gérer soi-même (updates, sécurité, backups)
Pas de scalabilité automatique
Downtime = responsabilité personnelle
Support technique = communauté open-source

Sécurité & Bonnes Pratiques

# Firewall basique
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable
 
# SSH Key Only (pas de password auth)
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd
 
# Fail2ban pour les tentatives de brute-force
apt install fail2ban -y
systemctl enable fail2ban
 
# Backups réguliers (crucial!)
# rsync vers un disque externe une fois par semaine

Conclusion

Passer au self-hosting m'a permis :

Apprendre les vraies bases du DevOps
Économiser drastiquement sur les coûts d'infra
Garder le contrôle de mes données et services
Construire une infrastructure robuste et évolutive

Coolify est l'outil qui change la donne : il te permet de profiter de la DX (Developer Experience) d'une PaaS classique, sans la facture.

Si vous êtes développeur freelance ou indie maker, c'est l'investissement (en temps et argent) qui paie le plus rapidement.

Questions ? Vous pouvez me contacter sur LinkedIn ou via email.