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.

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

A API Cloud Monitoring oferece uma maneira de gerenciar vários painéis ao mesmo tempo. Embora você possa usar Console do Google Cloud para gerenciar seus painéis, pode ser mais fácil usar a API para gerenciar 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 PromQL com a API

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

Quando um widget exibe dados de série temporal, como um widget de gráfico, a entrada no objeto Dashboard contém um objeto TimeSeriesQuery. Este objeto descreve os dados de série temporal para gráfico, e especifica esses dados usando um O filtro de monitoramento, um Consulta MQL ou consulta PromQL:

  • Para usar filtros do Monitoring, preencha o 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 em painéis

Você pode 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 Dashboard objeto. 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, seu projeto selecionado é 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 do EventType enumeração.
    • Um campo filter, que permite especificar uma consulta a ser anexada ao uma 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 for uma matriz vazia, o projeto selecionado será pesquisado.

O exemplo a seguir mostra um campo annotations que especifica uma 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 do 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 de painel

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

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

Conforme ilustrado no exemplo anterior, o campo labels é implementado como uma map, em que os campos key e value são strings. Quando você adiciona um rótulo a um painel, defina key como o nome dele e defina o 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 a funcionalidade fornecida no console do Google Cloud, a API oferece opções para mudar a PlotType do gráfico 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 é parecido com este exemplo:

Exemplo de um XyChart.

A próxima seção mostra como criar um widget de gráfico da Análise de dados de registros. como mostrar um limite em um gráfico e como definir se o gráfico usa o eixo Y à esquerda, o eixo Y à direita ou ambos.

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

Este painel mostra um painel com um gráfico da Análise de dados de registros. O exemplo de JSON 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`"
                  }
                }
              }
            ],
            "thresholds": [],
            "yAxis": {
              "label": "",
              "scale": "LINEAR"
            }
          }
        }
      }
    ]
  },
  "labels": {}
}

O gráfico no painel é parecido com este exemplo:

Exemplo de XyChart com uma consulta SQL da Análise de dados 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 exibir dados usando um gráfico de pizza. Cada série temporal contribui uma fatia à torta. 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 exibir 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, com um gráfico de pizza configurado como uma rosca:

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

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

Exemplo de widgets do **PieChart**.

Painel com um widget TimeSeriesTable

Os painéis podem exibir dados em formato tabular, onde há um de cada série temporal monitorada. As tabelas não mostram dados ao longo do tempo. Em vez disso, elas mostram apenas o valor mais recente.

Todas as tabelas são especificadas pelo widget TimeSeriesTable:

  • Para configurar o número máximo de linhas a serem exibidas, defina o pickTimeSeriesFilter. Por exemplo, para exibir apenas os dois eventos com o maior valor médio nos últimos 10 minutos, incluem 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, o O console do Google Cloud mostra o widget como um widget de Tabela.
    • Para exibir o valor e um indicador visual do valor comparado 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, use o campo columnSettings. O exemplo a seguir resulta em uma tabela com duas colunas, uma chamada Latest Value, que é uma coluna obrigatória, e a outra chamada Name (from instance_id):

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

    Se você omitir o campo columnSettings, a tabela exibirá uma coluna. para cada rótulo.

O exemplo a seguir mostra um painel com um widget Table e um Widget Lista dos principais:

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

Como mostrado na captura de tela a seguir, os dois widgets exibem dados em uma forma, e ambas contêm uma barra de filtro. No entanto, os dois widgets são pré-configuradas para mostrar colunas diferentes e representar o valor numérico de forma diferente:

Exemplo de painel com um widget de tabela.

As colunas da tabela correspondem aos rótulos. Cada linha corresponde a uma série temporal.

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 de 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. Na última exemplo, 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 dos recursos do tipo gce_instance. Ao configurar esse widget, é possível selecionar várias políticas de alertas ou vários tipos de recursos.

O widget de incidente no painel é parecido com este exemplo:

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 mostra 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 recolhível contém um único gráfico. que exibe o uso da CPU de uma instância de VM. Widgets de grupo recolhíveis que 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 de (0,0) e a altura é 4. O xyChart está na posição (0,0). Portanto, ele seja incluído no grupo. No entanto, se a posição desse gráfico for alterado para (0,5), o gráfico é 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, o dashboard deve ter um MosaicLayout.

O widget de grupo recolhível é parecido com este exemplo:

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

Painel com um widget SingleViewGroup

Um widget SingleViewGroup exibe um membro de um 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 no objeto SingleViewGroup é determinada pelos valores dos campos width e yPos. Os objetos com valores para o valor Os campos width e yPos correspondem à valores do objeto SingleViewGroup estão contidos nas 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. Você pode personalizar a entrada no sumário e incluir mais informações no widget. Também é possível configurar o widget para adicionar um divisor ao índice após a entrada do cabeçalho da seção.

Este painel mostra um painel com um único 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 de dividerBelow é true, então um divisor é adicionado ao sumário.

Painel com um widget de 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 mostrado no JSON anterior, os gráficos de SLO são representados como Objetos XyChart. Esses objetos especificam todos campos de agregação, limites e do campo filter é um seletor de série temporal. Para mais informações sobre esses seletores, consulte Como recuperar dados de 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