Exporters Prometheus

Les exporters sont des adaptateurs : ils transforment une source (système, base de données, réseau…) en un endpoint /metrics que Prometheus scrappe. Ce guide vous aide à choisir le bon outil et à comprendre comment ça s'emboîte.

Où se placent les exporters ?

[SOURCE] → (exporter / instrumentation) → /metrics  ──scrape──▶  Prometheus

• Source : OS, DB, service réseau, application…
• Exporter : pont qui rend la source "scrapable"
• Prometheus : collecte, stocke, interroge, alerte

Exporter ou instrumentation : comment décider ?

Situation	Solution	Pourquoi
J'ai le code de l'app	Instrumentation (client libs, OTel)	Métriques métier précises, moins d'approximation
Produit tiers, pas de code	Exporter dédié	MySQL, PostgreSQL, Redis, Nginx…
Système d'exploitation	Agent (Node/Windows Exporter)	CPU, RAM, disque, réseau
Vérifier la disponibilité externe	Blackbox Exporter	Probes HTTP, DNS, TCP, ICMP

Glissez pour voir

Instrumentation vs Exporter

Si vous contrôlez le code, instrumentez l'app (voir Instrumentation). Un exporter est un pont vers quelque chose que vous ne contrôlez pas.

Les 3 familles d'exporters

C'est LA distinction à comprendre avant de configurer quoi que ce soit.

Famille A, Single-target (agents)

Un exporter = une machine/service. L'exporter tourne sur ou près de la cible.

Exemple	Usage
Node Exporter	Métriques système Linux
Windows Exporter	Métriques système Windows

Glissez pour voir

Configuration Prometheus (simple) :

scrape_configs:
  - job_name: node
    static_configs:
      - targets: ['server1:9100', 'server2:9100']

Chaque target est directement l'exporter.

Famille B, Service (DB, caches, brokers)

L'exporter se connecte à un service (MySQL, PostgreSQL, Redis…) via TCP + credentials, puis expose /metrics.

Exemple	Usage
mysqld_exporter	MySQL/MariaDB
postgres_exporter	PostgreSQL
redis_exporter	Redis
mongodb_exporter	MongoDB

Glissez pour voir

Points d'attention :

• Droits minimum (read-only quand possible)
• Latence de collecte → ajuster scrape_timeout
• Cardinalité des labels

Famille C, Multi-target (proxy/prober)

Un seul exporter peut monitorer N cibles via un paramètre target=.... C'est le pattern multi-target exporter.

Exemple	Usage
Blackbox Exporter	Probes HTTP, DNS, TCP, ICMP
SNMP Exporter	Équipements réseau SNMP

Glissez pour voir

Pourquoi c'est différent ?

• L'exporter ne connaît pas les cibles à l'avance
• Prometheus passe la cible en paramètre via relabeling
• Un seul exporter peut sonder des centaines d'URLs

Pattern multi-target

Le guide officiel multi-target explique ce pattern en détail. Comprendre le relabeling est essentiel.

Choisir le bon outil (tableau de décision)

Intention	Outil	Famille	Ce que ça mesure
Santé machine Linux	Node Exporter	A	CPU, RAM, disque, réseau
Santé Windows	windows_exporter	A	Performance counters
Disponibilité HTTP/DNS/TCP/ICMP	Blackbox Exporter	C	Probes externes, SSL expiry
Santé MySQL/MariaDB	mysqld_exporter	B	Connexions, requêtes, réplication
Santé PostgreSQL	postgres_exporter	B	Connexions, locks, bloat
Santé Redis	redis_exporter	B	Mémoire, keys, ops/sec
Métriques conteneurs	cAdvisor / kubelet	Source	CPU, RAM, I/O par conteneur

Glissez pour voir

Liste complète des exporters officiels

cAdvisor n'est pas un exporter classique

cAdvisor expose des métriques conteneurs mais ne suit pas le pattern exporter. En Kubernetes, on le scrappe via kubelet ou kube-prometheus-stack.

Node Exporter (Famille A)

Le plus important : collecte les métriques système Linux.

Installation

Linux (binaire)

1. Télécharger

   cd /tmp
   VERSION="1.9.0"
   wget https://github.com/prometheus/node_exporter/releases/download/v${VERSION}/node_exporter-${VERSION}.linux-amd64.tar.gz

2. Installer

   tar xvfz node_exporter-${VERSION}.linux-amd64.tar.gz
   sudo cp node_exporter-${VERSION}.linux-amd64/node_exporter /usr/local/bin/
   sudo useradd --no-create-home --shell /usr/sbin/nologin node_exporter

3. Créer le service

   /etc/systemd/system/node_exporter.service

   [Unit]
   Description=Node Exporter
   Wants=network-online.target
   After=network-online.target
   
   [Service]
   User=node_exporter
   Group=node_exporter
   Type=simple
   ExecStart=/usr/local/bin/node_exporter
   Restart=always
   
   # Hardening
   NoNewPrivileges=true
   ProtectSystem=strict
   ProtectHome=true
   
   [Install]
   WantedBy=multi-user.target

4. Démarrer

   sudo systemctl daemon-reload
   sudo systemctl enable node_exporter
   sudo systemctl start node_exporter

Docker

docker run -d \
  --name node_exporter \
  --net host \
  --pid host \
  -v /:/host:ro,rslave \
  quay.io/prometheus/node-exporter:v1.9.0 \
  --path.rootfs=/host

Pourquoi --net host ?

Node Exporter doit accéder aux métriques réseau de l'hôte. Sans --net host, il ne voit que les métriques du conteneur.

Configuration Prometheus

prometheus.yml

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets:
          - 'server1:9100'
          - 'server2:9100'

Métriques clés

Métrique	Description
node_cpu_seconds_total	Temps CPU par mode (idle, user, system)
node_memory_MemAvailable_bytes	Mémoire disponible
node_filesystem_avail_bytes	Espace disque disponible
node_network_receive_bytes_total	Bytes reçus par interface
node_load1, node_load5, node_load15	Load average

Glissez pour voir

Requêtes PromQL utiles

# CPU utilisé (%)
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

# Mémoire utilisée (%)
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# Disque utilisé (%)
(1 - node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100

Blackbox Exporter (Famille C, Multi-target)

Surveille la disponibilité depuis l'extérieur : HTTP, DNS, TCP, ICMP. C'est du synthetic monitoring (probes), pas de la télémétrie interne.

Pourquoi le pattern multi-target ?

Blackbox ne "tourne pas sur" les cibles. Un seul Blackbox Exporter peut sonder des centaines d'URLs. La magie : Prometheus passe la cible en paramètre.

Prometheus scrappe:
  GET /probe?target=https://example.com&module=http_2xx

Blackbox répond:
  probe_success 1
  probe_duration_seconds 0.234

Installation

docker run -d \
  --name blackbox_exporter \
  -p 9115:9115 \
  -v $(pwd)/blackbox.yml:/config/blackbox.yml:ro \
  prom/blackbox-exporter:v0.25.0 \
  --config.file=/config/blackbox.yml

Configuration Blackbox

blackbox.yml

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2.0"]
      valid_status_codes: [200, 201, 204]
      follow_redirects: true

  tcp_connect:
    prober: tcp
    timeout: 5s

  icmp:
    prober: icmp
    timeout: 5s

  dns_resolve:
    prober: dns
    dns:
      query_name: "example.com"
      query_type: "A"

Configuration Prometheus (relabeling expliqué)

Le relabeling transforme une liste d'URLs en paramètres pour Blackbox :

prometheus.yml

scrape_configs:
  - job_name: 'blackbox-http'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com/health
          - https://docs.example.com
    relabel_configs:
      # 1. L'URL devient le paramètre ?target=
      - source_labels: [__address__]
        target_label: __param_target

      # 2. L'URL est aussi copiée dans le label "instance"
      - source_labels: [__param_target]
        target_label: instance

      # 3. L'adresse réelle de scrape devient Blackbox Exporter
      - target_label: __address__
        replacement: blackbox-exporter:9115

Ce qui se passe :

1. Prometheus voit https://example.com dans targets
2. Relabeling transforme en GET blackbox-exporter:9115/probe?target=https://example.com
3. Le label instance garde l'URL d'origine pour identifier les métriques

Métriques

Métrique	Description
probe_success	1 si probe réussie, 0 sinon
probe_duration_seconds	Durée totale de la probe
probe_http_status_code	Code HTTP retourné
probe_ssl_earliest_cert_expiry	Date d'expiration du certificat SSL

Glissez pour voir

Alertes courantes

rules/blackbox.yml

groups:
  - name: blackbox
    rules:
      - alert: EndpointDown
        expr: probe_success == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.instance }} is down"

      - alert: SSLCertExpiringSoon
        expr: probe_ssl_earliest_cert_expiry - time() < 86400 * 30
        for: 1h
        labels:
          severity: warning
        annotations:
          summary: "SSL cert for {{ $labels.instance }} expires in < 30 days"

Exporters bases de données (Famille B)

MySQL Exporter

1. Créer l'utilisateur MySQL (droits minimum)

   CREATE USER 'exporter'@'localhost' IDENTIFIED BY 'password';
   GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost';
   FLUSH PRIVILEGES;

2. Lancer l'exporter

   export DATA_SOURCE_NAME='exporter:password@(localhost:3306)/'
   ./mysqld_exporter

   Ou via Docker :

   docker run -d \
     --name mysqld_exporter \
     -p 9104:9104 \
     -e DATA_SOURCE_NAME='exporter:password@(mysql:3306)/' \
     prom/mysqld-exporter

3. Configuration Prometheus

   - job_name: 'mysql'
     static_configs:
       - targets: ['localhost:9104']

Métriques clés :

Métrique	Description
mysql_up	MySQL accessible (1/0)
mysql_global_status_threads_connected	Connexions actives
mysql_global_status_slow_queries	Requêtes lentes
mysql_global_status_questions	Requêtes exécutées

Glissez pour voir

PostgreSQL Exporter

export DATA_SOURCE_NAME='postgresql://exporter:password@localhost:5432/postgres?sslmode=disable'
./postgres_exporter

Métriques clés :

Métrique	Description
pg_up	PostgreSQL accessible
pg_stat_activity_count	Connexions par état
pg_stat_database_deadlocks	Deadlocks
pg_stat_database_tup_fetched	Lignes lues

Glissez pour voir

Redis Exporter

docker run -d \
  --name redis_exporter \
  -p 9121:9121 \
  oliver006/redis_exporter:v1.58.0 \
  --redis.addr=redis://localhost:6379

Créer votre propre exporter

Pour des métriques d'un système tiers non couvert, créez un exporter.

Instrumentation ≠ Exporter

Si vous avez le code de l'app, instrumentez directement (voir Instrumentation). Un exporter est un pont vers quelque chose d'externe.

Exemple Python (pont vers une API externe)

my_exporter.py

from prometheus_client import start_http_server, Gauge
import requests
import time

# Définir les métriques
ORDERS_PENDING = Gauge('orders_pending_total', 'Pending orders count')
ORDERS_VALUE = Gauge('orders_pending_value_euros', 'Value of pending orders')

def collect_metrics():
    """Collecte depuis une API externe."""
    response = requests.get('https://api.internal/orders/stats')
    data = response.json()
    ORDERS_PENDING.set(data['pending_count'])
    ORDERS_VALUE.set(data['pending_value'])

if __name__ == '__main__':
    start_http_server(8000)
    print("Exporter running on :8000/metrics")

    while True:
        collect_metrics()
        time.sleep(15)

Types de métriques

Type	Usage	Exemple
Counter	Valeur croissante uniquement	Requêtes, erreurs
Gauge	Monte et descend	Mémoire, connexions
Histogram	Distribution avec buckets	Latence
Summary	Quantiles côté client	Latence (moins recommandé)

Glissez pour voir

Conventions de nommage

namespace_name_unit_suffix

• myapp_http_requests_total ✅
• myapp_request_duration_seconds ✅
• requestCount ❌ (pas de namespace, pas d'unité)

Pièges classiques

Piège	Impact	Solution
/metrics exposé sans auth	Fuite d'infos	Firewall, TLS, basic auth
Trop de labels	Explosion cardinalité	Labels faible cardinalité uniquement
Scrape interval trop court	Surcharge exporter	15s-60s selon criticité
Scrape timeout trop court	Targets "DOWN"	Ajuster scrape_timeout

Glissez pour voir

Dépannage

Symptôme	Cause probable	Solution
Exporter non accessible	Firewall/réseau	curl http://exporter:port/metrics
Métriques vides	Pas de permissions	Vérifier droits DB/système
Scrape timeout	Exporter lent	Augmenter scrape_timeout
Target "DOWN"	DNS/réseau	Vérifier résolution + ping

Glissez pour voir

Commandes de debug :

# Vérifier l'endpoint
curl -s http://localhost:9100/metrics | head -20

# Vérifier dans Prometheus
# Status → Targets

# Pour Blackbox, tester la probe manuellement
curl "http://localhost:9115/probe?target=https://example.com&module=http_2xx"

À retenir

• 3 familles : single-target (Node), service (MySQL), multi-target (Blackbox)
• Instrumentation > Exporter si vous avez le code
• Blackbox = synthetic monitoring (disponibilité externe)
• Relabeling : essentiel pour le pattern multi-target
• Sécurité : ne jamais exposer /metrics sans protection réseau

Prochaines étapes

Instrumentation Instrumenter vos applications

Kubernetes kube-prometheus-stack et ServiceMonitors

Grafana Visualiser vos métriques

×

📖 Voir la documentation →