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.
# Utilisez votre espace de travail Grafana
'\$1 | Renvoie une liste de valeurs pour un champ en utilisant l'agrégation de termes et un filtre de requête Lucene spécifié. La requête utilisera la plage horaire actuelle du tableau de bord comme plage de temps pour la requête. |
Il existe une limite de taille par défaut de 500 pour les requêtes Terms. Pour définir une limite personnalisée, définissez la propriété de taille dans votre requête. Vous pouvez utiliser d'autres variables dans la requête. L'exemple de code suivant montre la définition de requête pour une variable nommée`$host`.
```
{"find": "terms", "field": "@hostname", "query": "@source:$source"}
```
Dans l'exemple précédent, nous utilisons une autre variable nommée `$source` dans la définition de la requête. Chaque fois que vous modifiez, à l'aide de la liste déroulante, la valeur actuelle de la `$source` variable, une mise à jour de la `$host` variable est initiée. Après la mise à jour, la `$host` variable contient uniquement les noms d'hôtes filtrés en fonction, dans ce cas, de la propriété du `@source` document.
Ces requêtes renvoient par défaut les résultats par ordre des termes (qui peuvent ensuite être triés alphabétiquement ou numériquement comme pour n'importe quelle variable). Pour produire une liste de termes triés par nombre de documents (une liste de valeurs supérieures à N), ajoutez une `orderBy` propriété de`doc_count`. Cela permet de sélectionner automatiquement un tri décroissant. L'utilisation `asc` avec doc\$1count (une liste inférieure à N) peut être effectuée en configurant`order: "asc"`, mais elle est déconseillée car cela augmente l'erreur sur le nombre de documents. Pour conserver les termes dans l'ordre du nombre de documents, définissez la liste déroulante de **tri** de la variable sur **Désactivé**. Vous pouvez également toujours utiliser **Alphabétique** pour les trier à nouveau.
```
{"find": "terms", "field": "@hostname", "orderBy": "doc_count"}
```
### Utilisation de variables dans les requêtes
`Exemple : @hostname : \$1hostname
+ `[[varname]]`Exemple : @hostname : [[hostname]]
Pourquoi de deux manières ? La première syntaxe est plus facile à lire et à écrire, mais elle ne permet pas d'utiliser une variable au milieu d'un mot. Lorsque les options *Multi-valeurs* ou *Inclure toutes les valeurs* sont activées, Grafana convertit les étiquettes du texte brut en une condition compatible avec Lucene.
Dans l'exemple précédent, nous avons une requête Lucene qui filtre les documents en fonction de la `@hostname` propriété à l'aide d'une variable nommée. `$hostname` Il utilise également une variable dans la zone de saisie du groupe *Termes* par champ. Cela vous permet d'utiliser une variable pour modifier rapidement le mode de regroupement des données.
## Annotations
[${__range_s}s]) != )
Regex:
```
### Utilisation d'`$__rate_interval`une variable
`Exemple : rate (http\$1requests\$1total \$1job=\$1"\$1job "\$1 [5m])
+ `[[varname]]`Exemple : rate (http\$1requests\$1total \$1job=\$1 "[[job]]"\$1 [5m])
Pourquoi de deux manières ? La première syntaxe est plus facile à lire et à écrire mais ne permet pas d'utiliser une variable au milieu d'un mot. Lorsque les options *Multi-valeurs* ou *Inclure toutes les valeurs* sont activées, Grafana convertit les étiquettes du texte brut en une chaîne compatible avec les regex. Ce qui signifie que vous devez utiliser `=~` au lieu de`=`.
## Annotations
`Exemple : apps.frontend. \$1server.requests.count
+ `${varname}`Exemple : apps.frontend. \$1 \$1server\$1 .requests.count
Pourquoi de deux manières ? La première syntaxe est plus facile à lire et à écrire mais ne permet pas d'utiliser une variable au milieu d'un mot. Utilisez la seconde syntaxe dans des expressions telles que`my.server${serverNumber}.count`.
### Utilisation de variables dans les requêtes de balises
`Exemple : `metric.label.$metric_label`
+ `[[varname]]`Exemple : `metric.label.[[metric_label]]`
Pourquoi de deux manières ? La première syntaxe est plus facile à lire et à écrire mais ne permet pas d'utiliser une variable au milieu d'un mot. Lorsque les options *Multi-valeurs* ou *Inclure toutes les valeurs* sont activées, Grafana convertit les étiquettes du texte brut en une chaîne compatible avec les regex, ce qui signifie que vous devez utiliser au lieu de. `=~` `=`
## Annotations
`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
atimestamp time,
aint value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in($hostname)
ORDER BY atimestamp
```
`[[varname]]`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
atimestamp as time,
aint as value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
ORDER BY atimestamp
```
#### Désactiver les guillemets pour les variables à valeurs multiples
`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
UNIX_TIMESTAMP(atimestamp) as time,
aint as value,
avarchar as metric
FROM my_table
WHERE $__timeFilter(atimestamp) and hostname in($hostname)
ORDER BY atimestamp ASC
```
`[[varname]]`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
UNIX_TIMESTAMP(atimestamp) as time,
aint as value,
avarchar as metric
FROM my_table
WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
ORDER BY atimestamp ASC
```
#### Désactiver les guillemets pour les variables à valeurs multiples
'\$1 | Renvoie une liste de valeurs pour un champ en utilisant l'agrégation de termes et un filtre de requête Lucene spécifié. La requête utilisera la plage horaire actuelle du tableau de bord comme plage de temps pour la requête. |
Il existe une limite de taille par défaut de 500 pour les requêtes Terms. Pour définir une limite personnalisée, définissez la propriété de taille dans votre requête. Vous pouvez utiliser d'autres variables dans la requête. L'exemple de code suivant montre la définition de requête pour une variable nommée`$host`.
```
{"find": "terms", "field": "@hostname", "query": "@source:$source"}
```
Dans l'exemple précédent, nous utilisons une autre variable nommée `$source` dans la définition de la requête. Chaque fois que vous modifiez, via la liste déroulante, la valeur actuelle de la `$source` variable, une mise à jour de la `$host` variable est initiée. Après la mise à jour, la `$host` variable contient uniquement les noms d'hôtes filtrés en fonction, dans ce cas, de la propriété du `@source` document.
Ces requêtes renvoient par défaut les résultats par ordre des termes (qui peuvent ensuite être triés alphabétiquement ou numériquement comme pour n'importe quelle variable). Pour produire une liste de termes triés par nombre de documents (une liste de valeurs supérieures à N), ajoutez une `orderBy` propriété de`doc_count`. Cela permet de sélectionner automatiquement un tri décroissant. L'utilisation `asc` avec doc\$1count (une liste inférieure à N) peut être effectuée en configurant`order: "asc"`, mais elle est déconseillée car cela augmente l'erreur sur le nombre de documents. Pour conserver les termes dans l'ordre du nombre de documents, définissez la liste déroulante **Trier** de la variable sur **Désactivé**. Vous pouvez également toujours utiliser **Alphabétique** pour les trier à nouveau.
```
{"find": "terms", "field": "@hostname", "orderBy": "doc_count"}
```
#### Utilisation de variables dans les requêtes
`Exemple : @hostname : \$1hostname
+ `[[varname]]`Exemple : @hostname : [[hostname]]
Pourquoi de deux manières ? La première syntaxe est plus facile à lire et à écrire, mais elle ne permet pas d'utiliser une variable au milieu d'un mot. Lorsque les options *Multi-valeurs* ou *Inclure toutes les valeurs* sont activées, Grafana convertit les étiquettes du texte brut en une condition compatible avec Lucene.
Dans l'exemple précédent, nous avons une requête Lucene qui filtre les documents en fonction de la `@hostname` propriété à l'aide d'une variable nommée. `$hostname` Il utilise également une variable dans la zone de saisie du groupe *Termes* par champ. Cela vous permet d'utiliser une variable pour modifier rapidement le mode de regroupement des données.
### Annotations
`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
atimestamp as time,
aint as value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in($hostname)
ORDER BY atimestamp ASC
```
`[[varname]]`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
atimestamp as time,
aint as value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
ORDER BY atimestamp ASC
```
#### Désactiver les guillemets pour les variables à valeurs multiples
`(N'importe quel chemin métrique peut être spécifié)
## Clés de légende
` des variables dans le champ « Alias par ». Exemple avec expression métrique = `avg:system.load.5{*}` : Entrée de champ « Alias par » : entrée de champ `$1: $2 seconds` RegExp « Alias » : `avg:(.+)\.(\d)` Résultat : `system.load: 5 seconds`
+ `$0`À utiliser pour obtenir l'expression complète. Exemple avec expression métrique = `datadog.dogstatsd.packet.count{*}` : Entrée de champ « Alias par » : entrée de champ `Expression: $0` RegExp « Alias » : `DOGstatsd\.(.*)\.(.*){\*}/i` Résultat : `Expression: datadog.dogstatsd.packet.count{*}`
Remarque : vous obtiendrez un message d'erreur en utilisant un numéro de groupe inexistant.
#### Arithmétique métrique
Server: $__nr_server Metric: $__nr_metric
```
### Modèles et variables
applications
```
Liste des métriques disponibles pour une application :
```
applications/{application_id}/metrics
```
### Macros NRQL
SELECT average(value) FROM $event_template_variable
$__timeFilter TIMESERIES
```
Pour plus d'informations sur l'utilisation des macros et des variables de modèle, consultez la section d'aide de l'éditeur.
### Événements d'alerte
`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
"atimestamp" as time,
"aint" as value
FROM table
WHERE $__timeFilter("atimestamp") AND "hostname" IN('$hostname')
ORDER BY "atimestamp" ASC
```
`[[varname]]`Exemple avec une variable de modèle nommée `hostname` :
```
SELECT
"atimestamp" as time,
"aint" as value
FROM table
WHERE $__timeFilter("atimestamp") AND "hostname" IN('[[hostname]]')
ORDER BY atimestamp ASC
```
# Connectez-vous à une source de données Salesforce
PASSWORD NO FORCE_FIRST_PASSWORD_CHANGE;
```
Ensuite, autorisez l'utilisateur à connecter le système via des clients tels que Grafana avec les éléments suivants :
```
ALTER USER ENABLE CLIENT CONNECT;
```
Enfin, donnez à l'utilisateur l'accès aux vues, tables et schémas nécessaires.
```
ALTER USER GRANT ROLE PUBLIC;
GRANT SELECT ON SCHEMA TO ;
```
**Autorisations au niveau de l'utilisateur**
Limitez l'accès à SAP HANA en cliquant sur l'onglet Autorisations de la page de configuration de la source de données pour activer les autorisations de source de données. Sur la page des autorisations, les administrateurs peuvent activer les autorisations et restreindre les autorisations de requête à des utilisateurs et à des équipes spécifiques.
## Éditeur de requêtes
)`— Applique la plage de temps de Grafana à la colonne spécifiée lorsqu'elle est utilisée dans la requête brute. Applicable aux colonnes date/timestamp/long temporelles.
+ `$__timeFilter(, )`— Comme ci-dessus. Mais donne la possibilité de spécifier le format de la time\$1column stockée dans la base de données.
+ `$__timeFilter(, "epoch", )`— Comme ci-dessus, mais peut être utilisé lorsque votre colonne de temps est en époque. Le format peut être l'un des suivants : « s », « ms » et « ns ».
+ `$__fromTimeFilter()`— Comme ci-dessus, mais peut être utilisé lorsque votre colonne de temps est en époque. Le format peut être l'un des suivants : « s », « ms » et « ns ».
+ `$__fromTimeFilter(, )`— Identique à ci-dessus, mais possibilité de spécifier comparison\$1predicate.
+ `$__fromTimeFilter(, )`— Comme ci-dessus, mais possibilité de spécifier le format de la colonne de temps.
+ `$__fromTimeFilter(, , )`— Identique à ci-dessus, mais possibilité de spécifier comparison\$1predicate.
+ `$__toTimeFilter()`— Renvoie la condition temporelle basée sur le temps de grafana sur un champ temporel.
+ `$__toTimeFilter(, )`— Identique à ci-dessus, mais possibilité de spécifier comparison\$1predicate.
+ `$__toTimeFilter(, )`— Comme ci-dessus, mais possibilité de spécifier le format de la colonne de temps.
+ `$__toTimeFilter(, )`— Identique à ci-dessus, mais possibilité de spécifier comparison\$1predicate.
+ `$__timeGroup(, )`— Étend la colonne de temps en groupes d'intervalles. Applicable aux colonnes date/timestamp/long temporelles.
**macro \$1\$1\$1timeFilter ()**
L'exemple suivant explique la `$__timeFilter()` macro :
```
- In the following example, the query
select ts, temperature from weather where $__timeFilter(ts)
--- will be translated into
select ts, temperature from weather where ts > '2021-02-24T12:52:48Z' AND ts < '2021-03-24T12:52:48Z'
--- where you can see the grafana dashboard's time range is applied to the column ts in the query.
```
**macro \$1\$1\$1timeFilter (,)**
Dans certains cas, les colonnes temporelles de la base de données sont stockées dans des formats personnalisés. L'exemple suivant explique la `$__timeFilter(, )` macro, qui permet de filtrer les horodatages personnalisés en fonction du sélecteur de temps de Grafana :
```
SELECT TO_TIMESTAMP("TS",'YYYYMMDDHH24MISS') AS METRIC_TIME , "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TS","YYYYMMDDHH24MISS") -- TS is in 20210421162012 format
SELECT TO_TIMESTAMP("TS",'YYYY-MON-DD') AS METRIC_TIME , "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TS","YYYY-MON-DD") -- TS is in 2021-JAN-15 format
```
Dans la macro, le format peut être l'un des formats HANA valides correspondant à votre colonne d'horodatage. Par exemple, `YYYYMMDDHH24MISS` est un format valide lorsque vos données sont stockées dans un `20210421162012` format.
**macro \$1\$1\$1timeFilter (, « époque »)**
Dans certains cas, les horodatages sont stockés sous forme d'horodatages d'époque dans votre base de données. L'exemple suivant explique la `$__timeFilter(, "epoch" )` macro qui permet de filtrer les horodatages d'époque en fonction du sélecteur de temps de Grafana. Dans la macro, le format peut être ms, s ou ns. S'il n'est pas spécifié, s sera traité comme format par défaut.
```
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP") AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch") -- Example : TIMESTAMP field stored in epoch_second format 1257894000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP") AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","s") -- Example : TIMESTAMP field stored in epoch_second format 1257894000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ms") -- Example : TIMESTAMP field stored in epoch_ms format 1257894000000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000000000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ns") -- Example : TIMESTAMP field stored in epoch_nanoseconds format 1257894000000000000
```
Au lieu d'utiliser le troisième argument du \$1\$1\$1timeFilter, vous pouvez utiliser l'un des arguments epoch\$1s, epoch\$1ms ou epoch\$1ns comme deuxième argument.
```
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ms")
-- is same as
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch_ms")
```
**Macros \$1\$1\$1 fromTimeFilter () et \$1\$1\$1 toTimeFilter ()**
La `$__fromTimeFilter()` macro s'étend à une condition sur un champ temporel en fonction du temps du sélecteur de temps de Grafana.
Cela accepte trois paramètres. Le premier paramètre est le nom du champ horaire. Vous pouvez passer comparison\$1predicate ou le format de la colonne de temps comme deuxième argument. Si vous souhaitez transmettre les deux, le format est le deuxième paramètre et utilisez comparison\$1predicate comme troisième paramètre.
****Si le format n'est pas spécifié, le plugin supposera que la colonne de temps est de timestamp/date type. Si votre colonne d'heure est stockée dans un format autre que l'horodatage/la date, transmettez le format comme deuxième argument. peut être l'un des formats epoch\$1s, epoch\$1ms, epoch\$1ns ou tout autre format personnalisé tel que. YYYY-MM-DD
****paramètre optionnel. S'il n'est pas transmis, le plugin utilisera > comme prédicat de comparaison. peut être l'un des suivants =, \$1 =, <>, <, <=, >, >=
`$__toTimeFilter()`fonctionne de la même manière que \$1\$1\$1 fromTimeFilter (). Au lieu d'utiliser Grafana de temps en temps, il l'utilisera au fil du temps. Le prédicat de comparaison par défaut sera également <.
**\$1\$1\$1timeGroup (,)**
Par exemple, la macro \$1\$1\$1timeGroup (timecol,1h) est étendue à SERIES\$1ROUND (« timecol », « INTERVAL 1 HOUR ») dans la requête.
L'exemple suivant explique `$__timeGroup(, ) macro.`
```
SELECT $__timeGroup(timestamp,1h), "user", sum("value") as "value"
FROM "salesdata"
WHERE $__timeFilter("timestamp")
GROUP BY $__timeGroup(timestamp,1h), "user"
ORDER BY $__timeGroup(timestamp,1h) ASC
```
Ceci est traduit dans la requête suivante où `$__timeGroup(timestamp,1h)` est développé en`SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR')`.
```
SELECT SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR') as "timestamp", "user", sum("value") as "value"
FROM "salesdata"
WHERE "timestamp" > '2020-01-01T00:00:00Z' AND "timestamp" < '2020-01-01T23:00:00Z'
GROUP BY SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR'), "user"
ORDER BY "timestamp" ASC
```
**Note**
Lorsque vous utilisez la macro group by avec \$1\$1\$1timeGroup, assurez-vous que vos champs de sélection et de tri par portent le même nom que votre groupe par champ. Dans le cas contraire, HANA risque de ne pas reconnaître la requête.
Si vous ne voulez pas coder en dur l'intervalle dans la fonction \$1\$1\$1timeGroup (), vous pouvez laisser Grafana s'en charger en spécifiant \$1\$1\$1interval comme intervalle. Grafana calculera cet intervalle à partir de la plage de temps du tableau de bord. Exemple de requête :
```
SELECT $__timeGroup(timestamp, $__interval), sum("value") as "value"
FROM "salesdata"
WHERE $__timeFilter("timestamp")
GROUP BY $__timeGroup(timestamp, $__interval)
ORDER BY $__timeGroup(timestamp, $__interval) ASC
```
Cette requête est traduite dans la requête suivante en fonction de la plage horaire du tableau de bord.
```
SELECT SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE'), sum("value") as "value"
FROM "salesdata"
WHERE "timestamp" > '2019-12-31T23:09:14Z' AND "timestamp" < '2020-01-01T23:17:54Z'
GROUP BY SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE')
ORDER BY SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE') ASC
```
### Alerte
FROM
```
Dans l'exemple suivant, une table comporte quatre champs appelés nom d'utilisateur, âge, ville et rôle. Ce tableau ne contient aucun champ horaire. Nous voulons avertir lorsque le nombre d'utilisateurs ayant le rôle de développeur est inférieur à trois.
```
SELECT TO_TIMESTAMP('${__to:date}'), count(*) as "count" FROM (
SELECT 'John' AS "username", 32 AS "age", 'Chennai' as "city", 'dev' as "role" FROM dummy
UNION ALL SELECT 'Jacob' AS "username", 32 AS "age", 'London' as "city", 'accountant' as "role" FROM dummy
UNION ALL SELECT 'Ali' AS "username", 42 AS "age", 'Delhi' as "city", 'admin' as "role" FROM dummy
UNION ALL SELECT 'Raja' AS "username", 12 AS "age", 'New York' as "city", 'ceo' as "role" FROM dummy
UNION ALL SELECT 'Sara' AS "username", 35 AS "age", 'Cape Town' as "city", 'dev' as "role" FROM dummy
UNION ALL SELECT 'Ricky' AS "username", 25 AS "age", 'London' as "city", 'accountant' as "role" FROM dummy
UNION ALL SELECT 'Angelina' AS "username", 31 AS "age", 'London' as "city", 'cxo' as "role" FROM dummy
) WHERE "role" = 'dev'
```
# Se connecter à une source ServiceNow de données
`Exemple avec une variable de modèle nommée `hostname` :
`[[varname]]`Exemple avec une variable de modèle nommée `hostname` :
## Alerte
,
,
,
<...>
from
where
$__timeFilter() // predefined where clause for time range
and $ = 1 // custom variables start with dollar sign
```
#### Format de requête SQL pour les séries chronologiques groupées par intervalle
,
,
from
where
$__timeFilter() // predefined where clause for time range
and $ = 1 // custom variables start with dollar sign
group by
```
#### Format de requête SQL pour les tables
, // optional if result format option is table
from
where
$__timeFilter(time_column) // macro for time range, optional if format as option is table
and $ = 1 // custom variables start with dollar sign
```
### Étape 3 : Création et utilisation de variables de modèle
from
WHERE column >= '$variable'
```
L'exemple suivant montre l'utilisation de variables à valeurs multiples dans une requête.
```
select
from
WHERE regexp '${variable:regex}'
```
#### Utilisation de la source de données Snowflake pour créer des variables
`. Par exemple `-1w`. [L'unité de temps](https://docs.splunk.com/Documentation/Splunk/latest/Search/Specifytimemodifiersinyoursearch) peut être`s, m, h, d, w, mon, q, y`.
#### Mode de recherche de variables
) : ts (...)
**Remarques**
+ Le s à la fin de chaque type de requête est facultatif.
+ Support pour toutes les minuscules. Vous pouvez utiliser des tagnames ou des tagNames, mais pas des TAGNAMES.
+ L'utilisation d'espaces autour du : est facultative
**WARNING**
`Multi-value`et ne `Include All option` sont actuellement pas pris en charge par le plugin Wavefront.
#### Utilisation de variables de modèle
` à la fin. Pour consulter les périodes fiscales, utilisez `fQ (fiscal quarter)` et unités de `fy (fiscal year)` temps.
L'opérateur plus vous permet d'avancer dans le temps par rapport au présent. Par exemple, vous pouvez utiliser cette fonctionnalité pour examiner les données prédites dans le futur.
Le tableau suivant fournit des exemples de plages relatives.
| Exemple de plage relative | De | À |
| --- | --- | --- |
| Les 5 dernières minutes | `now-5m` | `now` |
| Jusqu'à présent | `now/d` | `now` |
| Cette semaine | `now/w` | `now/w` |
| Jusqu'à présent cette semaine | `now/w` | `now` |
| Ce mois-ci | `now/M` | `now/M` |
| Ce mois-ci, jusqu'à présent | `now/M` | `now` |
| Mois précédent | `now-1M/M` | `now-1M/M` |
| Cette année jusqu'à présent | `now/Y` | `now` |
| Cette année | `now/Y` | `now/Y` |
| Exercice financier précédent | `now-1y/fy` | `now-1y/fy` |
**Note**
Grafana Alerting ne prend pas en charge les syntaxes suivantes :
`now+n`pour les futurs horodatages.
`now-1n/n`pour le *début de n jusqu'à la fin de n*, car il s'agit d'un horodatage absolu.
**Contrôles de plage de temps courants**
Les commandes horaires du tableau de bord et du panneau ont une interface utilisateur commune. Ce qui suit décrit les contrôles de plage de temps courants.
+ La plage horaire actuelle, également appelée *sélecteur de temps*, indique la plage de temps actuellement affichée dans le tableau de bord ou le panneau que vous consultez. Passez votre curseur sur le champ pour voir les horodatages exacts de la plage et leur source (telle que l'heure du navigateur local). Cliquez sur la *plage horaire actuelle* pour la modifier. Vous pouvez modifier l'heure actuelle en utilisant une *plage de temps relative*, telle que les 15 dernières minutes, ou une plage de temps absolue, telle que `2020-05-14 00:00:00` à`2020-05-15 23:59:59`.
+ La **plage de temps relative** peut être sélectionnée dans la liste des **plages de temps relatives**. Vous pouvez filtrer la liste à l'aide du champ de saisie situé en haut. Quelques exemples de plages horaires incluent les *30 dernières minutes*, les *12 dernières heures*, les *7 derniers jours*, les *2 dernières années*, *hier*, *avant-hier*, *ce jour la semaine dernière*, *aujourd'hui jusqu'à présent*, *cette semaine jusqu'à présent* et *Ce mois jusqu'à présent*.
+ La **plage de temps absolue** peut être définie de deux manières : en saisissant des valeurs temporelles exactes ou relatives dans les champs **De** et **à** et en cliquant sur **Appliquer la plage de temps**, ou en cliquant sur une date ou une plage de dates dans le calendrier affiché lorsque vous cliquez sur le champ **De ou **de**** fin. Pour appliquer vos sélections, cliquez sur **Appliquer la plage horaire**. Vous pouvez également choisir parmi une liste des plages temporelles absolues récemment utilisées.
+ La **plage de temps semi-relative** peut être sélectionnée dans les paramètres de plage de temps absolus. Par exemple, pour afficher l'activité depuis une date précise, vous pouvez choisir une heure absolue pour l'heure de début et une heure relative (telle que`now`) pour l'heure de fin.
En utilisant une plage de temps semi-relative, au fil du temps, votre tableau de bord effectue automatiquement et progressivement un zoom arrière pour afficher plus d'historique et moins de détails. Au même rythme, à mesure que la haute résolution des données diminue, les tendances historiques sur l'ensemble de la période deviendront plus claires.
**Note**
Les alertes ne prennent pas en charge les plages temporelles semi-relatives.
+ **Effectuez un zoom** arrière en sélectionnant l'icône de zoom arrière (ou en utilisant Cmd\$1Z ou Ctrl\$1Z comme raccourci clavier). Cela augmente la vue, en affichant une plage de temps plus large dans la visualisation du tableau de bord ou du panneau.
+ **Zoomez en** sélectionnant la plage de temps que vous souhaitez afficher sur le graphique de la visualisation.
**Note**
Le zoom avant ne s'applique qu'aux visualisations graphiques.
**Actualiser les tableaux de bord**
Cliquez sur l'icône **Actualiser le tableau de bord** pour exécuter immédiatement chaque requête sur le tableau de bord et actualiser les visualisations. Grafana annule toutes les demandes en attente lorsque vous déclenchez une actualisation.
Par défaut, Grafana n'actualise pas automatiquement le tableau de bord. Les requêtes sont exécutées selon leur propre calendrier en fonction des paramètres du panneau. Toutefois, si vous souhaitez actualiser régulièrement le tableau de bord, cliquez sur la flèche vers le bas à côté de l'icône **Actualiser le tableau de bord**, puis sélectionnez un intervalle d'actualisation.
**Contrôlez la plage horaire à l'aide d'une URL**
Vous pouvez contrôler la plage horaire d'un tableau de bord en fournissant les paramètres de requête suivants dans l'URL du tableau de bord.
+ `from`définit la limite inférieure de la plage de temps, spécifiée en ms epoch ou en [temps relatif.](#v10-dash-setting-dashboard-time-range)
+ `to`définit la limite supérieure de la plage de temps, spécifiée en ms epoch ou en temps relatif.
+ `time`et `time.window` définit une plage de temps allant de `time-time.window/2` à`time+time.window/2`. Les deux paramètres doivent être spécifiés en ms. Par exemple, les `?time=1500000000000&time.window=10000` résultats indiquent une plage de temps de 10 s comprise entre 1499999995000 et 1500000005000.
# Création de tableaux de bord
bouton **Restaurer à la version** dans la vue des différences. Si vous sélectionnez l'une de ces options, vous serez invité à confirmer la restauration.
Après la restauration d'une version précédente, une nouvelle version sera créée contenant exactement les mêmes données que la version précédente, mais avec un numéro de version différent. Cela est indiqué dans la **colonne Notes** de la ligne de la nouvelle version du tableau de bord. Cela garantit que les versions précédentes de votre tableau de bord ne sont pas affectées par la modification.
# Gestion des liens du tableau de bord
.
La playlist affiche chaque tableau de bord pendant la durée spécifiée dans le `Interval` champ, définie lors de la création ou de la modification d'une playlist. Après le démarrage d'une playlist, vous pouvez la contrôler à l'aide de la barre de navigation en haut de votre écran.
| Mode | Description |
| --- | --- |
| Mode normal | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/v10-dash-managing-playlists.html) |
| Mode TV | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/v10-dash-managing-playlists.html) |
| Mode TV (avec panneaux à ajustement automatique) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/v10-dash-managing-playlists.html) |
| Mode kiosque | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/v10-dash-managing-playlists.html) |
| Mode kiosque (avec panneaux à ajustement automatique) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/v10-dash-managing-playlists.html) |
**Contrôler une playlist**
Vous pouvez contrôler une playlist en mode **Normal** ou **TV** après son lancement, à l'aide de la barre de navigation en haut de votre écran. Appuyez sur la `Esc` touche de votre clavier pour arrêter la playlist.
| Button | Action |
| --- | --- |
| Suivant (double flèche droite) | Passe au tableau de bord suivant. |
| Retour (flèche gauche) | Retourne au tableau de bord précédent. |
| Stop (carré) | Termine la playlist et passe au tableau de bord actuel. |
| Mode d'affichage du cycle (icône du moniteur) | Fait pivoter l'affichage des tableaux de bord dans différents modes d'affichage. |
| Plage horaire | Affiche les données dans un intervalle de temps. Il peut être configuré pour afficher les 5 dernières minutes jusqu'à il y a 5 ans, ou une plage de temps personnalisée à l'aide de la flèche vers le bas. |
| Actualiser (flèche circulaire) | Recharge le tableau de bord pour afficher les données actuelles. Il peut être configuré pour se recharger automatiquement toutes les 5 secondes à 1 jour, à l'aide de la flèche déroulante. |
## Création d'une playlist
.
**Exemples**
Les variables sont répertoriées dans des listes déroulantes en haut de l'écran. Sélectionnez différentes variables pour voir comment les visualisations changent.
Pour voir les paramètres des variables, accédez à **Paramètres du tableau de bord > Variables**. Cliquez sur une variable dans la liste pour voir ses paramètres.
Les variables peuvent être utilisées dans les titres, les descriptions, les panneaux de texte et les requêtes. Les requêtes dont le texte commence par `$` sont des modèles. Tous les panneaux ne comporteront pas de modèles de requêtes.
**Bonnes pratiques variables**
+ Les listes déroulantes de variables sont affichées dans l'ordre dans lequel elles sont répertoriées dans la liste des variables dans les **paramètres du tableau de bord.**
+ Placez les variables que vous allez souvent modifier en haut, afin qu'elles apparaissent en premier (à l'extrême gauche du tableau de bord).
+ Les variables présélectionnent par défaut la valeur la plus élevée dans la liste déroulante. Si vous souhaitez plutôt choisir une valeur vide, modifiez les paramètres des variables comme suit :
1. Cochez la **case Tout inclure**.
1. Dans le champ **Personnaliser toutes les valeurs**, entrez la valeur`+`.
**Topics**
+ [Ajouter et gérer des variables](v10-dash-variable-add.md)
+ [Inspecter les variables](v10-dash-variable-add-inspect.md)
+ [Syntaxe variable](v10-dash-variable-syntax.md)
# Ajouter et gérer des variables
[ ^ " ] + ) |chip=" (?[ ^ " ] + )/g
```
Cela produirait la liste déroulante suivante :
```
Display Name Value
------------ -------------------------
enp216s0f0np0 0000:d7:00_0_0000:d8:00_0
enp216s0f0np1 0000:d7:00_0_0000:d8:00_1
enp216s0f0np2 0000:d7:00_0_0000:d8:00_2
enp216s0f0np3 0000:d7:00_0_0000:d8:00_3
```
Seuls `text` les noms de groupes de `value` capture et de capture sont pris en charge.
# Inspecter les variables
}`— Ce format vous permet de mieux contrôler la façon dont Grafana interprète les valeurs. Pour plus d'informations, consultez la section *Options avancées de format de variable*, à la suite de cette liste.
+ `[[varname]]`— Ne pas utiliser. Cette syntaxe est ancienne et est obsolète. Il sera supprimé dans une future version.
Avant que les requêtes ne soient envoyées à votre source de données, la requête est *interpolée*, ce qui signifie que la variable est remplacée par sa valeur actuelle. Pendant l'interpolation, la valeur de la variable peut être *évitée* afin de se conformer à la syntaxe du langage de requête et à l'endroit où elle est utilisée. Par exemple, une variable utilisée dans une expression regex dans une requête InfluxDB ou Prometheus sera échappée à l'expression régulière.
**Options avancées de format variable**
Le formatage de l'interpolation variable dépend de la source de données, mais dans certains cas, vous souhaiterez peut-être modifier le formatage par défaut.
Par exemple, la source de données MySQL par défaut consiste à joindre plusieurs valeurs séparées par des virgules par des guillemets :. `'server01','server02'` Dans certains cas, vous souhaiterez peut-être avoir une chaîne séparée par des virgules sans guillemets :. `server01,server02` Vous pouvez y parvenir grâce aux options avancées de mise en forme des variables répertoriées ci-dessous.
**Syntaxe générale**
Syntaxe : `${var_name:option}`
Si une option de mise en forme non valide est spécifiée, `glob` c'est l' default/fallback option.
**CSV**
Formate les variables comportant plusieurs valeurs sous forme de chaîne séparée par des virgules.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:csv}'
Interpolation result: 'test1,test2'
```
**Distribué - OpenTSDB**
Formate les variables avec plusieurs valeurs dans un format personnalisé pour OpenTSDB.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:distributed}'
Interpolation result: 'test1,servers=test2'
```
**Devis double**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `\"` et `"` met chaque valeur entre guillemets avec. `"`
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:doublequote}'
Interpolation result: '"test1","test2"'
```
**Globe - Graphite**
Formate les variables comportant plusieurs valeurs dans un glob (pour les requêtes Graphite).
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:glob}'
Interpolation result: '{test1,test2}'
```
**JSON**
Formate les variables comportant plusieurs valeurs sous forme de chaîne séparée par des virgules.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:json}'
Interpolation result: '["test1", "test2"]'
```
**Lucene - Elasticsearch**
Formate les variables avec plusieurs valeurs au format Lucene pour Elasticsearch.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:lucene}'
Interpolation result: '("test1" OR "test2")'
```
**Code en pourcentage**
Formate les variables à valeurs uniques et multiples à utiliser dans les paramètres d'URL.
```
servers = [ 'foo()bar BAZ', 'test2' ]
String to interpolate: '${servers:percentencode}'
Interpolation result: 'foo%28%29bar%20BAZ%2Ctest2'
```
**Tuyau**
Formate les variables comportant plusieurs valeurs dans une chaîne séparée par des tubes.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:pipe}'
Interpolation result: 'test1.|test2'
```
**Brut**
Désactive le formatage spécifique à la source de données, tel que les guillemets simples dans une requête SQL.
```
servers = [ 'test.1', 'test2' ]
String to interpolate: '${var_name:raw}'
Interpolation result: 'test.1,test2'
```
**Regex**
Formate les variables comportant plusieurs valeurs dans une chaîne regex.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:regex}'
Interpolation result: '(test1\.|test2)'
```
**Devis unique**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `\'` et `'` met chaque valeur entre guillemets avec. `'`
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:singlequote}'
Interpolation result: "'test1','test2'"
```
**Chaîne SQL**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `''` et `'` met chaque valeur entre guillemets avec. `'`
```
servers = [ "test'1", "test2" ]
String to interpolate: '${servers:sqlstring}'
Interpolation result: "'test''1','test2'"
```
**Text**
Formate les variables à valeurs uniques et multiples dans leur représentation textuelle. Pour une seule variable, elle renverra simplement la représentation textuelle. Pour les variables à valeurs multiples, elle renverra la représentation textuelle combinée avec`+`.
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:text}'
Interpolation result: "test1 + test2"
```
**Paramètres Query (Requête)**
Formate les variables à valeurs uniques et multiples dans leur représentation des paramètres de requête. Exemple : `var-foo=value1&var-foo=value2`
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:queryparam}'
Interpolation result: "var-servers=test1&var-servers=test2"
```
# Evaluation de l'utilisation du tableau
[${__range_s}s]) != )
```
**Sources de données spéciales**
**Grafana inclut également trois sources de données spéciales : **Grafana**, **Mixed** et Dashboard.** Pour de plus amples informations, veuillez consulter [Connexion aux sources de données](AMG-data-sources.md).
## Naviguez dans l'onglet de requête
numéro = numéro
+ Série de numéros = série
+ Série = série
Comme les expressions fonctionnent avec plusieurs séries ou nombres représentés par une seule variable, les opérations binaires effectuent également une union (jointure) entre les deux variables. Cela se fait sur la base des étiquettes d'identification associées à chaque série ou numéro individuel.
Ainsi, si vous avez des numéros avec des étiquettes comme `{host=web01}` in `$A` et un autre numéro `$B` avec les mêmes étiquettes, l'opération est effectuée entre ces deux éléments au sein de chaque variable, et le résultat partagera les mêmes étiquettes. Les règles de comportement de ce syndicat sont les suivantes :
+ Un article sans étiquette s'associera à quoi que ce soit.
+ Si `$A` les `$B` deux ne contiennent qu'un seul article (une série ou un numéro), ils se joindront.
+ Si les étiquettes correspondent exactement, elles se joindront.
+ Si les étiquettes sont un sous-ensemble des autres, par exemple si un élément `$A` est étiqueté `{host=A,dc=MIA}` et qu'un élément `$B` est étiqueté, `{host=A}` elles se joindront.
+ Si dans une variable, par exemple, `$A` il existe des clés de balise différentes pour chaque élément, le comportement de jointure n'est pas défini.
Les opérateurs relationnels et logiques renvoient 0 pour faux, 1 pour vrai.
**Fonctions mathématiques**
Bien que la plupart des fonctions existent dans les propres opérations d'expression, l'opération mathématique comporte certaines fonctions similaires aux opérateurs mathématiques ou aux symboles. Lorsque les fonctions peuvent prendre des nombres ou des séries, le même type que l'argument sera renvoyé. Lorsqu'il s'agit d'une série, l'opération est effectuée pour la valeur de chaque point de la série.
*abdos*
abs renvoie la valeur absolue de son argument qui peut être un nombre ou une série. Par exemple, `abs(-1)` ou `abs($A)`.
*is\$1inf*
is\$1inf prend un nombre ou une série et renvoie `1` des `Inf` valeurs (négatives ou positives) et `0` d'autres valeurs. Par exemple `is_inf($A)`.
**Note**
Si vous devez vérifier spécifiquement l'infini négatif par exemple, vous pouvez effectuer une comparaison comme`$A == infn()`.
*is\$1nan*
is\$1nan prend un nombre ou une série et renvoie `1` des `NaN` valeurs et `0` d'autres valeurs. Par exemple `is_nan($A)`. Cette fonction est requise pour cette vérification car elle n'`NaN`est pas égale à`NaN`.
*est\$1nul*
is\$1null prend un nombre ou une série et renvoie `1` des `null` valeurs et `0` d'autres valeurs. Par exemple `is_null($A)`.
*is\$1number*
is\$1number prend un nombre ou une série et renvoie toutes `1` les valeurs réelles et `0` les autres valeurs (qui sont`null`, `Inf+``Inf-`, et`NaN`). Par exemple `is_number($A)`.
*journal*
Log renvoie le logarithme naturel de son argument, qui peut être un nombre ou une série. Si la valeur est inférieure à 0, `NaN` est renvoyée. Par exemple, `log(-1)` ou `log($A)`.
*inf, infn, nan et null*
Les fonctions inf, infn, nan et null renvoient toutes une seule valeur du nom. Ils existent principalement pour les tests. Exemple: `null()`.
*round*
Round renvoie une valeur entière arrondie. Par exemple, `round(3.123)` ou `round($A)`.
*ceil*
Ceil arrondit le nombre à la valeur entière la plus proche. Par exemple, `ceil(3.123)` renvoie `4`.
*floor*
Floor arrondit le nombre à la valeur entière la plus proche. Par exemple,`floor(3.123`) renvoie`3`.
**Réduire**
Reduce prend une ou plusieurs séries chronologiques renvoyées par une requête ou une expression et transforme chaque série en un seul numéro. Les étiquettes de la série chronologique sont conservées sous forme d'étiquettes sur chaque nombre réduit produit.
*Champs :*
+ **Fonction** — La fonction de réduction à utiliser
+ **Entrée** — La variable (RefID (telle que`A`)) à rééchantillonner
+ **Mode** — Permet de contrôler le comportement de la fonction de réduction lorsqu'une série contient des valeurs non numériques (null, NaN, \$1-Inf)
**Fonctions de réduction**
*Count*
Count renvoie le nombre de points dans chaque série.
*Méchant*
La moyenne renvoie le total de toutes les valeurs de chaque série divisé par le nombre de points de cette série. En `strict` mode, si l'une des valeurs de la série est nulle ou nan, ou si la série est vide, NaN est renvoyé.
*Min et Max*
Min et Max renvoient respectivement la plus petite ou la plus grande valeur de la série. En `strict` mode, si l'une des valeurs de la série est nulle ou nan, ou si la série est vide, NaN est renvoyé.
*Sum*
Sum renvoie le total de toutes les valeurs de la série. Si la série est de longueur nulle, la somme sera égale à 0. En `strict` mode, s'il existe des valeurs NaN ou Null dans la série, NaN est renvoyé.
*Dernier*
Last renvoie le dernier chiffre de la série. Si la série n'a aucune valeur, elle renvoie NaN.
**Modes de réduction**
*Stricte*
En mode strict, la série d'entrées est traitée telle quelle. Si l'une des valeurs de la série n'est pas numérique (null, NaN ou \$1-Inf), NaN est renvoyé.
*Supprimer les données non numériques*
Dans ce mode, toutes les valeurs non numériques (null, NaN ou \$1-Inf) de la série d'entrée sont filtrées avant d'exécuter la fonction de réduction.
*Remplacer les données non numériques*
Dans ce mode, toutes les valeurs non numériques sont remplacées par une valeur prédéfinie.
**Rééchantillonner**
Resample modifie les horodatages de chaque série chronologique afin d'avoir un intervalle de temps constant. Le principal cas d'utilisation est que vous pouvez rééchantillonner des séries chronologiques qui ne partagent pas les mêmes horodatages afin de pouvoir effectuer des calculs entre elles. Cela peut être fait en rééchantillonnant chacune des deux séries, puis en effectuant une opération mathématique faisant référence aux variables rééchantillonnées.
*Champs :*
+ **Entrée** — Variable des données de séries chronologiques (RefID (par exemple`A`)) à rééchantillonner
+ **Rééchantillonner** vers : durée pendant laquelle le rééchantillonnage doit être effectué, par exemple. `10s` Les unités peuvent être `s` des secondes, `m` des minutes, `h` des heures, `d` des jours, `w` des semaines et `y` des années.
+ **Sous-échantillonnage** : fonction de réduction à utiliser lorsqu'il existe plusieurs points de données par échantillon de fenêtre. Voir l'opération de réduction pour plus de détails sur le comportement.
+ **Upsample** — Méthode à utiliser pour remplir un échantillon de fenêtre ne contenant aucun point de données.
+ **le pad** est rempli avec la dernière valeur connue
+ **remblai** avec la prochaine valeur connue
+ **fillna** pour remplir les fenêtres d'exemple vides avec NaNs
## Écrire une expression
pour une unité personnalisée qui doit suivre la valeur.
+ **préfixe :** pour une unité personnalisée qui doit précéder la valeur.
+ **heure :** pour les formats de date et d'heure personnalisés, tapez par exemple`time:YYYY-MM-DD`. Voir [format](https://momentjs.com/docs/#/displaying/) dans la *documentation Moment.js* pour la syntaxe et les options de format.
+ **si :** pour les unités SI personnalisées. Par exemple : `si: mF`. C'est un peu plus avancé car vous pouvez spécifier à la fois une unité et l'échelle des données source. Donc, si vos données sources sont représentées sous forme de milli (milliers de), préfixez l'unité avec ce caractère d'échelle SI.
+ **nombre :** pour une unité de comptage personnalisée.
+ **devise :** pour personnaliser une unité monétaire.
Vous pouvez également coller un emoji natif dans le sélecteur d'unités et le choisir comme unité personnalisée.
### Unités de chaînes
`— la valeur de l'étiquette par rapport à l'URL. Si votre étiquette contient des points, utilisez `__field.labels[""]` la syntaxe.
### Variables de valeur
/explore?panes=&schemaVersion=&orgId=
```
où :
+ `org_id`est l'identifiant de l'organisation
+ `schema_version`est la version du schéma (doit être définie sur la dernière version, qui est`1`.
+ `panes`est un objet JSON de volets codé en URL, où chaque clé est l'ID du volet et chaque valeur est un objet correspondant au schéma suivant :
```
{
datasource: string; // the pane's root datasource UID, or `-- Mixed --` for mixed datasources
queries: {
refId: string; // an alphanumeric identifier for this query, must be unique within the pane, i.e. "A", "B", "C", etc.
datasource: {
uid: string; // the query's datasource UID ie: "AD7864H6422"
type: string; // the query's datasource type-id, i.e: "loki"
}
// ... any other datasource-specific query parameters
}[]; // array of queries for this pane
range: {
from: string; // the start time, in milliseconds since epoch
to: string; // the end time, in milliseconds since epoch
}
}
```
**Note**
Les `to` champs `from` et acceptent également les plages relatives, comme décrit dans la [Configuration de la plage horaire du tableau de bord](v10-dash-using-dashboards.md#v10-dash-setting-dashboard-time-range) rubrique.
## Partager le lien raccourci
/public/emails/ng_alert_notification.html` Vous pouvez modifier ce fichier pour modifier l'apparence de tous les e-mails d'alerte.
# Gestionnaire d'alertes
auth =
}
```
## Fournir des points de contact et des modèles
*Remplacez-le par l'URL de votre webhook Slack (ou d'autres informations de point de contact).
Cet exemple crée un point de contact qui envoie des notifications d'alerte à Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
Les politiques de notification indiquent à Grafana comment acheminer les instances d'alerte, et non leur localisation. Ils connectent les alertes de tir à vos points de contact préalablement définis à l'aide d'un système d'étiquettes et de matchers.
**Pour configurer les politiques de notification et le routage**
1. Copiez ce bloc de code dans un fichier .tf sur votre machine locale.
Dans cet exemple, les alertes sont regroupées par`alertname`, ce qui signifie que toutes les notifications provenant d'alertes portant le même nom sont regroupées dans le même message Slack.
Si vous souhaitez acheminer des notifications spécifiques différemment, vous pouvez ajouter des sous-politiques. Les sous-politiques vous permettent d'appliquer un routage à différentes alertes en fonction de la correspondance des étiquettes. Dans cet exemple, nous appliquons une temporisation muette à toutes les alertes portant le label a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. Dans le champ mute\$1timings, associez une temporisation muette à votre politique de notification.
1. Exécutez la commande `terraform apply`.
1. Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre politique de notification.
**Note**
Vous ne pouvez pas modifier les ressources fournies par Terraform depuis l'interface utilisateur. Cela garantit que votre pile d'alertes reste toujours synchronisée avec votre code.
1. Cliquez sur **Tester** pour vérifier que le point de notification fonctionne correctement.
## Provisionner les horaires de mise en sourdine
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez vérifier que vos ressources d'alerte ont été créées dans Grafana.
**Pour consulter vos ressources approvisionnées dans Grafana**
1. Ouvrez votre instance Grafana.
1. Accédez à Alertes.
1. Cliquez sur un dossier de ressources d'alerte, par exemple, Règles d'alerte.
Les ressources provisionnées sont étiquetées **Provisioned**, de sorte qu'il est clair qu'elles n'ont pas été créées manuellement.
**Note**
Vous ne pouvez pas modifier les ressources provisionnées depuis Grafana. Vous ne pouvez modifier les propriétés des ressources qu'en modifiant le fichier de provisionnement et en redémarrant Grafana ou en effectuant un rechargement à chaud. Cela empêche les modifications apportées à la ressource qui seraient remplacées si un fichier était à nouveau provisionné ou si un rechargement à chaud était effectué.
# Configuration des alertes
` à la fin. Pour consulter les périodes fiscales, utilisez `fQ (fiscal quarter)` et unités de `fy (fiscal year)` temps.
L'opérateur plus vous permet d'avancer dans le temps par rapport au présent. Par exemple, vous pouvez utiliser cette fonctionnalité pour examiner les données prédites dans le futur.
Le tableau suivant fournit des exemples de plages relatives.
| Exemple de plage relative | De | À |
| --- | --- | --- |
| Les 5 dernières minutes | `now-5m` | `now` |
| Jusqu'à présent | `now/d` | `now` |
| Cette semaine | `now/w` | `now/w` |
| Jusqu'à présent cette semaine | `now/w` | `now` |
| Ce mois-ci | `now/M` | `now/M` |
| Ce mois-ci, jusqu'à présent | `now/M` | `now` |
| Mois précédent | `now-1M/M` | `now-1M/M` |
| Cette année, jusqu'à présent | `now/Y` | `now` |
| Cette année | `now/Y` | `now/Y` |
| Exercice financier précédent | `now-1y/fy` | `now-1y/fy` |
**Note**
Grafana Alerting ne prend pas en charge les horodatages `now+n` futurs ni le *début `now-1n/n` de n jusqu'à la fin de n.*
**Contrôles de plage de temps courants**
Les commandes horaires du tableau de bord et du panneau ont une interface utilisateur commune. Ce qui suit décrit les contrôles de plage de temps courants.
+ La plage horaire actuelle, également appelée *sélecteur de temps*, indique la plage de temps actuellement affichée dans le tableau de bord ou le panneau que vous consultez. Passez votre curseur sur le champ pour voir les horodatages exacts de la plage et leur source (par exemple, le navigateur local). Cliquez sur la *plage horaire actuelle* pour la modifier. Vous pouvez modifier l'heure actuelle en utilisant une *plage de temps relative*, telle que les 15 dernières minutes, ou une plage de temps absolue, telle que `2020-05-14 00:00:00` à`2020-05-15 23:59:59`.
+ La **plage de temps relative** peut être sélectionnée dans la liste des **plages de temps relatives**. Vous pouvez filtrer la liste à l'aide du champ de saisie situé en haut. Quelques exemples de plages horaires incluent les *30 dernières minutes*, les *12 dernières heures*, les *7 derniers jours*, les *2 dernières années*, *hier*, *avant-hier*, *ce jour la semaine dernière*, *aujourd'hui jusqu'à présent*, *cette semaine jusqu'à présent* et *Ce mois jusqu'à présent*.
+ La **plage de temps absolue** peut être définie de deux manières : en saisissant des valeurs temporelles exactes ou relatives dans les champs **De** et **à** et en cliquant sur **Appliquer la plage de temps**, ou en cliquant sur une date ou une plage de dates dans le calendrier affiché lorsque vous cliquez sur le champ **De ou **de**** fin. Pour appliquer vos sélections, cliquez sur **Appliquer la plage horaire**.
*Autres fonctionnalités de plage horaire*
1. **Pour effectuer un zoom arrière, cliquez sur **Cmd\$1Z ou Ctrl\$1Z**.** Cliquez sur l'icône pour afficher une plage de temps plus étendue dans la visualisation du tableau de bord ou du panneau.
1. Pour utiliser la fonction de zoom avant, cliquez et faites glisser pour sélectionner la plage de temps dans la visualisation que vous souhaitez afficher.
**Note**
Le zoom avant ne s'applique qu'aux visualisations graphiques.
*Actualiser les tableaux de bord*
Cliquez sur l'icône **Actualiser le tableau de bord** pour exécuter immédiatement chaque requête sur le tableau de bord et actualiser les visualisations. Grafana annule toutes les demandes en attente lorsque vous déclenchez une actualisation.
Par défaut, Grafana n'actualise pas automatiquement le tableau de bord. Les requêtes sont exécutées selon leur propre calendrier en fonction des paramètres du panneau. Toutefois, si vous souhaitez actualiser régulièrement le tableau de bord, cliquez sur la flèche vers le bas à côté de l'icône **Actualiser le tableau de bord**, puis sélectionnez un intervalle d'actualisation.
**Contrôlez la plage horaire à l'aide d'une URL**
Vous pouvez contrôler la plage horaire d'un tableau de bord en fournissant les paramètres de requête suivants dans l'URL du tableau de bord.
+ `from`définit la limite inférieure de la plage de temps, spécifiée en ms epoch ou en [temps relatif.](#v9-dash-setting-dashboard-time-range)
+ `to`définit la limite supérieure de la plage de temps, spécifiée en ms epoch ou en temps relatif.
+ `time`et `time.window` définit une plage de temps allant de `time-time.window/2` à`time+time.window/2`. Les deux paramètres doivent être spécifiés en ms. Par exemple, les `?time=1500000000000&time.window=10000` résultats indiquent une plage de temps de 10 s comprise entre 1499999995000 et 1500000005000.
# Création de tableaux de bord
bouton **Restaurer à la version** en haut à droite.
**Restauration vers une version de tableau de bord précédemment enregistrée**
Si vous devez restaurer une version du tableau de bord précédemment enregistrée, vous pouvez soit cliquer sur le bouton **Restaurer** situé à droite d'une ligne de la liste des versions du tableau de bord, soit cliquer sur le bouton **Restaurer à la version** qui apparaît dans la vue des différences. Cliquez sur le bouton pour afficher la fenêtre contextuelle suivante vous demandant de confirmer la restauration.
Après la restauration d'une version précédente, une nouvelle version sera créée contenant exactement les mêmes données que la version précédente, mais avec un numéro de version différent. Cela est indiqué dans la **colonne Notes** de la ligne de la nouvelle version du tableau de bord. Cela est fait simplement pour s'assurer que les versions précédentes de votre tableau de bord ne sont pas affectées par la modification.
# Gestion des liens du tableau de bord
.
**Exemples**
Les variables sont répertoriées dans des listes déroulantes en haut de l'écran. Sélectionnez différentes variables pour voir comment les visualisations changent.
Pour voir les paramètres des variables, accédez à **Paramètres du tableau de bord > Variables**. Cliquez sur une variable dans la liste pour voir ses paramètres.
Les variables peuvent être utilisées dans les titres, les descriptions, les panneaux de texte et les requêtes. Les requêtes dont le texte commence par `$` sont des modèles. Tous les panneaux ne comporteront pas de modèles de requêtes.
**Bonnes pratiques variables**
+ Les listes déroulantes de variables sont affichées dans l'ordre dans lequel elles sont répertoriées dans la liste des variables dans les **paramètres du tableau de bord.**
+ Placez les variables que vous allez souvent modifier en haut, afin qu'elles apparaissent en premier (à l'extrême gauche du tableau de bord).
# Ajouter et gérer des variables
[ ^ " ] + ) |chip=" (?[ ^ " ] + )/g
```
Cela produirait la liste déroulante suivante :
```
Display Name Value
------------ -------------------------
enp216s0f0np0 0000:d7:00_0_0000:d8:00_0
enp216s0f0np1 0000:d7:00_0_0000:d8:00_1
enp216s0f0np2 0000:d7:00_0_0000:d8:00_2
enp216s0f0np3 0000:d7:00_0_0000:d8:00_3
```
Seuls `text` les noms de groupes de `value` capture et de capture sont pris en charge.
##
}`— Ce format vous permet de mieux contrôler la façon dont Grafana interprète les valeurs. Pour plus d'informations, consultez la section *Options avancées de format variable*.
+ `[[varname]]`— Ne pas utiliser. Cette syntaxe est ancienne et est obsolète. Il sera supprimé dans une future version.
Avant que les requêtes ne soient envoyées à votre source de données, la requête est *interpolée*, ce qui signifie que la variable est remplacée par sa valeur actuelle. Pendant l'interpolation, la valeur de la variable peut être *évitée* afin de se conformer à la syntaxe du langage de requête et à l'endroit où elle est utilisée. Par exemple, une variable utilisée dans une expression regex dans une requête InfluxDB ou Prometheus sera échappée à l'expression régulière.
**Options avancées de format variable**
Le formatage de l'interpolation variable dépend de la source de données, mais dans certains cas, vous souhaiterez peut-être modifier le formatage par défaut.
Par exemple, la source de données MySQL par défaut consiste à joindre plusieurs valeurs séparées par des virgules par des guillemets :. `'server01','server02'` Dans certains cas, vous souhaiterez peut-être avoir une chaîne séparée par des virgules sans guillemets :. `server01,server02` Vous pouvez y parvenir grâce aux options avancées de mise en forme des variables répertoriées ci-dessous.
**Syntaxe générale**
Syntaxe : `${var_name:option}`
Si une option de mise en forme non valide est spécifiée, `glob` c'est l' default/fallback option.
**CSV**
Formate les variables comportant plusieurs valeurs sous forme de chaîne séparée par des virgules.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:csv}'
Interpolation result: 'test1,test2'
```
**Distribué - OpenTSDB**
Formate les variables avec plusieurs valeurs dans un format personnalisé pour OpenTSDB.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:distributed}'
Interpolation result: 'test1,servers=test2'
```
**Devis double**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `\"` et `"` met chaque valeur entre guillemets avec. `"`
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:doublequote}'
Interpolation result: '"test1","test2"'
```
**Globe - Graphite**
Formate les variables comportant plusieurs valeurs dans un glob (pour les requêtes Graphite).
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:glob}'
Interpolation result: '{test1,test2}'
```
**JSON**
Formate les variables comportant plusieurs valeurs sous forme de chaîne séparée par des virgules.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:json}'
Interpolation result: '["test1", "test2"]'
```
**Lucene - Elasticsearch**
Formate les variables avec plusieurs valeurs au format Lucene pour Elasticsearch.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:lucene}'
Interpolation result: '("test1" OR "test2")'
```
**Code en pourcentage**
Formate les variables à valeurs uniques et multiples à utiliser dans les paramètres d'URL.
```
servers = [ 'foo()bar BAZ', 'test2' ]
String to interpolate: '${servers:percentencode}'
Interpolation result: 'foo%28%29bar%20BAZ%2Ctest2'
```
**Tuyau**
Formate les variables comportant plusieurs valeurs dans une chaîne séparée par des tubes.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:pipe}'
Interpolation result: 'test1.|test2'
```
**Brut**
Désactive le formatage spécifique à la source de données, tel que les guillemets simples dans une requête SQL.
```
servers = [ 'test.1', 'test2' ]
String to interpolate: '${var_name:raw}'
Interpolation result: 'test.1,test2'
```
**Regex**
Formate les variables comportant plusieurs valeurs dans une chaîne regex.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:regex}'
Interpolation result: '(test1\.|test2)'
```
**Devis unique**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `\'` et `'` met chaque valeur entre guillemets avec. `'`
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:singlequote}'
Interpolation result: "'test1','test2'"
```
**Chaîne SQL**
Formate les variables à valeurs uniques ou multiples dans une chaîne séparée par des virgules, saisit chaque valeur par `''` et `'` met chaque valeur entre guillemets avec. `'`
```
servers = [ "test'1", "test2" ]
String to interpolate: '${servers:sqlstring}'
Interpolation result: "'test''1','test2'"
```
**Text**
Formate les variables à valeurs uniques et multiples dans leur représentation textuelle. Pour une seule variable, elle renverra simplement la représentation textuelle. Pour les variables à valeurs multiples, elle renverra la représentation textuelle combinée avec`+`.
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:text}'
Interpolation result: "test1 + test2"
```
**Paramètres Query (Requête)**
Formate les variables à valeurs uniques et multiples dans leur représentation des paramètres de requête. Exemple : `var-foo=value1&var-foo=value2`
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:queryparam}'
Interpolation result: "var-servers=test1&var-servers=test2"
```
# Evaluation de l'utilisation du tableau
pour l'unité personnalisée qui doit suivre la valeur.
+ **préfixe :** pour l'unité personnalisée qui doit précéder la valeur.
+ **heure :** pour les formats de date et heure personnalisés, tapez par exemple **time:YYYY-MM-DD**. Voir [formats](https://momentjs.com/docs/#/displaying/) pour connaître la syntaxe et les options de format.
+ **si :** pour les unités SI personnalisées. Par exemple : **si : mF**. Celui-ci est un peu plus avancé car vous pouvez spécifier à la fois une unité et l'échelle des données source. Donc, si vos données source sont représentées sous forme de milli (milliers de), préfixez l'unité avec ce caractère d'échelle SI.
+ **nombre :** pour une unité de comptage personnalisée.
+ **devise :** pour personnaliser une unité monétaire.
Vous pouvez également coller un emoji natif dans le sélecteur d'unités et le choisir comme unité personnalisée.
#### Unités de chaînes
[${__range_s}s]) != )
```
**Sources de données spéciales**
**Grafana inclut également trois sources de données spéciales : **Grafana**, **Mixed** et Dashboard.** Pour plus de détails, reportez-vous à la section Sources de données
## Naviguez dans l'onglet de requête
- la valeur de l'étiquette par rapport à l'URL. Si votre étiquette contient des points, utilisez la syntaxe **\$1\$1field.labels [» «**].
## Variables de valeur
/public/emails/ng_alert_notification.html` Vous pouvez modifier ce fichier pour modifier l'apparence de tous les e-mails d'alerte.
# Alertes sur les données numériques
auth =
}
```
## Fournir des points de contact et des modèles
* par l'URL de votre webhook Slack (ou autre contact)
Cet exemple crée un point de contact qui envoie des notifications d'alerte à Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
Les politiques de notification indiquent à Grafana comment acheminer les instances d'alerte, et non leur localisation. Ils connectent les alertes de tir à vos points de contact préalablement définis à l'aide d'un système d'étiquettes et de matchers.
**Pour configurer les politiques de notification et le routage**
1. Copiez ce bloc de code dans un fichier .tf sur votre machine locale.
Dans cet exemple, les alertes sont regroupées par`alertname`, ce qui signifie que toutes les notifications provenant d'alertes portant le même nom sont regroupées dans le même message Slack.
Si vous souhaitez acheminer des notifications spécifiques différemment, vous pouvez ajouter des sous-politiques. Les sous-politiques vous permettent d'appliquer un routage à différentes alertes en fonction de la correspondance des étiquettes. Dans cet exemple, nous appliquons une temporisation muette à toutes les alertes portant le label a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. Dans le champ mute\$1timings, associez une temporisation muette à votre politique de notification.
1. Exécutez la commande `terraform apply`.
1. Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre politique de notification.
**Note**
Vous ne pouvez pas modifier les ressources fournies par Terraform depuis l'interface utilisateur. Cela garantit que votre pile d'alertes reste toujours synchronisée avec votre code.
1. Cliquez sur **Tester** pour vérifier que le point de notification fonctionne correctement.
## Provisionner les horaires de mise en sourdine
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana, voir. [Travailler dans la version 10 de Grafana](using-grafana-v10.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez vérifier que vos ressources d'alerte ont été créées dans Grafana.
**Pour consulter vos ressources approvisionnées dans Grafana**
1. Ouvrez votre instance Grafana.
1. Accédez à Alertes.
1. Cliquez sur un dossier de ressources d'alerte, par exemple, Règles d'alerte.
Les ressources provisionnées sont étiquetées **Provisioned**, de sorte qu'il est clair qu'elles n'ont pas été créées manuellement.
**Note**
Vous ne pouvez pas modifier les ressources provisionnées depuis Grafana. Vous ne pouvez modifier les propriétés des ressources qu'en modifiant le fichier de provisionnement et en redémarrant Grafana ou en effectuant un rechargement à chaud. Cela empêche les modifications apportées à la ressource qui seraient remplacées si un fichier était à nouveau provisionné ou si un rechargement à chaud était effectué.
# Migration des alertes classiques du tableau de bord vers les alertes Grafana
[${__range_s}s]) != )
```
Pour plus d'informations sur la rédaction d'une requête pour votre source de données, consultez la documentation de cette source de données. Les sources de données sont répertoriées dans[Connexion aux sources de données](AMG-data-sources.md).
## Interface utilisateur de l'onglet Requête
`pour une unité personnalisée qui doit suivre la valeur.
+ `time:`pour les date/time formats personnalisés ; par exemple,`time:YYYY-MM-DD`. Pour la syntaxe et les options du format, voir [Affichage](https://momentjs.com/docs/#/displaying/).
+ `si:`pour les unités SI personnalisées ; par exemple,`si: mF`. Cette option est un peu plus avancée car vous pouvez spécifier à la fois une unité et l'échelle des données source. Par exemple, si vos données source sont représentées sous forme de milli (milliers d'unités), préfixez l'unité avec ce caractère d'échelle SI.
+ `count:`pour une unité de comptage personnalisée.
+ `currency:`pour personnaliser une unité monétaire.
Vous pouvez également coller un emoji natif dans le sélecteur d'unités et le choisir comme unité personnalisée.
##### Unités de chaînes
`
Utilisez l'opérateur plus pour avancer dans le temps par rapport au présent. Vous pouvez utiliser cette fonctionnalité pour consulter les données prédites pour le futur.
Voici quelques exemples :
| Exemple de plage relative | De | À |
| --- | --- | --- |
| Les 5 dernières minutes | now-5m | now |
| Jusqu'à présent | now/d | now |
| Cette semaine | now/w | now/w |
| Depuis le début de la semaine | now/w | now |
| Mois précédent | now-1M/M | now-1M/M |
## Contrôles de plage de temps courants
.
## Restauration vers une version de tableau de bord précédemment enregistrée
qui apparaît dans la vue des différences. Une fois que vous avez choisi de restaurer, une fenêtre contextuelle vous invite à confirmer la restauration.
Après la restauration d'une version précédente, une nouvelle version contenant exactement les mêmes données que la version précédente sera créée, mais avec un numéro de version différent. Cela est indiqué dans la colonne **Remarques**. Cela permet de garantir que les versions précédentes de votre tableau de bord ne sont pas affectées par la modification.
# Raccourcis clavier
`— Ajoute la valeur de l'étiquette à l'URL. Si votre étiquette contient des points, utilisez `__series.labels[""]` la syntaxe.
### Variables de champ
=value`.
## Bonnes pratiques variables
}`Ce format vous permet de mieux contrôler la façon dont Grafana interpole les valeurs. Pour de plus amples informations, veuillez consulter [Options avancées de format variable](#advanced-variable-format-options).
Avant que les requêtes ne soient envoyées à votre source de données, elles sont *interpolées*, ce qui signifie que la variable est remplacée par sa valeur actuelle. Pendant l'interpolation, la valeur de la variable peut être *évitée* pour se conformer à la syntaxe du langage de requête et à l'endroit où elle est utilisée. Par exemple, une variable utilisée dans une expression régulière d'une requête Prometheus sera échappée à une expression régulière. Consultez la rubrique de documentation spécifique à la source de données pour plus de détails sur l'échappement de valeur lors de l'interpolation.
Pour plus d'informations sur la syntaxe avancée permettant de remplacer le formatage par défaut de la source de données, consultez[Options avancées de format variable](#advanced-variable-format-options).
# Types de variables
[^"]+)|chip="(?[^"]+)/g
```
La liste déroulante suivante est produite.
```
Display Name Value
------------ -------------------------
enp216s0f0np0 0000:d7:00_0_0000:d8:00_0
enp216s0f0np1 0000:d7:00_0_0000:d8:00_1
enp216s0f0np2 0000:d7:00_0_0000:d8:00_2
enp216s0f0np3 0000:d7:00_0_0000:d8:00_3
```
**Remarque :** seuls les noms de groupes de `value` capture `text` et de capture sont pris en charge.
### Panneaux ou lignes répétitifs
, tout en minuscules, sans espace) ou une référence de chaîne (\$1, tout en minuscules, sans espace). Si vous utilisez le point de terminaison de l'API chat.postMessage Slack, cela est obligatoire. |
| Icône Emoji | Fournissez un emoji à utiliser comme icône pour le message du bot. Par exemple, :smile : |
| URL de l'icône | Fournissez l'URL d'une image à utiliser comme icône pour le message du bot. |
| Mentionner les utilisateurs | Mentionnez éventuellement un ou plusieurs utilisateurs dans la notification Slack envoyée par Grafana. Pour voir les utilisateurs, séparés par des virgules, via leur Slack correspondant IDs, cliquez sur le bouton de débordement sur le profil Slack de chaque utilisateur. |
| Mentionner des groupes | Mentionnez éventuellement un ou plusieurs groupes dans la notification Slack envoyée par Grafana. Vous pouvez voir les groupes, séparés par des virgules, via le Slack correspondant IDs (que vous pouvez obtenir à partir de l'URL du profil Slack de chaque groupe). |
| Mentionner la chaîne | Mentionnez éventuellement tous les membres de la chaîne ou uniquement les membres actifs. |
| Jeton | Si elle est fournie, Amazon Managed Grafana téléchargera l'image générée via l'opération API Slack file.upload, et non via la destination externe de l'image. Si vous utilisez le point de terminaison de l'API chat.postMessage Slack, cela est obligatoire. |
Si vous utilisez le jeton pour un robot Slack, vous devez inviter le bot à rejoindre le canal sur lequel vous souhaitez envoyer des notifications. Ajoutez ensuite la chaîne dans le champ du destinataire.
### PagerDuty