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 JSON-Daten sowohl für die Google Cloud CLI als auch für Cloud Monitoring API-Endpunkte angeben.

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 sollte die API oder die Google Cloud CLI verwendet werden?

Mit der Cloud Monitoring API und der Google Cloud CLI mehrere Dashboards gleichzeitig verwalten. Sie können zwar auch die Google Cloud Console zur Verwaltung Ihrer Dashboards verwenden, mit Scripts 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

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

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

  • Füllen Sie das Feld timeSeriesField aus, um Monitoring-Filter zu verwenden ein. 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 Dashboard-Layouts die verfügbar sind.

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 sowie 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, etwa ein Google Kubernetes Engine-Update oder ein VM-Fehler, durch Einfügen eines annotations-Felds in den Dashboard -Objekt enthält. Das Feld annotations enthält eine Instanz eines DashboardAnnotations-Objekts mit zwei Feldern:

  • Im Feld defaultResourceName werden die Standardeinstellungen auf Dashboard-Ebene für die Google Cloud-Projekten, um nach Ereignissen zu suchen. Wenn Sie dieses Feld nicht angeben, wird in Ihrem ausgewählten Projekt gesucht.

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

    • Das Feld displayName, mit dem Sie das Label der Ereignisspezifische Ein/Aus-Schaltfläche Wenn dieses Feld nicht angegeben ist oder der Wert ein leerer String ist, wird der Standardname des Ereignisses angezeigt.
    • Ein enabled-Feld, das den Wert der Ein/Aus-Schaltfläche des Ereignisses steuert. Wenn true angezeigt wird, befindet sich die Ein/Aus-Schaltfläche in der Position on und Ereignisse werden im Dashboard angezeigt. Wenn false, ist der Schalter in der Position off.
    • Ein eventType-Feld, das einen Wert aus EventType enthält Aufzählung.
    • Das Feld filter, mit dem Sie eine Abfrage angeben können, die an die ereignisspezifische Abfrage angegeben werden. Wenn der Wert dieses Felds ein leerer String ist, wird die ereignisspezifische Abfrage verwendet.
    • Das Feld resourceNames, mit dem Sie eine Liste von Google Cloud-Projekten, um nach Ereignissen zu suchen. Wenn dieses Feld ein leeres Array ist, wird das ausgewählte Projekt durchsucht.

Im folgenden Beispiel ist ein annotations-Feld zu sehen, in dem ein Google Kubernetes Engine-Ereignis angegeben ist:

{
  "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 einzuschränken. Das Feld displayName ist auf einen leeren String gesetzt. Daher wird der Standardname für den Ereignistyp auf der Ein/Aus-Schaltfläche des Ereignisses angezeigt. Da resourceNames auf ein leeres Array festgelegt ist, werden die Logeinträge in Ihrem aktuellen Google Cloud-Projekt abgefragt.

Dashboard-Filter hinzufügen

Sie können einem Dashboard dauerhafte Filter hinzufügen, um zu steuern, welche Daten Widgets auf einem Dashboard-Display. Ein Beispiel für ein Dashboard mit einem dauerhaften Filter finden Sie unter Dashboard-Filter.

Dashboard-Labels hinzufügen

In diesem Beispiel wird ein Dashboard-Objekt mit dem Label playbook gezeigt.

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

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

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 haben Sie mit der Google Cloud Console Diagramme in Dashboards erstellt, Instanzen des XyChart-Widgets sind.

Ähnlich wie die Funktionen in der Google Cloud Console 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 in etwa so aus:

Beispiel für einen XyChart

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

Dashboard mit einem Loganalysendiagramm

Dieses Dashboard enthält ein Dashboard mit einem Log Analytics-Diagramm. Die Beispiel-JSON 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  `TABLE_NAME_OF_LOG_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 angezeigt werden und in denen der linken und der rechten Achse. Im vorherigen Beispiel wurde ein Diagramm mit einem einzelnen Messwerttyp gezeigt, d. h., es gab ein Element im dataSets-Array. Wenn Sie zwei Messwerttypen grafisch darstellen, enthält das Array dataSets zwei Elemente: und jedes Element gibt seine 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 in etwa 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 Kurzübersicht sieht in etwa so aus:

Beispieldashboard mit einem Scorecard-Widget mit SparkChartView

Dashboard mit einem PieChart-Widget

In Dashboards können Daten in einem Kreisdiagramm dargestellt werden. Jede Zeitreihe trägt ein Stück zum Kuchen. In Kreisdiagrammen werden keine Daten im Zeitverlauf angezeigt, sondern nur der jeweils aktuelle Wert.

Alle Kreisdiagramme werden über das Widget PieChart festgelegt. Um das Diagramm so zu konfigurieren, dass es die Summe der letzten Messungen anzeigt, Setzen Sie das Feld chartType auf DONUT. Andernfalls legen Sie für dieses Feld den Wert Wert von PIE.

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

Im folgenden Beispiel wird ein Dashboard mit zwei Kreisdiagrammen konfiguriert, davon einem als Ring konfiguriertes Kreisdiagramm:

{
  "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, zeigen beide Widgets Daten als Kreisdiagramm an. In einem Widget wird die Summe der letzten Werte angezeigt:

Beispiel für **PieChart**-Widgets

Dashboard mit einem TimeSeriesTable-Widget

In Dashboards können Daten in Tabellenform dargestellt werden, wobei für jede Kombination eindeutiger Labelwerte eine Zeile vorhanden ist. In Tabellen werden keine Daten im Zeitverlauf angezeigt, sondern entweder der aktuelle Wert oder ein aggregierter Wert.

Alle Tabellen werden über das Widget TimeSeriesTable angegeben:

  • Mit dem Feld dataSets können Sie die anzuzeigende Zeitreihe konfigurieren. Jedes Objekt im dataSets-Array entspricht einem einzelnen Messwerttyp. Wenn Sie nach mehreren Messwerttypen fragen, versucht die Google Cloud Console, den jeweils neuesten Wert für jede Abfrage in derselben Tabellenzeile anzuzeigen. Weitere Informationen finden Sie unter Daten aus mehreren Messwerttypen in Tabellen zusammenführen.

    • Im Feld TimeSeriesQuery wird der Messwerttyp angegeben.
    • Wenn in der Tabelle der aggregierte Wert angezeigt werden soll, bei dem die Daten über den im Dashboard festgelegten Zeitraum aggregiert werden, legen Sie für das Feld timeSeriesQuery.outputFullDuration den Wert true fest.

  • Legen Sie im Feld pickTimeSeriesFilter die maximale Anzahl der Zeilen fest, die angezeigt werden sollen. Um beispielsweise nur die beiden Uhrzeiten mit dem höchsten Durchschnittswert während der letzten 10 Minuten umfassen Folgendes:

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

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

  • Um zu konfigurieren, wie die Daten in der Tabelle angezeigt werden, Verwenden Sie das Feld metricVisualization:

    • Wenn nur ein Wert wie „25 %“ angezeigt werden soll, lassen Sie dieses Feld leer oder setzen Sie den Wert auf "NUMBER". Wenn Sie diese Konfiguration verwenden, In der Google Cloud Console wird das Widget als Tabelle-Widget angezeigt.
    • Wenn Sie den Wert und eine visuelle Darstellung des Werts im Vergleich zum Bereich der möglichen Werte anzeigen lassen möchten, setzen Sie den Wert dieses Felds auf "BAR". Wenn Sie diese Konfiguration verwenden, In der Google Cloud Console wird das Widget als Top-Liste-Widget angezeigt.

  • Um zu konfigurieren, welche Spalten angezeigt werden, und ihre Eigenschaften festlegen, Verwenden Sie das Array columnSettings. Wenn dieses Feld nicht angegeben ist, wird in der Tabelle für jedes Label eine Spalte angezeigt.

    Der Wert des Felds "column" muss auf „Labelschlüssel“ oder auf value gesetzt sein, was dem letzten Wert der Zeitreihe entspricht. Sie können den Anzeigenamen für eine Spalte festlegen und die Ausrichtung der Daten in der Tabellenzelle konfigurieren:

    • Wenn Sie die Spaltenüberschrift anpassen möchten, verwenden Sie das Feld displayName.
    • Zum Färben der Zelle, in der der neueste Wert basierend auf der mit einem Schwellenwert vergleichen, fügen Sie ein thresholds-Objekt hinzu.
    • Wenn Sie die Textausrichtung ändern möchten, fügen Sie ein alignment-Feld hinzu.

    Das folgende Beispiel zeigt zwei Spalten:

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

Die folgende JSON beschreibt ein Dashboard mit zwei Tabellen. Die erste Tabelle zeigt zwei Messwerttypen an: die Anzahl der aus Instanzen gelesenen Byte und den Anzahl der in Instanzen geschriebenen Byte. Ein aggregierter Wert wird zusammen mit einen Referenzbalken. In der zweiten Tabelle ist der aktuelle Wert eines Messwerttyps zu sehen. Die Wertspalte ist so konfiguriert, dass die Zelle je nach Vergleich des Werts mit einem Schwellenwert eine bestimmte Farbe hat:

{
  "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 in etwa 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, dass Sie die Höhe eines Fehlerberichtsbereichs so konfigurieren, dass sie auf mindestens 16 Einheiten und die Breite mindestens 24 Einheiten. Im vorherigen Beispiel hat das Widget eine Höhe von 16 Einheiten und eine Breite von 24 Einheiten.

Im Bereich für Fehlerberichte werden die Fehlergruppen aus den ausgewählten Projekt ausgeführt werden. Dieser Bereich kann die Fehlergruppen auf eine bestimmte Ressource beschränken. Dienst oder Version eines Dienstes. Im folgenden Beispiel sehen Sie, Fehlerberichte zu erstellen:

Beispiel für den Konfigurationsbereich eines Error Reporting-Bereichs

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 wurde das Feld title auf Incidents gesetzt und konfiguriert Das Widget, um alle Vorfälle für Ressourcen vom Typ gce_instance anzuzeigen. Wenn Sie dieses Widget konfigurieren, können Sie mehrere Benachrichtigungsrichtlinien oder mehrere Ressourcentypen auswählen.

Das Vorfalls-Widget auf dem Dashboard sieht in etwa so aus:

Beispiel für ein Widget für Vorfälle

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 Logbereich werden die Logs aus den aufgeführten Google Cloud-Projekten angezeigt im Feld resourceNames ein. Im vorherigen Beispiel ist 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 der die CPU-Auslastung einer VM-Instanz anzeigt. Minimierbare Gruppen-Widgets die gesamte Zeile einer Tabelle abdecken. Ein Widget ist in einer Gruppe enthalten, Die Spezifikationen für (x,y)-Position und -Höhe der Gruppe umfassen die Werte (x,y) die Position des Widgets. Im vorherigen Beispiel hat die Gruppe die Position (0,0) und eine Höhe von 4. xyChart steht an der Position (0,0), sodass in der Gruppe enthalten ist. 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, wird die Höhe des minimierbaren Gruppen-Widgets möglicherweise maximiert.

Um ein Gruppen-Widget in ein Dashboard aufzunehmen, muss das Dashboard über ein MosaicLayout

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

Beispieldashboard mit einem minimierbaren Gruppen-Widget.

Dashboard mit einem SingleViewGroup-Widget

In einem SingleViewGroup-Widget wird jeweils nur ein Mitglied einer Gruppe angezeigt. Sie geben die Diagramme und anderen Widgets an, die Mitglieder sind. in der Gruppe. Außerdem legen Sie fest, welches Widget in der Gruppe über ein Menü im SingleViewGroup-Widget.

Dieses Dashboard enthält ein Dashboard mit einem SingleViewGroup-Widget:

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

Wie im vorherigen Beispiel enthält das tiles-Array ein SingleViewGroup-Objekt. Dieses Objekt gibt jedoch nicht an, welche Objekte es enthält. Stattdessen wird die Zugehörigkeit zum SingleViewGroup-Objekt anhand der Werte der Felder width und yPos bestimmt. Objekte, deren Werte für den Die Felder width und yPos stimmen mit des SingleViewGroup-Objekts sind im SingleViewGroup-Objekt. 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 finden Sie weitere Informationen im Widget. Sie können das Widget auch so konfigurieren, dass dem Inhaltsverzeichnis nach dem Abschnittsheader ein Trennstrich hinzugefü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 Felds title sowohl im Widget als auch im Inhaltsverzeichnis angezeigt. Der Wert der Eigenschaft Das Feld subtitle wird nur vom Widget angezeigt. Wenn der Wert von dividerBelow true ist, wird dem Inhaltsverzeichnis eine Trennlinie hinzugefügt.

Dashboard mit SLO-Widget

Dieses Dashboard zeigt 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 das vorherige JSON-Beispiel zeigt, werden SLO-Diagramme als XyChart-Objekte dargestellt. In diesen Objekten werden alle Aggregationsfelder und Grenzwerte angegeben. Der Wert des Felds filter ist ein Zeitachsenselektor. Weitere Informationen Informationen zu diesen Selektoren finden Sie unter SLO-Daten abrufen.

Das SLO-Widget sieht ungefähr so aus:

Beispieldashboard mit einem SLO-Widget

Dashboard mit einem leeren Widget

Dieses Beispiel zeigt ein Dashboard mit einem leeren Platzhalter-Widget. 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