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 die Google Cloud Console zum Verwalten Ihrer Dashboards, ist es möglicherweise einfacher, die API zur Verwaltung mehrere benutzerdefinierte Dashboards.

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 dem dashboards.create erstellt. . Sie übergeben ein Dashboard-Objekt an die API-Methode, das 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 und Sie geben diese Daten mithilfe eines Monitoringfilter, ein MQL-Abfrage oder PromQL-Abfrage:

  • Füllen Sie das Feld timeSeriesField aus, um Monitoring-Filter zu verwenden ein. In den Beispielen auf dieser Seite werden Cloud Monitoring-Filter verwendet.

  • Füllen Sie das Feld timeSeriesQueryLanguage aus, um eine MQL-Abfrage zu verwenden. Weitere Informationen finden Sie unter Diagramme erstellen.

  • Füllen Sie das Feld prometheusQuery aus, um eine PromQL-Abfrage zu verwenden. 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 zur Anzeige von Ereignissen konfigurieren können.

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-Objekt, das zwei Felder enthält:

  • 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 das ausgewählte Projekt durchsucht.

  • 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, steht der Schalter auf der Position on und die Ereignisse werden angezeigt auf dem Dashboard. Wenn false, befindet sich 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 Feldes 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 ist ein leeres Array, wird das ausgewählte Projekt durchsucht.

Das folgende Beispiel zeigt ein annotations-Feld, das eine Google Kubernetes Engine-Ereignis:

{
  "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 wurde die Abfrage mit dem Feld filter eingeschränkt. zum Cluster my-name. Das Feld displayName ist auf ein leerer String, sodass der Standardname für den Ereignistyp um die Ein/Aus-Schaltfläche des Ereignisses zu aktivieren. Da resourceNames auf Ein leeres Array, die Logeinträge im aktuellen Google Cloud-Projekt abgefragt werden.

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:

Dashboardlabels hinzufügen

Dieses Beispiel zeigt ein Dashboard-Objekt, das gibt das Label playbook an.

{
  "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 eine einem Dashboard, legen Sie für key den Namen des Labels fest und value in einen leeren String.

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

Dashboards mit Widgets

Dieser Abschnitt enthält Beispiele für Dashboards, die verschiedene Typen enthalten 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 in der Google Cloud Console bietet die API bietet Optionen, um den PlotType des Diagramms zu ändern oder Anzeigemodi des Diagramms konfigurieren

{
  "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 Log Analytics-Diagramm-Widget erstellen. wie ein Schwellenwert in einem Diagramm angezeigt wird und wie konfiguriert wird, ob das Diagramm die linke Y-Achse, die rechte Y-Achse oder beides verwendet.

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`"
                  }
                }
              }
            ],
            "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, in denen mehrere Messwerttypen angezeigt werden und in denen der linken und der rechten Achse. Im vorherigen Beispiel wurde ein Diagramm mit einen einzelnen Messwerttyp, d. h., es gibt 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

Dashboards können Daten mithilfe eines Kreisdiagramms darstellen. Jede Zeitreihe trägt ein Stück zum Kuchen. In Kreisdiagrammen werden keine Daten im Zeitverlauf dargestellt. verwenden Sie stattdessen wird nur der neueste Wert angezeigt.

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 dargestellt, werden Daten in beiden Widgets als Kreisdiagramm dargestellt. 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, Zeile für jede überwachte Zeitreihe. In Tabellen werden keine Daten im Zeitverlauf dargestellt. verwenden Sie stattdessen wird nur der neueste Wert angezeigt.

Alle Tabellen werden über das Widget TimeSeriesTable angegeben:

  • Um die maximale Anzahl der anzuzeigenden Zeilen zu konfigurieren, legen Sie den Parameter pickTimeSeriesFilter. Um beispielsweise nur die beiden Uhrzeiten mit dem höchsten Durchschnittswert in den letzten 10 Minuten umfassen Folgendes:

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

    Wenn Sie das Feld pickTimeSeriesFilter weglassen, wird die Tabelle maximal 300 Zeilen.

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

    • Um nur einen Wert wie „25 %“ anzuzeigen, lassen Sie dieses Feld entweder weg oder legen den Wert auf "NUMBER". Wenn Sie diese Konfiguration verwenden, In der Google Cloud Console wird das Widget als Tabelle-Widget angezeigt.
    • Zur Anzeige des Werts und einer visuellen Anzeige des Werts im Vergleich zum Bereich möglicher Werte möchten, legen Sie den Wert dieses Felds auf "BAR" fest. Wenn Sie diese Konfiguration verwenden, In der Google Cloud Console wird das Widget als Top-Liste-Widget angezeigt.

  • Mit dem Feld columnSettings können Sie konfigurieren, welche Spalten angezeigt werden. Im folgenden Beispiel wird eine Tabelle mit zwei Spalten erzeugt, eine mit dem Titel Latest Value, eine obligatorische Spalte, und die andere Spalte Name (from instance_id):

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

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

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

{
  "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 einem tabellarischen und enthalten beide eine Filterleiste. Die beiden Widgets sind jedoch die zur Anzeige verschiedener Spalten und zur Darstellung des numerischen Werts unterschiedlich:

Beispieldashboard mit einem Tabellen-Widget

Die Spalten der Tabelle entsprechen Labels. Jede Zeile entspricht einem Zeitreihe.

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 ungefähr 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. In der vorherigen Beispiel: Das Widget hat 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.

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 wird nur ein Projekt angegeben. Sie können jedoch mehrere Projekte in diese Liste aufnehmen.

Das Log-Feld sieht etwa so aus:

Beispieldashboard mit einem Log-Feld-Widget.

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

Dashboard mit einem CollapsibleGroup-Widget

In diesem Dashboard sehen Sie ein CollapsibleGroup-Widget:

{
  "category": "CUSTOM",
  "displayName": "Group testing",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "collapsibleGroup": {
            "collapsed": false
          },
          "title": "My group"
        },
        "width": 12,
        "xPos": 0,
        "yPos": 0
      },
      {
        "height": 4,
        "widget": {
          "title": "VM Instance - CPU utilization [MEAN]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "apiSource": "DEFAULT_CLOUD",
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_NONE",
                      "perSeriesAligner": "ALIGN_MEAN"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\"",
                    "secondaryAggregation": {
                      "alignmentPeriod": "60s",
                      "crossSeriesReducer": "REDUCE_NONE",
                      "perSeriesAligner": "ALIGN_NONE"
                    }
                  }
                }
              }
            ],
            "thresholds": [],
            "timeshiftDuration": "0s",
            "yAxis": {
              "label": "y1Axis",
              "scale": "LINEAR"
            }
          }
        },
        "width": 6,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

Im vorherigen Beispiel enthält das minimierbare Gruppen-Widget ein einzelnes Diagramm 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 befindet sich die Gruppe an der Position von (0,0) und ihre Höhe beträgt 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 das Diagramm aus der Gruppe ausgeschlossen. Zu guter Letzt die Position (x,y) eines Widgets dazu führt, dass das Widget in die Gruppe aufgenommen wird, die Höhe des Widgets für die minimierbare Gruppe 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 Widget für eine minimierbare Gruppe

Dashboard mit einem SingleViewGroup-Widget

Ein SingleViewGroup-Widget zeigt ein Mitglied einer jeweils einer Gruppe hinzufügen. 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 gezeigt, enthält das Array tiles SingleViewGroup-Objekt; Dieses Objekt gibt jedoch nicht an, welche Objekte enthält. Stattdessen wird die Mitgliedschaft im SingleViewGroup-Objekt bestimmt. durch die Werte der Felder width und yPos. Objekte, deren Werte für den Die Felder width und yPos entsprechen der des SingleViewGroup-Objekts sind im SingleViewGroup-Objekt. Im vorherigen Beispiel wurde das Objekt SingleViewGroup enthält zwei Diagramme.

Dashboard mit einem SectionHeader-Widget

Das Widget SectionHeader erstellt eine horizontale Trennlinie Ihr Dashboard und es wird ein Eintrag in der Tabelle des Dashboards Inhalte. Sie können den Eintrag im Inhaltsverzeichnis anpassen und finden Sie weitere Informationen im Widget. Sie können das Widget auch um dem Inhaltsverzeichnis nach dem Abschnittsüberschrift-Eintrag eine Trennlinie hinzuzufügen.

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

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk write bytes [RATE]",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        },
        "width": 24,
        "yPos": 4
      },
      {
        "height": 4,
        "widget": {
          "sectionHeader": {
            "dividerBelow": true,
            "subtitle": "Instance metrics"
          },
          "title": "Metrics"
        },
        "width": 48
      }
    ]
  }
}

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

Dashboard mit SLO-Widget

Dieses Dashboard enthält 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. Diese Objekte geben alle Aggregationsfelder, Schwellenwerte und die 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