DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesSurveiller ses applications avec Prometheus et Grafana02 - Interroger les métriques avec PromQL

Détails

  • 20 minutes
  • Débutant

Objectifs

  • Écrire des requêtes PromQL simples et filtrées
  • Utiliser les fonctions rate(), increase() et avg_over_time()
  • Combiner des métriques avec des opérateurs arithmétiques
Module Surveiller ses applications avec Prometheus et Grafana

Exercice 02 : Interroger les métriques avec PromQL

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

  • ✅ Exécuter des requêtes instantanées et sur plage temporelle
  • ✅ Filtrer les métriques par label avec {}
  • ✅ Calculer un taux avec rate() et une variation avec increase()
  • ✅ Utiliser avg_over_time() pour lisser une série
  • ✅ Combiner des métriques avec +, -, /

Durée estimée : 20 minutes

Difficulté : ⭐⭐☆☆☆ (Débutant)

Prérequis : Exercice 01 complété, Prometheus en cours d'exécution


📖 Contexte

PromQL (Prometheus Query Language) est le langage de requêtes de Prometheus. Il permet de sélectionner, filtrer, agréger et transformer des séries temporelles. Maîtriser PromQL est indispensable pour créer des alertes pertinentes et des dashboards Grafana efficaces.


📋 Énoncé

Utilisez l'interface Prometheus UI (http://localhost:9090) pour explorer les métriques avec des requêtes de complexité croissante.


🧭 Déroulement de l'exercice

Tâche 1 : Requêtes de base

Dans Prometheus UI → Graph, exécutez les requêtes suivantes une par une et observez les résultats :

  • up : état de tous les targets
  • prometheus_http_requests_total : compteur de requêtes HTTP totales

Indice : Un instant vector retourne la dernière valeur. Un range vector (avec [5m]) retourne une série sur 5 minutes - il ne s'affiche pas seul, il faut le passer dans une fonction.

Vérification : up retourne 1 pour chaque target active. prometheus_http_requests_total affiche plusieurs séries avec des labels handler, code, method.


Tâche 2 : Filtrer par label

Exécutez des requêtes filtrées :

  • prometheus_http_requests_total{job="prometheus"} : seulement le job prometheus
  • prometheus_http_requests_total{code="200"} : seulement les 200 OK
  • prometheus_http_requests_total{handler=~"/api.*"} : handlers qui commencent par /api

Indice : = (égal), != (différent), =~ (regex match), !~ (regex non-match). Les labels sont insensibles à la casse.

Vérification : Chaque requête retourne un sous-ensemble des séries. La requête regex filtre correctement les handlers.


Tâche 3 : Calculer un taux avec rate()

Calculez le taux de requêtes HTTP par seconde sur les 5 dernières minutes :

rate(prometheus_http_requests_total{code="200"}[5m])

Puis le nombre total de requêtes sur 1 heure :

increase(prometheus_http_requests_total[1h])

Indice : rate() est pour les counters - il calcule le taux de variation par seconde. increase() retourne l'augmentation absolue sur la période. Les deux requièrent un range vector [xm].

Vérification : rate() retourne des valeurs décimales (ex: 0.023 req/s). increase() retourne des entiers approximatifs.


Tâche 4 : Agréger et lire avg_over_time()

Calculez la moyenne du nombre de goroutines sur 10 minutes :

avg_over_time(go_goroutines{job="prometheus"}[10m])

Puis comptez le nombre de targets actives :

count(up == 1)

Indice : avg_over_time(), min_over_time(), max_over_time() s'appliquent sur des range vectors. count(), sum(), avg(), max(), min() sont des opérateurs d'agrégation sur des instant vectors.

Vérification : avg_over_time retourne une valeur lissée. count(up == 1) retourne le nombre de targets UP.


Tâche 5 : Opérateurs arithmétiques

Calculez le pourcentage de RAM utilisée (si Node Exporter tourne) :

100 * (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)

Ou, si Node Exporter n'est pas disponible, comparez deux métriques Prometheus :

prometheus_http_response_size_bytes_sum / prometheus_http_response_size_bytes_count

Indice : Les opérateurs +, -, *, /, %, ^ fonctionnent entre séries de même label. Pour combiner des séries avec des labels différents, utilisez on() ou ignoring().

Vérification : La requête RAM retourne un pourcentage entre 0 et 100. La division retourne la taille moyenne d'une réponse HTTP.


🗂️ Mini-Projet

Créez un fichier queries.txt qui documente 5 requêtes utiles pour surveiller Prometheus lui-même :

# 1. Est-ce que Prometheus est UP ?
up{job="prometheus"}

# 2. Taux de requêtes par handler (req/s sur 5 min)
rate(prometheus_http_requests_total[5m])

# 3. Taux d'erreurs HTTP (codes 5xx)
rate(prometheus_http_requests_total{code=~"5.."}[5m])

# 4. Taille mémoire utilisée par Prometheus (MB)
process_resident_memory_bytes{job="prometheus"} / 1024 / 1024

# 5. Nombre de séries temporelles en mémoire
prometheus_tsdb_head_series

Checkpoints :

  • Les 5 requêtes s'exécutent sans erreur dans Prometheus UI
  • Vous comprenez la différence entre instant vector et range vector
  • rate() et increase() retournent des résultats cohérents
  • Vous savez filtrer par label avec =, !=, =~

Retour au module

Sur cette page

  • 🎯 Objectifs
  • 📖 Contexte
  • 📋 Énoncé
  • 🧭 Déroulement de l'exercice
  • Tâche 1 : Requêtes de base
  • Tâche 2 : Filtrer par label
  • Tâche 3 : Calculer un taux avec rate()
  • Tâche 4 : Agréger et lire avg_over_time()
  • Tâche 5 : Opérateurs arithmétiques
  • 🗂️ Mini-Projet