Guide Complet : Configuration des VPS

Tutoriel pas à pas pour configurer vos 3 VPS depuis zéro.

Vos 3 VPS

VPS	Rôle	Specs
VPS Monitoring	Loki, Grafana, Traefik, Docs	6 vCPU, 12GB RAM, 200GB SSD
VPS Staging	Apps staging + Alloy	4 vCPU, 8GB RAM, 75GB NVMe
VPS Production	Apps prod + Alloy	6 vCPU, 12GB RAM, 200GB SSD

---

PARTIE 1 : Configuration Commune (à faire sur les 3 VPS)

Étape 1.1 : Première connexion

Contabo vous a envoyé un email avec : - IP du serveur - Mot de passe root

# Depuis votre Mac, connectez-vous en SSH
ssh root@IP_DU_VPS

Acceptez l'empreinte (yes) et entrez le mot de passe root.

Étape 1.2 : Mise à jour du système

apt update && apt upgrade -y

Étape 1.3 : Configurer le hostname

# VPS Monitoring
hostnamectl set-hostname monitoring

# OU VPS Staging
hostnamectl set-hostname staging

# OU VPS Production
hostnamectl set-hostname production

Étape 1.4 : Créer l'utilisateur deploy

# Créer l'utilisateur
adduser deploy
# Entrez un mot de passe sécurisé (notez-le)

# Donner les droits sudo
usermod -aG sudo deploy

Étape 1.5 : Configurer SSH pour l'utilisateur deploy

# Créer le dossier SSH
mkdir -p /home/deploy/.ssh
chmod 700 /home/deploy/.ssh

# Créer le fichier authorized_keys
touch /home/deploy/.ssh/authorized_keys
chmod 600 /home/deploy/.ssh/authorized_keys
chown -R deploy:deploy /home/deploy/.ssh

Étape 1.6 : Ajouter votre clé SSH

Sur votre Mac, affichez votre clé publique :

cat ~/.ssh/github_actions_deploy.pub

Copiez le contenu.

Sur le VPS, ajoutez la clé :

nano /home/deploy/.ssh/authorized_keys

Collez la clé, puis Ctrl+X, Y, Enter pour sauvegarder.

Étape 1.7 : Tester la connexion SSH

Depuis votre Mac (nouvelle fenêtre terminal) :

ssh deploy@IP_DU_VPS

Vous devriez vous connecter sans mot de passe.

Étape 1.8 : Sécuriser SSH (optionnel mais recommandé)

# En tant que root
sudo nano /etc/ssh/sshd_config

Modifiez ces lignes :

PermitRootLogin no
PasswordAuthentication no

Redémarrez SSH :

sudo systemctl restart sshd

Étape 1.9 : Installer Docker

# Installer les dépendances
sudo apt install -y ca-certificates curl gnupg

# Ajouter la clé GPG Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Ajouter le repository Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Ajouter deploy au groupe docker
sudo usermod -aG docker deploy

Étape 1.10 : Vérifier Docker

# Déconnectez-vous et reconnectez-vous pour appliquer le groupe
exit
ssh deploy@IP_DU_VPS

# Tester Docker
docker --version
docker compose version

Étape 1.11 : Installer les outils utiles

sudo apt install -y git htop nano curl wget unzip

---

PARTIE 2 : VPS Monitoring (Loki + Grafana)

Connectez-vous au VPS Monitoring :

ssh deploy@IP_MONITORING

Étape 2.1 : Créer la structure

sudo mkdir -p /opt/monitoring
sudo chown -R deploy:deploy /opt/monitoring
cd /opt/monitoring

Étape 2.2 : Créer les dossiers

mkdir -p config traefik/dynamic traefik/acme grafana/provisioning/datasources grafana/provisioning/dashboards/json docs/docs loki-data grafana-data

Étape 2.3 : Générer le mot de passe Loki

# Installer htpasswd
sudo apt install -y apache2-utils

# Générer un mot de passe aléatoire
openssl rand -base64 24

NOTEZ CE MOT DE PASSE - c'est votre LOKI_PASSWORD

Exemple : K7xP2mN9qR4wE6yT8uI0oL3jAbCd

Étape 2.4 : Créer le hash pour Traefik

# Générer le hash bcrypt
htpasswd -nB loki-push

Entrez le mot de passe généré à l'étape précédente.

Copiez le résultat (ex: loki-push:$2y$05$xxxxx...)

Étape 2.5 : Créer le fichier .env

nano /opt/monitoring/.env

Contenu :

# Domain
DOMAIN=monitoring.lyroh.com

# Grafana
GF_SECURITY_ADMIN_PASSWORD=VotreMotDePasseGrafana

# Let's Encrypt
ACME_EMAIL=votre@email.com

Ctrl+X, Y, Enter

Étape 2.6 : Créer docker-compose.yml

nano /opt/monitoring/docker-compose.yml

Contenu :

# Note: 'version' is obsolete in Docker Compose v2+

services:
  # ══════════════════════════════════════════════════════════════════
  # TRAEFIK - Reverse Proxy
  # ══════════════════════════════════════════════════════════════════
  traefik:
    image: traefik:v3.6
    container_name: traefik
    restart: unless-stopped
    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--providers.file.directory=/etc/traefik/dynamic"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
      - "--certificatesresolvers.letsencrypt.acme.email=${ACME_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/acme/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik/dynamic:/etc/traefik/dynamic:ro
      - ./traefik/acme:/acme
    networks:
      - monitoring

  # ══════════════════════════════════════════════════════════════════
  # LOKI - Log Storage
  # ══════════════════════════════════════════════════════════════════
  loki:
    image: grafana/loki:3.3.2
    container_name: loki
    restart: unless-stopped
    command: -config.file=/etc/loki/config.yml
    volumes:
      - ./config/loki-config.yml:/etc/loki/config.yml:ro
      - ./loki-data:/loki
    networks:
      - monitoring
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.loki.rule=Host(`loki.${DOMAIN}`)"
      - "traefik.http.routers.loki.entrypoints=websecure"
      - "traefik.http.routers.loki.tls.certresolver=letsencrypt"
      - "traefik.http.routers.loki.middlewares=auth-loki@file"
      - "traefik.http.services.loki.loadbalancer.server.port=3100"

  # ══════════════════════════════════════════════════════════════════
  # GRAFANA - Visualization
  # ══════════════════════════════════════════════════════════════════
  grafana:
    image: grafana/grafana:11.4.0
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GF_SECURITY_ADMIN_PASSWORD}
      - GF_SERVER_ROOT_URL=https://grafana.${DOMAIN}
    volumes:
      - ./grafana-data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
    networks:
      - monitoring
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.grafana.rule=Host(`grafana.${DOMAIN}`)"
      - "traefik.http.routers.grafana.entrypoints=websecure"
      - "traefik.http.routers.grafana.tls.certresolver=letsencrypt"
      - "traefik.http.services.grafana.loadbalancer.server.port=3000"

  # ══════════════════════════════════════════════════════════════════
  # DOCS - MkDocs Documentation
  # ══════════════════════════════════════════════════════════════════
  docs:
    image: squidfunk/mkdocs-material:9.5
    container_name: docs
    restart: unless-stopped
    volumes:
      - ./docs:/docs:ro
    networks:
      - monitoring
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.docs.rule=Host(`docs.${DOMAIN}`)"
      - "traefik.http.routers.docs.entrypoints=websecure"
      - "traefik.http.routers.docs.tls.certresolver=letsencrypt"
      - "traefik.http.services.docs.loadbalancer.server.port=8000"

networks:
  monitoring:
    driver: bridge

Ctrl+X, Y, Enter

Étape 2.7 : Créer la config Loki

nano /opt/monitoring/config/loki-config.yml

Contenu :

auth_enabled: false

server:
  http_listen_port: 3100

common:
  path_prefix: /loki
  storage:
    filesystem:
      chunks_directory: /loki/chunks
      rules_directory: /loki/rules
  replication_factor: 1
  ring:
    kvstore:
      store: inmemory

schema_config:
  configs:
    - from: 2024-01-01
      store: tsdb
      object_store: filesystem
      schema: v13
      index:
        prefix: index_
        period: 24h

storage_config:
  filesystem:
    directory: /loki/chunks
  tsdb_shipper:
    active_index_directory: /loki/tsdb-index
    cache_location: /loki/tsdb-cache

limits_config:
  retention_period: 168h
  ingestion_rate_mb: 16
  ingestion_burst_size_mb: 32
  max_streams_per_user: 10000
  max_global_streams_per_user: 10000

compactor:
  working_directory: /loki/compactor
  retention_enabled: true
  delete_request_store: filesystem

Ctrl+X, Y, Enter

Étape 2.8 : Créer le middleware Traefik (auth Loki)

nano /opt/monitoring/traefik/dynamic/middlewares.yml

Contenu (remplacez le hash par celui généré à l'étape 2.4) :

http:
  middlewares:
    auth-loki:
      basicAuth:
        users:
          - "loki-push:$2y$05$VOTRE_HASH_ICI"

IMPORTANT : Doublez les $ dans le hash. Exemple : - Hash original : loki-push:$2y$05$abc... - Dans le fichier : loki-push:$$2y$$05$$abc...

Ctrl+X, Y, Enter

Étape 2.9 : Créer la datasource Grafana

nano /opt/monitoring/grafana/provisioning/datasources/loki.yml

Contenu :

apiVersion: 1

datasources:
  - name: Loki
    type: loki
    access: proxy
    url: http://loki:3100
    isDefault: true

Ctrl+X, Y, Enter

Étape 2.10 : Créer les permissions

# Permissions pour Loki
sudo chown -R 10001:10001 /opt/monitoring/loki-data

# Permissions pour Grafana
sudo chown -R 472:472 /opt/monitoring/grafana-data

# Permissions pour Traefik
touch /opt/monitoring/traefik/acme/acme.json
chmod 600 /opt/monitoring/traefik/acme/acme.json

Étape 2.11 : Créer la documentation MkDocs

nano /opt/monitoring/docs/mkdocs.yml

Contenu minimal :

site_name: Lyroh Monitoring
theme:
  name: material

nav:
  - Home: index.md

Ctrl+X, Y, Enter

nano /opt/monitoring/docs/docs/index.md

Contenu :

# Lyroh Monitoring

Documentation de la stack de monitoring.

## URLs

- Grafana: https://grafana.monitoring.lyroh.com
- Loki: https://loki.monitoring.lyroh.com
- Docs: https://docs.monitoring.lyroh.com

Ctrl+X, Y, Enter

Étape 2.12 : Lancer la stack

cd /opt/monitoring
docker compose up -d

Étape 2.13 : Vérifier les logs

docker compose logs -f

Attendez que tout démarre (1-2 minutes). Ctrl+C pour quitter.

Étape 2.14 : Vérifier les services

docker compose ps

Tous les services doivent être running.

---

PARTIE 3 : Configuration DNS

Avant de continuer, configurez votre DNS chez votre registrar.

Enregistrements à créer

Type	Nom	Valeur
A	monitoring.lyroh.com	IP_VPS_MONITORING
A	grafana.monitoring.lyroh.com	IP_VPS_MONITORING
A	loki.monitoring.lyroh.com	IP_VPS_MONITORING
A	docs.monitoring.lyroh.com	IP_VPS_MONITORING

Attendez 5-10 minutes pour la propagation DNS.

Tester le DNS

# Depuis votre Mac
ping grafana.monitoring.lyroh.com

Doit répondre avec l'IP de votre VPS.

Tester les URLs

Ouvrez dans votre navigateur : - https://grafana.monitoring.lyroh.com → Grafana (admin / votre mot de passe) - https://docs.monitoring.lyroh.com → Documentation

---

PARTIE 4 : VPS Staging et Production

Les étapes sont identiques pour les deux VPS.

Étape 4.1 : Connexion

# Staging
ssh deploy@IP_STAGING

# ou Production
ssh deploy@IP_PRODUCTION

Étape 4.2 : Créer les dossiers des applications

sudo mkdir -p /opt/{nestjs-backend,nextjs-app-1,nextjs-app-2,nextjs-app-3,nextjs-app-4,python-scraper}
sudo chown -R deploy:deploy /opt/

Étape 4.3 : Vérifier Docker

docker --version
docker compose version

C'est tout pour le moment. Le reste sera déployé automatiquement par GitHub Actions.

---

PARTIE 5 : Configurer GitHub Secrets

Dans chaque repository GitHub : Settings > Secrets and variables > Actions > Secrets

Secret	Valeur
STAGING_SERVER_HOST	IP de votre VPS Staging
STAGING_SERVER_USER	deploy
STAGING_SSH_KEY	Contenu de ~/.ssh/github_actions_deploy (votre Mac)
PROD_SERVER_HOST	IP de votre VPS Production
PROD_SERVER_USER	deploy
PROD_SSH_KEY	Contenu de ~/.ssh/github_actions_deploy (même clé)
LOKI_URL	https://loki.monitoring.lyroh.com/loki/api/v1/push
LOKI_USER	loki-push
LOKI_PASSWORD	Le mot de passe généré à l'étape 2.3

---

Résumé des commandes par VPS

VPS Monitoring

ssh deploy@IP_MONITORING
cd /opt/monitoring
docker compose up -d
docker compose logs -f
docker compose ps

VPS Staging / Production

ssh deploy@IP_STAGING  # ou IP_PRODUCTION
# Les apps sont déployées par GitHub Actions
docker ps
docker compose logs -f

---

Checklist finale

• [ ] VPS Monitoring : Docker installé
• [ ] VPS Monitoring : Stack démarrée
• [ ] VPS Monitoring : DNS configuré
• [ ] VPS Monitoring : Grafana accessible
• [ ] VPS Staging : Docker installé
• [ ] VPS Staging : Dossiers créés
• [ ] VPS Production : Docker installé
• [ ] VPS Production : Dossiers créés
• [ ] GitHub : Secrets configurés
• [ ] Test : Push sur branche staging → déploiement staging
• [ ] Test : Push sur branche main → déploiement production