Prometheus

Introduction #

Présentation de PromQL et son importance dans Prometheus.

Qu'est-ce que PromQL ? #

PromQL (Prometheus Query Language) est le langage de requête utilisé dans Prometheus pour interroger les données de métriques. Il permet d'extraire des informations, de créer des alertes, et de visualiser des graphiques dans des outils comme Grafana.

Pourquoi utiliser PromQL ? #

PromQL est essentiel pour analyser les métriques collectées par Prometheus. Grâce à sa syntaxe puissante et flexible, vous pouvez :

• Surveiller les performances de vos systèmes.
• Configurer des alertes basées sur des seuils spécifiques.
• Créer des visualisations détaillées pour des tableaux de bord.

Bases de PromQL #

Comprendre les concepts fondamentaux de PromQL.

Types de données (Data Types) #

Une expression PromQL s'évalue toujours en l'un des quatre types suivants :

• Vecteur instantané (Instant vector) : Un ensemble de séries temporelles contenant une seule valeur (échantillon) pour chacune d'elles à un instant donné.
• Vecteur de plage (Range vector) : Un ensemble de séries temporelles contenant une plage de valeurs sur une période donnée (ex: [5m]).
• Scalaire (Scalar) : Une simple valeur numérique.
• Chaîne de caractères (String) : Une simple valeur sous forme de texte.

Types de Métriques #

PromQL travaille avec des métriques qui peuvent être de différents types :

• Counter : Une valeur cumulative qui ne décroît jamais (ex: nombre de requêtes HTTP). Fortement utilisé avec la fonction rate().
• Gauge : Une valeur qui peut augmenter ou diminuer arbitrairement (ex: utilisation de la mémoire).
• Histogram : Échantillonne des observations et les compte dans des seaux (buckets) configurables.
• Summary : Semblable à l'Histogram, mais calcule également des quantiles glissants.

Expressions simples #

Les expressions simples permettent de récupérer des métriques brutes :

http_requests_total

Cela retourne toutes les valeurs actuelles (Vecteur instantané) de la métrique http_requests_total.

Commandes récurrentes #

Les commandes les plus utilisées avec leurs explications et exemples.

Filtrage avec des étiquettes #

Les métriques peuvent être filtrées à l'aide d'étiquettes :

http_requests_total{method="GET", status="200"}

Cela retourne uniquement les métriques où method est GET et status est 200.

Agrégation #

Les fonctions d'agrégation permettent de résumer les données :

• sum(http_requests_total) : Somme de toutes les requêtes.
• avg(http_requests_total) : Moyenne des requêtes.
• max(http_requests_total) : Valeur maximale.
• min(http_requests_total) : Valeur minimale.

Fonctions #

PromQL offre des fonctions pour manipuler les séries temporelles :

• rate(metric[5m]) : Taux de changement par seconde sur une fenêtre de 5 minutes.
• increase(metric[1h]) : Augmentation totale sur une heure.
• irate(metric[1m]) : Taux instantané basé sur les points les plus récents.

Opérations arithmétiques #

PromQL permet de faire des calculs :

(http_requests_total{method="GET"} / http_requests_total) * 100

Cela calcule le pourcentage des requêtes GET par rapport au total.

Joindre des métriques #

Vous pouvez combiner plusieurs métriques :

sum(cpu_usage) by (instance) / sum(cpu_limit) by (instance)

Cela donne le ratio d'utilisation CPU par instance.

Opérations avancées #

Pour aller plus loin avec PromQL : opérateurs logiques, correspondances complexes et décalages.

Opérateurs logiques (Set Operators) #

Ces opérateurs permettent de filtrer et de combiner des vecteurs :

• and (intersection) : Retourne les éléments du vecteur de gauche pour lesquels il y a une correspondance à droite.
• or (union) : Retourne tous les éléments du vecteur de gauche et y ajoute ceux de droite n'ayant pas de correspondance à gauche.
• unless (différence) : Retourne les éléments du vecteur de gauche qui n'ont aucune correspondance à droite.

Correspondance de vecteurs (Vector Matching) #

Lorsque vous effectuez des opérations entre deux vecteurs, PromQL tente de faire correspondre les séries par leurs étiquettes. Vous pouvez altérer ce comportement :

• ignoring(label) ou on(label) : Pour restreindre la correspondance à un sous-ensemble d'étiquettes, ou en ignorer certaines.
• group_left ou group_right : Utilisé pour les jointures plusieurs-à-un (many-to-one) ou un-à-plusieurs (one-to-many).

Décalage temporel (Offset modifier) #

Le modificateur offset permet de décaler l'évaluation d'un vecteur dans le passé. Il est particulièrement utile pour comparer des données actuelles avec des données historiques :

http_requests_total offset 1w

Cela retourne la valeur de la métrique telle qu'elle était il y a exactement une semaine.

Visualisation des résultats #

Afficher et analyser les résultats dans Prometheus et Grafana.

Prometheus #

Dans l'interface web de Prometheus, entrez une requête PromQL dans la barre de recherche pour visualiser les résultats en temps réel.

Grafana #

Grafana offre une interface plus avancée pour créer des graphiques et des tableaux de bord basés sur les requêtes PromQL.

Exemples #

Quelques exemples de requêtes :

Utilisation du CPU #

• Charge moyenne sur tous les cœurs :

  avg(rate(node_cpu_seconds_total{mode!="idle"}[5m]))

  Cette requête calcule le taux moyen d'utilisation du CPU (hors mode idle) sur les 5 dernières minutes.
• Utilisation du CPU par instance :

  sum(rate(node_cpu_seconds_total{mode!="idle"}[5m])) by (instance)

Utilisation de la mémoire #

• Pourcentage de mémoire utilisée :

  100 * (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes))

• Mémoire utilisée en gigaoctets :

  (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / (1024 * 1024 * 1024)

Utilisation du disque #

• Pourcentage d'espace disque utilisé :

  100 * (node_filesystem_size_bytes{fstype!~"tmpfs|overlay"} - node_filesystem_free_bytes{fstype!~"tmpfs|overlay"}) / node_filesystem_size_bytes{fstype!~"tmpfs|overlay"}

• Espace libre sur un disque spécifique :

  node_filesystem_free_bytes{mountpoint="/"}

Surveillance des réseaux #

• Taux d'envoi de données sur une interface réseau :

  rate(node_network_transmit_bytes_total[1m])

• Taux de réception de données :

  rate(node_network_receive_bytes_total[1m])

Uptime d'une instance #

• Liste des instances en ligne :

  up == 1

• Instance cadvisor :

  up{instance="cadvisor:8080"}

Erreurs dans les applications #

• Taux d'erreurs HTTP 5xx :

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

• Pourcentage d'erreurs 5xx par rapport au trafic total :

  100 * rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])

Alimentation d'une alerte #

• CPU saturé (> 90 %) :

  avg(rate(node_cpu_seconds_total{mode!="idle"}[5m])) by (instance) > 0.9

• Moins de 10 % d'espace disque disponible :

  (node_filesystem_free_bytes / node_filesystem_size_bytes) < 0.1

Bonnes pratiques #

Conseils pour écrire des requêtes PromQL efficaces.

Simplifiez vos requêtes #

Évitez de surcharger vos requêtes avec des calculs complexes. Utilisez des fonctions simples et combinez-les au besoin.

Utilisez des agrégations #

Les agrégations comme sum et avg permettent de simplifier les données et de les rendre plus lisibles.

Filtrez les données #

Utilisez des étiquettes pour réduire le volume de données retournées, ce qui améliore la performance des requêtes.

Conclusion #

Résumé et prochaines étapes pour maîtriser PromQL.

PromQL est un langage puissant pour analyser et surveiller vos métriques dans Prometheus. En maîtrisant ses fonctionnalités, vous pouvez créer des alertes précises, des visualisations détaillées, et optimiser vos systèmes. Continuez à explorer les fonctions avancées et expérimentez avec vos métriques pour en tirer le maximum.