Crie um trabalho de extração personalizado do Prometheus a partir do seu cluster do Kubernetes usando um ConfigMap

Personalizar a coleta de métricas do Prometheus do cluster do Kubernetes descreve como usar o ConfigMap para personalizar a coleta de métricas do Prometheus de alvos padrão no seu cluster do Kubernetes. Este artigo descreve como usar o ConfigMap para criar trabalhos de recorte personalizados para personalização adicional e destinos adicionais.

ConfigMaps

A tabela a seguir descreve o ConfigMaps usado para criar trabalhos de extração personalizados. Esses ConfigMaps não existem por padrão no cluster quando o Managed Prometheus está habilitado.

Criar arquivo de configuração do Prometheus

Em vez de modificar ama-metrics-prometheus-configdiretamente, é mais fácil criar um arquivo de configuração e convertê-lo em um ConfigMap. Confira as configurações de configuração do Scrape abaixo para obter detalhes sobre as diferentes seções deste arquivo.

Crie um arquivo de configuração de raspagem do Prometheus nomeado prometheus-config usando o formato a seguir. Isso lista as configurações de extração na seção scrape_configs e pode, opcionalmente, usar a seção global para definir scrape_interval, scrape_timeout e external_labels globais. Consulte a referência de configuração de extração no Prometheus.io para obter detalhes completos sobre as opções disponíveis para uma configuração de extração.

global:
  scrape_interval: <duration>
  scrape_timeout: <duration>
  external_labels:
    <labelname1>: <labelvalue>
    <labelname2>: <labelvalue>
scrape_configs:
  - <job-x>
  - <job-y>

Veja a seguir um arquivo de configuração de scrape do Prometheus de exemplo:

global:
  scrape_interval: 30s
scrape_configs:
- job_name: my_static_config
  scrape_interval: 60s
  static_configs:
    - targets: ['my-static-service.svc.cluster.local:1234']
- job_name: prometheus_example_app
  scheme: http
  kubernetes_sd_configs:
    - role: service
  relabel_configs:
    - source_labels: [__meta_kubernetes_service_name]
      action: keep
      regex: "prometheus-example-service"

Validar o arquivo de configuração de scraping

O agente usa uma ferramenta personalizada promconfigvalidator para validar a configuração do Prometheus fornecida a ela por meio do ConfigMap. Se a configuração não for válida, a configuração personalizada será rejeitada pelo agente. Depois de criar o arquivo de configuração do Prometheus, você poderá usar essa ferramenta para validar a configuração antes de criar um ConfigMap para o agente.

A ferramenta promconfigvalidator é enviada dentro do pod do complemento de métricas do Azure Monitor. Você pode usar qualquer pod ama-metrics-node-* no namespace kube-system do seu cluster para baixar a ferramenta para validação. Use kubectl cp para baixar a ferramenta e sua configuração com o comando a seguir.

for podname in $(kubectl get pods -l rsName=ama-metrics -n=kube-system -o json | jq -r '.items[].metadata.name'); do kubectl cp -n=kube-system "${podname}":/opt/promconfigvalidator ./promconfigvalidator;  kubectl cp -n=kube-system "${podname}":/opt/microsoft/otelcollector/collector-config-template.yml ./collector-config-template.yml; chmod 500 promconfigvalidator; done

Depois de copiar o executável e o yaml, localize o caminho do arquivo de configuração do Prometheus. Em seguida, substitua <config path> no comando e execute o validador pelo comando a seguir.

./promconfigvalidator/promconfigvalidator --config "<config path>" --otelTemplate "./promconfigvalidator/collector-config-template.yml"

Executar o validador gerará o arquivo merged-otel-config.yaml de configuração mesclado se nenhum caminho for fornecido com o parâmetro opcional output . Não use esse arquivo mesclado gerado automaticamente, pois ele é usado apenas para fins de validação e depuração de ferramentas.

Implantar o arquivo de configuração como ConfigMap

Seu arquivo de configuração personalizado do Prometheus é consumido como um campo chamado prometheus-config dentro do ama-metrics-prometheus-config, ama-metrics-prometheus-config-node, ou ama-metrics-prometheus-config-node-windows ConfigMap no namespace kube-system. Crie um ConfigMap a partir do arquivo de configuração de scrape renomeando seu arquivo de configuração do Prometheus para prometheus-config sem extensão de arquivo e executando um ou mais dos seguintes comandos de exemplo, dependendo de qual ConfigMap você deseja criar para a configuração personalizada do trabalho de scrape.

Crie o ConfigMap a ser usado pelo replicaset:

kubectl create ConfigMap ama-metrics-prometheus-config --from-file=prometheus-config -n kube-system

Isso cria um ConfigMap nomeado ama-metrics-prometheus-config no kube-system namespace. Para ver se há algum problema com a validação, o processamento ou a mesclagem da configuração, você pode examinar os pods de réplica ama-metrics

Crie o ConfigMap a ser usado pelo Linux DaemonSet:

kubectl create ConfigMap ama-metrics-prometheus-config-node --from-file=prometheus-config -n kube-system

Isso cria um ConfigMap nomeado ama-metrics-prometheus-config-node no kube-system namespace. Para verificar se há algum problema com a validação, o processamento ou a mesclagem da configuração, você pode examinar os pods do deamonset do Linux ama-metrics-node

Criar ConfigMap a ser usado pelo Windows DaemonSet

kubectl create ConfigMap ama-metrics-prometheus-config-node-windows --from-file=prometheus-config -n kube-system

Isso cria um ConfigMap nomeado ama-metrics-prometheus-config-node-windows no kube-system namespace. Para verificar se há algum problema com a validação, o processamento ou a mesclagem da configuração, você pode examinar os pods deamonset do Windows ama-metrics-win-node

Resolução de problemas

Se você criou com sucesso o ConfigMap no namespace kube-system e ainda não vê os destinos personalizados sendo extraídos, verifique se há erros nos logs do pod réplica para o ConfigMap ama-metrics-prometheus-config ou nos logs do pod DaemonSet para o ConfigMap ama-metrics-prometheus-config-node usandokubectl logs, e certifique-se de que não há erros na seção Iniciar a mesclagem das configurações padrão e personalizadas do Prometheus, com o prefixo prometheus-config-merger

Configurações de extração

Atualmente, os métodos suportados de descoberta de destinos para uma configuração de extração são static_configs ou kubernetes_sd_configs para especificar ou descobrir destinos.

Uma configuração estática tem uma lista de destinos estáticos e quaisquer rótulos extras a serem adicionados a eles como no seguinte.

scrape_configs:
  - job_name: example
    - targets: [ '10.10.10.1:9090', '10.10.10.2:9090', '10.10.10.3:9090' ... ]
    - labels: [ label1: value1, label1: value2, ... ]

Os destinos descobertos usando kubernetes_sd_configs têm rótulos __meta_* diferentes, dependendo da função especificada. Você pode usar os rótulos na seção relabel_configs para filtrar destinos ou substituir os rótulos dos destinos.

Rotular novamente as configurações

A seção relabel_configs é aplicada no momento da descoberta de destino e se aplica a cada destino do trabalho. Os exemplos a seguir mostram as maneiras de usar relabel_configs.

Adicionar um rótulo Adicione um novo rótulo chamado example_label com o valor example_value a cada métrica do trabalho. Use __address__ como o rótulo de origem apenas porque esse rótulo sempre existe e adiciona o rótulo para cada destino do trabalho.

relabel_configs:
- source_labels: [__address__]
  target_label: example_label
  replacement: 'example_value'

Usar rótulos de Descoberta de Serviço do Kubernetes

Se um trabalho estiver sendo usado kubernetes_sd_configs para descobrir destinos, cada função terá rótulos __meta_* associados para as métricas. Os rótulos __* são removidos após a descoberta dos destinos. Para filtrar usando-os no nível das métricas, primeiro mantenha-os usando relabel_configs atribuindo um nome de rótulo. Em seguida, utilize metric_relabel_configs para filtrar.

# Use the kubernetes namespace as a label called 'kubernetes_namespace'
relabel_configs:
- source_labels: [__meta_kubernetes_namespace]
  action: replace
  target_label: kubernetes_namespace

# Keep only metrics with the kubernetes namespace 'default'
metric_relabel_configs:
- source_labels: [kubernetes_namespace]
  action: keep
  regex: 'default'

Rotular novamente o trabalho e a instância

Você pode alterar os valores do rótulo job e instance com base no rótulo de origem, assim como qualquer outro rótulo.

# Replace the job name with the pod label 'k8s app'
relabel_configs:
- source_labels: [__meta_kubernetes_pod_label_k8s_app]
  target_label: job

# Replace the instance name with the node name. This is helpful to replace a node IP
# and port with a value that is more readable
relabel_configs:
- source_labels: [__meta_kubernetes_node_name]
  target_label: instance

Configurações para rotular novamente a métrica

As configurações de nova rotulagem da métrica são aplicadas após a extração e antes da ingestão. Use a seção metric_relabel_configs para filtrar as métricas após a extração. Veja os exemplos a seguir.

Remover métricas por nome

# Drop the metric named 'example_metric_name'
metric_relabel_configs:
- source_labels: [__name__]
  action: drop
  regex: 'example_metric_name'

Manter apenas determinadas métricas por nome

# Keep only the metric named 'example_metric_name'
metric_relabel_configs:
- source_labels: [__name__]
  action: keep
  regex: 'example_metric_name'

# Keep only metrics that start with 'example_'
metric_relabel_configs:
- source_labels: [__name__]
  action: keep
  regex: '(example_.*)'

Filtrar métricas por rótulos

# Keep metrics only where example_label = 'example'
metric_relabel_configs:
- source_labels: [example_label]
  action: keep
  regex: 'example'

# Keep metrics only if `example_label` equals `value_1` or `value_2`
metric_relabel_configs:
- source_labels: [example_label]
  action: keep
  regex: '(value_1|value_2)'

# Keep metrics only if `example_label_1 = value_1` and `example_label_2 = value_2`
metric_relabel_configs:
- source_labels: [example_label_1, example_label_2]
  separator: ';'
  action: keep
  regex: 'value_1;value_2'

# Keep metrics only if `example_label` exists as a label
metric_relabel_configs:
- source_labels: [example_label_1]
  action: keep
  regex: '.+'

Renomear métricas Não há suporte para renomeação de métrica.

relabel_configs:
- source_labels: [__address__]
  target_label: example_label
  replacement: 'example_value'

Autenticação Básica e Tokens de Portador

Se você estiver usando nome de usuário, senha ou credenciais como texto sem formatação na configuração de recorte, nenhuma alteração adicional será necessária. Os valores especificados na configuração serão usados para a extração. Se você estiver usando o username_file ou password_file (ou qualquer configuração _file) para a configuração basic_auth ou bearer_token na configuração do Prometheus, siga as etapas abaixo:

1. Crie um segredo no namespace kube-system com o nome ama-metrics-mtls-secret.

   O nome da chave password1 pode ser qualquer um, desde que corresponda ao nome do arquivo no caminho de arquivo password_file na configuração de extração do Prometheus na próxima etapa. O valor da chave precisa ser codificado em base64.

   apiVersion: v1
   kind: Secret
   metadata:
     name: ama-metrics-mtls-secret
     namespace: kube-system
   type: Opaque
   data:
     password1: <base64-encoded-string>
   

   O segredo ama-metrics-mtls-secret é montado nos pods ama-metrics no caminho /etc/prometheus/certs/ e é disponibilizado para o extrator do Prometheus. A chave (password1 no exemplo acima) será o nome do arquivo. O valor é decodificado em base64 e adicionado como o sumário do arquivo dentro do contêiner.

2. Forneça o caminho do arquivo na configuração de raspagem personalizada no ConfigMap:

   Autenticação Básica O username campo deve conter a cadeia de caracteres de nome de usuário real. O campo password_file deve conter o caminho para o arquivo que contém a senha.

   # Sets the `Authorization` header on every scrape request with the
   # configured username and password.
   basic_auth:
     username: <username string>
     password_file: /etc/prometheus/certs/password1
   

   Token de portador O bearer_token_file campo deve conter o caminho para o arquivo que contém o token.

   # Sets the `Authorization` header on every scrape request with the bearer token
   # read from the configured file. It is mutually exclusive with `bearer_token`.
   bearer_token_file: /etc/prometheus/certs/password1
   

Consulte a documentação do Prometheus scrape_config para obter mais informações sobre essas configurações.

Extração baseada em TLS

Se você quiser coletar métricas do Prometheus de um ponto de extremidade HTTPS, a configuração do Prometheus, PodMonitor ou ServiceMonitor deverá ter o scheme definido como https e configurações adicionais de TLS.

1. Crie um segredo no namespace kube-system com o nome ama-metrics-mtls-secret. Cada par chave-valor especificado na seção de dados do objeto de segredo será montado como um arquivo separado neste local /etc/prometheus/certs com nomes de arquivo iguais às chaves especificadas na seção de dados. Os valores do segredo devem ser codificados em base64.

   Veja a seguir um exemplo de YAML de um segredo:

   apiVersion: v1
   kind: Secret
   metadata:
     name: ama-metrics-mtls-secret
     namespace: kube-system
   type: Opaque
   data:
     <certfile>: base64_cert_content    
     <keyfile>: base64_key_content 
   

   O segredo ama-metrics-mtls-secret é montado nos pods ama-metrics no caminho /etc/prometheus/certs/ e é disponibilizado para o extrator do Prometheus. A chave será o nome do arquivo. O valor é decodificado em base64 e adicionado como o sumário do arquivo dentro do contêiner.

2. Forneça o caminho do arquivo na configuração prometheus, podMonitor ou ServiceMonitor:

   • Use o exemplo a seguir para fornecer a configuração do TLS em um ConfigMap:

   tls_config:
      # CA certificate to validate API server certificate with.
      ca_file: /etc/prometheus/certs/<certfile>
   
      # Certificate and key files for client cert authentication to the server.
      cert_file: /etc/prometheus/certs/<certfile>
      key_file: /etc/prometheus/certs/<keyfile>
   
      # Disable validation of the server certificate.
      insecure_skip_verify: false
   

Autenticação Básica e TLS

Se você quiser usar as configurações básicas de autenticação ou token de portador (credenciais baseadas em arquivo) e TLS em seu ConfigMap, verifique se o segredo ama-metrics-mtls-secret inclui todas as chaves na seção de dados com seus valores codificados em base64 correspondentes, conforme mostrado no exemplo a seguir:

apiVersion: v1
kind: Secret
metadata:
  name: ama-metrics-mtls-secret
  namespace: kube-system
type: Opaque
data:
  certfile: base64_cert_content    # used for TLS
  keyfile: base64_key_content      # used for TLS
  password1: base64-encoded-string # used for basic auth
  password2: base64-encoded-string # used for basic auth

Configuração avançada: configurar trabalhos personalizados do Prometheus scrape para o DaemonSet

O pod de réplica ama-metrics consome a configuração personalizada do Prometheus e extrair os destinos especificados. Para um cluster com um grande número de nós e pods e um grande volume de métricas para extrair, alguns dos destinos de extração personalizados aplicáveis podem ser descarregados do único pod ama-metrics de Replica para o pod ama-metrics DaemonSet.

O ConfigMap ama-metrics-prometheus-config-node é semelhante ao ConfigMap do replica-set e pode ser criado para ter configurações de extração estáticas em cada nó. A configuração de raspagem deve ter como destino apenas um único nó e não deve usar anotações de descoberta/pod de serviço. Caso contrário, cada nó tentará coletar todos os destinos e fazer muitas chamadas para o servidor de API do Kubernetes.

Os destinos de raspagem personalizados podem seguir o mesmo formato usando static_configs com destinos e usando a $NODE_IP variável de ambiente e especificando a porta a ser raspada. Cada pod do DaemonSet pega a configuração, extrai as métricas e as envia para esse nó.

node-exporter A configuração a seguir é um dos destinos padrão para os pods DaemonSet. Ele usa a variável de ambiente $NODE_IP, que já está definida para cada contêiner de complemento ama-metrics para direcionar uma porta específica no nó.

- job_name: nodesample
  scrape_interval: 30s
  scheme: http
  metrics_path: /metrics
  relabel_configs:
  - source_labels: [__metrics_path__]
    regex: (.*)
    target_label: metrics_path
  - source_labels: [__address__]
    replacement: '$NODE_NAME'
    target_label: instance
  static_configs:
  - targets: ['$NODE_IP:9100']

Configurações para extração de dados

As seções a seguir descrevem as configurações com suporte no arquivo de configuração do Prometheus usado no ConfigMap. Consulte a referência de configuração do Prometheus para obter mais detalhes sobre essas configurações.

Configurações globais

O formato de configuração para configurações globais é o mesmo compatível com configuração do OSS Prometheus

global:
  scrape_interval: <duration>
  scrape_timeout: <duration>
  external_labels:
    <labelname1>: <labelvalue>
    <labelname2>: <labelvalue>
scrape_configs:
  - <job-x>
  - <job-y>

As configurações fornecidas na seção global se aplicam a todos os trabalhos de extração (trabalhos em Configmap e recursos personalizados), mas são substituídas se forem especificadas nos trabalhos individuais.

Próximas etapas

• Saiba mais sobre como coletar métricas do Prometheus.