Esta página foi traduzida pela API Cloud Translation.

Criar painéis visuais

Nesta página, descrevemos o processo de criação e gerenciamento de painéis na sua instância do Grafana instância de monitoramento do sistema. Use painéis para realizar operações de monitoramento no seu projeto, como monitoramento de rede e de servidor.

Depois que a plataforma de observabilidade coleta as métricas produzidas pelas cargas de trabalho implantadas no seu projeto do GDC, a configuração salva os rótulos de métricas associados e agrega arquivos de todas as fontes de dados. Em seguida, é possível criar painéis personalizados para consultar e visualizar métricas específicas na interface da instância de monitoramento.

Um painel é uma organização visual dinâmica de um ou mais painéis personalizáveis que interagem com as métricas do Prometheus configuradas em fontes de dados. Ao fazer consultas, você pode usar cada um desses painéis para visualizar e expor métricas específicas dos seus componentes do GDC.

A plataforma de observabilidade expõe uma API que permite configurar personalizações para a organização visual das métricas. Por exemplo, estabeleça limites de aceitação, mostre os indicadores adequados, rotule os gráficos e escolha uma resolução de tempo consistente.

Painéis disponíveis

Supondo que seu ambiente esteja funcionando, você vai ver imediatamente alguns painéis de métricas na página inicial da instância de monitoramento. Por exemplo, é possível observar o status da chave e a integridade dos componentes do sistema.

Use os painéis de switches e clusters para monitorar clusters e métricas de nós. Acesse os painéis de geração de registros e monitoramento para observar os clusters de administrador.

Página inicial com uma lista de painéis disponíveis e visualizados recentemente

As métricas mais relevantes do administrador da plataforma (PA, na sigla em inglês) são as seguintes:

Kubernetes / Servidor da API: mostra a integridade do servidor da API por cluster na organização.
Kubernetes / Recursos de computação / Multi-cluster: mostra a utilização de recursos em toda a organização.
Kubernetes / Recursos de computação / Cluster: mostra a utilização de recursos por cluster.
Kubernetes / Volumes permanentes: mostra a utilização de volumes permanentes do Kubernetes em cada cluster.
Status do nó: mostra o uso de recursos em cada nó de cada cluster.
Status do pod: mostra o consumo de recursos de cada pod em cada cluster.

A imagem a seguir mostra um exemplo do painel Kubernetes / Recursos de computação / Multi-cluster.

Gráfico de linhas mostrando o uso da CPU e lista de clusters com cotas de CPU

Acessar a instância de monitoramento do projeto

Você precisa de autorização para acessar os painéis de monitoramento. Para receber as permissões necessárias para fazer login e visualizar métricas na instância de monitoramento do seu projeto, peça ao administrador do IAM da organização para conceder a você o papel de Leitor do Grafana da organização (organization-grafana-viewer). O administrador do IAM da organização pode conceder acesso criando uma vinculação de função:

kubectl --kubeconfig ADMIN_KUBECONFIG create rolebinding pa-grafana-viewer-binding -n platform-obs --user=USER_NAME --clusterrole=organization-grafana-viewer

Substitua:

ADMIN_KUBECONFIG: o caminho do arquivo kubeconfig do cluster de administrador.
USER_NAME: o nome da conta do usuário que precisa da vinculação de função.

Confira os seguintes recursos para mais informações sobre atribuições de papéis:

Para uma descrição sobre o papel de leitor do Grafana da organização, consulte Descrições de papéis predefinidos.
Para instruções sobre como adicionar e remover papéis da UI, consulte Conceder acesso a recursos.

Criar painéis do Grafana

Esta seção descreve o processo de criação e gerenciamento de painéis na sua instância do Grafana.

Siga estas etapas para criar um painel no GDC:

Conclua os pré-requisitos da seção "Antes de começar".
Abra o endpoint do Grafana do seu projeto.
Crie um objeto ConfigMap para seu painel.
Crie um recurso personalizado (CR) Dashboard.

Antes de começar

Antes de criar painéis, você precisa ter acesso à instância de monitoramento. Para mais informações, consulte Acessar painéis.

Colete métricas do seu projeto do GDC antes de criar painéis.
Para fazer login, criar painéis e visualizar métricas, peça ao administrador do IAM do projeto para conceder a você a função de leitor do Grafana do projeto (project-grafana-viewer).
Defina o caminho do arquivo kubeconfig como uma variável de ambiente:
```
export KUBECONFIG=KUBECONFIG_FILE
```
Substitua KUBECONFIG_FILE pelo caminho do arquivo kubeconfig no cluster de administrador em que você quer criar o painel.

Endpoint de monitoramento

Abra o seguinte URL para acessar o endpoint 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.

Crie um objeto `ConfigMap` para seu painel

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

Acesse o endpoint do seu projeto.
No menu de navegação, clique no botão Adicionar.
No menu suspenso, clique em Painel. A instância cria um painel vazio.
No dashboard vazio, adicione todos os painéis que você quer. Você pode personalizar seus detalhes e editar os painéis para fornecer suas consultas ou fazer outras atualizações.

Observação: ao personalizar seu painel, implemente as práticas recomendadas para seu caso de uso e facilite a visualização e interpretação dos dados dos componentes. Por exemplo, estabeleça limites de aceitação, mostre indicadores úteis, rotule os gráficos corretamente e escolha uma resolução de tempo consistente.
Na barra de menus, clique no botão Configurações do painel para abrir a página Configurações.
No menu de navegação, clique na opção Modelo JSON.
Copie o modelo JSON do painel e cole em um arquivo de texto simples para mantê-lo disponível.
Substitua os campos de nível superior id e uid pelo valor null no modelo JSON.
Crie um objeto ConfigMap na linha de comando. Na seção data do objeto ConfigMap, cole o modelo JSON que você copiou anteriormente em um arquivo .json:
```
cat <<EOF | kubectl --kubeconfig ${KUBECONFIG} apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  namespace: PROJECT_NAMESPACE
  name: DASHBOARD_CONFIGMAP_NAME
data:
  JSON_FILE_NAME.json: |
    {
    <JSON model of the dashboard>
    }
EOF
```
Substitua:
- PROJECT_NAMESPACE: o namespace do projeto.
- DASHBOARD_CONFIGMAP_NAME: o nome que você quer dar ao objeto ConfigMap.
- JSON_FILE_NAME: o nome que você quer dar ao arquivo em que vai colar o modelo JSON do painel.
Para ver um exemplo de como esse objeto precisa ser, consulte o exemplo ConfigMap de um painel.
Implante o objeto ConfigMap do painel no cluster de administrador.

Exemplo de `ConfigMap` para um painel

O arquivo YAML a seguir mostra um exemplo do objeto ConfigMap de um painel para métricas 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": "-- Grafana --",
            "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 (CR, na sigla em inglês) Dashboard e ativar o painel no projeto:

Crie um CR Dashboard na linha de comando e configure o arquivo com o nome que você deu ao objeto ConfigMap do painel:
```
cat <<EOF | kubectl --kubeconfig ${KUBECONFIG} apply -f -
apiVersion: observability.gdc.goog/v1alpha1
kind: Dashboard
metadata:
  namespace: PROJECT_NAMESPACE
  name: CUSTOM_RESOURCE_NAME
spec:
  configMapRef:
    name: DASHBOARD_CONFIGMAP_NAME
    namespace: PROJECT_NAMESPACE
    key: JSON_FILE_NAME.json
  foldername: Default
EOF
```
Substitua:
- PROJECT_NAMESPACE: o namespace do projeto.
- CUSTOM_RESOURCE_NAME: o nome que você quer dar ao recurso personalizado Dashboard.
- DASHBOARD_CONFIGMAP_NAME: o nome que você deu ao objeto ConfigMap do painel.
- JSON_FILE_NAME: o nome que você deu ao arquivo que contém o modelo JSON do painel no objeto ConfigMap.
Implante o CR Dashboard no namespace do projeto. Essa ação configura o serviço de observabilidade para importar o painel predefinido para a instância de monitoramento do seu projeto.

Os painéis são isolados de outros projetos, assim como as métricas e os registros. Portanto, se você quiser usar o mesmo painel em vários projetos, implante um CR Dashboard em cada um deles. Além disso, os dados de geração de registros e monitoramento acessados pelo painel precisam estar disponíveis em todos esses projetos.

O processo que lida com os painéis detecta mudanças no CR Dashboard e no objeto ConfigMap. Se você modificar um ou outro, o programa vai refletir a mudança na instância de monitoramento. Para atualizar ou excluir um painel, aplique as mudanças no CR e implante-o novamente. Não é possível salvar atualizações feitas diretamente na UI de monitoramento.

Para criar um painel em uma pasta ou mudar as pastas, modifique o valor foldername na seção spec do CR Dashboard. Caso contrário, deixe como Default. O processo cria automaticamente as pastas, se elas não existirem.