Installation de Prometheus

Ce guide vous accompagne pour installer Prometheus sur différentes plateformes. À la fin, vous aurez un serveur Prometheus fonctionnel qui scrappe ses propres métriques et celles d'un node_exporter, votre premier "vrai" target.

Choisir sa version

• Latest (3.x) : recommandé pour lab et stack moderne, nouvelles features
• LTS (3.5 LTS jusqu'au 31 juillet 2026) : recommandé en production si vous voulez limiter les upgrades

Consultez la page de téléchargement et le cycle de release.

Prérequis

Plateforme	Prérequis
Linux	Ubuntu 22.04+ ou Rocky 9+, accès sudo
Docker	Docker Engine 24+
Kubernetes	Cluster K8s 1.28+, Helm 3

Glissez pour voir

Méthode d'installation

Linux (binaire)

L'installation par binaire vous donne un contrôle total sur la configuration. C'est la méthode recommandée pour comprendre Prometheus en profondeur.

Arborescence standard

On utilise les chemins attendus par les ops :

Chemin	Usage
/usr/local/bin/	Binaires prometheus, promtool
/etc/prometheus/	Configuration
/var/lib/prometheus/	Données TSDB

Glissez pour voir

Créer l'utilisateur système

Prometheus doit tourner avec un utilisateur dédié sans privilèges.

sudo useradd --no-create-home --shell /usr/sbin/nologin prometheus

Télécharger et installer

1. Télécharger la dernière version

   Récupérez le binaire depuis prometheus.io/download. Exemple avec la version 3.9.1 :

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

2. Vérifier l'intégrité (obligatoire en prod)

   grep "prometheus-${VERSION}.linux-amd64.tar.gz" sha256sums.txt | sha256sum -c -
   # Attendu : prometheus-3.9.1.linux-amd64.tar.gz: OK

3. Extraire et installer

   tar xvfz prometheus-${VERSION}.linux-amd64.tar.gz
   sudo cp prometheus-${VERSION}.linux-amd64/{prometheus,promtool} /usr/local/bin/
   sudo chown prometheus:prometheus /usr/local/bin/{prometheus,promtool}

4. Créer les répertoires

   sudo mkdir -p /etc/prometheus /var/lib/prometheus
   sudo cp -r prometheus-${VERSION}.linux-amd64/{consoles,console_libraries} /etc/prometheus/
   sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

Configuration initiale

Créez une configuration minimale. Prometheus se scrappe lui-même + node_exporter.

/etc/prometheus/prometheus.yml

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

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

Rétention (défaut 15 jours)

Pour modifier la rétention en production, utilisez la configuration (le flag --storage.tsdb.retention.time est déprécié) :

/etc/prometheus/prometheus.yml

storage:
  tsdb:
    retention:
      time: 30d

Service systemd (hardened)

Ce fichier de service inclut les directives de sécurité recommandées.

/etc/systemd/system/prometheus.service

[Unit]
Description=Prometheus Monitoring
Documentation=https://prometheus.io/docs/
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple

# Sécurité : bind local si lifecycle activé (pas d'accès externe non authentifié)
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --web.listen-address=127.0.0.1:9090 \
  --web.enable-lifecycle

ExecReload=/bin/kill -HUP $MAINPID
Restart=always
RestartSec=10

# Hardening systemd
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/var/lib/prometheus

[Install]
WantedBy=multi-user.target

Sécurité : --web.enable-lifecycle

L'endpoint /-/reload permet de recharger la config sans restart, mais aussi de shutdown Prometheus. Ne jamais exposer sur 0.0.0.0 sans reverse proxy authentifiant. En lab, 127.0.0.1 suffit.

Activez et démarrez le service :

sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus

Installer node_exporter (premier vrai target)

Pour que Prometheus scrappe des métriques système, installez node_exporter :

# Télécharger
cd /tmp
NODE_VERSION="1.9.0"
wget https://github.com/prometheus/node_exporter/releases/download/v${NODE_VERSION}/node_exporter-${NODE_VERSION}.linux-amd64.tar.gz

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

/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

[Install]
WantedBy=multi-user.target

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

Vérification

1. Vérifier les services

   sudo systemctl status prometheus node_exporter

   Les deux doivent être Active: active (running).

2. Accéder à l'interface web

   Comme on bind sur 127.0.0.1, accédez localement ou via SSH tunnel :

   # Depuis une autre machine
   ssh -L 9090:127.0.0.1:9090 user@server

   Ouvrez http://localhost:9090 dans votre navigateur.

3. Tester une requête PromQL

   Dans l'interface, tapez up et cliquez Execute. Vous devez voir 2 séries : up{job="prometheus"} 1 et up{job="node"} 1.

4. Vérifier les targets

   Allez dans Status → Targets. Les deux targets doivent être UP.

Docker

Docker est idéal pour tester rapidement ou pour un environnement de développement.

Démarrage rapide (lab)

docker run -d \
  --name prometheus \
  -p 9090:9090 \
  prom/prometheus:v3.9.1

Toujours pin la version

N'utilisez jamais prom/prometheus sans tag (= latest). Ça casse la reproductibilité. Utilisez prom/prometheus:v3.9.1 ou la version LTS.

Stack complète avec node_exporter

Pour un setup réaliste avec un vrai target et le reload activé :

1. Créer la configuration

   prometheus.yml

   global:
     scrape_interval: 15s
   
   scrape_configs:
     - job_name: 'prometheus'
       static_configs:
         - targets: ['prometheus:9090']
   
     - job_name: 'node'
       static_configs:
         - targets: ['node-exporter:9100']

2. Créer le docker-compose.yml

   docker-compose.yml

   services:
     prometheus:
       image: prom/prometheus:v3.9.1
       container_name: prometheus
       ports:
         - "9090:9090"
       volumes:
         - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
         - prometheus-data:/prometheus
       command:
         - '--config.file=/etc/prometheus/prometheus.yml'
         - '--storage.tsdb.path=/prometheus'
         - '--web.enable-lifecycle'
       restart: unless-stopped
       networks:
         - monitoring
   
     node-exporter:
       image: prom/node-exporter:v1.9.0
       container_name: node-exporter
       ports:
         - "9100:9100"
       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)($$|/)'
       restart: unless-stopped
       networks:
         - monitoring
   
   volumes:
     prometheus-data:
   
   networks:
     monitoring:
       driver: bridge

3. Lancer la stack

   docker compose up -d

4. Vérifier

   • Prometheus : http://localhost:9090
   • Targets : http://localhost:9090/targets (2 targets UP)
   • Requête : node_cpu_seconds_total pour voir les métriques CPU

Reload de configuration (Docker)

Avec --web.enable-lifecycle activé :

curl -X POST http://localhost:9090/-/reload

Kubernetes (Helm)

Sur Kubernetes, utilisez le chart Helm kube-prometheus-stack qui installe Prometheus, Alertmanager, Grafana et les exporters en une seule commande.

kube-prometheus-stack

Ce chart (maintenu par la communauté Prometheus) installe l'opérateur Prometheus et une stack d'observabilité complète. C'est la méthode recommandée en production.

ArtifactHub : kube-prometheus-stack

1. Ajouter le repo Helm

   helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
   helm repo update

2. Installer la stack

   helm install prometheus prometheus-community/kube-prometheus-stack \
     --namespace monitoring \
     --create-namespace \
     --version 81.5.0

3. Vérifier les pods

   kubectl get pods -n monitoring

   Attendez que tous les pods soient Running (peut prendre 2-3 minutes).

4. Trouver le Service Prometheus (robuste)

   Le nom du Service dépend du release name. Retrouvez-le dynamiquement :

   kubectl get svc -n monitoring -l app.kubernetes.io/name=prometheus

5. Accéder à Prometheus

   # Récupérer le nom exact du Service
   SVC=$(kubectl get svc -n monitoring -l app.kubernetes.io/name=prometheus -o jsonpath='{.items[0].metadata.name}')
   
   # Port-forward
   kubectl port-forward -n monitoring svc/$SVC 9090:9090

   Ouvrez http://localhost:9090.

Vérification

Une fois connecté à l'interface Prometheus :

1. Requête up : vous devez voir de nombreuses séries (nodes, pods, services)
2. Targets : Status → Targets montre tous les ServiceMonitors actifs
3. Métriques node : node_cpu_seconds_total fonctionne (node-exporter inclus)

Personnaliser l'installation

Créez un fichier values.yaml pour personnaliser :

values.yaml

prometheus:
  prometheusSpec:
    retention: 30d
    storageSpec:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 50Gi

alertmanager:
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 10Gi

grafana:
  adminPassword: "VotreMotDePasseSecurise"

helm upgrade prometheus prometheus-community/kube-prometheus-stack \
  -n monitoring \
  -f values.yaml

Options de démarrage importantes

Flag	Description	Valeur par défaut
--config.file	Chemin du fichier de config	prometheus.yml
--storage.tsdb.path	Répertoire de stockage	data/
--web.listen-address	Adresse d'écoute	0.0.0.0:9090
--web.enable-lifecycle	Active /-/reload et /-/quit	false
--web.enable-admin-api	Active l'API admin (snapshots, delete)	false

Glissez pour voir

Rétention via config (recommandé)

Le flag --storage.tsdb.retention.time est déprécié. Préférez la configuration :

storage:
  tsdb:
    retention:
      time: 30d

Par défaut : 15 jours. Règle empirique : ~1-2 bytes/sample.

Reload de configuration

Prometheus peut recharger sa configuration sans redémarrage.

Via API (recommandé)

Nécessite --web.enable-lifecycle :

curl -X POST http://localhost:9090/-/reload

Via signal

sudo kill -HUP $(pgrep prometheus)

Vérifier la configuration avant reload

promtool check config /etc/prometheus/prometheus.yml

Dépannage installation

Symptôme	Cause probable	Solution
Service ne démarre pas	Permissions incorrectes	chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus
Port 9090 déjà utilisé	Autre service	--web.listen-address=:9091
"permission denied" sur data/	SELinux	chcon -Rt svirt_sandbox_file_t /var/lib/prometheus
Pas de données	Config invalide	promtool check config prometheus.yml
Target node en DOWN	node_exporter non démarré	systemctl status node_exporter

Glissez pour voir

Logs à consulter :

# Linux
journalctl -u prometheus -f

# Docker
docker logs prometheus -f

# Kubernetes
kubectl logs -n monitoring -l app.kubernetes.io/name=prometheus

À retenir

• Versions : choisissez Latest (3.x) ou LTS selon votre stratégie
• Vérifier l'intégrité : SHA256 obligatoire en production
• Layout standard : /etc/prometheus/ (config), /var/lib/prometheus/ (data)
• Hardening systemd : NoNewPrivileges, ProtectSystem=strict
• Sécurité lifecycle : bind sur 127.0.0.1 ou mettre un reverse proxy
• Premier target : node_exporter pour voir des métriques réelles
• Docker : toujours pin la version (v3.9.1, pas latest)
• K8s : kube-prometheus-stack inclut tout (Prometheus, Grafana, exporters)

Prochaines étapes

Configuration Configurer scrape_configs, service discovery et rules

PromQL Vos premières requêtes et agrégations

Exporters Node, MySQL, Blackbox et exporters custom

Visualiser avec Grafana Brancher Prometheus comme datasource et bâtir vos dashboards

×

📖 Voir la documentation →