Este documento foi traduzido usando tecnologia de tradução automática de máquina. Sempre trabalhamos para apresentar traduções precisas, mas não oferecemos nenhuma garantia em relação à integridade, precisão ou confiabilidade do conteúdo traduzido. Em caso de qualquer discrepância, a versão original em inglês prevalecerá e constituirá o texto official.

Adicione gráficos personalizados aos componentes

Visão Geral

O SUSE Observability já fornece muitos gráficos de métricas por padrão na maioria dos tipos de componentes que representam recursos do Kubernetes. Gráficos de métricas extras podem ser adicionados a qualquer conjunto de componentes sempre que necessário. Ao adicionar métricas aos componentes, existem 2 opções:

  1. As métricas já são coletadas pelo SUSE Observability, mas não são visualizadas em um componente por padrão.

  2. As métricas ainda não são coletadas pelo SUSE Observability e, portanto, ainda não estão disponíveis.

Para a opção 1, os passos abaixo irão instruí-lo sobre como criar um vínculo de métrica que configurará o SUSE Observability para adicionar uma métrica específica a um conjunto específico de componentes.

No caso da opção 2, primeiro certifique-se de que as métricas estão disponíveis no SUSE Observability, enviando-as para o SUSE Observability usando o protocolo de escrita remota do Prometheus. Somente após isso, continue adicionando gráficos para as métricas aos componentes.

Etapas

Passos para criar um vínculo de métrica:

  1. Escreva o esboço do vínculo de métrica

  2. Escreva a consulta de topologia (STQL) para selecionar os componentes

  3. Escreva a consulta PromQL para a métrica desejada

  4. Vincule a série temporal correta a cada componente

  5. Crie ou atualize o vínculo de métrica no SUSE Observability

Como exemplo, os passos adicionarão um vínculo de métrica para o Replica counts das implantações do Kubernetes. Este é apenas um exemplo, esse vínculo de métrica já existe no SUSE Observability por padrão.

Escreva o esboço do vínculo de métrica

Crie um novo arquivo YAML chamado metric-bindings.yaml e adicione este modelo YAML a ele para criar seu próprio vínculo de métrica. Abra-o em seu editor de código favorito para alterá-lo ao longo deste guia. Ao final, o SUSE Observability CLI será usado para criar e atualizar os vínculos de métrica no SUSE Observability.

nodes:
- _type: MetricBinding
  chartType: line
  enabled: true
  tags: {}
  unit:
  name:
  description:
  priority:
  identifier: urn:custom:metric-binding:...
  queries:
    - expression:
      alias:
  scope:
  layout:
    metricPerspective:
      tab:
      section:
      weight:
    componentSummary:
      weight:

Os campos neste modelo são:

  • _type: O SUSE Observability precisa saber que isso é um vínculo de métrica, portanto, o valor sempre precisa ser MetricBinding.

  • chartType: O SUSE Observability suportará diferentes tipos de gráficos (line, bar, etc.), atualmente apenas line é suportado.

  • enabled: Defina como false para manter o vínculo de métrica, mas não mostrá-lo aos usuários.

  • tags: Será usado para organizar métricas na interface do usuário, podendo ser deixado em branco usando {}.

  • unit: A unidade dos valores na série temporal retornada pela consulta ou consultas, usada para renderizar o eixo Y do gráfico. Consulte a referência de unidades suportadas para ver todas as unidades.

  • name: O nome do vínculo de métrica

  • description: Descrição opcional, exibida ao passar o mouse sobre o nome.

  • priority: [Obsoleto] Um dos HIGH, MEDIUM ou LOW. Ordem principal de classificação para métricas em um componente (na ordem em que são mencionadas aqui), a ordem secundária de classificação é a name.

  • identifier: Um URN (identificador de recurso universal), usado como o identificador único do vínculo de métrica. Deve começar com urn:custom:metric-binding:, o restante é formato livre, desde que seja único entre todos os vínculos de métrica.

  • queries: Uma lista de consultas a serem exibidas no gráfico para o vínculo de métrica (veja também as seções seguintes).

  • scope: O escopo de topologia do vínculo de métrica, uma consulta de topologia que seleciona os componentes nos quais este vínculo de métrica será exibido.

  • layout: Como agrupar gráficos em diferentes perspectivas, por exemplo, na perspectiva de Métricas.

Preencha primeiro todas as partes já conhecidas (com as contagens de réplicas de implantação como exemplo).

_type: MetricBinding
chartType: line
enabled: true
tags: {}
unit: short
name: Replica counts
priority: MEDIUM
identifier: urn:custom:metric-binding:my-deployment-replica-counts
queries:
  - expression:
    alias:
scope:

As seções de consultas e escopo serão preenchidas nos próximos passos. Observe que a unidade utilizada é short, que simplesmente renderizará um valor numérico. Caso você ainda não tenha certeza sobre a unidade da métrica, pode deixá-la em aberto e decidir a unidade correta ao escrever a consulta PromQL.

Escreva a consulta de topologia

Use a visualização Explorar da perspectiva de Topologia, http://your-instance/#/views/explore, e selecione os componentes que precisam mostrar a nova métrica. Tanto a visualização básica quanto a avançada podem ser usadas para fazer a seleção. Os campos mais comuns para selecionar topologia em vínculos de métrica são type para o tipo de componente e label para selecionar todos os rótulos. Por exemplo, para as implantações:

type = "deployment" and label = "stackpack:kubernetes"

O filtro de tipo seleciona todas as implantações, enquanto o filtro de rótulo seleciona apenas os componentes criados pelo stackpack Kubernetes (o nome do rótulo é stackpack e o valor do rótulo é kubernetes). Este último também pode ser omitido para obter o mesmo resultado.

Mude para o modo avançado para copiar a consulta de topologia resultante e colocá-la no campo scope do vínculo de métrica.

Vínculos de métrica suportam apenas os filtros de consulta; funções de consulta como withNeighborsOf não são suportadas e não podem ser usadas.

Escreva a consulta PromQL

Vá para o explorador de métricas da sua instância SUSE Observability, http://your-instance/#/metrics, e use-o para consultar a métrica de interesse. O explorador possui autocompletar para métricas, rótulos, valores de rótulos, mas também funções PromQL e operadores para ajudar você. Comece com um intervalo de tempo curto, por exemplo, uma hora, para obter os melhores resultados.

Para o número total de réplicas, use a métrica kubernetes_state_deployment_replicas. Para tornar os gráficos mostrados para esta métrica representativos dos dados da série temporal, amplie a consulta para fazer uma agregação usando o parâmetro ${__interval}:

max_over_time(kubernetes_state_deployment_replicas[${__interval}])

Neste caso específico, use max_over_time para garantir que o gráfico sempre mostre o maior número de réplicas em qualquer momento. Para intervalos de tempo mais longos, isso significa que uma queda curta nas réplicas não será mostrada; para enfatizar o menor número de réplicas, use min_over_time em vez disso.

Copie a consulta na propriedade expression da primeira entrada no campo queries do vínculo de métrica. Use Total replicas como um álias. Este é o nome que aparecerá na legenda do gráfico.

No SUSE Observability, o tamanho do gráfico de métricas determina automaticamente a granularidade da métrica exibida no gráfico. As consultas PromQL podem ser ajustadas para fazer uso ideal desse comportamento e obter um gráfico representativo para a métrica. Escrever PromQL para gráficos explica isso em detalhes.

Vincule a série temporal correta a cada componente.

A vinculação da métrica com todos os campos preenchidos:

_type: MetricBinding
chartType: line
enabled: true
tags: {}
unit: short
name: Replica counts
priority: MEDIUM
identifier: urn:custom:metric-binding:my-deployment-replica-counts
queries:
  - expression: max_over_time(kubernetes_state_deployment_replicas[${__interval}])
    alias: Total replicas
scope: type = "deployment" and label = "stackpack:kubernetes"

Criá-la no SUSE Observability e visualizar o gráfico de "Contagem de réplicas" em um componente de implantação gera um resultado inesperado. O gráfico mostra as contagens de réplicas para todas as implantações. Logicamente, esperar-se-ia apenas 1 série temporal: a contagem de réplicas para esta implantação específica.

O gráfico incorreto para uma única implantação

Para corrigir isso, torne a consulta PromQL específica para um componente usando informações do componente. Filtre em rótulos de métrica suficientes para selecionar apenas a série temporal específica para o componente. Este é o vínculo da série temporal correta para o componente. Para quem tem experiência em criar painéis no Grafana, isso é semelhante a um painel com parâmetros que são usados em consultas no painel. Vamos mudar a consulta no vínculo de métrica para isto:

max_over_time(kubernetes_state_deployment_replicas{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}", deployment="${name}"}[${__interval}])
Após adicionar os filtros parametrizados

A consulta PromQL agora filtra em 3 rótulos, cluster_name, namespace e deployment. Em vez de especificar um valor real para esses rótulos, uma referência de variável aos campos do componente é usada. Neste caso, os rótulos cluster-name e namespace são usados, referenciados usando ${tags.cluster-name} e ${tags.namespace}. Além disso, o nome do componente é referenciado com ${name}.

As referências de variáveis suportadas são:

  • Qualquer rótulo de componente, usando ${tags.<label-name>}

  • O nome do componente, usando ${name}

Página de Destaques do Componente que mostra os rótulos e o nome do componente (ambos destacados em vermelho)

O nome do cluster, namespace e uma combinação do tipo e nome do componente geralmente são suficientes para selecionar as métricas de um componente específico do Kubernetes. Esses rótulos, ou rótulos semelhantes, geralmente estão disponíveis na maioria das métricas e componentes.

Crie ou atualize o vínculo de métrica no SUSE Observability.

Use a CLI da SUSE Observability para criar o vínculo de métrica no SUSE Observability. Certifique-se de que o metric-bindings.yaml está salvo e se parece com isto:

nodes:
- _type: MetricBinding
  chartType: line
  enabled: true
  tags: {}
  unit: short
  name: Replica counts
  priority: MEDIUM
  identifier: urn:custom:metric-binding:my-deployment-replica-counts
  queries:
    - expression: max_over_time(kubernetes_state_deployment_replicas{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}", deployment="${name}"}[${__interval}])
      alias: Total replicas
  scope: type = "deployment" and label = "stackpack:kubernetes"

Use a SUSE Observability CLI para criar a vinculação de métrica:

sts settings apply -f metric-bindings.yaml

Verifique os resultados na SUSE Observability abrindo a perspectiva de métricas para uma implantação. Se você não estiver satisfeito com o resultado, basta alterar a vinculação de métrica no arquivo YAML e executar o comando novamente para atualizá-la. A lista de nós suporta a adição de muitas vinculações de métricas. Basta adicionar outra entrada de vinculação de métrica ao array YAML usando os mesmos passos de antes.

O identificador é usado como a chave única de uma vinculação de métrica. Alterar o identificador criará uma nova vinculação de métrica em vez de atualizar a existente.

O comando sts settings tem mais opções, por exemplo, ele pode listar todos os vínculos de métrica:

sts settings list --type MetricBinding

Por fim, para excluir uma vinculação de métrica, use

sts settings delete --ids <id>

O <id> neste comando não é o identificador, mas o número na coluna Id da saída sts settings list.

A maneira recomendada de trabalhar é armazenar vínculos de métrica (e quaisquer outros recursos personalizados criados no SUSE Observability) como arquivos YAML em um repositório Git. A partir daí, as alterações podem ser aplicadas manualmente ou podem ser totalmente automatizadas usando o SUSE Observability CLI em um sistema CI/CD, como GitHub Actions ou GitLab Pipelines.

Outras opções

Mais de 1 série temporal em um gráfico

Há apenas 1 unidade para uma vinculação de métrica (ela é plotada no eixo y do gráfico). Como resultado, você deve combinar apenas consultas que produzem séries temporais com a mesma unidade em 1 vinculação de métrica. Às vezes, pode ser possível converter a unidade. Por exemplo, o uso de CPU pode ser relatado em millicores ou em cores; millicores podem ser convertidos em cores multiplicando por 1000, como neste exemplo (<original-query>) * 1000.

Existem 2 maneiras de obter mais de 1 série temporal em uma única vinculação de métrica e, portanto, em um único gráfico:

  1. Escreva uma consulta PromQL que retorne várias séries temporais para um único componente

  2. Adicione mais consultas PromQL à vinculação de métrica

Para a primeira opção, um exemplo é dado na próxima seção. A segunda opção pode ser útil para comparar métricas relacionadas. Alguns casos de uso típicos:

  • Comparando réplicas totais versus desejadas e disponíveis

  • Uso de recursos: limites, solicitações e uso em um único gráfico

Para adicionar mais consultas a uma vinculação de métrica, basta repetir passos 3. e 4. e adicionar a consulta como uma entrada extra na lista de consultas. Para as contagens de réplicas de implantação, existem várias métricas relacionadas que podem ser incluídas no mesmo gráfico:

nodes:
- _type: MetricBinding
  chartType: line
  enabled: true
  tags: {}
  unit: short
  name: Replica counts
  priority: MEDIUM
  identifier: urn:custom:metric-binding:my-deployment-replica-counts
  queries:
    - expression: max_over_time(kubernetes_state_deployment_replicas{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}", deployment="${name}"}[${__interval}])
      alias: Total replicas
    - expression: max_over_time(kubernetes_state_deployment_replicas_available{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}",  deployment="${name}"}[${__interval}])
      alias: Available - ${cluster_name} - ${namespace} - ${deployment}
    - expression: max_over_time(kubernetes_state_deployment_replicas_unavailable{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}",  deployment="${name}"}[${__interval}])
      alias: Unavailable - ${cluster_name} - ${namespace} - ${deployment}
    - expression: min_over_time(kubernetes_state_deployment_replicas_desired{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}",  deployment="${name}"}[${__interval}])
      alias: Desired - ${cluster_name} - ${namespace} - ${deployment}
  scope: type = "deployment" and label = "stackpack:kubernetes"
Vinculação de métrica com várias métricas

Usando rótulos de métrica em álias

Quando uma única consulta retorna várias séries temporais por componente, isso será exibido como várias linhas no gráfico. Mas na legenda, todas usarão o mesmo álias. Para poder ver a diferença entre as diferentes séries temporais, o álias pode incluir referências aos rótulos de métrica usando a sintaxe ${label}. Por exemplo, aqui está uma vinculação de métrica para a métrica "Reinicializações de contêiner" em um pod, note que um pod pode ter vários contêineres:

type: MetricBinding
chartType: line
enabled: true
id: -1
identifier: urn:custom:metric-binding:my-pod-restart-count
name: Container restarts
priority: MEDIUM
queries:
- alias: Restarts - ${container}
  expression: max by (cluster_name, namespace, pod_name, container) (kubernetes_state_container_restarts{cluster_name="${tags.cluster-name}", namespace="${tags.namespace}", pod_name="${name}"})
scope: (label = "stackpack:kubernetes" and type = "pod")
unit: short

Observe que o alias faz referência ao rótulo container da métrica. Certifique-se de que o rótulo esteja presente no resultado da consulta; quando o rótulo estiver ausente, o ${container} será renderizado como texto literal para ajudar na solução de problemas.

Layouts

Cada componente pode estar associado a várias tecnologias ou protocolos, como k8s, redes, ambientes de execução (por exemplo, JVM), protocolos (HTTP, AMQP), etc. Consequentemente, uma multidão de métricas diferentes pode ser exibida para cada componente. Para facilitar a leitura, o SUSE Observability pode organizar esses gráficos em abas e seções. Para exibir um gráfico (MetricBinding) dentro de uma aba ou seção específica, você precisa configurar a propriedade de layout. Qualquer MetricsBinding sem um layout especificado será exibido em uma aba e seção nomeadas Other.

Aqui está um exemplo de configuração:

layout:
  metricPerspective:
    tab: Kubernetes Pod
    section: Performance
    weight: 2
  componentSummary:
    weight: 2

Campos:

  • layout.metricPerspective - Define as métricas a serem exibidas em Metrics Perspective. As métricas são agrupadas em abas e, em seguida, seções.

  • layout.metricPerspective.tab - Nome da aba. As abas são ordenadas alfabeticamente.

  • layout.metricPerspective.section - Nome da seção. As seções são ordenadas alfabeticamente.

  • layout.metricPerspective.weight - As métricas dentro de uma seção são ordenadas principalmente por peso (crescente) e secundariamente por nome (alfabético).

  • layout.componentSummary - Especifica as métricas a serem exibidas na barra lateral Components details ao selecionar o componente. Os gráficos aparecem apenas quando esta propriedade é definida.

  • layout.componentSummary.weight - Isso representa o peso do gráfico. Os gráficos são ordenados em ordem crescente por peso e, em seguida, exibem os primeiros 3 gráficos.