Avant de lancer les conteneurs, créez l'arborescence locale qui accueillera la configuraton et la base de données temps réel de Prometheus.

mkdir -p /srv/prometheus/config /srv/prometheus/tsdb
sudo chown -R 65534:65534 /srv/prometheus

L'image officielle s'exécute avec l'utilisateur nobody (UID 65534) ; donner la propriété de ce répertoire évite les problèmes d'écriture.

Configuration de Prometheus

Créez le fichier de configuration principal /srv/prometheus/config/prometheus.yml :

global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    environnement: lab

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

  - job_name: 'node-exporter'
    static_configs:
      - targets: ['192.168.10.20:9100']
        labels:
          role: 'serveur-linux'

  - job_name: 'pushgateway'
    honor_labels: true
    static_configs:
      - targets: ['192.168.10.20:9091']

  - job_name: 'snmp-equipements'
    scrape_interval: 30s
    scrape_timeout: 20s
    static_configs:
      - targets: ['192.168.10.50:9116']
        labels:
          type: 'snmp'

Démarrage du serveur Prometheus

Lancez Prometheus en exposant le port 8080 de l'hôte et en montant les volumes persistants :

docker run -d \
  --name prometheus \
  -p 8080:9090 \
  -e TZ=Europe/Paris \
  -v /srv/prometheus/config:/etc/prometheus \
  -v /srv/prometheus/tsdb:/prometheus \
  --restart unless-stopped \
  prom/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/prometheus

Accédez ensuite à l'interface graphique :

http://192.168.10.10:8080/graph
http://192.168.10.10:8080/targets

Sur la page Targets, l'état de chaque cible doit passer à UP après quelques secondes. Pensez à ouvrir les ports correspondants sur le pare-feu.

Collecte des métriques système avec Node Exporter

Déployez un agent Node Exporter sur la machine à surveiller :

docker run -d \
  --name node_exporter \
  --net host \
  --pid host \
  --restart unless-stopped \
  -v /:/host:ro,rslave \
  prom/node-exporter \
  --path.rootfs=/host

Le conteneur expose ses métriques sur le port 9100 de l'hôte.

Visualisation avec Grafana

Préparez un volume pour Grafana puis démarrez le conteneur :

mkdir -p /srv/grafana/data
sudo chown -R 472:472 /srv/grafana

docker run -d \
  --name grafana \
  -p 3000:3000 \
  -e TZ=Europe/Paris \
  -v /srv/grafana/data:/var/lib/grafana \
  --restart unless-stopped \
  grafana/grafana

Connectez-vous à http://192.168.10.10:3000 avec les identifiants par défaut admin/admin, puis ajoutez Prometheus comme source de données via l'URL interne http://prometheus:9090 si Grafana et Prometheus partagent le même réseau Docker.

Les exporters et format de métriques

Un exporter est tout programme capable de fournir des séries temporelles au format attendu par Prometheus. On distingue principalement :

• Les exporters communautaires : Node Exporter, MySQL Exporter, Redis Exporter, Kafka Exporter, SNMP Exporter, Blackbox Exporter, etc.
• Les exporters personnalisés : développés à l'aide des bibliothèques officielles (Go, Java, Python, Ruby, etc.).

Les métriques doivent respecter le format texte suivant :

# HELP node_cpu_seconds_total Temps passé par le CPU dans chaque mode.
# TYPE node_cpu_seconds_total counter
node_cpu_seconds_total{cpu="0",mode="idle"} 362812.79

# HELP node_load1 Charge moyenne sur 1 minute.
# TYPE node_load1 gauge
node_load1 3.07

Modes de collecte : pull et push

Par défaut, Prometheus fonctionne en mode pull : le serveur interroge régulièrement chaque cible via une requête HTTP GET.

Le mode push, quant à lui, passe par un intermédiaire nommé Pushgateway :

1. Les applications ou scripts envoient leurs métriques vers Pushgateway.
2. Prometheus récupère ensuite ces métriques en pull depuis Pushgateway.

Utilisez Pushgateway uniquement lorsque Prometheus ne peut pas atteindre directement les cibles, par exemple à cause d'un pare-feu, d'un NAT ou d'une durée de vie courte des conteneurs.

Découverte de services

Au lieu de lister manuellement chaque cible dans prometheus.yml, Prometheus peut découvrir automatiquement les nouvelles instances via plusieurs mécanismes :

• file_sd : fichiers YAML/JSON surveillés.
• dns_sd : enregistrements DNS.
• consul_sd : catalogue Consul.
• kubernetes_sd : API Kubernetes.

Exemple avec file_sd :

scrape_configs:
  - job_name: 'backend-api'
    file_sd_configs:
      - files:
          - /etc/prometheus/targets/backend-*.json
        refresh_interval: 30s

Gestion des alertes

Promethues évalue des règles d'alerte et les transmet à Alertmanager, qui se charge du routage, du regroupement et de l'envoi via différents canaux (e-mail, Slack, PagerDuty, etc.).

Schéma type d'une chaîne d'alerting :

Prometheus → Alertmanager → Notification (e-mail, Slack, webhook)

Grafana fournit également un moteur d'alertes intégré depuis la version 4.0, qui peut servir d'alternative plus simple pour certains cas d'usage.