Painéis e layouts de amostra

Nesta página, você verá como criar painéis usando a API Cloud Monitoring. Para cada exemplo, a definição do painel em JSON e o painel correspondente são mostrados. É possível fornecer JSON para a CLI do Google Cloud e para os endpoints da API Cloud Monitoring.

O Cloud Monitoring também fornece um conjunto selecionado de definições de painel no GitHub. É possível instalar essas definições no projeto do Google Cloud como painéis personalizados. Para informações sobre esse repositório e como instalar esses painéis, consulte Instalar painéis de amostra.

Quando usar a API ou a Google Cloud CLI

A API Cloud Monitoring e a Google Cloud CLI oferecem uma maneira de gerenciar muitos painéis de uma só vez. É possível usar o console do Google Cloud para gerenciar seus painéis, mas talvez seja mais fácil usar scripts que gerenciam os painéis personalizados em massa.

Você também precisa usar a API quando quiser adicionar o widget de marcador em branco ao seu painel.

Como usar o MQL ou o PromQL com a API

Você cria painéis usando o método dashboards.create. Você transmite ao método da API um objeto Dashboard, que contém uma entrada para cada widget mostrado no painel.

Quando um widget mostra dados de séries temporais, como um widget de gráfico, a entrada dele no objeto Dashboard contém um objeto TimeSeriesQuery. Esse objeto descreve os dados de série temporal a serem incluídos no gráfico. Especifique esses dados usando um filtro do Monitoring, uma consulta MQL ou uma consulta PromQL:

  • Para usar os filtros de monitoramento, preencha o campo timeSeriesField. Os exemplos nesta página usam filtros do Cloud Monitoring.

  • Para usar uma consulta MQL, preencha o campo timeSeriesQueryLanguage. Para mais informações, consulte Como criar gráficos.

  • Para usar uma consulta PromQL, preencha o campo prometheusQuery. Para informações gerais, consulte PromQL no Cloud Monitoring.

Layouts de painel

Esta seção contém informações sobre os diferentes layouts de painéis que estão disponíveis.

Painel em GridLayout

Este painel mostra um GridLayout com três widgets.

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

O painel é semelhante a este exemplo:

Exemplo de painel com layout de grade

Painel em MosaicLayout

Este painel mostra um MosaicLayout com dois widgets.

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

O painel é semelhante a este exemplo:

Exemplo de painel com layout de mosaico

Painel em RowLayout

Este painel exibe um RowLayout com três widgets.

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

O painel é semelhante a este exemplo:

Exemplo de painel com layout de linhas

Painel em ColumnLayout

Este painel exibe um ColumnLayout com três widgets.

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

O painel é semelhante a este exemplo:

Exemplo de painel com layout de colunas

Ativar eventos do painel e adicionar filtros e rótulos

Nesta seção, descrevemos como adicionar filtros e rótulos a um painel e como configurar um painel para mostrar eventos.

Ativar eventos nos painéis

É possível configurar um painel para mostrar eventos, como um evento de atualização do Google Kubernetes Engine ou um evento de falha de máquina virtual, incluindo um campo annotations no objeto Dashboard. O campo annotations contém uma instância de um Objeto DashboardAnnotations, que contém dois campos:

  • O campo defaultResourceName lista os padrões do painel para os projetos do Google Cloud para pesquisar eventos. Se você não especificar esse campo, o projeto selecionado será pesquisado.

  • Uma matriz de objetos EventAnnotation. Cada contém o seguinte:

    • Um campo displayName, que permite definir o rótulo na para alternar eventos específicos. Quando esse campo não é especificado ou quando o valor deste campo é uma string vazia, o nome padrão do evento é exibido.
    • Um campo enabled, que controla o valor do botão de alternância do evento. Quando true, o botão fica na posição on, e os eventos são mostrados no painel. Quando false, o botão fica na posição off.
    • Um campo eventType, que contém um valor da enumeração EventType.
    • Um campo filter, que permite especificar uma consulta para anexar à consulta específica do evento. Quando o valor desse campo é uma string vazia, a consulta específica do evento é usada.
    • Um campo resourceNames, que permite definir uma lista de projetos do Google Cloud para pesquisar eventos. Quando esse campo é uma matriz vazia, o projeto selecionado é pesquisado.

O exemplo a seguir mostra um campo annotations que especifica um evento do Google Kubernetes Engine:

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

No exemplo anterior, o campo filter é usado para restringir a consulta ao cluster my-name. O campo displayName está definido como uma string vazia, portanto, o nome padrão do tipo de evento é exibido na o botão de alternância do evento. Por fim, como o resourceNames está definido como uma matriz vazia, as entradas de registro do seu projeto atual do Google Cloud são consultados.

Adicionar filtros ao painel

Você pode adicionar filtros permanentes a um painel para controlar quais dados o widgets em um painel de controle. Para ver um exemplo de painel com filtro permanente, consulte Filtros do painel.

Adicionar rótulos do painel

Este exemplo mostra um objeto Dashboard que especifica o rótulo chamado playbook.

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

Como o exemplo anterior ilustra, o campo labels é implementado como um map, em que os campos key e value são strings. Ao adicionar um rótulo a um painel, defina key como o nome do rótulo e o campo value como uma string vazia.

Adicionar rótulos a um painel é opcional.

Painéis com Widgets

Esta seção inclui exemplos de painéis com diferentes tipos de widgets.

Painel com um XyChart

Este painel mostra um painel com um simples XyChart. Se você já usou o console do Google Cloud para criar gráficos em painéis, são instâncias do widget XyChart.

Assim como na funcionalidade fornecida no console do Google Cloud, a API oferece opções para mudar o PlotType ou configurar os modos de visualização do gráfico.

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

O gráfico no painel é semelhante ao exemplo a seguir:

Exemplo de um XyChart.

A próxima seção ilustra como criar um widget de gráfico do Log Analytics, como mostrar um limite em um gráfico e como configurar se o gráfico usa o eixo Y à esquerda, o eixo Y à direita ou ambos.

Painel com um gráfico da Análise de registros

Este painel mostra um painel com um gráfico do Log Analytics. O JSON de exemplo contém uma consulta SQL.

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

O gráfico no painel é semelhante ao exemplo a seguir:

Exemplo de XyChart com uma consulta SQL da Análise de registros.

Painel com um XyChart e um limite

Este painel mostra um painel com um XyChart básico, um limite e o eixo Y esquerdo configurado.

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

No exemplo anterior, o JSON especifica o uso do eixo Y esquerdo porque ele contém uma estrutura y2Axis. No campo targetAxis, use "Y1" para o eixo Y direito e "Y2" para o eixo Y esquerdo. Se você omitir o campo targetAxis, o eixo Y à direita será usado.

O gráfico nesse painel é semelhante ao exemplo a seguir:

Exemplo de XyChart que usa o eixo Y esquerdo e tem um limite.

É possível criar gráficos que mostram vários tipos de métricas e que usam os eixos esquerdo e direito. O exemplo anterior ilustrava um gráfico com Um único tipo de métrica, ou seja, há um elemento na matriz dataSets. Quando você cria um gráfico com dois tipos de métrica, a matriz dataSets contém dois elementos, e cada elemento especifica o próprio targetAxis.

Painel com um XyChart com um STACKED_AREA PlotType

Este painel mostra um XyChart com um 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
      }
    ]
  }
}

O gráfico no painel é semelhante ao exemplo a seguir:

Exemplo de XyChart com um gráfico de área empilhada

Painel com um XyChart com um STACKED_BAR PlotType

Este painel mostra um XyChart com um 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
      }
    ]
  }
}

O painel é semelhante a este exemplo:

Exemplo de XyChart com um gráfico de colunas empilhadas

Painel com um Scorecard básico

Este painel mostra um Scorecard sem um medidor ou gráfico. O exemplo mostra a utilização da CPU do Compute Engine e a visão geral tem dois limites. Um limite usa a cor amarela para indicar que a utilização da CPU está acima de 70%, a outra usa vermelho para indicar que a utilização da CPU está acima de 90%.

Como a utilização atual da CPU é inferior aos limites especificados, a cor é verde.

{
  "dashboardFilters": [],
  "displayName": "Example-basic scorecard",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 8,
        "widget": {
          "scorecard": {
            "thresholds": [
              {
                "color": "YELLOW",
                "direction": "ABOVE",
                "label": "",
                "value": 0.7
              },
              {
                "color": "RED",
                "direction": "ABOVE",
                "label": "",
                "value": 0.9
              }
            ],
            "timeSeriesQuery": {
              "outputFullDuration": true,
              "timeSeriesFilter": {
                "aggregation": {
                  "alignmentPeriod": "60s",
                  "crossSeriesReducer": "REDUCE_MEAN",
                  "groupByFields": [],
                  "perSeriesAligner": "ALIGN_MEAN"
                },
                "filter": "metric.type=\"compute.googleapis.com/instance/cpu/utilization\" resource.type=\"gce_instance\""
              }
            }
          },
          "title": "VM Instance - CPU utilization [MEAN]"
        },
        "width": 16
      }
    ]
  }
}

O painel é semelhante a este exemplo:

Exemplo de painel com um widget de visão geral

Painel com Scorecard com GaugeView

Este painel adiciona um medidor à visão geral básica no exemplo anterior. O objeto GaugeView pode especificar um limite superior e um inferior para definir o intervalo de valores a ser exibido no medidor. Como a visão geral mostra valores de 0 a 1, esses limites superior e inferior são razoáveis. Para adicionar o medidor, adicione o seguinte ao JSON para a visão geral básica:

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

Veja a seguir a especificação completa do painel modificado: o valor atual está abaixo dos limites, que são coloridos adequadamente no medidor.

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

O gráfico nesse painel é semelhante ao exemplo a seguir:

Exemplo de painel com um widget de visão geral com o GaugeView

Painel com Scorecard com SparkChartView

Esse painel substitui o medidor no exemplo anterior por um minigráfico. O objeto SparkChartView pode criar gráficos de linhas ou de barras em uma visão geral. Este exemplo usa uma linha. Se o valor não violar um limite, ele ficará verde. Para adicionar o gráfico, substitua o objeto JSON gaugeView no gráfico anterior pelo seguinte:

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

A visão geral é semelhante ao exemplo a seguir:

Exemplo de painel com um widget de visão geral com o GaugeView

Painel com um widget PieChart

Os painéis podem mostrar dados usando um gráfico de pizza. Cada série temporal contribui com uma fatia do gráfico. Os gráficos de pizza não mostram dados ao longo do tempo. Em vez disso, elas mostram apenas o valor mais recente.

Todos os gráficos de pizza são especificados pelo widget PieChart. Para configurar o gráfico para mostrar a soma das medições mais recentes, defina o campo chartType como DONUT. Caso contrário, defina o campo como o de PIE.

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

O exemplo a seguir configura um painel com dois gráficos de pizza, sendo um deles configurado como um gráfico de rosquinha:

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

Conforme mostrado na captura de tela a seguir, os dois widgets mostram dados como um gráfico de pizza, com um widget exibindo a soma dos valores mais recentes:

Exemplo de widgets **PieChart**.

Painel com um widget TimeSeriesTable

Os painéis podem exibir dados em um formato tabular, em que há um linha para cada combinação de valores de rótulo exclusivos. As tabelas não mostram dados acima tempo Elas mostram o valor mais recente ou um valor agregado.

Todas as tabelas são especificadas pelo widget TimeSeriesTable:

  • Para configurar a série temporal a ser mostrada, use o campo dataSets. Cada objeto na matriz dataSets corresponde a um único tipo de métrica. Se você consultar vários tipos de métrica, o console do Google Cloud tenta exibir o valor mais recente para cada consulta no mesmo linha da tabela. Para mais informações, consulte Como as tabelas mesclam dados de vários tipos de métricas.

    • O campo TimeSeriesQuery especifica o tipo de métrica.
    • Se você quiser que a tabela mostre o valor agregado, em que os dados são agregados sobre o valor do intervalo de tempo definido pelo painel, defina timeSeriesQuery.outputFullDuration como true.

  • Para configurar o número máximo de linhas a serem exibidas, defina o pickTimeSeriesFilter. Por exemplo, para mostrar apenas as duas séries temporais com o maior valor médio nos 10 minutos anteriores, inclua o seguinte:

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

    Se você omitir o campo pickTimeSeriesFilter, a tabela exibirá no máximo 300 linhas.

  • Para configurar como a tabela exibe os dados, use o campo metricVisualization:

    • Para exibir somente um valor como "25%", omita esse campo ou defina o como "NUMBER". Quando você usa essa configuração, os O console do Google Cloud mostra o widget como um widget de Tabela.
    • Para mostrar o valor e um indicador visual do valor em comparação com o intervalo de valores possíveis, defina o valor desse campo como "BAR". Quando você usa essa configuração, os O console do Google Cloud mostra o widget da Lista de principais.

  • Para configurar quais colunas são exibidas e as propriedades da coluna, use a matriz columnSettings. Se esse campo não for especificado, a tabela exibe uma coluna para cada rótulo.

    O valor do campo "column" precisa ser definido como a chave do rótulo ou como value. que se refere ao valor mais recente da série temporal. É possível definir de exibição de uma coluna, e é possível configurar o alinhamento da dados na célula da tabela:

    • Para personalizar o cabeçalho da coluna, defina o campo displayName.
    • Para colorir a célula que mostra o valor mais recente com base na comparação do valor com um limite, adicione um objeto thresholds.
    • Para mudar o alinhamento do texto, adicione um campo alignment.

    O exemplo a seguir ilustra duas colunas:

    "columnSettings": [
  {
    "column": "device_name",
    "displayName": "Device",
    "visible": true
  },
  {
    "alignment": "CENTER",
    "column": "value",
    "displayName": "Disk Write Bytes",
    "thresholds": [
      {
        "color": "YELLOW",
        "direction": "ABOVE",
        "value": 4000
      },
      {
        "color": "RED",
        "direction": "ABOVE",
        "value": 5000
      }
    ],
    "visible": true
  }
],

O JSON a seguir descreve um painel com duas tabelas. A primeira tabela exibe dois tipos de métrica: o número de bytes lidos das instâncias e o o número de bytes gravados nas instâncias. Um valor agregado é mostrado uma barra de referência. A segunda tabela mostra o último valor de um tipo de métrica, e a coluna de valor foi configurada para codificar por cores a célula com base em como o valor se compara a um limite:

{
  "displayName": "Example",
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "width": 44,
        "height": 17,
        "widget": {
          "title": "VM Instance - Disk read bytes [RATE], Disk write bytes [RATE]",
          "timeSeriesTable": {
            "dataSets": [
              {
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/read_bytes_count\" resource.type=\"gce_instance\"",
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE",
                      "groupByFields": []
                    },
                    "pickTimeSeriesFilter": {
                      "rankingMethod": "METHOD_MEAN",
                      "numTimeSeries": 30,
                      "direction": "TOP"
                    }
                  },
                  "unitOverride": "",
                  "outputFullDuration": true
                },
                "tableTemplate": "",
                "minAlignmentPeriod": "60s"
              },
              {
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\"",
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE",
                      "groupByFields": []
                    },
                    "pickTimeSeriesFilter": {
                      "rankingMethod": "METHOD_MEAN",
                      "numTimeSeries": 30,
                      "direction": "TOP"
                    }
                  },
                  "unitOverride": "",
                  "outputFullDuration": true
                },
                "tableTemplate": "",
                "minAlignmentPeriod": "60s"
              }
            ],
            "metricVisualization": "BAR",
            "columnSettings": [
              {
                "column": "Name (from instance_id)",
                "visible": true
              },
              {
                "column": "zone",
                "visible": true
              },
              {
                "column": "device_name",
                "visible": true
              },
              {
                "column": "storage_type",
                "visible": true
              },
              {
                "column": "device_type",
                "visible": true
              },
              {
                "column": "value",
                "visible": true,
                "displayName": "Read bytes"
              },
              {
                "column": "value-1",
                "visible": true,
                "displayName": "Written bytes"
              }
            ],
            "opsAnalyticsSettings": {
              "maxRows": "0",
              "showFilterBar": false,
              "pageSize": "0"
            },
            "displayColumnType": false
          },
          "id": ""
        }
      },
      {
        "yPos": 17,
        "width": 44,
        "height": 16,
        "widget": {
          "title": "VM Instance - Disk write bytes [RATE]",
          "timeSeriesTable": {
            "columnSettings": [
              {
                "column": "device_name",
                "displayName": "Device",
                "visible": true
              },
              {
                "alignment": "LEFT",
                "column": "instance_name",
                "displayName": "Instance name",
                "visible": true
              },
              {
                "column": "storage_type",
                "displayName": "Storage type",
                "visible": true
              },
              {
                "column": "device_type",
                "displayName": "Device Type",
                "visible": true
              },
              {
                "alignment": "CENTER",
                "column": "value",
                "displayName": "Disk Write Bytes",
                "thresholds": [
                  {
                    "color": "YELLOW",
                    "direction": "ABOVE",
                    "label": "",
                    "value": 4000
                  },
                  {
                    "color": "RED",
                    "direction": "ABOVE",
                    "label": "",
                    "value": 5000
                  }
                ],
                "visible": true
              },
              {
                "alignment": "LEFT",
                "column": "Name (from instance_id)",
                "displayName": "ID",
                "visible": true
              }
            ],
            "dataSets": [
              {
                "minAlignmentPeriod": "60s",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "alignmentPeriod": "60s",
                      "perSeriesAligner": "ALIGN_RATE"
                    },
                    "filter": "metric.type=\"compute.googleapis.com/instance/disk/write_bytes_count\" resource.type=\"gce_instance\""
                  }
                }
              }
            ],
            "displayColumnType": false,
            "metricVisualization": "NUMBER",
            "opsAnalyticsSettings": {
              "maxRows": "0",
              "pageSize": "0",
              "showFilterBar": false
            }
          }
        }
      }
    ]
  },
  "dashboardFilters": [],
  "labels": {}
}

A captura de tela abaixo ilustra a tabela definida anteriormente:

Exemplo de painel com um widget de tabela.

Painel com um widget Text

Este exemplo mostra um painel simples com um widget Text.

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

O widget de texto é semelhante ao exemplo a seguir:

Exemplo de um widget de texto.

Painel com um widget AlertChart

Este painel mostra um painel com um widget AlertChart:

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

Diferentemente de outros widgets do painel, não é possível especificar um título ou um filtro de métrica para esses widgets. Em vez disso, especifique o nome do recurso para uma política de alertas. A última entrada no campo name é o identificador da política de alertas.

O gráfico no painel é semelhante ao exemplo a seguir:

Exemplo de um gráfico para uma política de alertas.

Neste exemplo, a política de alertas está monitorando o uso da CPU de duas máquinas virtuais diferentes. A linha tracejada mostra o limite de condição, que é definido como 50%. O ícone verde com o rótulo No incidents indica que não há incidentes abertos para a política de alertas. Se você colocar o ponteiro no ícone de incidentes, uma caixa de diálogo será aberta com links para a política de alertas subjacente.

Painel com um widget ErrorReportingPanel

Este painel mostra um painel com um widget ErrorReportingPanel:

{
  "dashboardFilters": [],
  "displayName": "Error reporting widget",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "errorReportingPanel": {
            "projectNames": [
              "projects/my-project"
            ],
            "services": [],
            "versions": []
          },
          "title": "Error Reporting Panel"
        },
        "width": 24,
      }
    ]
  }
}

Recomendamos que você configure a altura de um painel de relatório de erros como no mínimo 16 unidades e a largura pelo menos 24. No exemplo anterior, o widget tem uma altura de 16 unidades e uma largura de 24 unidades.

O painel do Error Reporting exibe os grupos de erros das projeto. Este painel pode restringir os grupos de erros a um recurso tipo, serviço ou versão de um serviço. O exemplo a seguir ilustra um painel do Error Reporting:

Exemplo de um painel de configuração do painel do Error Reporting.

Painel com um widget IncidentList

Este painel mostra um painel com um widget IncidentList:

{
  "category": "CUSTOM",
  "dashboardFilters": [],
  "displayName": "Incident widget",
  "labels": {},
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 5,
        "widget": {
          "incidentList": {
            "monitoredResources": [],
            "policyNames": []
          },
          "title": "Incidents"
        },
        "width": 8,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

O exemplo anterior define o campo title como Incidents e configura o widget para mostrar todos os incidentes de recursos do tipo gce_instance. Ao configurar esse widget, você pode selecionar várias políticas de alerta ou vários tipos de recursos.

O widget de incidentes no painel é semelhante ao exemplo a seguir:

Exemplo de um widget de incidente.

Painel com um widget LogsPanel

Este painel mostra um painel com um widget: LogsPanel.

{
  "category": "CUSTOM",
  "displayName": "Logs Panel",
  "mosaicLayout": {
    "columns": 12,
    "tiles": [
      {
        "height": 4,
        "widget": {
          "logsPanel": {
            "filter": "",
            "resourceNames": [
              "projects/012012012012"
            ]
          },
          "title": "Logs Panel"
        },
        "width": 6,
        "xPos": 0,
        "yPos": 0
      }
    ]
  }
}

Recomendamos que você configure a altura de um painel de registros para que seja de pelo menos três unidades e a largura de pelo menos quatro unidades. No exemplo anterior, o widget tem uma altura de quatro unidades e uma largura de seis unidades.

O painel de registros exibe os registros dos projetos do Google Cloud listados no campo resourceNames. O exemplo anterior especifica apenas um projeto. No entanto, é possível incluir vários projetos nessa lista.

O painel de registros é semelhante ao exemplo a seguir:

Exemplo de painel com um widget de painel de registros.

Para informações sobre solução de problemas, consulte A chamada de API para criar um painel com um painel de registros falha.

Painel com um widget CollapsibleGroup

Este painel mostra um painel com um widget: CollapsibleGroup.

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

No exemplo anterior, o widget de grupo colapsável contém um único gráfico que mostra a utilização da CPU de uma instância de VM. Os widgets de grupo recolhível abrangem uma linha inteira de uma tabela. Um widget é incluído em um grupo quando as especificações de posição e altura (x,y) do grupo incluem o valor (x,y) do widget. No exemplo anterior, o grupo está na posição (0,0) e a altura dele é 4. O xyChart está na posição (0,0), então ele é incluído no grupo. No entanto, se a posição desse gráfico for alterada para (0,5), ele será excluído do grupo. Por fim, quando o resultado da posição (x,y) de um widget na inclusão do widget no grupo, o A altura do widget de grupo recolhível pode ser expandida.

Para incluir um widget de grupo em um painel, ele precisa ter um MosaicLayout.

O widget de grupo colapsável é semelhante ao exemplo abaixo:

Exemplo de painel com um widget de grupo recolhível.

Painel com um widget SingleViewGroup

Um widget SingleViewGroup mostra um membro de um grupo por vez. Você especifica os gráficos e outros widgets que são membros no grupo. Além disso, você controla qual widget do grupo é exibido usando um menu no widget SingleViewGroup.

Este painel mostra um painel com um widget SingleViewGroup:

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

Como mostrado no exemplo anterior, a matriz tiles contém um objeto SingleViewGroup; No entanto, esse objeto não especifica quais objetos o que ele contém. Em vez disso, a associação ao objeto SingleViewGroup é determinada pelos valores dos campos width e yPos. Os objetos cujos valores dos campos width e yPos correspondem aos valores do objeto SingleViewGroup estão contidos no objeto SingleViewGroup. No exemplo anterior, o objeto SingleViewGroup contém dois gráficos.

Painel com um widget SectionHeader

Um widget SectionHeader cria um divisor horizontal em seu painel e cria uma entrada na tabela do painel de conteúdo. É possível personalizar a entrada na tabela de conteúdo e incluir informações adicionais no widget. Também é possível configurar o widget para adicionar um divisor à tabela de conteúdos após a entrada do cabeçalho da seção.

Esse painel mostra um painel com apenas um gráfico e um widget SectionHeader:

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

No objeto SectionHeader, o valor do campo title é exibido tanto no widget quanto no sumário. O valor do parâmetro O campo subtitle é exibido apenas pelo widget. Quando o valor dividerBelow é true, então um divisor é adicionado ao sumário.

Painel com um widget SLO

Este painel mostra um painel com um widget de SLO:

{
  "dashboardFilters": [],
  "displayName": "Example",
  "labels": {},
  "mosaicLayout": {
    "columns": 48,
    "tiles": [
      {
        "height": 16,
        "widget": {
          "title": "SLO Error Budget: 99.5% - Distribution Cut - Calendar month",
          "xyChart": {
            "chartOptions": {
              "mode": "COLOR"
            },
            "dataSets": [
              {
                "breakdowns": [],
                "dimensions": [],
                "legendTemplate": "Remaining error requests before SLO is burned",
                "measures": [],
                "plotType": "LINE",
                "targetAxis": "Y1",
                "timeSeriesQuery": {
                  "timeSeriesFilter": {
                    "aggregation": {
                      "perSeriesAligner": "ALIGN_NEXT_OLDER"
                    },
                    "filter": "select_slo_budget(\"projects/Project_Number/services/SERVICE_ID/serviceLevelObjectives/SLO_ID\")",
                  },
                  "unitOverride": "1"
                }
              }
            ],
            "thresholds": []
          }
        },
        "width": 24
      }
    ]
  }
}

Como mostra o JSON anterior, os gráficos de SLO são representados como objetos XyChart. Esses objetos especificam todos os campos de agregação, os limites e o valor do campo filter é um seletor de série temporal. Para mais informações sobre esses seletores, consulte Como recuperar dados SLO.

O widget de SLO é parecido com este exemplo:

Exemplo de painel com um widget de SLO.

Painel com um widget em branco

Este exemplo mostra um painel com um widget vazio de marcador de posição. O valor do campo displayName aparece no widget.

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

O painel é semelhante a este exemplo:

Exemplo de painel com um widget em branco