Recording rules Prometheus : écrire et nommer vos règles (level:metric:operations)

Recording rules Prometheus : écrire un fichier de règles, appliquer le nommage level:metric:operations et le tester avec promtool avant déploiement.
Recording rules Prometheus : écrire et nommer vos règles (level:metric:operations)

Les recording rules Prometheus précalculent une expression PromQL à intervalle régulier et enregistrent le résultat comme une nouvelle série. Un tableau de bord ou une alerte lit alors cette série prête à l’emploi, au lieu de recalculer une agrégation coûteuse à chaque affichage. Cet article montre comment écrire ces règles, les nommer selon la convention level:metric:operations, les tester avec promtool et les relire dans une démarche SRE.

Le besoin apparaît vite : un SLI de taux d’erreur calculé sur des centaines d’instances, affiché sur dix tableaux de bord et évalué par trois alertes, refait dix fois le même travail. Une règle d’enregistrement le fait une seule fois, avec un nom que toute l’équipe comprend. Le sujet complète la récupération de métriques Prometheus sur Kubernetes, qui traite de l’ingestion plutôt que du calcul.

En bref

  • Une recording rule est une paire record (nom de la nouvelle série) et expr (expression PromQL), rangée dans un groupe évalué à intervalle fixe.
  • La convention officielle de nommage est level:metric:operations : niveau d’agrégation, métrique d’origine, opérations appliquées.
  • On agrège toujours le numérateur et le dénominateur séparément, puis on divise ; on ne moyenne jamais un ratio.
  • promtool check rules valide la syntaxe, promtool test rules vérifie les résultats sur des séries fabriquées.

Pourquoi des recording rules Prometheus

Une requête comme sum(rate(http_requests_total[5m])) parcourt toutes les séries concernées à chaque exécution. Sur un cluster Kubernetes chargé, quelques dizaines de panneaux qui la répètent suffisent à ralentir l’interface. Précalculer une fois par minute déplace le coût vers un point unique, prévisible et mesurable.

Le bénéfice est aussi organisationnel. Un nom stable comme path:http_requests:rate5m devient un contrat : les alertes, les tableaux de bord et les rapports de SLO s’appuient sur la même définition du trafic. Cela réduit le toil de relecture et les écarts entre deux écrans qui n’affichent pas le même chiffre. Pour situer Prometheus par rapport à OpenTelemetry, voir OpenTelemetry vs Prometheus.

La structure d’un fichier de règles

Selon la documentation Prometheus, les fichiers de règles sont en YAML et chargés par le champ rule_files de la configuration. Un groupe porte un name obligatoire et unique dans le fichier, un interval facultatif (par défaut global.evaluation_interval) et une liste rules. Une recording rule contient record, un nom de métrique valide, expr, une expression PromQL, et des labels facultatifs ajoutés ou écrasés sur chaque résultat stocké.

Voici un fichier de trois règles qui calcule le trafic, les échecs et le ratio d’échecs par chemin.

Fichier rules.yml : trois recording rules path:http_requests:rate5m, path:http_request_failures:rate5m et le ratio d'échecs
groups:
  - name: http_requests
    interval: 1m
    rules:
      - record: path:http_requests:rate5m
        expr: sum without (instance, status) (rate(http_requests_total[5m]))
      - record: path:http_request_failures:rate5m
        expr: sum without (instance, status) (rate(http_requests_total{status=~"5.."}[5m]))
      - record: path:http_request_failures_per_requests:ratio_rate5m
        expr: path:http_request_failures:rate5m / path:http_requests:rate5m

Les métriques http_requests_total et leurs labels (instance, path, status) sont ici un exemple de l’article, pas une métrique imposée par Prometheus. Le ratio réutilise les noms des deux premières règles, ce qui garde son expression lisible.

Nommer avec level:metric:operations

La page Recording rules des bonnes pratiques Prometheus décrit la forme générale level:metric:operations.

  1. level : le niveau d’agrégation, c’est-à-dire les labels de la sortie. Ici path.
  2. metric : le nom de la métrique, inchangé, sauf que _total est retiré des compteurs utilisés avec rate() ou irate(). Ici http_requests_total devient http_requests.
  3. operations : la liste des opérations appliquées, la plus récente d’abord. Ici rate5m.

La même page ajoute quelques règles : sans opération évidente, utiliser sum ; pour un ratio, séparer les deux métriques par _per_ et nommer l’opération ratio, d’où path:http_request_failures_per_requests:ratio_rate5m. Les opérations associatives peuvent être fusionnées : min_min s’écrit min.

Agréger avec without plutôt que by

La documentation recommande de toujours utiliser une clause without listant les labels retirés, afin de conserver des labels comme job. Le niveau de sortie ne doit différer du niveau d’entrée que par les labels supprimés : si les niveaux ne correspondent pas, c’est un signe d’erreur. Le préfixe path du nom de la règle rappelle quels labels subsistent à côté de job.

Ne jamais moyenner un ratio

Selon la même page, il faut agréger numérateur et dénominateur séparément, puis diviser. Faire la moyenne de ratios ou de moyennes n’est pas statistiquement valide, car une instance qui reçoit peu de trafic pèserait autant qu’une instance très sollicitée. C’est exactement ce que fait le fichier ci-dessus.

Tester les règles avec promtool

Avant tout déploiement, validez le fichier sans démarrer de serveur :

promtool check rules rules.yml

Selon la documentation, la commande affiche les règles analysées et retourne le code 0 en cas de succès ; sur une erreur de syntaxe, elle écrit sur stderr et retourne 1. Ce code de retour se branche directement dans une étape d’intégration continue.

Pour vérifier les valeurs, la page Unit testing for rules décrit promtool test rules test.yml. Le fichier de test déclare les règles à charger, des séries d’entrée et les échantillons attendus. La notation 0+90x10 génère une série qui démarre à 0 puis augmente de 90 à chacun des 10 pas.

Fichier test.yml pour promtool test rules : séries d'entrée http_requests_total et échantillons attendus à 10 minutes

Les valeurs attendues (3,5 requête par seconde au total, 0,5 en échec) résultent d’un calcul à la main : 90 requêtes par minute par instance en succès, soit 1,5 par seconde, deux instances, plus 12 et 18 par minute en erreur. Ce fichier n’a pas été exécuté pour cet article : lancez-le chez vous et corrigez la valeur attendue si votre version de Prometheus extrapole autrement.

Recharger et surveiller les règles

Pour recharger les fichiers à chaud, la documentation indique d’envoyer SIGHUP au processus Prometheus ; les changements ne s’appliquent que si tous les fichiers de règles sont bien formés. Il existe un point de vigilance de fiabilité : si un groupe n’a pas fini son évaluation avant la suivante, celle-ci est sautée et la série enregistrée présente un trou. Le compteur rule_group_iterations_missed_total augmente à chaque itération manquée. Alertez dessus, car un SLI avec des trous fausse la consommation d’error budget. Pour les SLO, voir le comparatif SLO avec Prometheus.

Bonnes pratiques

  • Un groupe par thème (trafic, latence, saturation) et un interval adapté à la fenêtre de la requête.
  • Un nom conforme à level:metric:operations pour chaque règle, sans abréviation maison.
  • Des tests promtool test rules dans le dépôt, exécutés en CI avec check rules.
  • Peu de règles, ciblées sur les requêtes lourdes et réutilisées : chaque règle crée de nouvelles séries à stocker.
  • Une alerte sur les évaluations manquées.

Questions fréquentes

Quelle est la différence entre recording rule et alerting rule ?

Les deux vivent dans un groupe de règles. La recording rule stocke le résultat d’une expression dans une nouvelle série ; l’alerting rule évalue une condition et déclenche des alertes. Une alerte peut s’appuyer sur une série enregistrée.

Dois-je respecter la convention de nommage ?

Prometheus ne l’impose pas : record accepte tout nom de métrique valide. La convention vient des bonnes pratiques officielles et rend les séries lisibles d’un coup d’œil, ce qui compte en astreinte.

Ces séries sont-elles utilisables avec OpenTelemetry ou Dynatrace ?

Une série enregistrée reste une métrique Prometheus ordinaire. Pour la transporter vers une autre plateforme, suivez la méthode décrite dans cet article sur Prometheus et Kubernetes et vérifiez dans la documentation de la plateforme cible le traitement des compteurs et des jauges. Les règles elles-mêmes restent évaluées par Prometheus.

Conclusion

Les recording rules Prometheus déplacent les agrégations coûteuses hors des tableaux de bord et donnent aux SLI un nom stable. Appliquez level:metric:operations, agrégez avec without, divisez après avoir agrégé, testez avec promtool et surveillez les itérations manquées. La différence entre observabilité et simple supervision, qui motive ce travail sur les SLI, est détaillée dans cet article.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Prometheus est un projet de la Cloud Native Computing Foundation. Les procédures évoluent : vérifiez toujours la documentation officielle avant un changement en production.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Alerte logs Dynatrace : créer l'alerte et réduire le bruit

Alerte logs Dynatrace : créer l’alerte et réduire le bruit

Next Post
Fidélité RAG : évaluer un RAG et comprendre les limites de la métrique

Fidélité RAG : évaluer un RAG et comprendre les limites de la métrique

Related Posts