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.

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 verwendet werden?

Mit der Cloud Monitoring API können Sie viele Dashboards gleichzeitig verwalten. Sie können zwar auch die Google Cloud Console zum Verwalten Ihrer Dashboards verwenden, aber möglicherweise ist es einfacher, Ihre benutzerdefinierten Dashboards mit der API im Bulk zu verwalten.

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 ein Dashboard-Objekt an die API-Methode, das einen Eintrag für jedes Widget enthält, das im Dashboard angezeigt wird.

Wenn ein Widget Zeitreihendaten anzeigt, z. B. ein Diagrammwidget, enthält der Eintrag im Dashboard-Objekt ein TimeSeriesQuery-Objekt. Dieses Objekt beschreibt die Zeitreihendaten, die im Diagramm dargestellt werden sollen. Sie geben diese Daten mithilfe eines Monitoring-Filters, 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

Dashboards mit Widgets

Dashboard mit einem XyChart

In diesem Dashboard sehen Sie ein einfaches XyChart. Wenn Sie jemals mit der Google Cloud Console Diagramme in Dashboards erstellt haben, sind diese Diagramme Instanzen des XyChart-Widgets.

Ähnlich wie die Funktionen in der Google Cloud Console bietet die API Optionen zum Ändern des PlotType des Diagramms oder zum Konfigurieren der Ansichtsmodi des Diagramms.

{
  "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 gezeigt, wie Sie ein Loganalyse-Diagramm-Widget erstellen, einen Schwellenwert in einem Diagramm anzeigen und konfigurieren, ob das Diagramm die linke Y-Achse, die rechte Y-Achse oder beides verwendet.

Dashboard mit einem Loganalysen-Diagramm

Dieses Dashboard zeigt ein Dashboard mit einem Loganalyse-Diagramm. Die Beispiel-JSON-Datei enthält eine SQL-Abfrage.

{
  "displayName": "Example Log Analytics",
  "dashboardFilters": [],
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "width": 24,
        "height": 16,
        "widget": {
          "title": "Sample Log Analytics chart",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [
                  {
                    "column": "location",
                    "columnType": "STRING",
                    "maxBinCount": 5,
                    "sortColumn": "location",
                    "sortOrder": "SORT_ORDER_ASCENDING"
                  }
                ],
                "measures": [
                  {
                    "aggregationFunction": {
                      "parameters": [],
                      "type": "count"
                    },
                    "column": ""
                  }
                ],
                "plotType": "STACKED_BAR",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "opsAnalyticsQuery": {
                    "queryHandle": "",
                    "sql": "SELECT\n  CAST(JSON_VALUE(resource.labels.location) AS STRING) AS location,\n  severity,\nFROM\n  `TABLE`"
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  },
  "labels": {}
}

Das Diagramm im Dashboard sieht in etwa so aus:

Beispiel-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, die mehrere Messwerttypen anzeigen und die linke und rechte Achse verwenden. Im vorherigen Beispiel wurde ein Diagramm mit einem einzelnen Messwerttyp dargestellt, d. h., das Array dataSets enthält ein Element. Wenn Sie zwei Messwerttypen grafisch darstellen, enthält das dataSets-Array 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 Übersicht sieht in etwa so aus:

Beispieldashboard mit einem Scorecard-Widget mit SparkChartView

Dashboard mit einem PieChart-Widget

In Dashboards können Daten mithilfe eines Kreisdiagramms angezeigt werden. Jede Zeitreihe trägt ein Slice zum Kreis bei. Kreisdiagramme zeigen Daten nicht im Zeitverlauf, sondern nur den aktuellsten Wert.

Alle Kreisdiagramme werden mit dem PieChart-Widget angegeben. Wenn das Diagramm so konfiguriert werden soll, dass die Summe der letzten Messungen angezeigt wird, setzen Sie das Feld chartType auf DONUT. Andernfalls legen Sie für dieses Feld den Wert PIE fest.

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

Im folgenden Beispiel wird ein Dashboard mit zwei Kreisdiagrammen konfiguriert, von denen eines als Ring konfiguriert ist:

{
  "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 dargestellt, zeigen beide Widgets Daten als Kreisdiagramm an, wobei ein Widget die Summe der letzten Werte anzeigt:

Beispiel für **PieChart**-Widgets.

Dashboard mit einem TimeSeriesTable-Widget

Dashboards können Daten in einem tabellarischen Format anzeigen, wobei es für jede überwachte Zeitreihe eine Zeile gibt. In Tabellen werden keine Daten im Zeitverlauf angezeigt, sondern nur der neueste Wert.

Alle Tabellen werden mit dem TimeSeriesTable-Widget angegeben:

  • Legen Sie das Feld pickTimeSeriesFilter fest, um die maximale Anzahl der anzuzeigenden Zeilen zu konfigurieren. Wenn Sie beispielsweise nur die beiden Zeitachsen mit dem größten Durchschnittswert in den letzten 10 Minuten anzeigen lassen 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 konfigurieren Sie, wie die Daten in der Tabelle angezeigt werden:

    • Wenn nur ein Wert wie „25 %“ angezeigt werden soll, lassen Sie dieses Feld entweder weg oder setzen Sie den Wert auf "NUMBER". Wenn Sie diese Konfiguration verwenden, wird das Widget in der Google Cloud Console als Tabelle-Widget angezeigt.
    • Setzen Sie den Wert dieses Felds auf "BAR", um den Wert und einen visuellen Indikator des Werts im Vergleich zum Bereich der möglichen Werte anzuzeigen. Wenn Sie diese Konfiguration verwenden, wird das Widget in der Google Cloud Console als Widget der Top-Liste angezeigt.
  • Mit dem Feld columnSettings konfigurieren Sie, welche Spalten angezeigt werden. Das folgende Beispiel ergibt eine Tabelle mit zwei Spalten, einer mit dem Titel Latest Value (Pflichtspalte) und der anderen mit dem Titel Name (from instance_id):

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

    Wenn Sie das Feld columnSettings weglassen, wird in der Tabelle für jedes Label eine Spalte angezeigt.

Das folgende Beispiel zeigt ein Dashboard mit einem Table-Widget und einem Top List-Widget:

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

Wie im folgenden Screenshot dargestellt, zeigen beide Widgets Daten in Tabellenform an und beide Widgets enthalten eine Filterleiste. Die beiden Widgets sind jedoch so vorkonfiguriert, dass sie unterschiedliche Spalten und den numerischen Wert unterschiedlich darstellen:

Beispieldashboard mit einem Tabellen-Widget

Die Spalten der Tabelle entsprechen Labels. Jede Zeile entspricht einer Zeitachse.

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": "Alert 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 Benachrichtigungsdiagramm

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 Ihnen, die Höhe eines Fehlerberichts von mindestens 16 Einheiten und seine Breite mit 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 für Fehlerberichte werden die Fehlergruppen des ausgewählten Projekts angezeigt. Dieser Bereich kann die Fehlergruppen auf einen bestimmten Ressourcentyp, einen Dienst oder eine Version eines Dienstes beschränken. Das folgende Beispiel zeigt einen Bereich zur Meldung von Fehlern:

Beispiel für einen Konfigurationsbereich für den Bereich mit Fehlerberichten.

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 gesetzt 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 auf dem 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 Logbereich werden die Logs aus den Google Cloud-Projekten angezeigt, die im Feld resourceNames aufgeführt sind. Im vorherigen Beispiel ist nur ein Projekt angegeben. Sie können diese Liste jedoch auch mehrere Projekte hinzufügen.

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 Widget für minimierbare Gruppen ein einzelnes Diagramm, das die CPU-Auslastung einer VM-Instanz anzeigt. Minimierbare Gruppen-Widgets erstrecken sich über eine ganze Tabellenzeile. Ein Widget ist in einer Gruppe enthalten, wenn die (x,y)-Angaben für Position und Höhe der Gruppe die (x,y)-Position des Widgets enthalten. Im vorherigen Beispiel befindet sich die Gruppe an der Position (0,0) und hat eine Höhe von 4. 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 das Diagramm aus der Gruppe ausgeschlossen. Wenn schließlich die Position (x, y) eines Widgets dazu führt,dass das Widget in die Gruppe aufgenommen wird, kann die Höhe des minimierbaren Gruppen-Widgets erweitert werden.

Damit ein Gruppen-Widget in ein Dashboard aufgenommen werden kann, muss das Dashboard eine MosaicLayout haben.

Das Widget für minimierbare Gruppen sieht ungefähr so aus:

Beispieldashboard mit einem minimierbaren Gruppen-Widget.

Dashboard mit einem SingleViewGroup-Widget

Mit einem SingleViewGroup-Widget wird jeweils nur ein Mitglied einer Gruppe angezeigt. Sie geben die Diagramme und andere Widgets an, die der Gruppe angehören. Außerdem können Sie über ein Menü des SingleViewGroup-Widgets steuern, welches Widget in der Gruppe angezeigt wird.

In diesem Dashboard wird ein Dashboard mit einem SingleViewGroup-Widget angezeigt:

{
  "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 gezeigt, enthält das tiles-Array ein SingleViewGroup-Objekt. Dieses Objekt gibt jedoch nicht an, 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 Objekts SingleViewGroup übereinstimmen, sind im Objekt SingleViewGroup enthalten. Im vorherigen Beispiel enthält das Objekt SingleViewGroup zwei Diagramme.

Dashboard mit einem SectionHeader-Widget

Mit einem SectionHeader-Widget wird eine horizontale Trennlinie in Ihrem Dashboard erstellt und ein Eintrag in der Inhaltstabelle des Dashboards erstellt. Sie können den Eintrag im Inhaltsverzeichnis anpassen und zusätzliche Informationen in das Widget aufnehmen. Sie können das Widget auch so konfigurieren, dass nach der Abschnittsüberschrift eine Trennlinie für das 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 Felds 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

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 die vorherige JSON-Datei zeigt, werden SLO-Diagramme als XyChart-Objekte dargestellt. Diese Objekte geben alle Aggregationsfelder und Schwellenwerte an. Der Wert des Felds filter ist ein Zeitachsenselektor. Weitere Informationen zu diesen Selektoren finden Sie unter SLO-Daten abrufen.

Das SLO-Widget sieht in etwa 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

Dashboards mit dauerhaften Filtern

Ein Beispiel für ein Dashboard mit einem dauerhaften Filter finden Sie unter Dashboard-Filter.