Lors de l’article précédent, nous avions découvert l’installation de la stack prometheus/grafana. Continuons pour découvrir aujourd’hui quelques rudiments du promql. Vous pouvez vous rendre sur cette page si vous souhaitez consulter toute cette formation prometheus/grafana gratuite.

Nous avions vu le principe de label dans prometheus à travers le langage promql. Ainsi, chaque ligne de métriques dispose d’autant de cardinalités qu’elles disposent de labels différents. Par exemple, si la métrique node_load_5 prend un label instance et un label datacenter, nous avons autant de cette métrique que d’instance pour l’ensemble des datacenters. C’est pourquoi certaines métriques peuvent être très lourdes en matière de traitement des métriques (des load-balancers par exemple). Et lorsque l’on utilise ces métriques il est nécessaires de les filtrer pour les exploiter.

Pour filtrer les métriques, il suffit de placer des requêtes sur les labels de la métrique en question. Par exemple sur le datacenter ou l’instance spécifiquement.

Ainsi on pourra utiliser des expressions régulières de cette manière :

node_network_receive_bytes_total{device=="eth0"}
node_network_receive_bytes_total{device=~"eth.+"}
node_network_receive_bytes_total{device=~"eth0|lo"}
node_network_receive_bytes_total{device!~"eth0|lo"}

Ainsi :

• Le premier cas s’attache à une équivalence stricte.

• Le second à une regex qui permettra de rappatrier toutes les métriques node_network_receive_bytes_total mais dont le label device commence par “eth” et est suivi d’au moins un caractère ou plus.

• Le troisième dans le cas où pour la même métrique on souhaite rappartier soit les devices “eth0” ou “lo”.

• Enfin la différence en appliquant une regex.

D’autres opérations : le BY

Commençons par le regroupement grâce à l’opérateur “by” qui permet de faire l’équivalent de “GROUP BY” en SQL. Ainsi sur certaines fonctions comme les sommes, les comptages… vous pourrez regrouper ce calcul par un ou plusieurs labels. Par exemple pour compter le nombre de lignes de la métrique node_cpu_seconds_total par cpu, nous procéderons de la sorte :

count(node_cpu_seconds_total) by (cpu)

Ce qui nous permet, après avoir engendré un résultat d’une ligne par cpu, la possibilité de calculer le nombre de CPU :

count(count(node_cpu_seconds_total) by (cpu))

Et donc pour compter cela par serveur, il faudra ajouter le label “instance” à notre calcul

count(count(node_cpu_seconds_total) by (cpu,instance)) by (instance)

On compte donc dans un premier temps le nombre de ligne par cpu unqiuement pour regrouper cette métrique disposant de plusieurs lignes. Puis on compte le nombre de fois où l’on retrouve cette ligne regroupée pour avoir le nombre de cpu par instance.

Le facteur temps : offset et vector

Parmi les principaux éléments de temps importants dans prometheus, il en existe 2 :

• le vector : c’est la plage de temps sur laquelle certains calculs vont être réalisés (une somme, une moyenne, une dérivée…)
• l’offset : il s’agit du point de référence auquel vous souhaitez réaliser le calcul. Par exemple, il peut être intéressant de se placer 24h en arrière pour comparer avec les métriques actuelles…

Le range vector est intéressant pour les calculs mais aussi pour commencer pour voir le nombre de valeur sur lesquels on réalise un calcul. Ainsi si on passe un range vector de 3m à partir de maintenant sur une métrique on l’écrit comme ceci :

node_cpu_seconds_total[3m]

Cette requête va vous permettre d’afficher toutes les valeurs de la métrique node_cpu_seconds au cours de 3 dernières minutes. Plus le scrape est fréquent et plus vous avez de valeurs.

Les valeurs de cette requête sont classées par timestamp en format epoch. Vous pouvez néanmoins les convertir en format “humain” grâce à la commande date :

date -d "@1574340307.27"

Ainsi, pour calcculer une moyenne au cours des 3 dernières minutes, vous pouvez le faire de cette manière :

avg_over_time(node_cpu_seconds_total[3m])

Pour les offset, il suffit d’ajouter le mot offset. Prenons un exemple. Nous voulons comparer le nombre de requêtes actuelles avec celui d’il y a 5 minutes. Comme nous avons besoin de 2 courbes, nous allons faire deux requêtes.

La première qui collecte l’information sur le moment :

sum(http_requests_total)by (code)

Ensuite la seconde en demandant un offset placé 5 minutes en arrière :

sum(http_requests_total offset 5m)by (code)

Simple non ?

Les opérateurs

Dans les éléments simples à connaître pour débuter avec prometheus, il y a les opérateurs. Il s’agit de simple test conditionnels.

Par exemple, nous voulons savoir si une métrique est supérieur à 0.

Ainsi parmi les résultats, comme pour les labels, prometheus ne retournera que les métriques correspondantes. Et bien cûr cela peut se faire sur des résultats de fonctions (calculs).

Et on pourra aussi combiner les tests. Voici la liste des opérateurs promql disponibles :

    == (equal)
    != (not-equal)
    > (greater-than)
    < (less-than)
    >= (greater-or-equal)
    <= (less-or-equal)
    and (intersection)
    or (union)
    unless (complement)

Je vous propose un exemple simple :

node_load1 > 1.0 and node_load1<1.6

Dans ce cas nous retenons uniquement les métriques node_load inférieures à 1.6 et supérieure à 1.0. nous aurions aussi pu l’écrire de la manière suivante :

node_load1 > 1.0 <1.6

J’espère que cet article vous permettra de débuter le promql tranquillement et vous lèvera quelques doutes. N’hésitez pas à consulter les tutoriels prometheus/grafana sur la chaine xavki.