Cette page explique comment créer des tableaux de bord à l'aide de l'API Cloud Monitoring. Pour chaque exemple, la définition du tableau de bord au format JSON et le tableau de bord correspondant sont affichés. Vous pouvez fournir JSON vers la Google Cloud CLI et les points de terminaison de l'API Cloud Monitoring.
Cloud Monitoring fournit également un ensemble organisé de définitions de tableau de bord sur GitHub. Vous pouvez installer ces définitions dans votre projet Google Cloud en tant que tableaux de bord personnalisés. Pour en savoir plus sur ce dépôt et sur l'installation de ces tableaux de bord, consultez la page Installer des exemples de tableaux de bord.
Quand utiliser l'API ou la Google Cloud CLI
Avec l'API Cloud Monitoring et la Google Cloud CLI, vous pouvez la gestion de plusieurs tableaux de bord à la fois. Même si vous pouvez utiliser la console Google Cloud pour gérer vos tableaux de bord, vous trouverez peut-être qu'il est plus facile d'utiliser des scripts qui gèrent des tableaux de bord personnalisés de façon 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 pouvez créer des tableaux de bord à l'aide de la méthode dashboards.create
.
. Vous transmettez à la méthode de l'API un objet Dashboard
, qui contient une entrée pour chaque widget affiché dans le tableau de bord.
Lorsqu'un widget affiche des données de série temporelle, 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
dans un graphique. Vous spécifiez ces données à l'aide d'un
Filtre Monitoring, un
Requête MQL ou requête PromQL:
Pour utiliser des filtres de surveillance, renseignez le champ
timeSeriesField
. 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, remplissez le champ
prometheusQuery
. Pour obtenir des informations générales, consultez la page PromQL dans Cloud Monitoring.
Dispositions de tableaux de bord
Cette section contient des informations sur les différentes dispositions des tableaux 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 les événements,
comme un événement de mise à jour Google Kubernetes Engine ou de défaillance d'une machine virtuelle,
en incluant un champ annotations
dans le fichier Dashboard
.
. Le champ annotations
contient une instance d'un objet DashboardAnnotations
, qui contient deux champs :
Le champ
defaultResourceName
liste les valeurs par défaut au niveau du tableau de bord pour les projets Google Cloud à rechercher des événements. Si vous ne spécifiez pas ce champ, le projet sélectionné est recherché.Tableau d'objets
EventAnnotation
. Chaque contient les éléments suivants:- Champ
displayName
, qui vous permet de définir le libellé du bouton d'activation/de désactivation spécifique à l'événement. Si ce champ n'est pas spécifié ou lorsque la valeur de ce champ est une chaîne vide, le nom par défaut de l'événement s'affiche. - Champ
enabled
, qui contrôle la valeur du bouton d'activation/de désactivation de l'événement. Lorsquetrue
, le bouton bascule est en positionon
et les événements s'affichent sur le tableau de bord. Lorsque la valeur estfalse
, le bouton est en positionoff
. - Champ
eventType
, qui contient une valeur de l'énumérationEventType
. - 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, alors c'est la requête spécifique à l'événement qui est utilisée. - Un champ
resourceNames
, qui vous permet de définir une liste de projets Google Cloud pour rechercher des événements. Lorsque ce champ est un tableau vide, la recherche est effectuée sur le projet sélectionné.
- 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
permet de limiter la requête au cluster my-name
. Le champ displayName
étant défini sur une chaîne vide, le nom par défaut du type d'événement s'affiche sur le bouton d'activation/de désactivation de l'événement. Enfin, comme 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 aux tableaux de bord
Vous pouvez ajouter des filtres permanents à un tableau de bord qui contrôlent les données affichées par les widgets. Pour obtenir un exemple de tableau de bord avec un filtre permanent, consultez la section Filtres du tableau de bord.
Ajouter des étiquettes 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 un libellé à un tableau de bord, définissez key
sur le nom du libellé et le champ value
sur une chaîne vide.
L'ajout de libellés à 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
Ce tableau de bord affiche un tableau de bord comportant un widget XyChart
de base. Si
vous avez déjà utilisé la console Google Cloud pour créer des graphiques sur des tableaux de bord,
sont des instances du widget XyChart
.
À l'instar de la fonctionnalité fournie dans la console Google Cloud, l'API propose des options permettant de modifier la ressource PlotType
ou de configurer les modes d'affichage du graphique.
{
"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 montre comment créer un widget de graphique d'Analyse de journaux, afficher un seuil sur un graphique et configurer si le graphique utilise l'axe Y de gauche, l'axe Y de droite ou les deux.
Tableau de bord avec un graphique d'Analyse de journaux
Ce tableau de bord affiche un tableau de bord avec un graphique Log Analytics. La exemple de 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 `TABLE_NAME_OF_LOG_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
Ce tableau de bord affiche un tableau de bord comportant un XyChart
de base, un seuil et l'axe y à 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 de gauche et de droite. L'exemple précédent
illustrait un graphique avec
Un type de métrique unique, c'est-à-dire que le tableau dataSets
comporte un élément.
Lorsque vous représentez 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 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 utilise le rouge pour indiquer qu'il est supérieur à 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
}
]
}
}
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, afin d'indiquer 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,
},
Vous trouverez ci-dessous la spécification complète du tableau de bord modifié. 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_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
}
]
}
}
Le graphique de ce tableau de bord ressemble à l'exemple suivant:
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 des données à l'aide d'un diagramme circulaire. Chaque série temporelle contribue un segment au camembert. Les graphiques à secteurs n'affichent pas les données au fil du temps. Ils n'affichent que la valeur la plus récente.
Tous les graphiques à secteurs sont spécifiés par le widget PieChart
.
Pour configurer le graphique afin d'afficher la somme des mesures les plus récentes, procédez comme suit :
définissez le champ chartType
sur DONUT
. Sinon, définissez ce champ sur la valeur
la valeur de PIE
.
"pieChart": {
"chartType": "DONUT",
},
L'exemple suivant configure un tableau de bord avec deux graphiques circulaires, dont l'un est configuré en tant que graphique 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 la forme d'un graphique à secteurs, avec un widget affichant la somme des valeurs les plus récentes:
Tableau de bord avec un widget TimeSeriesTable
Les tableaux de bord peuvent afficher les données sous forme de tableau, lorsqu'il en existe une 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 dans le tableaudataSets
correspond à 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 dans le même ligne du tableau. Pour en savoir plus, consultez la section Comment les tableaux fusionnent-ils les données de plusieurs types de métriques ?.- Le champ
TimeSeriesQuery
spé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 la période définie par votre tableau de bord, définissez le champ
timeSeriesQuery.outputFullDuration
surtrue
.
- Le champ
Pour configurer le nombre maximal de lignes à afficher, définissez le
pickTimeSeriesFilter
. Par exemple, pour n'afficher que les deux avec la valeur moyenne la plus élevée au cours des 10 dernières minutes, incluent les éléments suivants:"pickTimeSeriesFilter": { "direction": "TOP", "numTimeSeries": 2, "rankingMethod": "METHOD_MEAN" },
Si vous omettez le champ
pickTimeSeriesFilter
, la table affiche de 300 lignes au maximum.Pour configurer la façon dont le tableau affiche les données, utilisez le champ
metricVisualization
:- Pour n'afficher qu'une valeur de type "25 %", omettez ce champ ou définissez la
sur
"NUMBER"
. Lorsque vous utilisez cette configuration, La console Google Cloud affiche le widget en tant que widget Table. - 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 console Google Cloud affiche le widget sous forme de widget Top List.
- Pour n'afficher qu'une valeur de type "25 %", omettez ce champ ou définissez la
sur
Pour configurer les colonnes affichées et les propriétés de la colonne, utilisez le tableau
columnSettings
. Si ce champ n'est pas spécifié, alors le tableau affiche une colonne pour chaque étiquette.La valeur du champ
"column"
doit être définie sur la 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 pour une colonne et configurer l'alignement des données dans la cellule de la table :- 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 façon dont la
à 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 avec deux tableaux. Le premier tableau affiche deux types de métriques : le nombre d'octets lus à partir des instances et le nombre d'octets écrits dans les instances. Une valeur agrégée est affichée 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 comparer la valeur à 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
Ce tableau de bord affiche un tableau de bord comportant 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%. L'icône verte portant le libellé No incidents
indique qu'aucun incident n'est ouvert pour la règle d'alerte. Si vous placez votre pointeur sur l'icône d'incident, une boîte de dialogue s'ouvre et renvoie vers la règle d'alerte sous-jacente.
Tableau de bord avec un widget ErrorReportingPanel
Ce tableau de bord affiche un tableau de bord comportant 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 un panneau de signalement d'erreurs avec une hauteur d'au moins 16 unités et une largeur d'au moins 24 unités. Lors de Par exemple, le widget a une hauteur de 16 unités et une largeur de 24 unités.
Le panneau de création de rapports d'erreurs affiche les groupes d'erreurs des projet. Ce panneau peut limiter les groupes d'erreurs à une ressource spécifique le type, le service ou la version d'un service. L'exemple suivant illustre un panneau de création de rapports d'erreurs:
Tableau de bord avec un widget IncidentList
Ce tableau de bord affiche un tableau de bord comportant un widget IncidentList
:
{
"category": "CUSTOM",
"dashboardFilters": [],
"displayName": "Incident widget",
"labels": {},
"mosaicLayout": {
"columns": 12,
"tiles": [
{
"height": 5,
"widget": {
"incidentList": {
"monitoredResources": [],
"policyNames": []
},
"title": "Incidents"
},
"width": 8,
"xPos": 0,
"yPos": 0
}
]
}
}
L'exemple précédent définit le champ title
sur Incidents
et configure
le widget permettant d'afficher tous les incidents 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.
Le widget d'incident du tableau de bord ressemble à l'exemple suivant:
Tableau de bord avec un widget LogsPanel
Ce tableau de bord 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 listé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
Ce tableau de bord 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éductibles couvrent une ligne entière d'un tableau. Un widget est inclus dans un groupe lorsque la
les spécifications de position et de hauteur (x,y) du groupe incluent les (x,y)
la position 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 étendue.
Pour inclure un widget de groupe dans un tableau de bord, celui-ci doit disposer d'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 les autres widgets
dans le groupe. Vous pouvez également contrôler quel widget du groupe s'affiche.
à l'aide d'un menu dans le widget SingleViewGroup
.
Ce tableau de bord montre un tableau de bord avec un widget SingleViewGroup
:
{
"dashboardFilters": [],
"displayName": "Example",
"labels": {},
"mosaicLayout": {
"columns": 48,
"tiles": [
{
"height": 16,
"widget": {
"singleViewGroup": {},
"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. À la place, l'appartenance à l'objet SingleViewGroup
est déterminée
par les valeurs des champs width
et yPos
. Les objets dont les valeurs
Les champs width
et yPos
correspondent aux
de l'objet SingleViewGroup
sont contenues dans
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 cela crée une entrée dans la table du tableau de bord
contenus. 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 de l'en-tête de section.
Ce tableau de bord affiche 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 paramètre
Le champ subtitle
n'est affiché 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
Ce tableau de bord montre un tableau de bord avec un widget 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
Objets XyChart
. Ces objets spécifient tous
les champs d'agrégation, les seuils
la valeur du champ filter
est un sélecteur de série temporelle. Pour plus d'informations
sur ces sélecteurs, consultez la section Récupérer les données de SLO.
Le widget SLO ressemble à l'exemple suivant:
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 :