Les définitions de tableau de bord JSON vous permettent de configurer de manière programmatique les mises en page, les filtres, les annotations d'événements et les widgets des tableaux de bord personnalisés à l'aide de l'API Cloud Monitoring ou de la Google Cloud CLI. Ce document fournit des exemples de configurations JSON et montre comment chaque définition s'affiche sur un tableau de bord personnalisé.
Pour installer des définitions de tableau de bord JSON prédéfinies pour les services Google Cloud à partir de GitHub, consultez Installer un modèle de tableau de bord.
Quand utiliser l'API ou la Google Cloud CLI ?
L'API Cloud Monitoring et la Google Cloud CLI vous permettent de gérer plusieurs tableaux de bord à la fois. Bien que vous puissiez utiliser la consoleGoogle Cloud pour gérer vos tableaux de bord, il peut être plus facile d'utiliser des scripts qui gèrent vos tableaux de bord personnalisés de manière groupée.
Vous devez également utiliser l'API lorsque vous souhaitez ajouter le widget à espace réservé vide à votre tableau de bord.
Utiliser MQL ou PromQL avec l'API
Vous créez des tableaux de bord à l'aide de la méthode dashboards.create. Vous transmettez à la méthode API un objet Dashboard, qui contient une entrée pour chaque widget affiché par le tableau de bord.
Lorsqu'un widget affiche des données de séries temporelles, comme un widget de graphique, son entrée dans l'objet Dashboard contient un objet TimeSeriesQuery.
Cet objet décrit les données de séries temporelles à représenter dans un graphique. Vous spécifiez ces données à l'aide d'un filtre Monitoring, d'une requête MQL ou d'une requête PromQL :
Pour utiliser les filtres Monitoring, renseignez le champ
timeSeriesFilter. Les exemples de cette page utilisent des filtres Cloud Monitoring.Pour utiliser une requête MQL, renseignez le champ
timeSeriesQueryLanguage. Pour en savoir plus, consultez Créer des graphiques.Pour utiliser une requête PromQL, renseignez le champ
prometheusQuery. Pour en savoir plus, consultez PromQL dans Cloud Monitoring.
Dispositions de tableaux de bord
Cette section contient des informations sur les différentes mises en page de tableau de bord disponibles.
Tableau de bord dans GridLayout
Ce tableau de bord affiche une ressource GridLayout comportant trois widgets.
{
"displayName": "Grid Layout Example",
"gridLayout": {
"columns": "2",
"widgets": [
{
"title": "Widget 1",
"xyChart": {
"dataSets": {
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"agent.googleapis.com/nginx/connections/accepted_count\"",
"aggregation": {
"perSeriesAligner": "ALIGN_RATE"
}
},
"unitOverride": "1"
},
"plotType": "LINE"
},
"timeshiftDuration": "0s",
"yAxis": {
"label": "y1Axis",
"scale": "LINEAR"
}
}
},
{
"text": {
"content": "Widget 2"
}
},
{
"title": "Widget 3",
"xyChart": {
"dataSets": {
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"agent.googleapis.com/nginx/connections/accepted_count\"",
"aggregation": {
"perSeriesAligner": "ALIGN_RATE"
}
},
"unitOverride": "1"
},
"plotType": "STACKED_BAR"
},
"timeshiftDuration": "0s",
"yAxis": {
"label": "y1Axis",
"scale": "LINEAR"
}
}
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord dans MosaicLayout
Ce tableau de bord affiche une ressource MosaicLayout comportant deux widgets.
{
"displayName": "Mosaic Layout Example",
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"xPos": 2,
"yPos": 2,
"width": 7,
"height": 2,
"widget": {
"title": "CPU utilization in us-central1-a",
"scorecard": {
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\" resource.label.zone=\"us-central1-a\"",
"aggregation": {
"perSeriesAligner": "ALIGN_MEAN",
"crossSeriesReducer": "REDUCE_MAX"
}
},
"unitOverride": "1"
},
"gaugeView": {
"upperBound": 1.5
},
"thresholds": [
{
"value": 0.8,
"color": "YELLOW",
"direction": "ABOVE"
},
{
"value": 1,
"color": "RED",
"direction": "ABOVE"
}
]
}
}
},
{
"xPos": 1,
"yPos": 5,
"width": 4,
"height": 4,
"widget": {
"title": "My Chart",
"xyChart": {
"dataSets": [
{
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\"",
"aggregation": {
"perSeriesAligner": "ALIGN_MEAN",
"crossSeriesReducer": "REDUCE_MAX",
"groupByFields": [
"resource.label.zone"
]
}
},
"unitOverride": "'1'"
},
"plotType": "LINE",
"minAlignmentPeriod": "60s"
}
],
"yAxis": {
"label": "y1Axis",
"scale": "LINEAR"
}
}
}
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord dans RowLayout
Ce tableau de bord affiche une ressource RowLayout comportant trois widgets.
{
"displayName": "Row Layout Example",
"rowLayout": {
"rows": [
{
"weight": "1",
"widgets": [
{
"text": {
"content": "Widget 1",
"format": "MARKDOWN"
}
},
{
"text": {
"content": "Widget 2",
"format": "MARKDOWN"
}
},
{
"text": {
"content": "Widget 3",
"format": "MARKDOWN"
}
}
]
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord dans ColumnLayout
Ce tableau de bord affiche une ressource ColumnLayout comportant trois widgets.
{
"displayName": "Column Layout Example",
"columnLayout": {
"columns": [
{
"weight": "1",
"widgets": [
{
"text": {
"content": "Widget 1",
"format": "MARKDOWN"
}
},
{
"text": {
"content": "Widget 2",
"format": "MARKDOWN"
}
},
{
"text": {
"content": "Widget 3",
"format": "MARKDOWN"
}
}
]
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Activer les événements du tableau de bord, et ajouter des filtres et des libellés
Cette section explique comment ajouter des filtres et des libellés à un tableau de bord, et comment configurer un tableau de bord pour afficher des événements.
Activer les événements sur les tableaux de bord
Vous pouvez configurer un tableau de bord pour afficher des événements, tels qu'un événement de mise à jour Google Kubernetes Engine ou un événement de défaillance de machine virtuelle, en incluant un champ annotations dans l'objet Dashboard. Le champ annotations contient une instance d'un objet DashboardAnnotations, qui contient deux champs :
Le champ
defaultResourceNamesliste les valeurs par défaut au niveau du tableau de bord pour les projetsGoogle Cloud dans lesquels rechercher des événements. Si vous ne spécifiez pas ce champ, la recherche est effectuée dans le projet sélectionné.Tableau d'objets
EventAnnotation. Chaque objet contient les éléments suivants :- Un champ
displayName, qui vous permet de définir l'étiquette du bouton d'activation/désactivation spécifique à l'événement. Lorsque ce champ n'est pas spécifié ou que sa valeur est une chaîne vide, le nom par défaut de l'événement s'affiche. - Un champ
enabled, qui contrôle la valeur du bouton d'activation/de désactivation de l'événement. Lorsquetrue, le bouton bascule est en positiononet les événements sont affichés sur le tableau de bord. Lorsquefalse, le bouton est en positionoff. - Un champ
eventType, qui contient une valeur de l'énumérationEventType. - Un champ
filter, qui vous permet de spécifier une requête à ajouter à la requête spécifique à l'événement. Lorsque la valeur de ce champ est une chaîne vide, la requête spécifique à l'événement est utilisée. - Un champ
resourceNames, qui vous permet de définir une liste de projetsGoogle Cloud pour rechercher des événements. Lorsque ce champ est un tableau vide, votre projet sélectionné est recherché.
- Un champ
L'exemple suivant montre un champ annotations qui spécifie un événement Google Kubernetes Engine :
{
"displayName": "Annotation example",
"annotations": {
"defaultResourceNames": [],
"eventAnnotations": [
{
"displayName": "",
"enabled": true,
"eventType": "GKE_CLUSTER_UPDATE",
"filter": "resource.labels.cluster_name=my-cluster",
"resourceNames": []
}
]
},
"dashboardFilters": [],
"mosaicLayout": {
...
},
"labels": {}
}
Dans l'exemple précédent, le champ filter est utilisé pour limiter la requête au cluster my-cluster. Le champ displayName est défini sur une chaîne vide. Le nom par défaut du type d'événement s'affiche donc sur le bouton d'activation/de désactivation de l'événement. Enfin, étant donné que le champ resourceNames est défini sur un tableau vide, les entrées de journal de votre projet Google Cloud actuel sont interrogées.
Ajouter des filtres et des variables de tableau de bord
Pour contrôler les données affichées par les widgets d'un tableau de bord, vous pouvez ajouter des variables et des filtres épinglés. Les variables diffèrent des filtres épinglés, car elles s'appliquent à des widgets spécifiques.
Si vous créez un filtre ou une variable épinglés, Monitoring met à jour la barre d'outils de votre tableau de bord personnalisé pour afficher un filtre.
Pour les filtres épinglés, le nom du filtre de la barre d'outils est le nom du filtre épinglé. Pour les variables, le nom du filtre de la barre d'outils est un signe dollar $ suivi du nom de la variable. Chaque filtre de la barre d'outils contient un menu qui vous permet de modifier la valeur du filtre ou de la variable épinglés associés.
Pour les variables, vous pouvez remplacer le filtre de la barre d'outils par un widget de tableau de bord. Pour en savoir plus, consultez Tableau de bord avec un widget FilterControl.
Pour en savoir plus sur les variables et les filtres épinglés, et pour découvrir comment appliquer une variable à un widget, consultez Filtres de tableau de bord.
Ajouter des libellés de tableau de bord
Cet exemple montre un objet Dashboard qui spécifie l'étiquette nommée playbook.
{
"displayName": "Example",
"mosaicLayout": {
"columns": 12,
"tiles": [
...
]
},
"dashboardFilters": [],
"labels": {
"playbook": ""
}
}
Comme l'illustre l'exemple précédent, le champ labels est implémenté en tant que map, où les champs key et value sont tous deux des chaînes. Lorsque vous ajoutez une étiquette à un tableau de bord, définissez key sur le nom de l'étiquette et définissez le champ value sur une chaîne vide.
L'ajout d'étiquettes à un tableau de bord est facultatif.
Tableaux de bord avec Widgets
Cette section inclut des exemples de tableaux de bord contenant différents types de widgets.
Tableau de bord avec un widget XyChart
Cet exemple montre un tableau de bord avec un XyChart de base. Si vous avez déjà utilisé la console Google Cloud pour créer des graphiques sur des tableaux de bord, ces graphiques sont des instances du widget XyChart.
Comme pour les fonctionnalités fournies dans la console Google Cloud , l'API propose des options permettant de modifier le PlotType du graphique ou de configurer ses modes d'affichage.
{
"dashboardFilters": [],
"displayName": "Example line chart",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_MEAN",
"groupByFields": [
"resource.label.\"zone\""
],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24
}
]
}
}
Le graphique du tableau de bord ressemble à l'exemple suivant :
La section suivante explique comment créer un widget de graphique d'analyse de l'observabilité, comment afficher un seuil sur un graphique et comment configurer l'utilisation de l'axe Y de gauche, de l'axe Y de droite ou des deux.
Tableau de bord avec un graphique Analyse de l'observabilité
Cet exemple montre un tableau de bord avec un graphique d'analyse de l'observabilité. L'exemple JSON contient une requête SQL.
{
"displayName": "Example",
"dashboardFilters": [],
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"width": 24,
"height": 16,
"widget": {
"title": "Sample analytics chart",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"breakdowns": [],
"dimensions": [
{
"column": "location",
"columnType": "STRING",
"maxBinCount": 5,
"sortColumn": "location",
"sortOrder": "SORT_ORDER_ASCENDING"
}
],
"measures": [
{
"aggregationFunction": {
"parameters": [],
"type": "count"
},
"column": ""
}
],
"plotType": "STACKED_BAR",
"targetAxis": "Y1",
"timeSeriesQuery": {
"opsAnalyticsQuery": {
"queryHandle": "",
"sql": "SELECT\n CAST(JSON_VALUE(resource.labels.location) AS STRING) AS location,\n severity,\nFROM\n `VIEW`"
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
}
}
]
},
"labels": {}
}
Le graphique du tableau de bord ressemble à l'exemple suivant :
Tableau de bord avec un XyChart et un seuil
Cet exemple montre un tableau de bord avec un XyChart de base, un seuil et l'axe Y de gauche configuré.
{
"dashboardFilters": [],
"displayName": "Example line with threshold",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_MEAN",
"groupByFields": [
"resource.label.\"zone\""
],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [
{
"label": "",
"targetAxis": "Y1",
"value": 0.2
}
],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24
}
]
}
}
Dans l'exemple précédent, le fichier JSON spécifie l'utilisation de l'axe Y à gauche, car il contient une structure y2Axis. Dans le champ targetAxis, utilisez "Y1" pour l'axe Y de droite et "Y2" pour l'axe Y de gauche. Si vous omettez le champ targetAxis, l'axe Y de droite est utilisé.
Le graphique de ce tableau de bord ressemble à l'exemple suivant:
Vous pouvez créer des graphiques qui affichent plusieurs types de métriques et qui utilisent les axes gauche et droit. L'exemple précédent illustre un graphique avec un seul type de métrique, c'est-à-dire qu'il n'y a qu'un seul élément dans le tableau dataSets.
Lorsque vous représentez graphiquement deux types de métriques, le tableau dataSets contient deux éléments, et chaque élément spécifie son targetAxis.
Tableau de bord avec un widget XyChart comportant une ressource STACKED_AREA PlotType
Ce tableau de bord affiche un widget XyChart comportant une ressource STACKED_AREA PlotType.
{
"dashboardFilters": [],
"displayName": "Example stacked area",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "STACKED_AREA",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_MEAN",
"groupByFields": [
"resource.label.\"zone\""
],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24
}
]
}
}
Le graphique du tableau de bord ressemble à l'exemple suivant :
Tableau de bord avec un widget XyChart comportant une ressource STACKED_BAR PlotType
Ce tableau de bord affiche un widget XyChart comportant une ressource STACKED_BAR PlotType.
{
"dashboardFilters": [],
"displayName": "Example stacked bar",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "STACKED_BAR",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_MEAN",
"groupByFields": [
"resource.label.\"zone\""
],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord avec un XyChart configuré en tant qu'histogramme
Pour afficher les données les plus récentes sous forme d'histogramme, configurez le tableau DataSet.dimensions, qui est un champ d'un XyChart.
Un histogramme fournit des informations sur la fréquence relative de la valeur la plus récente de plusieurs séries temporelles. Autrement dit, l'axe des abscisses est indexé par des intervalles, chacun correspondant à une plage de valeurs.
L'axe des ordonnées spécifie un nombre, qui correspond au nombre d'échantillons dont les valeurs se trouvent dans la plage de la classe.
Pour configurer un histogramme, procédez comme suit dans la structure XyChart :
- Définissez le champ
DataSet.plotTypesur"STACKED_BAR". - Définissez le champ
DataSet.dimension.columnsur"metric_value".
Si vous souhaitez contrôler le modèle de bin au lieu de laisser Cloud Monitoring déterminer les bins en fonction de vos données, ajoutez les champs suivants à la structure DataSet.dimension :
xMinetxMax: définissez les valeurs minimale et maximale pour le type de métrique.maxBinCountounumericBinSize: définissez le nombre de classes ou la taille des classes. Si vous définissez le nombre de bins, nous vous recommandons de choisir une valeur comprise entre 5 et 50. Le nombre maximal de bins est de 1 000.
Le code JSON suivant décrit un tableau de bord qui affiche les données avec la visualisation de l'histogramme :
{
"displayName": "Histogram example",
"dashboardFilters": [],
"description": "",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"width": 24,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"displayHorizontal": false,
"mode": "COLOR"
},
"dataSets": [
{
"dimensions": [
{
"column": "metric_value"
}
],
"minAlignmentPeriod": "60s",
"plotType": "STACKED_BAR",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"groupByFields": [],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"scale": "LINEAR"
}
}
}
}
]
}
}
Le champ dataSets.dimensions entraîne l'affichage de XyChart sous forme d'histogramme.
L'histogramme de l'exemple de tableau de bord utilise les paramètres par défaut. Le champ dimension contient donc un sous-champ, "column": "metric_value".
La capture d'écran suivante montre un XyChart configuré en tant qu'histogramme :
Tableau de bord avec un widget XyChart qui définit un remplacement de période
Par défaut, les widgets du tableau de bord affichent les données sur une période définie au niveau du tableau de bord. Toutefois, les widgets XyChart offrent une fonctionnalité de remplacement de la période. Utilisez cette fonctionnalité lorsque vous souhaitez qu'un graphique affiche des données sur une période plus longue ou plus courte que celle qui convient aux autres widgets du tableau de bord. Prenons les cas d'utilisation suivants :
Un tableau de bord affiche une métrique de quota, qui comporte un échantillon par jour, et des données de métrique échantillonnées toutes les 60 secondes. Le graphique des métriques de quota nécessite une période d'au moins un jour, voire d'une semaine. Toutefois, cette période est trop longue pour afficher les pics ou les creux dans les métriques échantillonnées toutes les 60 secondes.
Pour une métrique, vous souhaitez afficher à la fois les tendances et les mesures actuelles. Vous ajoutez donc deux graphiques au tableau de bord. Pour un graphique, vous définissez le remplacement de la période sur huit jours, soit un peu plus d'une semaine. L'autre graphique affiche une heure de données, ce qui correspond au paramètre de période du tableau de bord.
Pour configurer un remplacement de période, définissez le champ widget.timeRange. Dans l'exemple suivant, ce champ est défini sur "relativeDuration": "21600s", ce qui signifie que le graphique affiche les données des six dernières heures :
{
"displayName": "Test Dashboard",
"dashboardFilters": [],
"description": "",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"xPos": 24,
"height": 16,
"width": 24,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"timeRange": {
"relativeDuration": "21600s"
},
"xyChart": {
"chartOptions": {
"displayHorizontal": false,
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"groupByFields": [],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"scale": "LINEAR"
}
}
}
}
]
}
}
Tableau de bord avec un widget Scorecard de base
Ce tableau de bord affiche un widget Scorecard sans jauge ni graphique sparkline. L'exemple montre l'utilisation du processeur Compute Engine et le tableau de données comporte deux seuils. Un seuil utilise la couleur jaune pour indiquer que l'utilisation du processeur est supérieure à 70 %. L'autre seuil utilise la couleur rouge pour indiquer que l'utilisation du processeur est supérieure à 90%.
Étant donné que l'utilisation actuelle du processeur est inférieure aux seuils spécifiés, la couleur est verte.
{
"dashboardFilters": [],
"displayName": "Example-basic scorecard",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 8,
"widget": {
"scorecard": {
"thresholds": [
{
"color": "YELLOW",
"direction": "ABOVE",
"label": "",
"value": 0.7
},
{
"color": "RED",
"direction": "ABOVE",
"label": "",
"value": 0.9
}
],
"timeSeriesQuery": {
"outputFullDuration": true,
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_MEAN",
"groupByFields": [],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
},
"title": "VM Instance - CPU utilization [MEAN]"
},
"width": 16
}
]
}
}
Ces widgets peuvent afficher plusieurs tableaux de données. Par exemple, si les paramètres d'agrégation génèrent trois séries temporelles, ce widget affiche trois fiches, une pour chaque série temporelle.
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord avec un widget Scorecard comportant une ressource GaugeView
Ce tableau de bord ajoute une jauge au widget Scorecard de base de l'exemple précédent.
L'objet GaugeView peut spécifier une limite supérieure et une limite inférieure pour définir la plage de valeurs à afficher sur la jauge. Étant donné que le widget Scorecard affiche des valeurs comprises entre 0 et 1, ces limites supérieure et inférieure sont raisonnables. Pour ajouter la jauge, ajoutez ce qui suit au fichier JSON du widget Scorecard de base :
"gaugeView": {
"lowerBound": 0,
"upperBound": 1,
},
Dans la spécification de tableau de bord modifiée suivante, la valeur actuelle est inférieure aux seuils, qui sont colorés de manière appropriée sur la jauge :
{
"dashboardFilters": [],
"displayName": "Example-Gauge",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 8,
"widget": {
"scorecard": {
"gaugeView": {
"lowerBound": 0,
"upperBound": 1
},
"thresholds": [
{
"color": "YELLOW",
"direction": "ABOVE",
"label": "",
"value": 0.7
},
{
"color": "RED",
"direction": "ABOVE",
"label": "",
"value": 0.9
}
],
"timeSeriesQuery": {
"outputFullDuration": true,
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_SUM",
"groupByFields": [
"resource.labels.\"zone\""
],
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
}
}
},
"title": "VM Instance - CPU utilization [MEAN]"
},
"width": 16
}
]
}
}
Ces widgets peuvent afficher plusieurs jauges. Par exemple, la capture d'écran suivante montre un widget Scorecard configuré avec un GaugeView, et ce widget affiche trois jauges :
Le nombre de jauges affichées par le widget dépend de vos paramètres d'agrégation. Dans l'exemple, les paramètres d'agrégation génèrent trois séries temporelles, de sorte que trois jauges sont affichées. Vous définissez les seuils au niveau du widget, de sorte qu'ils s'appliquent à chaque série temporelle. Dans cet exemple, une jauge est rouge, une autre est orange et la troisième est verte.
Tableau de bord avec un widget Scorecard comportant une ressource SparkChartView
Ce tableau de bord remplace la jauge de l'exemple précédent par un graphique sparkline.
L'objet SparkChartView peut créer des graphiques en courbes ou à barres dans un widget Scorecard.
Cet exemple utilise une courbe. Tant que la valeur n'enfreint pas un seuil, elle est verte. Pour ajouter le graphique sparkline, remplacez l'objet JSON gaugeView dans le graphique précédent par ce qui suit :
"sparkChartView": {
"sparkChartType": "SPARK_LINE"
},
Le tableau de données ressemble à l'exemple suivant :
Tableau de bord avec un widget PieChart
Les tableaux de bord peuvent afficher les données à l'aide d'un graphique à secteurs. Chaque série temporelle contribue à une tranche du graphique. Les graphiques à secteurs n'affichent pas les données au fil du temps, mais seulement la valeur la plus récente.
Tous les graphiques à secteurs sont spécifiés par le widget PieChart.
Pour configurer le graphique de sorte qu'il affiche la somme des mesures les plus récentes, définissez le champ chartType sur DONUT. Sinon, définissez ce champ sur la valeur PIE.
"pieChart": {
"chartType": "DONUT",
},
L'exemple suivant configure un tableau de bord avec deux graphiques à secteurs, dont l'un est configuré en anneau :
{
"dashboardFilters": [],
"displayName": "Example Pie Donut",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"pieChart": {
"chartType": "DONUT",
"dataSets": [
{
"minAlignmentPeriod": "60s",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
"secondaryAggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_MEAN"
}
}
}
}
]
},
"title": "VM Instance - Disk read bytes [MEAN]"
},
"width": 24
},
{
"height": 16,
"widget": {
"pieChart": {
"chartType": "PIE",
"dataSets": [
{
"minAlignmentPeriod": "60s",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
"secondaryAggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_MEAN"
}
}
}
}
]
},
"title": "VM Instance - Disk read bytes [MEAN]"
},
"width": 24,
"xPos": 24
},
]
}
}
Comme le montre la capture d'écran suivante, les deux widgets affichent les données sous forme de graphique à secteurs, l'un d'eux affichant la somme des valeurs les plus récentes :
Tableau de bord avec un widget Treemap
Pour afficher les données les plus récentes sous la forme d'une série de rectangles imbriqués, où chaque rectangle correspond à un ensemble unique de valeurs d'étiquettes, ajoutez une carte proportionnelle.
Supposons que vous ayez agrégé les données que vous représentez graphiquement par l'étiquette zone.
Si vous définissez le type de widget sur "Treemap", chaque rectangle de la carte proportionnelle correspond à une zone. La saturation des couleurs d'un rectangle est proportionnelle à la valeur qu'il représente.
Lorsque vous explorez une carte proportionnelle, utilisez votre pointeur pour activer l'info-bulle du rectangle.
Le code JSON suivant configure un widget Treemap qui regroupe les séries temporelles par zone et par type de stockage :
{
"displayName": "Example Treemap",
"dashboardFilters": [],
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"xPos": 24,
"height": 16,
"width": 24,
"widget": {
"title": "VM Instance - Write read bytes [SUM]",
"id": "",
"treemap": {
"dataSets": [
{
"breakdowns": [],
"measures": [],
"timeSeriesQuery": {
"outputFullDuration": true,
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_SUM",
"groupByFields": [
"resource.label.\"zone\"",
"metric.label.\"storage_type\""
],
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
},
"unitOverride": ""
}
}
],
"treemapHierarchy": [
"resource.label.\"zone\"",
"metric.label.\"storage_type\""
]
}
}
}
]
}
}
La capture d'écran suivante montre le widget de carte proportionnelle avec la configuration précédente :
Dans la capture d'écran, l'info-bulle s'affiche pour un rectangle.
Tableau de bord avec un widget TimeSeriesTable
Les tableaux de bord peuvent afficher les données sous forme de tableau, avec une ligne pour chaque combinaison de valeurs d'étiquettes uniques. Les tableaux n'affichent pas les données au fil du temps. Ils affichent plutôt la valeur la plus récente ou une valeur agrégée.
Toutes les tables sont spécifiées par le widget TimeSeriesTable :
Pour configurer la série temporelle à afficher, utilisez le champ
dataSets. Chaque objet du tableaudataSetscorrespond à un seul type de métrique. Si vous interrogez plusieurs types de métriques, la console Google Cloud tente d'afficher la valeur la plus récente pour chaque requête sur la même ligne du tableau. Pour en savoir plus, consultez Comment les tableaux fusionnent les données de plusieurs types de métriques.- Le champ
TimeSeriesQueryspécifie le type de métrique. - Si vous souhaitez que le tableau affiche la valeur agrégée, où les données sont agrégées sur la valeur de période définie par votre tableau de bord, définissez le champ
timeSeriesQuery.outputFullDurationsurtrue.
- Le champ
Pour configurer le nombre maximal de lignes à afficher, définissez le champ
pickTimeSeriesFilter. Par exemple, pour n'afficher que les deux séries temporelles ayant la valeur moyenne la plus élevée au cours des 10 dernières minutes, incluez les éléments suivants :"pickTimeSeriesFilter": { "direction": "TOP", "numTimeSeries": 2, "rankingMethod": "METHOD_MEAN" },Si vous omettez le champ
pickTimeSeriesFilter, le tableau affiche au maximum 300 lignes.Pour configurer l'affichage des données dans le tableau, utilisez le champ
metricVisualization:- Pour n'afficher qu'une valeur telle que "25%", omettez ce champ ou définissez la valeur sur
"NUMBER". Lorsque vous utilisez cette configuration, la consoleGoogle Cloud affiche le widget sous la forme d'un widget Tableau. - Pour afficher la valeur et un indicateur visuel de la valeur par rapport à la plage de valeurs possibles, définissez la valeur de ce champ sur
"BAR". Lorsque vous utilisez cette configuration, la consoleGoogle Cloud affiche le widget sous la forme d'un widget Liste des meilleurs.
- Pour n'afficher qu'une valeur telle que "25%", omettez ce champ ou définissez la valeur sur
Pour configurer les colonnes affichées et leurs propriétés, utilisez le tableau
columnSettings. Si ce champ n'est pas spécifié, le tableau affiche une colonne pour chaque étiquette.La valeur du champ
"column"doit être définie sur une clé d'étiquette ou survalue, qui fait référence à la dernière valeur de la série temporelle. Vous pouvez définir le nom à afficher d'une colonne et configurer l'alignement des données dans la cellule du tableau :- Pour personnaliser l'en-tête de colonne, définissez le champ
displayName. - Pour colorer la cellule qui affiche la valeur la plus récente en fonction de la comparaison de la valeur avec un seuil, ajoutez un objet
thresholds. - Pour modifier l'alignement du texte, ajoutez un champ
alignment.
L'exemple suivant illustre deux colonnes :
"columnSettings": [ { "column": "device_name", "displayName": "Device", "visible": true }, { "alignment": "CENTER", "column": "value", "displayName": "Disk Write Bytes", "thresholds": [ { "color": "YELLOW", "direction": "ABOVE", "value": 4000 }, { "color": "RED", "direction": "ABOVE", "value": 5000 } ], "visible": true } ],- Pour personnaliser l'en-tête de colonne, définissez le champ
Le code JSON suivant décrit un tableau de bord comportant deux tables. Le premier tableau affiche deux types de métriques : le nombre d'octets lus à partir des instances et le nombre d'octets écrits sur les instances. Une valeur agrégée s'affiche avec une barre de référence. Le deuxième tableau affiche la dernière valeur d'un type de métrique, et la colonne de valeur a été configurée pour appliquer un code couleur à la cellule en fonction de la comparaison de la valeur avec un seuil :
{
"displayName": "Example",
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"width": 44,
"height": 17,
"widget": {
"title": "VM Instance - Disk read bytes [RATE], Disk write bytes [RATE]",
"timeSeriesTable": {
"dataSets": [
{
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE",
"groupByFields": []
},
"pickTimeSeriesFilter": {
"rankingMethod": "METHOD_MEAN",
"numTimeSeries": 30,
"direction": "TOP"
}
},
"unitOverride": "",
"outputFullDuration": true
},
"tableTemplate": "",
"minAlignmentPeriod": "60s"
},
{
"timeSeriesQuery": {
"timeSeriesFilter": {
"filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\"",
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE",
"groupByFields": []
},
"pickTimeSeriesFilter": {
"rankingMethod": "METHOD_MEAN",
"numTimeSeries": 30,
"direction": "TOP"
}
},
"unitOverride": "",
"outputFullDuration": true
},
"tableTemplate": "",
"minAlignmentPeriod": "60s"
}
],
"metricVisualization": "BAR",
"columnSettings": [
{
"column": "Name (from instance_id)",
"visible": true
},
{
"column": "zone",
"visible": true
},
{
"column": "device_name",
"visible": true
},
{
"column": "storage_type",
"visible": true
},
{
"column": "device_type",
"visible": true
},
{
"column": "value",
"visible": true,
"displayName": "Read bytes"
},
{
"column": "value-1",
"visible": true,
"displayName": "Written bytes"
}
],
"opsAnalyticsSettings": {
"maxRows": "0",
"showFilterBar": false,
"pageSize": "0"
},
"displayColumnType": false
},
"id": ""
}
},
{
"yPos": 17,
"width": 44,
"height": 16,
"widget": {
"title": "VM Instance - Disk write bytes [RATE]",
"timeSeriesTable": {
"columnSettings": [
{
"column": "device_name",
"displayName": "Device",
"visible": true
},
{
"alignment": "LEFT",
"column": "instance_name",
"displayName": "Instance name",
"visible": true
},
{
"column": "storage_type",
"displayName": "Storage type",
"visible": true
},
{
"column": "device_type",
"displayName": "Device Type",
"visible": true
},
{
"alignment": "CENTER",
"column": "value",
"displayName": "Disk Write Bytes",
"thresholds": [
{
"color": "YELLOW",
"direction": "ABOVE",
"label": "",
"value": 4000
},
{
"color": "RED",
"direction": "ABOVE",
"label": "",
"value": 5000
}
],
"visible": true
},
{
"alignment": "LEFT",
"column": "Name (from instance_id)",
"displayName": "ID",
"visible": true
}
],
"dataSets": [
{
"minAlignmentPeriod": "60s",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
}
}
}
],
"displayColumnType": false,
"metricVisualization": "NUMBER",
"opsAnalyticsSettings": {
"maxRows": "0",
"pageSize": "0",
"showFilterBar": false
}
}
}
}
]
},
"dashboardFilters": [],
"labels": {}
}
La capture d'écran suivante illustre la table définie précédemment :
Tableau de bord avec un widget Text
Cet exemple montre un tableau de bord avec un widget Text.
{
"dashboardFilters": [],
"displayName": "DB2+TE",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
...
{
"height": 16,
"widget": {
"text": {
"content": "# Support information\n\n\nContact information: my-support-team@example.com\nOnline help: [Playbooks](https://example.com)\n\n",
"format": "MARKDOWN",
"style": {
"backgroundColor": "",
"fontSize": "FS_LARGE",
"horizontalAlignment": "H_LEFT",
"padding": "P_EXTRA_SMALL",
"textColor": "",
"verticalAlignment": "V_TOP"
}
}
},
"width": 24,
"yPos": 14
}
]
}
}
Le widget de texte ressemble à l'exemple suivant :
Tableau de bord avec un widget AlertChart
Cet exemple montre un tableau de bord avec un widget AlertChart :
{
"category": "CUSTOM",
"displayName": "Alerting policy chart example",
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"height": 4,
"widget": {
"alertChart": {
"name": "projects/my-project/alertPolicies/14205854094151528373"
}
},
"width": 6,
}
]
}
}
Contrairement aux autres widgets de tableau de bord, vous ne spécifiez pas de titre ni de filtre de métriques pour ces widgets. À la place, vous devez spécifier le nom de ressource pour une règle d'alerte. La dernière entrée du champ name correspond à l'identifiant de la règle d'alerte.
Le graphique du tableau de bord ressemble à l'exemple suivant :
Dans cet exemple, la règle d'alerte surveille l'utilisation du processeur de deux machines virtuelles différentes. La ligne en pointillé affiche le seuil de condition, qui est défini sur 50%. Le chip vert portant l'étiquette No alerts indique qu'il n'y a aucune alerte ouverte pour la règle d'alerte. Si vous placez le pointeur sur le chip d'alerte, une boîte de dialogue s'ouvre et renvoie vers la règle d'alerte sous-jacente.
Tableau de bord avec un widget ErrorReportingPanel
Cet exemple montre un tableau de bord avec un widget ErrorReportingPanel :
{
"dashboardFilters": [],
"displayName": "Error reporting widget",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"errorReportingPanel": {
"projectNames": [
"projects/my-project"
],
"services": [],
"versions": []
},
"title": "Error Reporting Panel"
},
"width": 24,
}
]
}
}
Nous vous recommandons de configurer la hauteur d'un panneau de rapport d'erreurs sur au moins 16 unités et sa largeur sur au moins 24 unités. Dans l'exemple précédent, le widget a une hauteur de 16 unités et une largeur de 24 unités.
Le panneau de rapport d'erreurs affiche les groupes d'erreurs du projet sélectionné. Ce panneau peut limiter les groupes d'erreurs à un type de ressource, un service ou une version de service spécifique. L'exemple suivant illustre un panneau de signalement d'erreurs :
Tableau de bord avec un widget FilterControl
Si vous créez une variable, Monitoring met à jour la barre d'outils de votre tableau de bord personnalisé pour afficher un filtre pour la variable. Le nom du filtre est un signe dollar $ suivi du nom de la variable.
Exemple :$my-variable Chaque filtre contient un menu qui vous permet de modifier la valeur de la variable.
La gestion de la valeur d'une variable à l'aide d'un filtre de barre d'outils n'est peut-être pas optimale. Par exemple, supposons que vous disposiez d'un tableau de bord comportant de nombreux graphiques et que vous ayez une variable qui ne s'applique qu'à deux graphiques. Dans ce scénario, vous pouvez procéder comme suit :
- Ajoutez un widget
CollapsibleGroupà votre tableau de bord et placez ces deux graphiques dans le groupe. Ajoutez un widget
FilterControlà votre tableau de bord. Vous configurez ce widget pour la variable et vous l'ajoutez également au groupe.Le widget de groupe contient le widget
FilterControl, qui vous permet de modifier la valeur de la variable, ainsi que les widgets auxquels la variable s'applique. De plus, la barre d'outils du tableau de bord n'affiche plus de filtre pour la variable.
Le tableau de bord suivant contient un widget FilterControl :
{
"displayName": "Dashboard with filter control widget",
"dashboardFilters": [
{
"filterType": "RESOURCE_LABEL",
"labelKey": "project_id",
"stringValue": "my-project",
"templateVariable": "proj",
"valueType": "STRING"
}
],
"description": "",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"yPos": 70,
"height": 5,
"width": 16,
"widget": {
"title": "Project control",
"filterControl": {
"templateVariable": "proj"
}
}
}
]
}
}
L'exemple précédent définit une variable, proj, et ajoute un widget FilterControl. Avec cette configuration, le menu de la variable est déplacé de la barre d'outils du tableau de bord vers le widget intitulé Project control.
Ce widget contient un menu que vous pouvez utiliser pour sélectionner le projet.
Tableau de bord avec un widget IncidentList pour lister les alertes
Cet exemple montre un tableau de bord avec un widget IncidentList pour lister les alertes :
{
"category": "CUSTOM",
"dashboardFilters": [],
"displayName": "Incident widget",
"labels": {},
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"height": 5,
"widget": {
"incidentList": {
"monitoredResources": [],
"policyNames": []
},
"title": "Alerts"
},
"width": 8,
"xPos": 0,
"yPos": 0
}
]
}
}
L'exemple précédent définit le champ title sur Alerts et configure le widget pour afficher toutes les alertes pour les ressources de type gce_instance.
Lorsque vous configurez ce widget, vous pouvez sélectionner plusieurs règles d'alerte ou plusieurs types de ressources.
Dans la console Google Cloud , le widget est appelé widget Alertes. Le widget ressemble à l'exemple suivant :
Tableau de bord avec un widget LogsPanel
Cet exemple montre un tableau de bord avec un widget LogsPanel :
{
"category": "CUSTOM",
"displayName": "Logs Panel",
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"height": 4,
"widget": {
"logsPanel": {
"filter": "",
"resourceNames": [
"projects/012012012012"
]
},
"title": "Logs Panel"
},
"width": 6,
"xPos": 0,
"yPos": 0
}
]
}
}
Nous vous recommandons de configurer un panneau de journaux avec une hauteur d'au moins trois unités et une largeur d'au moins quatre unités. Dans l'exemple précédent, le widget a une hauteur de quatre unités et une largeur de six unités.
Le panneau des journaux affiche les journaux des projets Google Cloud répertoriés dans le champ resourceNames. L'exemple précédent ne spécifie qu'un seul projet. Cependant, vous pouvez inclure plusieurs projets dans cette liste.
Le panneau des journaux ressemble à l'exemple suivant :
Pour obtenir des informations de dépannage, consultez la section Échec de l'appel d'API pour créer un tableau de bord avec un panneau de journaux.
Tableau de bord avec un widget CollapsibleGroup
Cet exemple montre un tableau de bord avec un widget CollapsibleGroup :
{
"category": "CUSTOM",
"displayName": "Group testing",
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"height": 4,
"widget": {
"collapsibleGroup": {
"collapsed": false
},
"title": "My group"
},
"width": 12,
"xPos": 0,
"yPos": 0
},
{
"height": 4,
"widget": {
"title": "VM Instance - CPU utilization [MEAN]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"apiSource": "DEFAULT_CLOUD",
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_NONE",
"perSeriesAligner": "ALIGN_MEAN"
},
"filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\"",
"secondaryAggregation": {
"alignmentPeriod": "60s",
"crossSeriesReducer": "REDUCE_NONE",
"perSeriesAligner": "ALIGN_NONE"
}
}
}
}
],
"thresholds": [],
"timeshiftDuration": "0s",
"yAxis": {
"label": "y1Axis",
"scale": "LINEAR"
}
}
},
"width": 6,
"xPos": 0,
"yPos": 0
}
]
}
}
Dans l'exemple précédent, le widget de groupe réductible contient un seul graphique qui affiche l'utilisation du processeur d'une instance de VM. Les widgets de groupe réductible s'étendent sur une ligne entière d'un tableau. Un widget est inclus dans un groupe lorsque les spécifications de position (x,y) et de hauteur du groupe incluent la position (x,y) du widget. Dans l'exemple précédent, le groupe se trouve à la position (0,0) et sa hauteur est de 4. Le xyChart se trouve à la position (0,0). Il est donc inclus dans le groupe. Toutefois, si la position de ce graphique est modifiée pour être (0,5), le graphique est exclu du groupe. Enfin, lorsque la position (x,y) d'un widget entraîne son inclusion dans le groupe, la hauteur du widget de groupe réductible peut être augmentée.
Pour inclure un widget de groupe dans un tableau de bord, celui-ci doit comporter un MosaicLayout.
Le widget de groupe réductible ressemble à l'exemple suivant :
Tableau de bord avec un widget SingleViewGroup
Un widget SingleViewGroup affiche un membre d'un groupe à la fois. Vous spécifiez les graphiques et autres widgets qui sont membres du groupe. Vous pouvez également contrôler quel widget du groupe est affiché à l'aide d'un menu sur le widget SingleViewGroup.
Le widget SingleViewGroup accepte deux styles d'affichage : DROPDOWN et TAB. La différence entre ces deux styles réside dans la manière dont vous sélectionnez le membre du groupe à afficher. Les widgets de style DROPDOWN fournissent un menu. Les widgets de style TAB fournissent des onglets dans la barre d'outils du widget :
{
"dashboardFilters": [],
"displayName": "Example",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"singleViewGroup": {
"displayType": "DROPDOWN"
},
"title": "Untitled group"
},
"width": 24,
"yPos": 16
},
{
"height": 16,
"widget": {
"title": "VM Instance - Disk read bytes [RATE]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24,
"yPos": 16
},
{
"height": 16,
"widget": {
"title": "VM Instance - Disk write bytes [RATE]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24,
"yPos": 16
}
]
}
}
Comme indiqué dans l'exemple précédent, le tableau tiles contient un objet SingleViewGroup. Toutefois, cet objet ne spécifie pas les objets qu'il contient. L'appartenance à l'objet SingleViewGroup est déterminée par les valeurs des champs width et yPos. Les objets dont les valeurs des champs width et yPos correspondent aux valeurs de l'objet SingleViewGroup sont contenus dans l'objet SingleViewGroup. Dans l'exemple précédent, l'objet SingleViewGroup contient deux graphiques.
Tableau de bord avec un widget SectionHeader
Un widget SectionHeader crée un séparateur horizontal dans votre tableau de bord et une entrée dans la table des matières du tableau de bord. Vous pouvez personnaliser l'entrée dans la table des matières et inclure des informations supplémentaires dans le widget. Vous pouvez également configurer le widget pour ajouter un séparateur à la table des matières après l'entrée d'en-tête de section.
Cet exemple montre un tableau de bord avec un seul graphique et un widget SectionHeader :
{
"dashboardFilters": [],
"displayName": "Example",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "VM Instance - Disk write bytes [RATE]",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"minAlignmentPeriod": "60s",
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"alignmentPeriod": "60s",
"perSeriesAligner": "ALIGN_RATE"
},
"filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
}
}
}
],
"thresholds": [],
"yAxis": {
"label": "",
"scale": "LINEAR"
}
}
},
"width": 24,
"yPos": 4
},
{
"height": 4,
"widget": {
"sectionHeader": {
"dividerBelow": true,
"subtitle": "Instance metrics"
},
"title": "Metrics"
},
"width": 48
}
]
}
}
Dans l'objet SectionHeader, la valeur du champ title s'affiche à la fois dans le widget et dans la table des matières. La valeur du champ subtitle n'est affichée que par le widget. Lorsque la valeur de dividerBelow est true, une séparation est ajoutée à la table des matières.
Tableau de bord avec un widget SLO
Cet exemple montre un tableau de bord avec un widget de SLO :
{
"dashboardFilters": [],
"displayName": "Example",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"title": "SLO Error Budget: 99.5% - Distribution Cut - Calendar month",
"xyChart": {
"chartOptions": {
"mode": "COLOR"
},
"dataSets": [
{
"breakdowns": [],
"dimensions": [],
"legendTemplate": "Remaining error requests before SLO is burned",
"measures": [],
"plotType": "LINE",
"targetAxis": "Y1",
"timeSeriesQuery": {
"timeSeriesFilter": {
"aggregation": {
"perSeriesAligner": "ALIGN_NEXT_OLDER"
},
"filter": "select_slo_budget(\"projects/Project_Number/services/SERVICE_ID/serviceLevelObjectives/SLO_ID\")",
},
"unitOverride": "1"
}
}
],
"thresholds": []
}
},
"width": 24
}
]
}
}
Comme le montre le code JSON précédent, les graphiques de SLO sont représentés sous forme d'objets XyChart. Ces objets spécifient tous les champs d'agrégation, les seuils et la valeur du champ filter est un sélecteur de séries temporelles. Pour en savoir plus sur ces sélecteurs, consultez Récupérer des données de SLO.
Le widget SLO ressemble à l'exemple suivant :
Tableau de bord avec des données de trace
Pour afficher les données de trace sur un tableau de bord, vous utilisez une structure XyChart ou TimeSeriesTable.
Lorsque vous souhaitez une carte de densité ou un graphique en courbes, utilisez la structure XyChart. Pour un affichage sous forme de tableau, utilisez la structure TimeSeriesTable.
Ce tableau de bord affiche les données de trace sous forme de carte de densité et dans deux tableaux :
{
"displayName": "Example trace chart",
"dashboardFilters": [],
"description": "",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 22,
"width": 48,
"widget": {
"title": "Visualizer",
"xyChart": {
"chartOptions": {
"displayHorizontal": false,
"mode": "COLOR"
},
"dataSets": [
{
"plotType": "HEATMAP",
"timeSeriesQuery": {
"traceQuery": {
"resourceContainer": "projects/my-project",
"spanDataValue": "SPAN_DURATION",
"spanFilters": {
"apphubServices": [],
"apphubWorkloads": [],
"applicationIds": [],
"attributes": [],
"displayNames": [
"/taskqueue.QueryAndOwnTasks"
],
"isRootSpan": false,
"kinds": [],
"services": [],
"status": []
}
}
}
}
],
"thresholds": [],
"yAxis": {
"scale": "LINEAR"
}
}
}
},
{
"yPos": 22,
"height": 16,
"width": 24,
"widget": {
"title": "Grouped span table",
"timeSeriesTable": {
"columnSettings": [],
"dataSets": [
{
"breakdowns": [
{
"aggregationFunction": {
"type": "none"
},
"column": "serviceOrWorkload",
"limit": 0,
"sortOrder": "SORT_ORDER_NONE"
}
],
"timeSeriesQuery": {
"traceQuery": {
"resourceContainer": "projects/my-project",
"spanDataValue": "SPAN_DURATION",
"spanFilters": {
"apphubServices": [],
"apphubWorkloads": [],
"applicationIds": [],
"attributes": [],
"displayNames": [],
"isRootSpan": false,
"kinds": [],
"services": [],
"status": []
}
}
}
}
],
"metricVisualization": "NUMBER"
}
}
},
{
"yPos": 22,
"xPos": 24,
"height": 16,
"width": 24,
"widget": {
"title": "Span table",
"timeSeriesTable": {
"columnSettings": [],
"dataSets": [
{
"timeSeriesQuery": {
"traceQuery": {
"resourceContainer": "projects/my-project",
"spanDataValue": "SPAN_DURATION",
"spanFilters": {
"apphubServices": [],
"apphubWorkloads": [],
"applicationIds": [],
"attributes": [],
"displayNames": [],
"isRootSpan": false,
"kinds": [],
"services": [],
"status": []
}
}
}
}
],
"metricVisualization": "NUMBER"
}
}
}
]
}
}
Comme indiqué dans le code JSON précédent, vous pouvez configurer des filtres et les appliquer à des objets individuels.
Le tableau de bord ressemble à l'image suivante :
Tableau de bord avec un widget vide
Cet exemple montre un tableau de bord avec un widget d'espace réservé vide.
La valeur du champ displayName apparaît dans le widget.
{
"displayName": "Demo Dashboard",
"gridLayout": {
"widgets": [
{
"blank": {}
}
]
}
}
Le tableau de bord ressemble à l'exemple suivant :
Tableau de bord avec visibilité des widgets configurée
Ce tableau de bord contient un widget de texte et une variable. La valeur de la variable détermine si le widget de texte est affiché ou masqué :
La variable nommée
showa une valeur par défaut dea. Les valeurs de la variable sont définies comme suit :a,betc. Comme le champvalueTypeestSTRING_ARRAY, la variable peut également être définie sur des valeurs telles quea or b.Dans le widget de texte, l'entrée intitulée
visibilityConditiondéfinit la visibilité du widget. Lorsque la valeur de la variableshowinclutb, le widget de texte s'affiche. Sinon, le widget de texte ne s'affiche pas.
{
"displayName": "Conditional Widget Example",
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"yPos": 16,
"width": 24,
"height": 16,
"widget": {
"title": "A text widget",
"text": {
"content": "Example showing how to use a custom variable to control visibility.",
"format": "MARKDOWN",
"style": {
"backgroundColor": "#FFFFFF",
"fontSize": "FS_LARGE",
"horizontalAlignment": "H_LEFT",
"padding": "P_EXTRA_SMALL",
"pointerLocation": "POINTER_LOCATION_UNSPECIFIED",
"textColor": "#212121",
"verticalAlignment": "V_TOP"
}
},
"visibilityCondition": {
"templateVariableCondition": {
"templateVariable": "show",
"templateVariableValue": "b",
"comparator": "REGEX_FULL_MATCH"
}
}
}
}
]
},
"dashboardFilters": [
{
"labelKey": "",
"templateVariable": "show",
"stringArrayValue": {
"values": [
"a"
]
},
"filterType": "VALUE_ONLY",
"valueType": "STRING_ARRAY",
"stringArray": {
"values": [
"a",
"b",
"c"
]
}
}
],
"labels": {}
}
Pour connaître les restrictions liées à la configuration de la visibilité d'un widget, consultez Définir la visibilité d'un widget.