Prometheus

Mise à jour : 19/08/2024

Je vais vous guider à travers Prometheus, un système de surveillance et d’alerte open-source largement utilisé dans le domaine du DevOps. Prometheus a été conçu pour collecter et stocker des métriques de séries temporelles, les analyser et envoyer des alertes basées sur ces données. Que vous soyez un administrateur système cherchant à améliorer la surveillance de votre infrastructure ou un ingénieur DevOps désireux de mettre en place une solution d’alerte efficace, ce guide vous fournira une compréhension approfondie de ses fonctionnalités, de son historique, et de ses concepts clés.

Prometheus est devenu un standard de facto dans la surveillance des systèmes modernes, grâce à sa capacité à s’intégrer facilement avec de nombreux autres outils et services. Il offre une flexibilité remarquable avec son langage de requête puissant, PromQL, permettant aux utilisateurs d’extraire des informations détaillées et précises à partir des données collectées.

Historique

Prometheus a été initialement développé par SoundCloud en 2012. À cette époque, SoundCloud faisait face à des défis importants en matière de surveillance de son infrastructure. Les outils existants ne répondaient pas adéquatement à leurs besoins, en particulier en ce qui concerne la capacité de stocker et de traiter de grandes quantités de données de métriques temporelles. Cela a conduit à la création de Prometheus, un projet open-source conçu pour répondre à ces besoins spécifiques.

L’objectif principal de Prometheus était de fournir une solution de monitoring qui soit :

Scalable : capable de gérer des milliers de points de données par seconde.
Flexible : facile à intégrer avec d’autres systèmes et services.
Précis : offrant des données en temps réel et un langage de requête puissant pour l’analyse.

Prometheus a rapidement gagné en popularité grâce à sa capacité à répondre aux exigences des environnements de production modernes. En 2016, il est devenu un projet de la Cloud Native Computing Foundation (CNCF), aux côtés d’autres projets majeurs comme Kubernetes. Cette intégration à la CNCF a renforcé la crédibilité de Prometheus et a accéléré son adoption dans l’industrie.

L’une des forces de Prometheus réside dans sa communauté active et son écosystème croissant. De nombreux exporters ont été développés pour permettre la collecte de métriques à partir de diverses sources, et des outils complémentaires comme Grafana permettent de visualiser les données collectées de manière intuitive.

Depuis sa création, Prometheus a évolué avec plusieurs versions majeures, ajoutant de nouvelles fonctionnalités et améliorations. Sa capacité à évoluer et à s’adapter aux besoins changeants des utilisateurs en a fait un outil incontournable pour la surveillance et l’alerte dans les environnements DevOps.

Concepts Clés

Pour utiliser Prometheus efficacement, il est important de comprendre certains concepts clés. Voici une explication détaillée de ces concepts :

Metrics

Les metrics sont des données quantitatives collectées par Prometheus. Elles sont stockées sous forme de séries temporelles, chaque série étant identifiée par un nom de métrique et des étiquettes (labels). Les metrics sont classées en quatre types principaux :

Counter : un compteur qui augmente uniquement (par exemple, le nombre de requêtes HTTP).
Gauge : une valeur qui peut augmenter ou diminuer (par exemple, l’utilisation de la mémoire).
Histogram : une distribution des observations dans des buckets prédéfinis (par exemple, les durées de requêtes).
Summary : des quantiles de distribution des observations (similaire à l’histogramme mais avec des quantiles).

Scraping

Le processus de scraping consiste à collecter périodiquement des metrics depuis des endpoints exposés par les services. Prometheus envoie des requêtes HTTP aux endpoints configurés et recueille les données retournées. La configuration du scraping se fait principalement dans le fichier prometheus.yml.

PromQL

Le Prometheus Query Language (PromQL) est un langage de requête conçu pour interroger et analyser les données de séries temporelles. PromQL permet de créer des expressions complexes pour extraire des informations spécifiques à partir des metrics collectées. Par exemple, pour obtenir le taux de requêtes HTTP 200 au cours des cinq dernières minutes :

rate(http_requests_total{status="200"}[5m])

Alerting

L’alerting dans Prometheus permet de définir des règles d’alerte basées sur les metrics collectées. Ces règles sont configurées pour surveiller certaines conditions et envoyer des alertes lorsque ces conditions sont remplies. Les alertes sont gérées par Alertmanager, qui se charge de la notification via différents canaux (e-mail, Slack, etc.). Une règle d’alerte peut ressembler à ceci :

groups:
  - name: example
    rules:
      - alert: HighMemoryUsage
        expr: node_memory_Active_bytes > 8e+09
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High memory usage detected"
          description: "The memory usage is above 8GB for more than 5 minutes."

Service Discovery

Le Service Discovery permet à Prometheus de découvrir automatiquement les endpoints à scrapper dans des environnements dynamiques comme Kubernetes, Consul, et d’autres. Cela évite d’avoir à configurer manuellement chaque cible et permet de suivre les changements dans l’infrastructure.

Exporters

Les exporters sont des programmes qui collectent des metrics spécifiques à partir de différentes sources et les exposent au format attendu par Prometheus. Par exemple, le Node Exporter collecte des metrics système (CPU, mémoire, disque) et les expose pour que Prometheus puisse les scrapper.

Targets

Les targets sont les endpoints HTTP que Prometheus scrappe pour collecter les metrics. Chaque target est identifié par un nom de job et une liste de labels. La configuration des targets se fait dans le fichier prometheus.yml.

Labels

Les labels sont des paires clé-valeur attachées aux metrics qui permettent de les identifier et de les organiser. Les labels facilitent le filtrage et l’agrégation des metrics dans PromQL. Par exemple, une metric de requête HTTP peut avoir des labels comme method="GET" et status="200".

Time Series Database (TSDB)

Prometheus utilise une base de données de séries temporelles (TSDB) pour stocker les metrics collectées. La TSDB est optimisée pour les opérations d’écriture rapide et de lecture efficace, permettant de gérer de grandes quantités de données temporelles avec une latence minimale.

Installation de Prometheus

Pour commencer à utiliser Prometheus, il est nécessaire de l’installer et de le configurer correctement. Voici un guide étape par étape pour l’installation de Prometheus sur un système Linux. J’aurais pu aussi l’installer dans un cluster Kubernetes, mais je préfère détailler la méthode d’installation classique.

Avant de commencer l’installation, assurez-vous d’avoir :

Un système Linux (Ubuntu, CentOS, etc.)
Un accès root ou des privilèges sudo

La première étape consiste à télécharger la dernière version de Prometheus depuis le site officiel. Utilisez la commande suivante pour télécharger et décompresser les fichiers nécessaires :

sudo useradd --no-create-home --shell /usr/sbin/nologin prometheus
sudo -i
cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.53.1/prometheus-2.53.1.linux-amd64.tar.gz
cd /opt
tar xvfz /tmp/prometheus-2.53.1.linux-amd64.tar.gz
cd prometheus-2.53.1.linux-amd64
ln -s prometheus-2.53.1.linux-amd64 prometheus
sudo chown -R prometheus:prometheus /opt/prometheus*
quit

La configuration de Prometheus se fait principalement via un fichier nommé prometheus.yml. Voici un exemple de configuration de base :

global:
  scrape_interval: 15s  # Intervalle global de scraping
  evaluation_interval: 15s  # Intervalle d'évaluation des règles

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

Pour exécuter Prometheus en tant que service, vous pouvez créer un fichier de service systemd. Voici un exemple de fichier de service pour Prometheus :

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
ExecStart=/opt/prometheus/prometheus --config.file=/opt/prometheus/prometheus.yml --storage.tsdb.path=/opt/prometheus/data
Restart=always

[Install]
WantedBy=multi-user.target

Placez ce fichier dans /etc/systemd/system/prometheus.service, puis activez et démarrez le service avec les commandes suivantes :

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

Pour vérifier que Prometheus fonctionne correctement, vous pouvez accéder à l’interface web à l’adresse http://localhost:9090. Vous devriez voir la page de tableau de bord de Prometheus où vous pouvez exécuter des requêtes PromQL et visualiser les metrics collectées.

Configuration de Prometheus

Une fois Prometheus installé, il est important de le configurer correctement pour qu’il puisse surveiller les bonnes cibles et collecter les métriques nécessaires.

Le fichier prometheus.yml est le principal fichier de configuration pour Prometheus. Il définit les règles globales, les targets à scrapper, et les règles d’alertes. reprenons le contenu vu précédement :

global:
  scrape_interval: 15s  # Intervalle global de scraping
  evaluation_interval: 15s  # Intervalle d'évaluation des règles

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

Les paramètres globaux définissent le comportement général de Prometheus. Deux paramètres couramment utilisés sont :

scrape_interval : Intervalle de scraping par défaut pour tous les jobs
evaluation_interval : Intervalle d’évaluation des règles d’alerte

global:
  scrape_interval: 15s  # Intervalle de scraping par défaut pour tous les jobs
  evaluation_interval: 15s  # Intervalle d'évaluation des règles d'alerte

Les scrape_configs définissent les jobs de scraping, c’est-à-dire les ensembles de targets à partir desquelles Prometheus doit collecter des métriques. Chaque job de scraping peut avoir ses propres paramètres, comme le nom du job et la liste des targets.

scrape_configs:
  - job_name: 'webserver'
    static_configs:
      - targets: ['webserver1.example.com:9100', 'webserver2.example.com:9100']

Prometheus peut utiliser des mécanismes de découverte de service (Service Discovery) pour découvrir automatiquement les targets dans des environnements dynamiques comme Kubernetes. Voici un exemple de configuration pour Kubernetes :

scrape_configs:
  - job_name: 'kubernetes-nodes'
    kubernetes_sd_configs:
      - role: node

Le relabelling permet de modifier les labels des targets avant qu’ils ne soient stockés. C’est utile pour filtrer, renommer, ou ajouter des labels.

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']
    relabel_configs:
      - source_labels: [__address__]
        target_label: instance
        regex: '(.*):9100'
        replacement: '$1'

Les règles d’alerte sont définies dans le fichier de configuration et spécifient les conditions pour déclencher des alertes. Les alertes sont envoyées à l’Alertmanager pour notification.

rule_files:
  - "alert.rules.yml"

Dont voici le contenu :

groups:
  - name: example
    rules:
      - alert: HighMemoryUsage
        expr: node_memory_Active_bytes > 8e+09
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High memory usage detected"
          description: "The memory usage is above 8GB for more than 5 minutes."

Prometheus utilise Alertmanager pour gérer les alertes. La configuration d’Alertmanager se fait via un fichier alertmanager.yml.

global:
  resolve_timeout: 5m

route:
  receiver: 'default'

receivers:
  - name: 'default'
    email_configs:
    - to: 'votre-email@example.com'

Prometheus permet de recharger la configuration sans redémarrer le serveur. Pour ce faire, envoyez un signal SIGHUP au processus Prometheus ou utilisez l’endpoint /-/reload via une requête HTTP POST.

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

Alertmanager

Alertmanager est un composant essentiel de l’écosystème Prometheus. Il est responsable de la gestion des alertes générées par les règles d’alerte définies dans Prometheus. Alertmanager permet de regrouper, dédupliquer et acheminer les alertes vers différents canaux de notification comme les e-mails, Slack, PagerDuty, et bien d’autres.

Installation d’Alertmanager

Si vous utilisez Prometheus dans un environnement Kubernetes, Alertmanager peut être déployé via Helm. Pour une installation manuelle sur un système Linux, suivez ces étapes :

Téléchargez la dernière version d’Alertmanager depuis le site officiel et extrayez les fichiers :

sudo -i
cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.27.0/alertmanager-0.27.0.linux-amd64.tar.gz
cd /opt
tar xvfz /tmp/alertmanager-0.27.0.linux-amd64.tar.gz
ln -s alertmanager-0.25.0.linux-amd64 alertmanager
chown -R prometheus:prometheus /opt/alertmanager*
cd alertmanager

Configuration d’Alertmanager

La configuration d’Alertmanager se fait via un fichier alertmanager.yml. Ce fichier définit les routes d’alerte et les récepteurs. Voici un exemple de configuration de base :

global:
  resolve_timeout: 5m

route:
  receiver: 'default'

receivers:
  - name: 'default'
    email_configs:
      - to: 'votre-email@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'user'
        auth_password: 'password'

Routes d’Alerte

Les routes d’alerte définissent comment les alertes doivent être acheminées et traitées. Une route d’alerte peut spécifier des conditions de correspondance pour les labels d’alerte et des actions à entreprendre.

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 3h
  receiver: 'team-X-mails'

  routes:
    - match:
        severity: critical
      receiver: 'team-X-pager'
    - match_re:
        service: ^(foo1|foo2|baz)$
      receiver: 'team-X-mails'
    - match:
        service: files
      receiver: 'team-Y-mails'
      continue: true

Récepteurs

Les récepteurs définissent où et comment les notifications d’alerte doivent être envoyées. Les récepteurs peuvent être configurés pour envoyer des notifications via différents canaux comme les e-mails, Slack, ou PagerDuty.

receivers:
  - name: 'slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
        channel: '#alerts'
        send_resolved: true

Groupement des Alertes

Alertmanager peut regrouper les alertes similaires pour réduire le bruit et envoyer des notifications consolidées. Le groupement est configuré via les paramètres group_by, group_wait, group_interval, et repeat_interval.

group_by : Labels utilisés pour regrouper les alertes.
group_wait : Temps d’attente avant d’envoyer la première notification.
group_interval : Intervalle entre les notifications groupées.
repeat_interval : Intervalle entre les répétitions des notifications.

Silences

Les silences permettent de muter temporairement des alertes spécifiques. Ils sont utiles pour éviter les notifications pendant les périodes de maintenance ou lorsqu’un problème est déjà connu et en cours de résolution.

Les silences peuvent être créés via l’interface web d’Alertmanager ou en utilisant l’API. Voici un exemple de création de silence via l’API :

curl -XPOST http://localhost:9093/api/v1/silences -d '
{
  "matchers": [
    {
      "name": "alertname",
      "value": "HighCPUUsage",
      "isRegex": false
    }
  ],
  "startsAt": "2024-01-01T00:00:00Z",
  "endsAt": "2024-01-01T01:00:00Z",
  "createdBy": "user",
  "comment": "Maintenance window"
}'

Intégration avec Prometheus

Pour que Prometheus envoie des alertes à Alertmanager, ajoutez la configuration d’Alertmanager dans le fichier prometheus.yml :

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - 'localhost:9093'

Exporters

Prometheus utilise des exporters pour collecter des métriques spécifiques à partir de divers systèmes, applications, et services. Les exporters sont des programmes ou des services qui collectent des données et les exposent sous forme de métriques que Prometheus peut scraper. Dans ce chapitre, nous allons explorer les différents types d’exporters disponibles et comment les configurer pour une surveillance efficace.

Les exporters sont essentiels pour étendre les capacités de Prometheus en lui permettant de collecter des métriques à partir de sources qui ne sont pas nativement supportées. Par exemple, un exporter peut collecter des métriques sur l’utilisation du CPU, la mémoire, ou les performances d’une base de données.

Voici quelques exemples d’exporters couramment utilisés :

Node Exporter collecte des métriques système telles que l’utilisation du CPU, la mémoire, le disque et le réseau.

Installation de Node Exporter :

wget https://github.com/prometheus/node_exporter/releases/download/v1.2.0/node_exporter-1.2.0.linux-amd64.tar.gz
tar xvfz node_exporter-1.2.0.linux-amd64.tar.gz
cd node_exporter-1.2.0.linux-amd64
./node_exporter

Configuration de Prometheus pour Node Exporter :

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

MySQL Exporter collecte des métriques sur l’état et les performances des bases de données MySQL.

Installation de MySQL Exporter :

wget https://github.com/prometheus/mysqld_exporter/releases/download/v0.12.1/mysqld_exporter-0.12.1.linux-amd64.tar.gz
tar xvfz mysqld_exporter-0.12.1.linux-amd64.tar.gz
cd mysqld_exporter-0.12.1.linux-amd64
./mysqld_exporter

Configuration de Prometheus pour MySQL Exporter :

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

Blackbox Exporter est utilisé pour surveiller les endpoints réseau (HTTP, HTTPS, DNS, TCP, ICMP).

Installation de Blackbox Exporter :

wget https://github.com/prometheus/blackbox_exporter/releases/download/v0.18.0/blackbox_exporter-0.18.0.linux-amd64.tar.gz
tar xvfz blackbox_exporter-0.18.0.linux-amd64.tar.gz
cd blackbox_exporter-0.18.0.linux-amd64
./blackbox_exporter

Configuration de Prometheus pour Blackbox Exporter :

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
        - http://example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: 127.0.0.1:9115  # Blackbox exporter.

Vous pouvez aussi développer vos propres Exporters dans le langage de votre choix.

Utilisation de PromQL

Prometheus Query Language (PromQL) est un langage de requête puissant et flexible utilisé pour interroger les données de séries temporelles collectées par Prometheus. PromQL permet de créer des expressions complexes pour extraire et analyser des metrics, facilitant ainsi la surveillance et le dépannage des systèmes. Dans ce chapitre, nous allons explorer les bases de PromQL et fournir des exemples concrets pour illustrer son utilisation.

PromQL suit une syntaxe simple et intuitive pour interroger les données. Voici quelques exemples de requêtes de base :

Pour sélectionner toutes les séries temporelles d’une métrique spécifique, utilisez le nom de la métrique :

up

Cette requête retourne l’état de toutes les cibles surveillées (1 pour “up” et 0 pour “down”).

Pour filtrer les séries temporelles par des labels spécifiques, utilisez les accolades {} :

http_requests_total{job="api", status="200"}

Cette requête sélectionne toutes les séries temporelles de la métrique http_requests_total où le job est “api” et le status est “200”.

PromQL permet d’effectuer diverses opérations sur les séries temporelles, comme les agrégations, les arithmétiques et les fonctions.

Les fonctions d’agrégation permettent de combiner plusieurs séries temporelles en une seule. Par exemple, pour obtenir le taux de requêtes HTTP 200 au cours des cinq dernières minutes :

rate(http_requests_total{status="200"}[5m])

Vous pouvez effectuer des opérations arithmétiques sur les séries temporelles :

node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes

Cette requête calcule la mémoire utilisée en soustrayant la mémoire disponible de la mémoire totale.

Les fonctions promQL

PromQL offre une variété de fonctions pour manipuler les séries temporelles. Voici quelques fonctions couramment utilisées :

rate()

La fonction rate() calcule le taux de changement par seconde d’un compteur :

rate(http_requests_total[5m])

avg()

La fonction avg() calcule la moyenne des valeurs dans une série temporelle :

avg(node_cpu_seconds_total)

sum()

La fonction sum() additionne les valeurs de toutes les séries temporelles sélectionnées :

sum(http_requests_total{status="200"})

Expressions Complexes

Vous pouvez combiner plusieurs opérations et fonctions pour créer des expressions complexes. Par exemple, pour obtenir le pourcentage d’utilisation de la CPU par cœur :

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

Intégration de Prometheus avec Grafana

Grafana est une plateforme de visualisation et d’analyse de métriques open-source qui permet de créer des tableaux de bord interactifs et informatifs. L’intégration de Prometheus avec Grafana permet de visualiser les métriques collectées par Prometheus de manière intuitive et efficace. Dans ce chapitre, nous allons explorer comment configurer Prometheus en tant que datasource dans Grafana et comment créer des tableaux de bord utilisant les métriques de Prometheus.

Utilisation de Prometheus comme Datasource

Accéder à Grafana : Ouvrez votre navigateur web et accédez à l’interface de Grafana (par défaut, c’est http://localhost:3000).
Ajouter une nouvelle Datasource :
- Connectez-vous à Grafana avec vos identifiants.
- Cliquez sur l’icône de configuration (engrenage) sur le panneau de gauche et sélectionnez “Data Sources”.
- Cliquez sur le bouton “Add data source”.
Configurer la Datasource Prometheus :
- Sélectionnez “Prometheus” parmi les options de type de datasource.
- Dans le champ “HTTP URL”, entrez l’URL de votre serveur Prometheus. Par exemple, http://localhost:9090.
- Configurez les autres options selon vos besoins. Les paramètres par défaut sont généralement suffisants pour une configuration de base.
- Cliquez sur “Save & Test” pour vérifier que Grafana peut se connecter à votre serveur Prometheus.

Création de Tableaux de Bord avec Prometheus

Une fois la datasource Prometheus configurée, vous pouvez commencer à créer des tableaux de bord pour visualiser les métriques.

Créer un Nouveau Tableau de Bord :
- Cliquez sur l’icône ”+” sur le panneau de gauche et sélectionnez “Dashboard”.
- Cliquez sur “Add new panel” pour ajouter un nouveau panneau à votre tableau de bord.
Configurer une Requête Prometheus :
- Dans la section “Query”, sélectionnez “Prometheus” comme datasource.
- Écrivez une requête PromQL pour les métriques que vous souhaitez visualiser. Par exemple, pour afficher l’utilisation du CPU, vous pouvez utiliser :
```
100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
```
- Grafana affichera un aperçu des données basées sur la requête PromQL.
Configurer le Graphique :
- Utilisez les options de configuration pour personnaliser l’affichage du panneau, y compris le type de graphique (ligne, barres, etc.), les axes, les légendes et autres options de style.
- Cliquez sur “Apply” pour ajouter le panneau au tableau de bord.
Répéter pour d’Autres Métriques :
- Ajoutez autant de panneaux que nécessaire pour visualiser différentes métriques ou aspects de votre système.
- Sauvegardez le tableau de bord une fois que vous avez terminé.

Exemple de Tableau de Bord

Voici un exemple de tableau de bord simple avec deux panneaux :

Panneau 1 : Utilisation du CPU

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

Panneau 2 : Utilisation de la Mémoire

node_memory_Active_bytes / node_memory_MemTotal_bytes * 100

Ces panneaux montrent l’utilisation du CPU et de la mémoire de vos nœuds surveillés.

Plus d’infos

Pour plus d’informations et de ressources, consultez les sites officiels suivants :

Site officiel de Prometheus : https://prometheus.io ↗
Documentation de Prometheus : https://prometheus.io/docs/introduction/overview/ ↗
Projet Prometheus sur GitHub : https://github.com/prometheus/prometheus ↗