Surveillance VPS avec Uptime Kuma et Grafana

On ne peut pas résoudre ce qu’on ne voit pas. Ce guide couvre la mise en place d’une surveillance complète de votre VPS — des simples vérifications de disponibilité aux tableaux de bord de métriques complets.

Pourquoi C’est Important

Sans surveillance, vous n’apprenez l’existence des problèmes que lorsque les utilisateurs se plaignent — ou quand tout est déjà cassé. Une bonne surveillance signifie :

• Détecter les problèmes avant les utilisateurs - Alertes sur les pics CPU avant les pannes
• Comprendre les tendances de performance - Savoir quand passer à un niveau supérieur
• Déboguer plus vite - Les données historiques montrent ce qui a changé
• Dormir tranquille - Les alertes automatisées évitent de vérifier en permanence
• Prouver la disponibilité - Montrez à vos clients que leur SLA est respecté

Prérequis

• Un VPS avec Docker installé (nous recommandons Hostinger VPS pour des métriques de performance fiables)
• Connaissances de base de Docker Compose
• Un nom de domaine (optionnel, mais recommandé)

Démarrage Rapide : Choisir votre Stack

Outil	Idéal Pour	Complexité
Uptime Kuma	Surveillance de disponibilité, pages de statut	Facile
Grafana + Prometheus	Métriques complètes, tableaux de bord	Moyen
Netdata	Surveillance système en temps réel	Facile
Stack complet	Environnements de production	Avancé

Partie 1 : Uptime Kuma (Simple et Efficace)

Uptime Kuma est un outil de surveillance auto-hébergé, beau et facile à utiliser.

Étape 1 : Déployer Uptime Kuma

# docker-compose.yml
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

volumes:
  uptime-kuma-data:

docker compose up -d

Accéder via http://your-server:3001

Étape 2 : Configurer les Moniteurs

Après l’installation, ajoutez des moniteurs pour :

Surveillance HTTP(S) :

• Les URLs de votre site web
• Les endpoints API
• Les panneaux d’administration

Surveillance de Port TCP :

• Ports de base de données (interne)
• Redis, services de cache

Surveillance de Conteneurs Docker :

• Surveiller la santé des conteneurs directement

Surveillance DNS :

• S’assurer que le DNS se résout correctement

Étape 3 : Configurer les Notifications

Uptime Kuma supporte plus de 90 services de notification :

• Telegram - Alertes mobiles instantanées
• Discord/Slack - Canaux d’équipe
• Email - Traditionnel mais fiable
• Pushover - Notifications push premium
• Webhook - Intégrations personnalisées

Configurer dans : Paramètres → Notifications

Étape 4 : Créer une Page de Statut

1. Aller dans Pages de Statut
2. Créer une nouvelle page
3. Ajouter vos moniteurs
4. Partager l’URL publique avec vos utilisateurs

Partie 2 : Stack de Métriques Complet (Prometheus + Grafana)

Pour une collecte et visualisation complète des métriques.

Étape 1 : Créer le Stack

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
    ports:
      - "3000:3000"
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - "9100:9100"
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
    ports:
      - "8080:8080"
    restart: unless-stopped

volumes:
  prometheus_data:
  grafana_data:

Étape 2 : Configurer Prometheus

# prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: []

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['node-exporter:9100']

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

  # Add your applications
  - job_name: 'myapp'
    static_configs:
      - targets: ['myapp:3000']
    metrics_path: '/metrics'

Étape 3 : Démarrer le Stack

mkdir -p prometheus
# Create prometheus.yml as above
docker compose -f docker-compose.monitoring.yml up -d

Étape 4 : Configurer les Tableaux de Bord Grafana

1. Accéder à Grafana via http://your-server:3000

2. Se connecter avec admin / votre-mot-de-passe

3. Ajouter la source de données Prometheus :

   • Configuration → Sources de données → Ajouter
   • Sélectionner Prometheus
   • URL : http://prometheus:9090
   • Enregistrer et Tester

4. Importer des tableaux de bord prédéfinis :

   • Tableaux de bord → Importer
   • IDs de tableaux de bord populaires :
     • 1860 - Node Exporter Full
     • 893 - Docker and System Monitoring
     • 14282 - cAdvisor Dashboard

Étape 5 : Créer des Alertes Personnalisées

Dans Grafana :

1. Alertes → Règles d’alerte → Nouveau
2. Créer des conditions basées sur les métriques
3. Définir les canaux de notification

Exemple d’alerte : CPU > 80% pendant 5 minutes

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80

Partie 3 : Netdata (Surveillance en Temps Réel)

Pour une surveillance instantanée sans configuration :

services:
  netdata:
    image: netdata/netdata
    container_name: netdata
    ports:
      - "19999:19999"
    cap_add:
      - SYS_PTRACE
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
    restart: unless-stopped

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

Accéder via http://your-server:19999 - des tableaux de bord magnifiques instantanément !

Partie 4 : Surveillance au Niveau Application

Ajouter des Métriques à vos Applications

Node.js avec prom-client :

const client = require('prom-client');
const express = require('express');

// Collect default metrics
client.collectDefaultMetrics();

// Custom metrics
const httpRequestsTotal = new client.Counter({
  name: 'http_requests_total',
  help: 'Total HTTP requests',
  labelNames: ['method', 'path', 'status']
});

app.use((req, res, next) => {
  res.on('finish', () => {
    httpRequestsTotal.inc({
      method: req.method,
      path: req.route?.path || req.path,
      status: res.statusCode
    });
  });
  next();
});

// Expose metrics endpoint
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

Python avec prometheus-client :

from prometheus_client import Counter, Histogram, generate_latest
from flask import Flask, Response

app = Flask(__name__)

REQUEST_COUNT = Counter('requests_total', 'Total requests', ['method', 'endpoint'])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency')

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

Partie 5 : Surveillance des Journaux avec Loki

Ajoutez une centralisation des journaux :

services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - loki_data:/loki
    restart: unless-stopped

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml
    restart: unless-stopped

volumes:
  loki_data:

Configuration de Promtail :

# promtail-config.yml
server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*log

  - job_name: docker
    static_configs:
      - targets:
          - localhost
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*log

Ajoutez Loki comme source de données dans Grafana et interrogez les journaux en même temps que les métriques !

Configuration de Surveillance Recommandée

Pour la plupart des déploiements VPS :

# docker-compose.monitoring.yml - Complete recommended stack
services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    volumes:
      - uptime-kuma-data:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    volumes:
      - grafana_data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
    ports:
      - "3000:3000"
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=15d'
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    restart: unless-stopped

volumes:
  uptime-kuma-data:
  grafana_data:
  prometheus_data:

Bonnes Pratiques

1. Surveiller de l’extérieur - Les vérifications externes détectent les problèmes réseau
2. Définir des seuils raisonnables - Éviter la fatigue des alertes
3. Superposer votre surveillance - Disponibilité + métriques + journaux
4. Conserver les données de manière appropriée - 15-30 jours pour les métriques, plus longtemps pour les agrégats
5. Documenter les runbooks - Que faire quand l’alerte X se déclenche
6. Tester vos alertes - S’assurer qu’elles vous parviennent bien
7. Surveiller les moniteurs - Utiliser un service externe pour surveiller votre système de surveillance
8. Sécuriser vos tableaux de bord - Les métriques peuvent révéler des informations sensibles (voir notre guide de sécurité VPS)

Erreurs Courantes à Éviter

❌ Trop d’alertes - La fatigue des alertes conduit à ignorer les vrais problèmes

❌ Pas de surveillance externe - Si votre serveur est hors ligne, votre surveillance l’est aussi

❌ Exposer les métriques publiquement - Utilisez l’authentification ou des réseaux internes

❌ Ne pas définir la rétention - Le disque se remplit avec les anciennes données

❌ Surveiller sans agir - Les tableaux de bord ne résolvent pas les problèmes

❌ Canal de notification unique - L’email est en panne ? Plus d’alertes

❌ Pas de référence de base - Vous devez savoir à quoi ressemble le “normal”

❌ Sur-surveillance - Commencez simplement, ajoutez de la complexité au besoin

Métriques Clés à Surveiller

Métriques Système

• Utilisation CPU - Alerte à partir de 80%+ soutenu
• Utilisation mémoire - Alerte à partir de 85%+
• Utilisation disque - Alerte à partir de 80%+ (les disques se remplissent vite)
• I/O disque - Une attente élevée indique un goulot d’étranglement du stockage
• Débit réseau - Référence de base et détection d’anomalies

Métriques Application

• Temps de réponse - Latences p50, p95, p99
• Taux d’erreurs - Pourcentage de réponses 5xx
• Taux de requêtes - Patterns de trafic
• Connexions actives - Utilisation du pool de base de données
• Profondeur de file - Arriéré des tâches en arrière-plan

Métriques Métier

• Inscriptions/achats - Une baisse indique des problèmes
• Utilisateurs actifs - Santé de l’engagement
• Revenus - La métrique ultime

FAQ

Combien de ressources la surveillance consomme-t-elle ?

Très peu. Uptime Kuma : ~100 Mo de RAM. Stack Prometheus/Grafana complet : ~500 Mo-1 Go. C’est amplement justifié pour la visibilité obtenue.

Dois-je utiliser une surveillance cloud ou auto-hébergée ?

Auto-hébergée pour contrôler les coûts et la propriété des données. Cloud (Datadog, New Relic) si vous avez le budget et souhaitez une solution gérée. Hostinger VPS dispose de suffisamment de ressources pour la surveillance auto-hébergée.

Comment surveiller depuis l’extérieur de mon réseau ?

Utilisez des services externes comme :

• Uptime Robot (offre gratuite)
• Pingdom
• Better Uptime
• StatusCake

Ces services détectent les problèmes que votre surveillance auto-hébergée ne peut pas voir.

Quels seuils d’alerte dois-je définir ?

Commencez de manière conservative, ajustez selon l’expérience :

• CPU : 80% pendant 5 minutes
• Mémoire : 85%
• Disque : 80%
• Temps de réponse : 2x votre p95 de référence

Combien de temps conserver les métriques ?

• Haute résolution (15s) : 7-15 jours
• Agrégées (5m) : 30-90 jours
• Plus agrégées : 1-2 ans

Équilibrez le niveau de détail par rapport aux coûts de stockage.

Puis-je surveiller plusieurs serveurs ?

Oui ! Prometheus + Node Exporter passent bien à l’échelle. Ajoutez simplement de nouvelles cibles à votre configuration de scrape et vous pouvez surveiller plus de 100 serveurs depuis un seul tableau de bord.

---

Votre stack de surveillance est prêt ! Combinez ceci avec notre guide de sauvegarde et notre guide de sécurité pour un VPS prêt pour la production.