Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Création de modèles d'étiquettes et d'annotations

Vous pouvez utiliser des modèles pour inclure des données issues de requêtes et d'expressions dans des étiquettes et des annotations. Par exemple, vous pouvez définir l'étiquette de gravité d'une alerte en fonction de la valeur de la requête, ou utiliser l'étiquette d'instance de la requête dans une annotation récapitulative afin de savoir quel serveur utilise beaucoup le processeur.

Tous les modèles doivent être écrits en texte/modèle. Que vous modélisiez une étiquette ou une annotation, vous devez écrire chaque modèle en ligne à l'intérieur de l'étiquette ou de l'annotation que vous modélisez. Cela signifie que vous ne pouvez pas partager de modèles entre les étiquettes et les annotations, mais que vous devez copier les modèles là où vous souhaitez les utiliser.

Chaque modèle est évalué chaque fois que la règle d'alerte est évaluée, et est évalué séparément pour chaque alerte. Par exemple, si votre règle d'alerte comporte un modèle d'annotation récapitulative et qu'elle comporte 10 alertes déclenchées, le modèle sera exécuté 10 fois, une fois pour chaque alerte. Vous devriez essayer d'éviter autant que possible d'effectuer des calculs coûteux dans vos modèles.

Exemples

Plutôt que d'écrire un didacticiel complet sur le texte/le modèle, les exemples suivants tentent de montrer les cas d'utilisation les plus courants que nous avons vus pour les modèles. Vous pouvez utiliser ces exemples mot pour mot ou les adapter selon les besoins de votre cas d'utilisation. Pour plus d'informations sur la façon d'écrire du texte/modèle, consultez la documentation du texte/modèle.

Imprimer toutes les étiquettes, séparées par des virgules

Pour imprimer toutes les étiquettes, séparées par des virgules, imprimez la $labels variable :

{{ $labels }}

Par exemple, si vous recevez une alerte avec les étiquettes alertname=High CPU usageinstance=server1, grafana_folder=CPU alerts cela imprimerait :

alertname=High CPU usage, grafana_folder=CPU alerts, instance=server1

Imprimez toutes les étiquettes, une par ligne

Pour imprimer toutes les étiquettes, une par ligne, utilisez a range pour itérer sur chaque paire clé/valeur et imprimez-les individuellement. Ici $k fait référence au nom et $v à la valeur de l'étiquette actuelle :

{{ range $k, $v := $labels -}}
{{ $k }}={{ $v }}
{{ end }}

Par exemple, si vous recevez une alerte avec les étiquettes alertname=High CPU usageinstance=server1, grafana_folder=CPU alerts cela imprimerait :

alertname=High CPU usage
grafana_folder=CPU alerts
instance=server1

Imprimer une étiquette individuelle

Pour imprimer une étiquette individuelle, utilisez la index fonction avec la $labels variable :

The host {{ index $labels "instance" }} has exceeded 80% CPU usage for the last 5 minutes

Par exemple, si une alerte comporte une étiquetteinstance=server1, cela imprimerait :

The host server1 has exceeded 80% CPU usage for the last 5 minutes

Imprimer la valeur d'une requête

Pour imprimer la valeur d'une requête instantanée, vous pouvez imprimer son ID de référence à l'aide de la index fonction et de la $values variable :

{{ index $values "A" }}

Par exemple, étant donné une requête instantanée qui renvoie la valeur 81,2345, ceci affichera :

81.2345

Pour imprimer la valeur d'une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction. Vous pouvez ensuite imprimer le résultat de l'expression de réduction en utilisant plutôt son ID de référence. Par exemple, si l'expression de réduction prend la moyenne de A et a l'ID de référence B, vous devez écrire :

{{ index $values "B" }}

Imprimer la valeur humanisée d'une requête

Pour imprimer la valeur humanisée d'une requête instantanée, utilisez la humanize fonction :

{{ humanize (index $values "A").Value }}

Par exemple, étant donné une requête instantanée qui renvoie la valeur 81,2345, ceci affichera :

81.234

Pour imprimer la valeur humanisée d'une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction. Vous pouvez ensuite imprimer le résultat de l'expression de réduction en utilisant plutôt son ID de référence. Par exemple, si l'expression de réduction prend la moyenne de A et a l'ID de référence B, vous devez écrire :

{{ humanize (index $values "B").Value }}

Imprimer la valeur d'une requête sous forme de pourcentage

Pour imprimer la valeur d'une requête instantanée sous forme de pourcentage, utilisez la humanizePercentage fonction :

{{ humanizePercentage (index $values "A").Value }}

Cette fonction s'attend à ce que la valeur soit un nombre décimal compris entre 0 et 1. Si la valeur est plutôt un nombre décimal compris entre 0 et 100, vous pouvez la diviser par 100 dans votre requête ou à l'aide d'une expression mathématique. Si la requête est une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction.

Définir une sévérité à partir de la valeur d'une requête

Pour définir une étiquette de gravité à partir de la valeur d'une requête, utilisez une instruction if et la fonction de comparaison supérieure à celle de comparaison. Assurez-vous d'utiliser des décimales (80.0,,, etc.) lorsque vous effectuez des comparaisons 50.00.0, $values car le texte/le modèle ne prend pas en charge la coercition de type. Vous trouverez une liste de toutes les fonctions de comparaison prises en charge ici.

{{ if (gt $values.A.Value 80.0) -}}
high
{{ else if (gt $values.A.Value 50.0) -}}
medium
{{ else -}}
low
{{- end }}

Imprimez toutes les étiquettes à partir d'un état classique

Vous ne pouvez pas utiliser $labels pour imprimer des étiquettes à partir de la requête si vous utilisez des conditions classiques et vous devez les utiliser à la $values place. Cela s'explique par le fait que les conditions classiques suppriment ces étiquettes pour imposer un comportement unidimensionnel (au plus une alerte par règle d'alerte). Si les conditions classiques n'éliminaient pas ces étiquettes, les requêtes renvoyant de nombreuses séries chronologiques provoqueraient des interruptions entre le déclenchement et la résolution constante des alertes, car les étiquettes changeaient à chaque fois que la règle d'alerte était évaluée.

Au lieu de cela, la $values variable contient les valeurs réduites de toutes les séries chronologiques pour toutes les conditions qui se déclenchent. Par exemple, si vous avez une règle d'alerte avec une requête A qui renvoie deux séries chronologiques, et une condition B classique avec deux conditions, alors $values contiendrait B0B1, B2 etB3. Si la condition B classique ne comportait qu'une seule condition, $values elle contiendrait uniquement B0 etB1.

Pour imprimer toutes les étiquettes de toutes les séries chronologiques de cuisson, utilisez le modèle suivant (assurez-vous de remplacer B l'expression régulière par l'ID de référence de la condition classique s'il est différent) :

{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Labels }}{{ end }}
{{ end }}

Par exemple, une condition classique pour deux séries chronologiques dépassant une seule condition imprimerait :

B0: instance=server1
B1: instance=server2

Si la condition classique comporte deux conditions ou plus et qu'une série chronologique dépasse plusieurs conditions en même temps, ses étiquettes seront dupliquées pour chaque condition dépassée :

B0: instance=server1
B1: instance=server2
B2: instance=server1
B3: instance=server2

Si vous devez imprimer des étiquettes uniques, vous devriez plutôt envisager de modifier vos règles d'alerte en les remplaçant par des règles unidimensionnelles par des règles multidimensionnelles. Vous pouvez le faire en remplaçant votre condition classique par des expressions de réduction et mathématiques.

Imprimer toutes les valeurs d'une condition classique

Pour imprimer toutes les valeurs d'une condition classique, prenez l'exemple précédent et remplacez-le $v.Labels par $v.Value :

{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Value }}{{ end }}
{{ end }}

Par exemple, une condition classique pour deux séries chronologiques dépassant une seule condition imprimerait :

B0: 81.2345
B1: 84.5678

Si la condition classique comporte au moins deux conditions et qu'une série chronologique dépasse plusieurs conditions en même temps, elle $values contiendra les valeurs de toutes les conditions :

B0: 81.2345
B1: 92.3456
B2: 84.5678
B3: 95.6789

Variables

Les variables suivantes sont à votre disposition lors de la création de modèles d'étiquettes et d'annotations :

La variable labels

La $labels variable contient tous les libellés de la requête. Supposons, par exemple, que vous ayez une requête qui renvoie l'utilisation du processeur pour tous vos serveurs, et que vous disposiez d'une règle d'alerte qui se déclenche lorsque l'un de vos serveurs a dépassé 80 % d'utilisation du processeur au cours des 5 dernières minutes. Vous souhaitez ajouter une annotation récapitulative à l'alerte qui indique quel serveur utilise beaucoup le processeur. Avec la $labels variable, vous pouvez écrire un modèle qui imprime une phrase lisible par l'homme, telle que :

CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes

La variable de valeur

La $value variable est une chaîne contenant les libellés et les valeurs de toutes les requêtes instantanées, les expressions de seuil, de réduction et mathématiques, ainsi que les conditions classiques de la règle d'alerte. Il ne contient pas les résultats des requêtes de plage, car celles-ci peuvent renvoyer de 10 à 10 000 lignes ou métriques. Si tel était le cas, pour des requêtes particulièrement volumineuses, une seule alerte pourrait utiliser des dizaines de Mo de mémoire et Grafana manquerait de mémoire très rapidement.

Pour imprimer la $value variable dans le résumé, vous devez écrire quelque chose comme ceci :

CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ $value }}

Et cela ressemblerait à ceci :

CPU usage for instance1 has exceeded 80% for the last 5 minutes: [ var='A' labels={instance=instance1} value=81.234 ]

Ici, il var='A' fait référence à la requête instantanée avec l'ID de labels={instance=instance1} référence A, aux étiquettes et value=81.234 à l'utilisation moyenne du processeur au cours des 5 dernières minutes.

Si vous souhaitez imprimer une partie de la chaîne au lieu de la chaîne complète, utilisez la $values variable. Il contient les mêmes informations que$value, mais dans un tableau structuré, et il est beaucoup plus facile à utiliser que d'écrire une expression régulière correspondant exactement au texte souhaité.

La variable de valeurs

La $values variable est une table contenant les étiquettes et les valeurs à virgule flottante de toutes les requêtes et expressions instantanées, indexées par leurs ID de référence.

Pour imprimer la valeur de la requête instantanée avec l'ID de référence A :

CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "A" }}

Par exemple, à partir d'une alerte avec les libellés instance=server1 et d'une requête instantanée avec la valeur81.2345, ceci imprimerait :

CPU usage for instance1 has exceeded 80% for the last 5 minutes: 81.2345

Si la requête dans l'ID de référence A est une requête de plage plutôt qu'une requête instantanée, ajoutez une expression de réduction avec l'ID de référence B et remplacez-la par (index $values "A") (index $values "B") :

CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "B" }}

Fonctions

Les fonctions suivantes sont à votre disposition lors de la création de modèles d'étiquettes et d'annotations :

args

La args fonction traduit une liste d'objets en une carte avec les clés arg0, arg1, etc. Cela a pour but de permettre la transmission de plusieurs arguments aux modèles.

{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}

1 2

URL externe

La externalURL fonction renvoie l'URL externe du serveur Grafana.

{{ externalURL }}

https://example.com/grafana

GraphLink

La graphLink fonction renvoie le chemin d'accès à la vue graphique Explorez dans la version 10 de Grafana pour l'expression et la source de données données.

{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}

/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]

humaniser

La humanize fonction humanise les nombres décimaux.

{{ humanize 1000.0 }}

1k

humaniser 1024

Il humanize1024 fonctionne de manière similaire humanize mais utilise 1024 comme base au lieu de 1000.

{{ humanize1024 1024.0 }}

1ki

Humaniser la durée

La humanizeDuration fonction humanise une durée en secondes.

{{ humanizeDuration 60.0 }}

1m 0s

Pourcentage d'humanisation

La humanizePercentage fonction humanise une valeur de ratio par rapport à un pourcentage.

{{ humanizePercentage 0.2 }}

20%

Humaniser l'horodatage

La humanizeTimestamp fonction humanise un horodatage Unix.

{{ humanizeTimestamp 1577836800.0 }}

2020-01-01 00:00:00 +0000 UTC

match

La match fonction compare le texte à un modèle d'expression régulière.

{{ match "a.*" "abc" }}

true

Préfixe de chemin

La pathPrefix fonction renvoie le chemin du serveur Grafana.

{{ pathPrefix }}

/grafana

Tableau Link

La tableLink fonction renvoie le chemin d'accès à la vue tabulaire Explorez dans la version 10 de Grafana pour l'expression et la source de données données.

{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}

/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]

title

La title fonction met en majuscule le premier caractère de chaque mot.

{{ title "hello, world!" }}

Hello, World!

ToLower

La toLower fonction renvoie tout le texte en minuscules.

{{ toLower "Hello, world!" }}

hello, world!

ToupPper

La toUpper fonction renvoie tout le texte en majuscules.

{{ toUpper "Hello, world!" }}

HELLO, WORLD!

reReplaceAll

La reReplaceAll fonction remplace le texte correspondant à l'expression régulière.

{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}

example.com:8080