Esta página foi traduzida pela API Cloud Translation.

Criar painéis de visualização

Esta página descreve o processo de criação e gerenciamento de painéis na sua instância do Grafana, usada para visualizações de registros e métricas do seu projeto isolado do Google Distributed Cloud (GDC).

Um painel oferece uma representação visual dinâmica da performance do seu sistema. Ele consiste em um ou mais painéis personalizáveis, cada um configurado para consultar e mostrar métricas específicas dos componentes do GDC. Com esses painéis, é possível:

Visualize métricas usando vários tipos de gráficos.
Defina limites de alerta para acionar notificações com base nos valores das métricas.
Personalize propriedades de exibição, como rótulos, unidades e períodos.
Defina resoluções de tempo consistentes para comparações precisas.

Ao usar os painéis do Grafana de maneira eficaz, você pode ter insights valiosos sobre o desempenho e a integridade do seu ambiente do GDC.

Antes de começar

Para receber as permissões necessárias para acessar e visualizar painéis do Grafana, peça ao administrador do IAM da organização ou do projeto para conceder a você uma das funções predefinidas de leitor do Grafana.

Além disso, para ter as permissões necessárias para gerenciar os objetos da API necessários para criar painéis, peça ao administrador do IAM da organização ou do projeto para conceder a você os papéis associados ConfigMap e Dashboard.

Dependendo do nível de acesso e das permissões necessárias, você pode receber papéis de criador, editor ou leitor para esses recursos em uma organização ou um projeto. Para mais informações, consulte Preparar permissões do IAM.

Depois de conseguir as funções correspondentes, siga estas etapas antes de criar painéis:

Colete métricas das suas cargas de trabalho.
Defina o caminho do arquivo kubeconfig como uma variável de ambiente:
```
export KUBECONFIG=KUBECONFIG_PATH
```
Substitua KUBECONFIG_PATH pelo caminho para o arquivo kubeconfig do servidor da API Management em que você quer criar o painel.

Identificar seu endpoint do Grafana

O URL a seguir é o endpoint da instância do Grafana do seu projeto:

https://GDC_URL/PROJECT_NAMESPACE/grafana

Substitua:

GDC_URL: o URL da sua organização no GDC.
PROJECT_NAMESPACE: o namespace do projeto.

Por exemplo, o endpoint do Grafana para o projeto platform-obs na organização org-1 é https://org-1/platform-obs/grafana.

Criar um painel personalizado

Siga estas etapas para criar um painel do Grafana e personalizar suas configurações:

Abra o endpoint do Grafana para mostrar a interface do usuário.
No menu de navegação, clique em Adicionar.
No menu suspenso, clique em Painel. O Grafana cria um painel vazio.
No dashboard vazio, adicione todos os painéis que você quer.
No menu Fonte de dados de cada painel, selecione a fonte de dados que você quer usar, incluindo métricas (prometheus), registros de auditoria (auditloki) e registros operacionais (oploki).

Para universos de várias zonas, o Grafana tem fontes de dados rotuladas por zona que podem ser usadas para criar visualizações de painel com métricas e registros de várias zonas. Essas fontes de dados são nomeadas no formato DATA_SOURCE-ZONE_ID, em que:
- DATA_SOURCE pode ter um dos seguintes valores:
  - Prometheus (prometheus ou metrics) para mostrar métricas.
  - Registros de auditoria (auditloki) para mostrar os registros.
  - Registros operacionais (oploki) para mostrar os registros operacionais.
- ZONE_ID é o ID da zona de que você quer mostrar dados no painel.
Além disso, para criar um painel de visualização de recursos entre zonas, o nome da fonte de dados é --Mixed--. Com ela, é possível adicionar várias consultas por zona e ter visualizações de dados entre zonas em um único painel. Use esse recurso para comparar comportamentos entre, por exemplo, uma única métrica ou consulta de registro em várias zonas do seu universo.
Personalize seus detalhes e edite os painéis para fornecer suas consultas ou fazer outras atualizações.

Dica: ao personalizar seu painel, implemente práticas recomendadas para seu caso de uso e facilite a visualização e interpretação dos dados de observabilidade dos seus componentes. Por exemplo, estabeleça limites de aceitação, mostre indicadores úteis, adicione rótulos aos gráficos e escolha uma resolução de tempo consistente.
Na barra de menus, clique em Configurações do painel para abrir a página Configurações.
No menu de navegação, selecione Modelo JSON.
Copie o modelo JSON do painel e cole em um arquivo de texto simples para uso futuro.

Criar um objeto `ConfigMap`.

Siga estas etapas para criar um objeto ConfigMap que contenha o modelo JSON do painel:

Abra uma janela de terminal.
Criar um objeto ConfigMap. Na seção data do objeto ConfigMap, cole o modelo JSON que você copiou antes:
```
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: PROJECT_NAMESPACE
  name: CONFIGMAP_NAME
data:
  JSON_FILE_NAME.json: |
    {
    JSON_MODEL
    }
```
Substitua:
- PROJECT_NAMESPACE: o namespace do projeto.
- CONFIGMAP_NAME: o nome que você quer dar ao objeto ConfigMap.
- JSON_FILE_NAME: o nome que você quer dar ao arquivo do modelo JSON do painel.
- JSON_MODEL: o modelo JSON do seu painel personalizado.
Para ver um exemplo de como esse objeto precisa ser, consulte um exemplo de ConfigMap.

Aplique o objeto ConfigMap ao servidor da API Management:

kubectl --kubeconfig ${KUBECONFIG} apply -f CONFIGMAP_NAME.yaml

Um exemplo de `ConfigMap`

O arquivo YAML a seguir mostra um exemplo do objeto ConfigMap de um painel no namespace platform-obs:

  apiVersion: v1
  kind: ConfigMap
  metadata:
    namespace: platform-obs
    name: my-project-dashboard-configmap
  data:
    my-project-dashboard.json: |
      {
      "annotations": {
        "list": [
          {
            "builtIn": 1,
            "datasource": "--",
            "enable": true,
            "hide": true,
            "iconColor": "rgba(0, 211, 255, 1)",
            "name": "Annotations & Alerts",
            "type": "dashboard"
          }
        ]
      },
      "editable": true,
      "graphTooltip": 0,
      "id": null,
      "links": [],
      "panels": [],
      "schemaVersion": 27,
      "style": "dark",
      "tags": [],
      "templating": {
        "list": []
      },
      "time": {
        "from": "now-6h",
        "to": "now"
      },
      "timepicker": {},
      "timezone": "",
      "title": "Sample dashboard",
      "uid": null,
      "version": 0
      }

Criar um recurso personalizado `Dashboard`

Siga estas etapas para criar um recurso personalizado Dashboard e importar seu painel personalizado para a instância do Grafana do seu projeto:

Abra uma janela de terminal.
Crie um recurso personalizado Dashboard e configure o arquivo com o nome que você deu ao objeto ConfigMap:
```
apiVersion: observability.gdc.goog/v1
kind: Dashboard
metadata:
  namespace: PROJECT_NAMESPACE
  name: DASHBOARD_NAME
spec:
  configMapRef:
    name: CONFIGMAP_NAME
    namespace: PROJECT_NAMESPACE
    key: JSON_FILE_NAME.json
  foldername: Default
```
Substitua:
- PROJECT_NAMESPACE: o namespace do projeto.
- DASHBOARD_NAME: o nome que você quer dar ao recurso personalizado Dashboard.
- CONFIGMAP_NAME: o nome que você deu ao objeto ConfigMap.
- JSON_FILE_NAME: o nome que você deu ao arquivo que contém o modelo JSON do painel no objeto ConfigMap.
Observação: para organizar painéis em pastas, especifique o foldername na seção spec do recurso Dashboard. Se você omitir esse campo, o padrão será a pasta Default. As pastas são criadas automaticamente se não existirem.

Aplique o recurso personalizado Dashboard ao servidor da API Management:

kubectl --kubeconfig ${KUBECONFIG} apply -f DASHBOARD_NAME.yaml

O sistema monitora mudanças no recurso personalizado Dashboard e no objeto ConfigMap associado. Para atualizar ou excluir um painel, modifique estes recursos. Qualquer modificação aciona uma atualização do Grafana. Não é possível salvar atualizações feitas diretamente na interface do usuário do Grafana.

Criar painéis de visualização Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.