Beispiele für Dashboards und Layouts

Auf dieser Seite wird gezeigt, wie Sie Dashboards mit der Cloud Monitoring API erstellen. Für jedes Beispiel wird die Dashboard-Definition in JSON und das entsprechende Dashboard angezeigt. Sie können sowohl der Google Cloud CLI als auch den Cloud Monitoring API-Endpunkten JSON bereitstellen.

Cloud Monitoring bietet auch eine ausgewählte Gruppe von Dashboard-Definitionen auf GitHub. Sie können diese Definitionen als benutzerdefinierte Dashboards in Ihrem Google Cloud -Projekt installieren. Informationen zu diesem Repository und zur Installation dieser Dashboards finden Sie unter Beispiel-Dashboards installieren.

Wann die API oder die Google Cloud CLI verwendet werden sollte

Mit der Cloud Monitoring API und der Google Cloud CLI können Sie viele Dashboards gleichzeitig verwalten. Sie können zwar auch die Google Cloud -Konsole zur Verwaltung Ihrer Dashboards verwenden, mit Skripts ist die Verwaltung mehrerer benutzerdefinierter Dashboards jedoch einfacher.

Sie müssen die API auch verwenden, wenn Sie das leere Platzhalter-Widget zu Ihrem Dashboard hinzufügen möchten.

MQL oder PromQL mit der API verwenden

Sie erstellen Dashboards mit der Methode dashboards.create. Sie übergeben an die API-Methode ein Dashboard-Objekt, das einen Eintrag für jedes Widget enthält, das im Dashboard angezeigt wird.

Wenn in einem Widget Zeitreihendaten angezeigt werden, z. B. in einem Diagramm-Widget, enthält der zugehörige Eintrag im Dashboard-Objekt ein TimeSeriesQuery-Objekt. Dieses Objekt beschreibt die Zeitachsendaten, die dargestellt werden sollen. Sie geben diese Daten mit einem Monitoring-Filter, einer MQL-Abfrage oder einer PromQL-Abfrage an:

  • Wenn Sie Monitoring-Filter verwenden möchten, füllen Sie das Feld timeSeriesField aus. In den Beispielen auf dieser Seite werden Cloud Monitoring-Filter verwendet.

  • Wenn Sie eine MQL-Abfrage verwenden möchten, füllen Sie das Feld timeSeriesQueryLanguage aus. Weitere Informationen finden Sie unter Diagramme erstellen.

  • Wenn Sie eine PromQL-Abfrage verwenden möchten, füllen Sie das Feld prometheusQuery aus. Allgemeine Informationen finden Sie unter PromQL in Cloud Monitoring.

Dashboard-Layouts

Dieser Abschnitt enthält Informationen zu den verschiedenen verfügbaren Dashboard-Layouts.

Dashboard im GridLayout

In diesem Dashboard wird ein GridLayout mit drei Widgets angezeigt.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit Rasterlayout

Dashboard im MosaicLayout

In diesem Dashboard wird ein MosaicLayout mit zwei Widgets angezeigt.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit Mosaiklayout

Dashboard im RowLayout

In diesem Dashboard wird ein RowLayout mit drei Widgets angezeigt.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit Zeilenlayout

Dashboard im ColumnLayout

In diesem Dashboard wird ein ColumnLayout mit drei Widgets angezeigt.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit Spaltenlayout

Dashboard-Ereignisse aktivieren und Filter und Labels hinzufügen

In diesem Abschnitt wird beschrieben, wie Sie einem Dashboard Filter und Labels hinzufügen und wie Sie ein Dashboard so konfigurieren, dass Ereignisse angezeigt werden.

Ereignisse in Dashboards aktivieren

Sie können ein Dashboard so konfigurieren, dass Ereignisse angezeigt werden, z. B. ein Google Kubernetes Engine-Updateereignis oder ein Ereignis für einen virtuellen Maschinenfehler. Dazu müssen Sie das Feld annotations in das Objekt Dashboard einfügen. Das Feld annotations enthält eine Instanz eines DashboardAnnotations-Objekts, das zwei Felder enthält:

  • Im Feld defaultResourceName sind die Standardeinstellungen auf Dashboard-Ebene für dieGoogle Cloud -Projekte aufgeführt, in denen nach Ereignissen gesucht werden soll. Wenn Sie dieses Feld nicht angeben, wird in Ihrem ausgewählten Projekt gesucht.

  • Ein Array von EventAnnotation-Objekten. Jedes Objekt enthält Folgendes:

    • Ein displayName-Feld, mit dem Sie das Label für den ereignisspezifischen Schalter definieren können. Wenn dieses Feld nicht angegeben ist oder der Wert dieses Felds eine leere Zeichenfolge ist, wird der Standardname für das Ereignis angezeigt.
    • Ein enabled-Feld, das den Wert des Ereignistoggles steuert. Wenn true, befindet sich der Schalter in der Position on und Ereignisse werden im Dashboard angezeigt. Wenn false, befindet sich der Schalter in der Position off.
    • Ein eventType-Feld, das einen Wert aus der EventType-Aufzählung enthält.
    • Ein filter-Feld, mit dem Sie eine Abfrage angeben können, die an die ereignisspezifische Abfrage angehängt werden soll. Wenn der Wert dieses Felds ein leerer String ist, wird die ereignisspezifische Abfrage verwendet.
    • Ein resourceNames-Feld, mit dem Sie eine Liste vonGoogle Cloud -Projekten definieren können, in denen nach Ereignissen gesucht werden soll. Wenn dieses Feld ein leeres Array ist, wird in Ihrem ausgewählten Projekt gesucht.

Im folgenden Beispiel sehen Sie ein annotations-Feld, das ein Google Kubernetes Engine-Ereignis angibt:

{
  "displayName": "Annotation example",
  "annotations": {
    "defaultResourceNames": [],
    "eventAnnotations": [
      {
        "displayName": "",
        "enabled": true,
        "eventType": "GKE_CLUSTER_UPDATE",
        "filter": "resource.labels.cluster_name=my-cluster",
        "resourceNames": []
      }
    ]
  },
  "dashboardFilters": [],
  "mosaicLayout": {
  ...
  },
  "labels": {}
}

Im vorherigen Beispiel wird das Feld filter verwendet, um die Abfrage auf den Cluster my-name zu beschränken. Das Feld displayName ist auf einen leeren String gesetzt, sodass der Standardname für den Ereignistyp auf dem Ein/Aus-Schalter des Ereignisses angezeigt wird. Da resourceNames auf ein leeres Array festgelegt ist, werden die Logeinträge in Ihrem aktuellen Google Cloud Projekt abgefragt.

Dashboardfilter und ‑variablen hinzufügen

Wenn Sie festlegen möchten, welche Daten in den Widgets eines Dashboards angezeigt werden, können Sie Variablen und angepinnte Filter hinzufügen. Variablen unterscheiden sich von angepinnten Filtern dadurch, dass sie für bestimmte Widgets gelten.

Wenn Sie einen angepinnten Filter oder eine angepinnte Variable erstellen, wird die Symbolleiste Ihres benutzerdefinierten Dashboards in Monitoring aktualisiert, um einen Filter anzuzeigen. Bei angepinnten Filtern ist der Name des Symbolleistenfilters der Name des angepinnten Filters. Bei Variablen ist der Name des Symbolleistenfilters ein Dollarzeichen $ gefolgt vom Namen der Variable. Jeder Symbolleistenfilter enthält ein Menü, in dem Sie den Wert des zugehörigen angepinnten Filters oder der zugehörigen angepinnten Variablen ändern können. Bei Variablen können Sie den Symbolleistenfilter durch ein Dashboard-Widget ersetzen. Weitere Informationen finden Sie unter Dashboard mit einem FilterControl-Widget.

Weitere Informationen zu Variablen und angepinnten Filtern sowie dazu, wie Sie eine Variable auf ein Widget anwenden, finden Sie unter Dashboard-Filter.

Dashboard-Labels hinzufügen

In diesem Beispiel wird ein Dashboard-Objekt gezeigt, in dem das Label mit dem Namen playbook angegeben ist.

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

Wie das vorherige Beispiel zeigt, wird das Feld labels als map implementiert, wobei die Felder key und value beide Strings sind. Wenn Sie einem Dashboard ein Label hinzufügen, legen Sie key auf den Namen des Labels und das Feld value auf einen leeren String fest.

Das Hinzufügen von Labels zu einem Dashboard ist optional.

Dashboards mit Widgets

Dieser Abschnitt enthält Beispiele für Dashboards mit verschiedenen Arten von Widgets.

Dashboard mit einem XyChart

In diesem Dashboard sehen Sie ein einfaches XyChart. Wenn Sie schon einmal die Google Cloud Console zum Erstellen von Diagrammen in Dashboards verwendet haben, sind diese Diagramme Instanzen des XyChart-Widgets.

Ähnlich wie die Funktionen in der Google Cloud -Konsole bietet die API Optionen zum Ändern des PlotType oder die Konfiguration der Anzeigemodi von Diagrammen.

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

Das Diagramm im Dashboard sieht ungefähr so aus:

Beispiel für einen XyChart

Im nächsten Abschnitt wird veranschaulicht, wie Sie ein Log Analytics-Diagramm-Widget erstellen, einen Grenzwert in einem Diagramm anzeigen und konfigurieren, ob das Diagramm die linke oder rechte Y-Achse oder beide verwendet.

Dashboard mit einem Log Analytics-Diagramm

Dieses Dashboard enthält ein Dashboard mit einem Log Analytics-Diagramm. Das JSON-Beispiel enthält eine SQL-Abfrage.

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

Das Diagramm im Dashboard sieht ungefähr so aus:

Beispiel für ein XyChart mit einer Log Analytics-SQL-Abfrage.

Dashboard mit einem XyChart und einem Grenzwert

In diesem Dashboard sehen Sie einen einfachen XyChart mit einem Grenzwert und der linken Y-Achse.

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

Im vorherigen Beispiel gibt der JSON-Code die Verwendung der linken Y-Achse an, da er eine y2Axis-Struktur enthält. Verwenden Sie im Feld targetAxis "Y1" für die rechte Y-Achse und "Y2" für die linke Y-Achse. Wenn Sie das Feld targetAxis weglassen, wird die rechte Y-Achse verwendet.

Das Diagramm in diesem Dashboard sieht ungefähr so aus:

Beispiel-XyChart mit der linken Y-Achse und einem Grenzwert

Sie können Diagramme erstellen, in denen mehrere Messwerttypen dargestellt werden und die linke und rechte Achse verwendet werden. Im vorherigen Beispiel wurde ein Diagramm mit einem einzelnen Messwerttyp veranschaulicht. Das bedeutet, dass das dataSets-Array ein Element enthält. Wenn Sie zwei Messwerttypen darstellen, enthält das dataSets-Array zwei Elemente und jedes Element gibt seinen targetAxis an.

Dashboard mit einem XyChart und STACKED_AREA PlotType

Dieses Dashboard enthält ein XyChart mit 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
      }
    ]
  }
}

Das Diagramm im Dashboard sieht ungefähr so aus:

Beispiel-XyChart mit Flächendiagramm

Dashboard mit XyChart und STACKED_BAR PlotType

Dieses Dashboard enthält ein XyChart mit 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
      }
    ]
  }
}

Das Dashboard sieht ungefähr so aus:

Beispiel-XyChart mit Balkendiagramm

Dashboard mit einem einfachen Scorecard

Dieses Dashboard zeigt ein Scorecard ohne Messgerät oder Sparkline. Das Beispiel zeigt die Compute Engine-CPU-Auslastung und die Kurzübersicht (Scorecard) hat zwei Grenzwerte. Ein Grenzwert verwendet eine Farbe gelb, um anzuzeigen, dass die CPU-Auslastung über 70 % liegt, der andere Grenzwert rot, um anzugeben, dass die CPU-Auslastung über 90 % liegt.

Da die aktuelle CPU-Auslastung unter den angegebenen Grenzwerten liegt, ist die Farbe grün.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit Scorecard-Widget

Dashboard mit Scorecard und GaugeView

Dieses Dashboard fügt der einfachen Übersicht im vorherigen Beispiel eine Anzeige hinzu. Das GaugeView-Objekt kann eine Ober- und eine Untergrenze angeben, um den Wertebereich anzugeben, der auf der Anzeige angezeigt werden soll. Da die Kurzübersicht Werte von 0 bis 1 enthält, sind diese Ober- und Untergrenzen angemessen. Fügen Sie der JSON-Datei für die einfache Übersicht Folgendes hinzu:

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

Im Folgenden sehen Sie die vollständige geänderte Dashboard-Spezifikation: Der aktuelle Wert liegt unter den Schwellenwerten, die auf der Anzeige entsprechend eingefärbt sind.

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

Das Diagramm in diesem Dashboard sieht ungefähr so aus:

Beispieldashboard mit einem Scorecard-Widget mit GaugeView

Dashboard mit Scorecard und SparkChartView

Dieses Dashboard ersetzt die Anzeige im vorherigen Beispiel durch eine Sparkline. Das SparkChartView-Objekt kann Liniendiagramme oder Balkendiagramme in einer Kurzübersicht erstellen. In diesem Beispiel wird eine Linie verwendet. Solange der Wert nicht gegen einen Grenzwert verstößt, ist er grün. Um die Sparkline hinzuzufügen, ersetzen Sie das JSON-Objekt gaugeView im vorherigen Diagramm durch Folgendes:

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

Die Übersicht sieht etwa so aus:

Beispieldashboard mit einem Scorecard-Widget mit SparkChartView

Dashboard mit einem PieChart-Widget

In Dashboards können Daten mithilfe eines Kreisdiagramms dargestellt werden. Jede Zeitreihe trägt ein Segment zum Kreisdiagramm bei. In Kreisdiagrammen werden keine Daten im Zeitverlauf dargestellt, sondern nur der letzte Wert.

Alle Kreisdiagramme werden durch das Widget PieChart angegeben. Wenn Sie das Diagramm so konfigurieren möchten, dass die Summe der letzten Messungen angezeigt wird, legen Sie das Feld chartType auf DONUT fest. Andernfalls legen Sie für dieses Feld den Wert PIE fest.

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

Im folgenden Beispiel wird ein Dashboard mit zwei Kreisdiagrammen konfiguriert. Eines der Kreisdiagramme ist als Ringdiagramm konfiguriert:

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

Wie im folgenden Screenshot zu sehen ist, werden die Daten in beiden Widgets als Kreisdiagramm dargestellt. In einem Widget wird die Summe der letzten Werte angezeigt:

Beispiel für **Kreisdiagramm**-Widgets

Dashboard mit einem Treemap-Widget

Fügen Sie eine Strukturkarte hinzu, um die neuesten Daten als verschachtelte Rechtecke darzustellen, wobei jedes Rechteck einem eindeutigen Satz von Labelwerten entspricht. Angenommen, Sie haben die Daten, die Sie in einem Diagramm darstellen möchten, anhand des Labels zone aggregiert. Wenn Sie den Widget-Typ auf „Strukturkarte“ festlegen, entspricht jedes Rechteck auf der Strukturkarte einer Zone. Die Farbsättigung eines Rechtecks ist proportional zum Wert, den es darstellt.

Wenn Sie eine Strukturkarte untersuchen, bewegen Sie den Mauszeiger auf das Rechteck, um die Kurzinfo zu aktivieren.

Mit der folgenden JSON-Konfiguration wird ein Treemap-Widget konfiguriert, in dem die Zeitreihen nach Zone und Speichertyp aggregiert werden:

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

Der folgende Screenshot zeigt das Strukturkarten-Widget mit der vorherigen Konfiguration:

Beispiel für ein **Strukturkarten-Widget**

Im Screenshot ist die Kurzinfo für ein Rechteck zu sehen.

Dashboard mit einem TimeSeriesTable-Widget

In Dashboards können Daten in Tabellenform dargestellt werden. Dabei gibt es eine Zeile für jede Kombination aus eindeutigen Labelwerten. In Tabellen werden keine Daten im Zeitverlauf angezeigt, sondern entweder der letzte Wert oder ein aggregierter Wert.

Alle Tabellen werden durch das Widget TimeSeriesTable angegeben:

  • Verwenden Sie das Feld dataSets, um die anzuzeigenden Zeitreihen zu konfigurieren. Jedes Objekt im dataSets-Array entspricht einem einzelnen Messwerttyp. Wenn Sie mehrere Messwerttypen abfragen, wird in der Google Cloud Console versucht, den letzten Wert für jede Abfrage in derselben Tabellenzeile anzuzeigen. Weitere Informationen finden Sie unter Wie Daten für mehrere Messwerttypen in Tabellen zusammengeführt werden.

    • Das Feld TimeSeriesQuery gibt den Messwerttyp an.
    • Wenn in der Tabelle der aggregierte Wert angezeigt werden soll, wobei die Daten über den von Ihrem Dashboard festgelegten Zeitraum aggregiert werden, legen Sie das Feld timeSeriesQuery.outputFullDuration auf true fest.

  • Wenn Sie die maximale Anzahl der anzuzeigenden Zeilen konfigurieren möchten, legen Sie das Feld pickTimeSeriesFilter fest. Wenn Sie beispielsweise nur die beiden Zeitreihen mit dem größten Durchschnittswert in den letzten 10 Minuten anzeigen möchten, fügen Sie Folgendes ein:

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

    Wenn Sie das Feld pickTimeSeriesFilter weglassen, werden in der Tabelle maximal 300 Zeilen angezeigt.

  • Mit dem Feld metricVisualization können Sie konfigurieren, wie die Daten in der Tabelle angezeigt werden:

    • Wenn Sie nur einen Wert wie „25 %“ anzeigen möchten, lassen Sie dieses Feld entweder weg oder legen Sie den Wert auf "NUMBER" fest. Wenn Sie diese Konfiguration verwenden, wird das Widget in derGoogle Cloud Console als Tabellenwidget angezeigt.
    • Wenn Sie den Wert und eine visuelle Darstellung des Werts im Vergleich zum Bereich der möglichen Werte anzeigen möchten, legen Sie den Wert dieses Felds auf "BAR" fest. Wenn Sie diese Konfiguration verwenden, wird das Widget in derGoogle Cloud -Konsole als Top-Liste-Widget angezeigt.

  • Mit dem columnSettings-Array können Sie konfigurieren, welche Spalten angezeigt werden und welche Eigenschaften die Spalten haben. Wenn dieses Feld nicht angegeben ist, enthält die Tabelle eine Spalte für jedes Label.

    Der Wert des Felds "column" muss auf den Labelschlüssel oder auf value festgelegt werden. value bezieht sich auf den letzten Wert der Zeitreihe. Sie können den Anzeigenamen für eine Spalte festlegen und die Ausrichtung der Daten in der Tabellenzelle konfigurieren:

    • Legen Sie das Feld displayName fest, um die Spaltenüberschrift anzupassen.
    • Wenn Sie die Zelle, in der der letzte Wert angezeigt wird, basierend darauf, wie hoch der Wert im Vergleich zu einem Grenzwert ist, farblich kennzeichnen möchten, fügen Sie ein thresholds-Objekt hinzu.
    • Wenn Sie die Textausrichtung ändern möchten, fügen Sie ein alignment-Feld hinzu.

    Im folgenden Beispiel sind zwei Spalten zu sehen:

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

Im folgenden JSON-Code wird ein Dashboard mit zwei Tabellen beschrieben. In der ersten Tabelle werden zwei Messwerttypen angezeigt: die Anzahl der Bytes, die aus Instanzen gelesen wurden, sowie die Anzahl der Bytes, die in Instanzen geschrieben wurden. Ein aggregierter Wert wird zusammen mit einem Referenzbalken angezeigt. In der zweiten Tabelle wird der letzte Wert eines Messwerttyps angezeigt. Die Wertspalte wurde so konfiguriert, dass die Zelle basierend darauf, wie hoch der Wert im Vergleich zu einem Grenzwert ist, farblich gekennzeichnet wird:

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

Der folgende Screenshot zeigt die zuvor definierte Tabelle:

Beispieldashboard mit einem Tabellen-Widget

Dashboard mit einem Text-Widget

Dieses Beispiel zeigt ein einfaches Dashboard mit einem Text-Widget.

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

Das Text-Widget sieht in etwa so aus:

Beispiel für ein Text-Widget

Dashboard mit einem AlertChart-Widget

Dieses Dashboard zeigt ein Dashboard mit einem AlertChart-Widget:

{
  "category": "CUSTOM",
  "displayName": "Alerting policy chart example",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "alertChart": {
            "name": "projects/my-project/alertPolicies/14205854094151528373"
          }
        },
        "width": 6,
      }
    ]
  }
}

Im Gegensatz zu anderen Dashboard-Widgets geben Sie keinen Titel oder Messwertmesswert für diese Widgets an. Stattdessen geben Sie den Ressourcennamen für eine Benachrichtigungsrichtlinie an. Der letzte Eintrag im Feld name ist die Kennung der Benachrichtigungsrichtlinie.

Das Diagramm im Dashboard sieht ungefähr so aus:

Beispiel für ein Diagramm für eine Benachrichtigungsrichtlinie.

In diesem Beispiel überwacht die Benachrichtigungsrichtlinie die CPU-Nutzung von zwei verschiedenen virtuellen Maschinen. Die gestrichelte Linie zeigt den Bedingungsgrenzwert an, der auf 50 % festgelegt ist. Der grüne Chip mit dem Label No incidents gibt an, dass es keine offenen Vorfälle für die Benachrichtigungsrichtlinie gibt. Wenn Sie den Zeiger auf dem Chip für Vorfälle platzieren, wird ein Dialogfeld geöffnet, das mit der zugrunde liegenden Benachrichtigungsrichtlinie verknüpft ist.

Dashboard mit einem ErrorReportingPanel-Widget

Dieses Dashboard zeigt ein Dashboard mit einem ErrorReportingPanel-Widget:

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

Wir empfehlen, die Höhe eines Fehlerberichtsfelds auf mindestens 16 Einheiten und die Breite auf mindestens 24 Einheiten zu konfigurieren. Im vorherigen Beispiel hat das Widget eine Höhe von 16 Einheiten und eine Breite von 24 Einheiten.

Im Bereich „Fehlerberichte“ werden die Fehlergruppen des ausgewählten Projekts angezeigt. Sie können die Fehlergruppen auf einen bestimmten Ressourcentyp, Dienst oder eine bestimmte Version eines Dienstes beschränken. Das folgende Beispiel zeigt einen Bereich für die Fehlerberichterstattung:

Beispiel für den Konfigurationsbereich eines Fehlerberichts.

Dashboard mit einem FilterControl-Widget

Wenn Sie eine Variable erstellen, wird die Symbolleiste Ihres benutzerdefinierten Dashboards in Monitoring aktualisiert und enthält dann einen Filter für die Variable. Der Name des Filters ist ein Dollarzeichen $ gefolgt vom Namen der Variablen. Beispiel: $my-variable. Jeder Filter enthält ein Menü, in dem Sie den Wert der Variablen ändern können.

Die Verwaltung des Werts einer Variablen mithilfe eines Symbolleistenfilters ist möglicherweise nicht optimal. Angenommen, Sie haben ein Dashboard mit vielen Diagrammen und eine Variable, die nur für zwei Diagramme gilt. In diesem Szenario haben Sie folgende Möglichkeiten:

  1. Fügen Sie Ihrem Dashboard ein CollapsibleGroup-Widget hinzu und platzieren Sie die beiden Diagramme in der Gruppe.

  2. Fügen Sie Ihrem Dashboard ein FilterControl-Widget hinzu. Sie konfigurieren dieses Widget für die Variable und fügen es der Gruppe hinzu.

    Das Gruppen-Widget enthält das FilterControl-Widget, mit dem Sie den Wert der Variablen ändern können, sowie die Widgets, auf die die Variable angewendet wird. Außerdem wird in der Dashboard-Symbolleiste kein Filter für die Variable mehr angezeigt.

Das folgende Dashboard enthält ein FilterControl-Widget:

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

Im vorherigen Beispiel wird eine Variable, proj, definiert und ein FilterControl-Widget hinzugefügt. Bei dieser Konfiguration wird das Menü für die Variable aus der Dashboard-Symbolleiste in das Widget mit dem Titel Project control verschoben. Dieses Widget enthält ein Menü, über das Sie das Projekt auswählen können.

Dashboard mit einem IncidentList-Widget

Dieses Dashboard zeigt ein Dashboard mit einem IncidentList-Widget:

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

Im vorherigen Beispiel wird das Feld title auf Incidents festgelegt und das Widget so konfiguriert, dass alle Vorfälle für Ressourcen vom Typ gce_instance angezeigt werden. Wenn Sie dieses Widget konfigurieren, können Sie mehrere Benachrichtigungsrichtlinien oder mehrere Ressourcentypen auswählen.

Das Vorfall-Widget im Dashboard sieht in etwa so aus:

Beispiel für ein Vorfall-Widget

Dashboard mit einem LogsPanel-Widget

In diesem Dashboard sehen Sie ein LogsPanel-Widget:

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

Wir empfehlen, die Höhe eines Log-Felds auf mindestens drei Einheiten und die Breite auf mindestens vier Einheiten zu konfigurieren. Im vorherigen Beispiel hat das Widget eine Höhe von vier Einheiten und eine Breite von sechs Einheiten.

Im Bereich „Logs“ werden die Logs der Google Cloud -Projekte angezeigt, die im Feld resourceNames aufgeführt sind. Im vorherigen Beispiel wird nur ein Projekt angegeben. Sie können jedoch mehrere Projekte in diese Liste aufnehmen.

Das Log-Feld sieht etwa so aus:

Beispieldashboard mit einem Log-Feld-Widget.

Informationen zur Fehlerbehebung finden Sie unter Fehler beim API-Aufruf zum Erstellen eines Dashboards mit einem Log-Feld.

Dashboard mit einem CollapsibleGroup-Widget

In diesem Dashboard sehen Sie ein CollapsibleGroup-Widget:

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

Im vorherigen Beispiel enthält das minimierbare Gruppen-Widget ein einzelnes Diagramm, in dem die CPU-Auslastung einer VM-Instanz dargestellt wird. Minimierbare Gruppen-Widgets erstrecken sich über eine ganze Zeile einer Tabelle. Ein Widget ist in einer Gruppe enthalten, wenn die (x,y)-Position und die Höhenangaben der Gruppe die (x,y)-Position des Widgets umfassen. Im vorherigen Beispiel befindet sich die Gruppe an der Position (0,0) und hat eine Höhe von 4. Der Punkt xyChart befindet sich an der Position (0,0) und ist daher in der Gruppe enthalten. Wenn die Position dieses Diagramms jedoch in (0,5) geändert wird, wird es aus der Gruppe ausgeschlossen. Wenn die (x, y)-Position eines Widgets dazu führt,dass es in die Gruppe aufgenommen wird, kann sich die Höhe des minimierbaren Gruppen-Widgets vergrößern.

Damit ein Gruppenwidget in einem Dashboard angezeigt werden kann, muss das Dashboard eine MosaicLayout haben.

Das Widget für die minimierbare Gruppe sieht etwa so aus:

Beispieldashboard mit einem Widget für eine minimierbare Gruppe

Dashboard mit einem SingleViewGroup-Widget

In einem SingleViewGroup-Widget wird jeweils ein Mitglied einer Gruppe angezeigt. Sie geben die Diagramme und anderen Widgets an, die zur Gruppe gehören. Außerdem können Sie über ein Menü im SingleViewGroup-Widget festlegen, welches Widget in der Gruppe angezeigt wird.

Das SingleViewGroup-Widget unterstützt zwei Anzeigestile: DROPDOWN und TAB. Der Unterschied zwischen diesen beiden Stilen besteht darin, wie Sie auswählen, welches Mitglied der Gruppe angezeigt werden soll. Widgets mit dem Stil DROPDOWN bieten ein Menü. Widgets mit dem Stil TAB haben Tabs in der Symbolleiste des Widgets:

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

Wie im vorherigen Beispiel gezeigt, enthält das tiles-Array ein SingleViewGroup-Objekt. In diesem Objekt wird jedoch nicht angegeben, welche Objekte es enthält. Stattdessen wird die Mitgliedschaft im SingleViewGroup-Objekt durch die Werte der Felder width und yPos bestimmt. Objekte, deren Werte für die Felder width und yPos mit den Werten des SingleViewGroup-Objekts übereinstimmen, sind im SingleViewGroup-Objekt enthalten. Im vorherigen Beispiel enthält das SingleViewGroup-Objekt zwei Diagramme.

Dashboard mit einem SectionHeader-Widget

Mit einem SectionHeader-Widget wird eine horizontale Trennlinie in Ihrem Dashboard erstellt und ein Eintrag im Inhaltsverzeichnis des Dashboards. Sie können den Eintrag im Inhaltsverzeichnis anpassen und zusätzliche Informationen in das Widget einfügen. Sie können das Widget auch so konfigurieren, dass nach dem Eintrag für die Abschnittsüberschrift eine Trennlinie im Inhaltsverzeichnis eingefügt wird.

Dieses Dashboard zeigt ein Dashboard mit einem einzelnen Diagramm und einem SectionHeader-Widget:

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

Im SectionHeader-Objekt wird der Wert des Feldes title sowohl im Widget als auch im Inhaltsverzeichnis angezeigt. Der Wert des Felds subtitle wird nur vom Widget angezeigt. Wenn der Wert von dividerBelow true ist, wird dem Inhaltsverzeichnis eine Trennlinie hinzugefügt.

Dashboard mit einem SLO-Widget

In diesem Dashboard sehen Sie ein Dashboard mit einem SLO-Widget:

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

Wie im vorherigen JSON-Beispiel zu sehen ist, werden SLO-Diagramme als XyChart-Objekte dargestellt. Diese Objekte geben alle Aggregationsfelder und Grenzwerte an. Der Wert des Felds filter ist ein Zeitachsenselektor. Weitere Informationen zu diesen Selektoren finden Sie unter SLO-Daten abrufen.

Das SLO-Widget sieht etwa so aus:

Beispieldashboard mit einem SLO-Widget.

Dashboard mit einem leeren Widget

Dieses Beispiel zeigt ein Dashboard mit einem leeren Platzhalterwidget. Der Wert des Feldes displayName wird im Widget angezeigt.

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

Das Dashboard sieht ungefähr so aus:

Beispieldashboard mit einem leeren Widget

Dashboard mit konfigurierter Widget-Sichtbarkeit

Dieses Dashboard enthält ein Text-Widget und eine Variable. Der Wert der Variablen bestimmt, ob das Text-Widget angezeigt oder ausgeblendet wird:

  • Die Variable mit dem Namen show hat den Standardwert a. Die Werte der Variablen sind als a, b und c definiert. Da das Feld valueType STRING_ARRAY ist, kann die Variable auch auf Werte wie a or b festgelegt werden.

  • Im Text-Widget wird die Sichtbarkeit des Widgets durch den Eintrag mit der Bezeichnung visibilityCondition definiert. Wenn der Wert der Variablen show b enthält, wird das Text-Widget angezeigt. Andernfalls wird das Text-Widget nicht angezeigt.


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

Einschränkungen im Zusammenhang mit der Konfiguration der Sichtbarkeit eines Widgets finden Sie unter Sichtbarkeit eines Widgets festlegen.