Esempi di dashboard e layout

Questa pagina illustra come creare dashboard utilizzando l'API Cloud Monitoring. Per ogni esempio vengono mostrate la definizione della dashboard in JSON e la dashboard corrispondente.

Cloud Monitoring offre inoltre un set selezionato di definizioni di dashboard su GitHub. Puoi installare queste definizioni nel tuo progetto Google Cloud come dashboard personalizzate. Per informazioni su questo repository e su come installarle, consulta Installare dashboard di esempio.

Quando utilizzare l'API

L'API Cloud Monitoring consente di gestire molte dashboard contemporaneamente. Sebbene sia possibile utilizzare la console Google Cloud per gestire le dashboard, potrebbe essere più semplice utilizzare l'API per gestire le dashboard personalizzate in blocco.

Devi utilizzare l'API anche quando vuoi aggiungere il widget segnaposto vuoto alla tua dashboard.

Utilizzo di MQL o PromQL con l'API

Puoi creare le dashboard utilizzando il metodo dashboards.create. Passi al metodo API un oggetto Dashboard, che contiene una voce per ogni widget visualizzato nella dashboard.

Quando un widget mostra dati di serie temporali, ad esempio un widget grafico, la relativa voce nell'oggetto Dashboard contiene un oggetto TimeSeriesQuery. Questo oggetto descrive i dati della serie temporale da rappresentare in un grafico e puoi specificare tali dati utilizzando un filtro di Monitoring, una query MQL o una query PromQL:

• Per utilizzare i filtri di Monitoring, compila il campo timeSeriesField. Gli esempi in questa pagina utilizzano i filtri di Cloud Monitoring.

• Per utilizzare una query MQL, compila il campo timeSeriesQueryLanguage. Per ulteriori informazioni, consulta la sezione Creare grafici.

• Per usare una query PromQL, compila il campo prometheusQuery. Per informazioni generali, vedi PromQL in Cloud Monitoring.

Layout della dashboard

Questa sezione contiene informazioni sui diversi layout di dashboard disponibili.

Dashboard in GridLayout

Questa dashboard mostra una GridLayout con tre widget.

{
  "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"
          }
        }
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Dashboard in MosaicLayout

Questa dashboard mostra una MosaicLayout con due widget.

{
  "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"
            }
          }
        }
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Dashboard in RowLayout

Questa dashboard mostra una RowLayout con tre widget.

{
  "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"
            }
          }
        ]
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Dashboard in ColumnLayout

Questa dashboard mostra un elemento ColumnLayout con tre widget.

{
  "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"
            }
          }
        ]
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Abilita gli eventi della dashboard e aggiungi filtri ed etichette

Questa sezione descrive come aggiungere filtri ed etichette a una dashboard e come configurarne una per mostrare gli eventi.

Abilita gli eventi nelle dashboard

Puoi configurare una dashboard per mostrare gli eventi, ad esempio un evento di aggiornamento di Google Kubernetes Engine o un evento di errore di una macchina virtuale, includendo un campo annotations nell'oggetto Dashboard. Il campo annotations contiene un'istanza di un oggetto DashboardAnnotations, che contiene due campi:

• Il campo defaultResourceName elenca i valori predefiniti a livello di dashboard per i progetti Google Cloud in cui cercare eventi. Se non specifichi questo campo, la ricerca viene eseguita nel progetto selezionato.

• Un array di oggetti EventAnnotation. Ogni oggetto contiene quanto segue:

  • Un campo displayName, che consente di definire l'etichetta sul pulsante di attivazione/disattivazione specifico dell'evento. Quando questo campo non viene specificato o se il valore di questo campo è una stringa vuota, viene visualizzato il nome predefinito dell'evento.
  • Un campo enabled, che controlla il valore del pulsante di attivazione/disattivazione dell'evento. Quando true, il pulsante di attivazione/disattivazione è nella posizione on e gli eventi vengono visualizzati nella dashboard. Quando false, il pulsante di attivazione/disattivazione è nella posizione off.
  • Un campo eventType, che contiene un valore dell'enumerazione EventType.
  • Un campo filter, che consente di specificare una query da aggiungere alla query specifica dell'evento. Quando il valore di questo campo è una stringa vuota, viene usata la query specifica dell'evento.
  • Un campo resourceNames, che consente di definire un elenco di progetti Google Cloud in cui cercare eventi. Quando questo campo è un array vuoto, la ricerca viene eseguita nel progetto selezionato.

L'esempio seguente mostra un campo annotations che specifica un evento di 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": {}
}

Nell'esempio precedente, il campo filter viene utilizzato per limitare la query al cluster my-name. Il campo displayName è impostato su una stringa vuota, quindi il nome predefinito per il tipo di evento viene visualizzato sul pulsante di attivazione/disattivazione dell'evento. Infine, poiché resourceNames è impostato su un array vuoto, vengono eseguite query sulle voci di log nel progetto Google Cloud attuale.

Aggiungere filtri alla dashboard

Puoi aggiungere filtri permanenti a una dashboard per controllare quali dati vengono visualizzati sui widget. Per un esempio di dashboard con un filtro permanente, consulta Filtri della dashboard.

Aggiungi etichette della dashboard

Questo esempio mostra un oggetto Dashboard che specifica l'etichetta denominata playbook.

{
  "displayName": "Example",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      ...
    ]
  },
  "dashboardFilters": [],
  "labels": {
    "playbook": ""
  }
}

Come illustrato nell'esempio precedente, il campo labels viene implementato come map, dove i campi key e value sono entrambi stringhe. Quando aggiungi un'etichetta a una dashboard, imposta key sul nome dell'etichetta e imposta il campo value su una stringa vuota.

L'aggiunta di etichette a una dashboard è facoltativa.

Dashboard con Widgets

Questa sezione include esempi di dashboard che contengono diversi tipi di widget.

Dashboard con XyChart

Questa dashboard mostra una dashboard con un elemento XyChart di base. Se hai mai utilizzato la console Google Cloud per creare grafici sulle dashboard, questi grafici sono istanze del widget XyChart.

Analogamente alla funzionalità fornita nella console Google Cloud, l'API offre opzioni per modificare l'elemento PlotType del grafico o per configurare le modalità di visualizzazione del grafico.

{
  "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
      }
    ]
  }
}

Il grafico nella dashboard è simile al seguente esempio:

La sezione successiva illustra come creare un widget del grafico di Analisi dei log, visualizzare una soglia in un grafico e configurare se il grafico utilizza l'asse Y sinistro, l'asse Y destro o entrambi.

Dashboard con un grafico di Analisi dei log

Questa dashboard mostra una dashboard con un grafico di Analisi dei log. Il JSON di esempio contiene una query 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`"
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  },
  "labels": {}
}

Il grafico nella dashboard è simile al seguente esempio:

Dashboard con XyChart e una soglia

Questa dashboard mostra una dashboard con un XyChart di base, una soglia e l'asse Y sinistro configurati.

{
  "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
      }
    ]
  }
}

Nell'esempio precedente, il codice JSON specifica l'utilizzo dell'asse Y sinistro perché contiene una struttura y2Axis. Nel campo targetAxis, utilizza "Y1" per l'asse Y destro e "Y2" per l'asse Y sinistro. Se ometti il campo targetAxis, viene utilizzato l'asse Y destro.

Il grafico in questa dashboard è simile al seguente esempio:

Puoi costruire grafici che visualizzano più tipi di metriche e che utilizzano gli assi sinistro e destro. L'esempio precedente illustrava un grafico con un singolo tipo di metrica, ovvero c'è un elemento nell'array dataSets. Quando crei un grafico con due tipi di metriche, l'array dataSets contiene due elementi e ogni elemento specifica il proprio targetAxis.

Dashboard con XyChart con STACKED_AREA PlotType

Questa dashboard mostra una XyChart con 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
      }
    ]
  }
}

Il grafico nella dashboard è simile al seguente esempio:

Dashboard con un grafico XyChart con STACKED_BAR PlotType

Questa dashboard mostra una XyChart con 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
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Dashboard con Scorecard di base

Questa dashboard mostra un elemento Scorecard senza indicatore o sparkline. L'esempio mostra l'utilizzo della CPU di Compute Engine e il prospetto ha due soglie. Una soglia utilizza il colore giallo per indicare che l'utilizzo della CPU è superiore al 70%, l'altra soglia utilizza il rosso per indicare che l'utilizzo della CPU è superiore al 90%.

Poiché l'utilizzo attuale della CPU è inferiore alle soglie specificate, il colore è verde.

{
  "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
      }
    ]
  }
}

La dashboard è simile all'esempio seguente:

Dashboard con Scorecard e GaugeView

Questa dashboard aggiunge un indicatore al prospetto di base nell'esempio precedente. L'oggetto GaugeView può specificare un limite superiore e uno inferiore per indicare l'intervallo di valori da visualizzare sul misuratore. Poiché il prospetto mostra valori compresi da 0 a 1, i limiti superiore e inferiore sono ragionevoli. Per aggiungere l'indicatore, aggiungi quanto segue al file JSON per il prospetto di base:

  "gaugeView": {
    "lowerBound": 0,
    "upperBound": 1,
  },

Di seguito è riportata la specifica completa della dashboard modificata: Il valore attuale è inferiore alle soglie, che sono colorate in modo appropriato sull'indicatore.

{
  "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
      }
    ]
  }
}

Il grafico in questa dashboard è simile al seguente esempio:

Dashboard con Scorecard e SparkChartView

Questa dashboard sostituisce l'indicatore dell'esempio precedente con uno sparkline. L'oggetto SparkChartView può creare grafici a linee o a barre in un prospetto. In questo esempio viene utilizzata una linea. Se non viola una soglia, il valore è verde. Per aggiungere lo sparkline, sostituisci l'oggetto JSON gaugeView nel grafico precedente con quanto segue:

  "sparkChartView": {
    "sparkChartType": "SPARK_LINE"
  },

Il prospetto è simile al seguente esempio:

Dashboard con un widget PieChart

Le dashboard possono visualizzare i dati utilizzando un grafico a torta. Ogni serie temporale contribuisce con una sezione alla torta. I grafici a torta non mostrano dati nel tempo, ma mostrano solo il valore più recente.

Tutti i grafici a torta sono specificati dal widget PieChart. Per configurare il grafico in modo che mostri la somma delle misurazioni più recenti, imposta il campo chartType su DONUT. In caso contrario, imposta questo campo sul valore PIE.

"pieChart": {
  "chartType": "DONUT",
},

L'esempio seguente configura una dashboard con due grafici a torta, con un grafico a torta configurato come un'anello:

{
  "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
      },
    ]
  }
}

Come mostrato nello screenshot seguente, entrambi i widget visualizzano i dati sotto forma di grafico a torta, con un widget che mostra la somma dei valori più recenti:

Dashboard con un widget TimeSeriesTable

Le dashboard possono visualizzare i dati in formato tabulare, con una riga per ogni serie temporale monitorata. Le tabelle non mostrano dati nel tempo, ma solo il valore più recente.

Tutte le tabelle sono specificate dal widget TimeSeriesTable:

• Per configurare il numero massimo di righe da visualizzare, imposta il campo pickTimeSeriesFilter. Ad esempio, per visualizzare solo le due serie temporali con il valore medio maggiore negli ultimi 10 minuti, includi quanto segue:

  "pickTimeSeriesFilter": {
      "direction": "TOP",
      "numTimeSeries": 2,
      "rankingMethod": "METHOD_MEAN"
  },
  

  Se ometti il campo pickTimeSeriesFilter, la tabella mostra un massimo di 300 righe.

• Per configurare la modalità di visualizzazione dei dati nella tabella, utilizza il campo metricVisualization:

  • Per visualizzare solo un valore come "25%", ometti questo campo o imposta il valore su "NUMBER". Quando utilizzi questa configurazione, la console Google Cloud mostra il widget come widget Tabella.
  • Per visualizzare il valore e un indicatore visivo rispetto all'intervallo dei valori possibili, imposta il valore di questo campo su "BAR". Quando utilizzi questa configurazione, la console Google Cloud mostra il widget come Elenco principale.

• Per configurare quali colonne visualizzare, utilizza il campo columnSettings. L'esempio seguente restituisce una tabella con due colonne, una denominata Latest Value, che è obbligatoria, e l'altra denominata Name (from instance_id):

  "columnSettings": [
    {
      "column": "Name (from instance_id)",
      "visible": true
    }
  ],
  

  Se ometti il campo columnSettings, la tabella mostra una colonna per ogni etichetta.

L'esempio seguente mostra una dashboard con un widget Tabella e un widget Elenco principale:

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "value",
                "visible": false
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "metricVisualization": "NUMBER"
          },
          "title": "Table"
        },
        "width": 24,
        "yPos": 16
      },
      {
        "height": 16,
        "widget": {
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "value",
                "visible": false
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "metricVisualization": "BAR"
          },
          "title": "Top List"
        },
        "width": 24
      }
    ]
  }
}

Come mostrato nello screenshot seguente, entrambi i widget visualizzano i dati in formato tabulare ed entrambi contengono una barra dei filtri. Tuttavia, i due widget sono preconfigurati per mostrare colonne diverse e rappresentare in modo diverso il valore numerico:

Le colonne della tabella corrispondono alle etichette. Ogni riga corrisponde a una serie temporale.

Dashboard con un widget Text

Questo esempio mostra una dashboard con un widget Text.

{
  "dashboardFilters": [],
  "displayName": "DB2+TE",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
    ...
      {
        "height": 16,
        "widget": {
          "text": {
            "content": "# Support information\n\n\nContact information: [e-mail]\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
      }
    ]
  }
}

Il widget del testo è simile al seguente esempio:

Dashboard con un widget AlertChart

Questa dashboard mostra una dashboard con 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,
      }
    ]
  }
}

A differenza degli altri widget della dashboard, non devi specificare un titolo o un filtro delle metriche per questi widget. Puoi invece specificare il nome della risorsa per un criterio di avviso. L'ultima voce nel campo name è l'identificatore del criterio di avviso.

Il grafico nella dashboard è simile al seguente esempio:

In questo esempio, il criterio di avviso monitora l'utilizzo della CPU di due diverse macchine virtuali. La linea tratteggiata mostra la soglia della condizione, impostata su 50%. Il chip verde con l'etichetta No incidents indica che non ci sono incidenti aperti per il criterio di avviso. Se posizioni il puntatore sul chip degli incidenti, si apre una finestra di dialogo che rimanda al criterio di avviso sottostante.

Dashboard con un widget ErrorReportingPanel

Questa dashboard mostra una dashboard con 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,
      }
    ]
  }
}

Ti consigliamo di configurare l'altezza di un riquadro per la segnalazione degli errori in modo che sia di almeno 16 unità e la sua larghezza di almeno 24 unità. Nell'esempio precedente, il widget ha un'altezza di 16 unità e una larghezza di 24 unità.

Il riquadro dei report degli errori mostra i gruppi di errori del progetto selezionato e può limitare i gruppi di errori a un tipo di risorsa, un servizio o una versione specifici di un servizio. L'esempio seguente illustra un riquadro di segnalazione degli errori:

Dashboard con un widget IncidentList

Questa dashboard mostra una dashboard con 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'esempio precedente imposta il campo title su Incidents e configura il widget in modo da visualizzare tutti gli incidenti per le risorse di tipo gce_instance. Quando configuri questo widget, puoi selezionare più criteri di avviso o più tipi di risorse.

Il widget degli incidenti sulla dashboard è simile al seguente esempio:

Dashboard con un widget LogsPanel

Questa dashboard mostra una dashboard con 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
      }
    ]
  }
}

Ti consigliamo di configurare l'altezza di un riquadro dei log su almeno 3 unità e la larghezza di almeno 4 unità. Nell'esempio precedente, il widget ha un'altezza di 4 unità e una larghezza di 6 unità.

Il riquadro dei log visualizza i log dei progetti Google Cloud elencati nel campo resourceNames. L'esempio precedente specifica un solo progetto, ma puoi includere più progetti in questo elenco.

Il riquadro dei log è simile al seguente esempio:

Per informazioni sulla risoluzione dei problemi, consulta La chiamata API per la creazione di una dashboard con un riquadro dei log non funziona.

Dashboard con un widget CollapsibleGroup

Questa dashboard mostra una dashboard con 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
      }
    ]
  }
}

Nell'esempio precedente, il widget dei gruppi comprimibili contiene un singolo grafico che mostra l'utilizzo della CPU di un'istanza VM. I widget di gruppo comprimibili coprono un'intera riga di una tabella. Un widget è incluso in un gruppo quando le specifiche della posizione (x,y) e dell'altezza del gruppo includono la posizione (x,y) del widget. Nell'esempio precedente, il gruppo si trova nella posizione (0,0) e la sua altezza è 4. xyChart è nella posizione (0,0), quindi è incluso nel gruppo. Tuttavia, se la posizione del grafico viene modificata in (0,5), il grafico viene escluso dal gruppo. Infine, quando la posizione (x,y) di un widget comporta l'inclusione del widget nel gruppo, l'altezza del widget del gruppo comprimibile potrebbe essere espansa.

Per includere un widget del gruppo in una dashboard, quest'ultima deve avere un MosaicLayout.

Il widget del gruppo comprimibile è simile al seguente esempio:

Dashboard con un widget SingleViewGroup

Un widget SingleViewGroup mostra un membro di un gruppo alla volta. Puoi specificare i grafici e gli altri widget che sono membri del gruppo. Puoi anche stabilire quale widget del gruppo viene visualizzato usando un menu nel widget SingleViewGroup.

Questa dashboard mostra una dashboard con 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
      }
    ]
  }
}

Come mostrato nell'esempio precedente, l'array tiles contiene un oggetto SingleViewGroup, che però non specifica quali oggetti contiene. L'appartenenza all'oggetto SingleViewGroup è invece determinata dai valori dei campi width e yPos. Gli oggetti i cui valori per i campi width e yPos corrispondono ai valori dell'oggetto SingleViewGroup sono contenuti nell'oggetto SingleViewGroup. Nell'esempio precedente, l'oggetto SingleViewGroup contiene due grafici.

Dashboard con un widget SectionHeader

Un widget SectionHeader crea un divisore orizzontale nella dashboard e una voce nella tabella dei contenuti della dashboard. Puoi personalizzare la voce nel sommario e includere informazioni aggiuntive nel widget. Puoi anche configurare il widget per aggiungere un divisore al sommario dopo la voce dell'intestazione della sezione.

Questa dashboard mostra una dashboard con un singolo grafico e 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
      }
    ]
  }
}

Nell'oggetto SectionHeader, il valore del campo title viene visualizzato sia nel widget sia nel sommario. Il valore del campo subtitle viene visualizzato solo dal widget. Quando il valore di dividerBelow è true, viene aggiunto un divisore al sommario.

Nota: se rimuovi tutti i widget dell'intestazione della sezione da una dashboard, viene rimosso anche il sommario.

Dashboard con un widget SLO

Questa dashboard mostra una dashboard con 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
      }
    ]
  }
}

Come mostra il file JSON precedente, i grafici SLO sono rappresentati come oggetti XyChart. Questi oggetti specificano tutti i campi di aggregazione, le soglie e il valore del campo filter è un selettore di serie temporali. Per ulteriori informazioni su questi selettori, consulta Recupero dei dati dello SLO.

Il widget SLO è simile al seguente esempio:

Dashboard con un widget vuoto

Questo esempio mostra una dashboard con un widget segnaposto vuoto. Il valore del campo displayName viene visualizzato nel widget.

{
  "displayName": "Demo Dashboard",
  "gridLayout": {
    "widgets": [
      {
        "blank": {}
      }
    ]
  }
}

La dashboard è simile all'esempio seguente: