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.
# Travailler dans la version 10 de Grafana
` à 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