Coletar métricas do Prometheus

Neste documento, descrevemos a configuração e o uso de um receptor de métricas do Agente de operações que pode ser usado para coletar métricas do Prometheus no Compute Engine. Este documento também descreve um exemplo que pode ser usado para testar o receptor.

Os usuários do Google Kubernetes Engine puderam coletar métricas do Prometheus usando o Google Cloud Managed Service para Prometheus. O receptor do Prometheus do agente de operações oferece aos usuários do Compute Engine a mesma capacidade.

É possível usar todas as ferramentas fornecidas pelo Cloud Monitoring, incluindo o PromQL, para visualizar e analisar os dados coletados pelo receptor do Prometheus. Por exemplo, é possível usar o Metrics Explorer, conforme descrito no Console do Google Cloud para o Monitoring, para consultar seus dados. Também é possível criar painéis e políticas de alertas do Cloud Monitoring para monitorar as métricas do Prometheus. Recomendamos usar o PromQL como a linguagem de consulta para suas métricas do Prometheus.

Também é possível visualizar as métricas do Prometheus em interfaces fora do Cloud Monitoring, como a IU do Prometheus e o Grafana.

Escolher o receptor certo

Antes de decidir usar o receptor do Prometheus, determine se já existe uma integração de agente de operações para o aplicativo que você está usando. Para informações sobre as integrações atuais com o Agente de operações, consulte Como monitorar aplicativos de terceiros. Se já houver uma integração, recomendamos o uso dela. Para mais informações, consulte Como escolher uma integração.

Recomendamos o uso do receptor do Prometheus do agente de operações quando o seguinte for verdadeiro:

Integrações atuais

O Agente de operações oferece integrações para vários aplicativos de terceiros. Estas integrações oferecem o seguinte:

  • Um conjunto de métricas workload.googleapis.com selecionadas para o aplicativo
  • Um painel para visualizar as métricas

As métricas ingeridas com uma integração estão sujeitas a preços baseados em bytes para métricas coletadas pelo agente. O número e os tipos das métricas são conhecidos com antecedência, e é possível usar essas informações para estimar custos.

Por exemplo, se você estiver usando a integração do Apache Web Server (httpd), o agente de operações coletará cinco métricas escalares. Cada ponto de dados conta como 8 bytes. Se você mantiver a frequência de amostragem padrão do Agente de operações de 60 segundos, o número de bytes ingeridos por dia será de 57.600 * o número de hosts:

  • 8 (bytes) * 1.440 (minutos por dia) * 5 (métricas) * n (hosts) ou
  • 57.600 * n (hosts)

Para mais informações sobre estimativas de custos, consulte Exemplos de preços com base em bytes ingeridos.

O receptor do Prometheus

Quando você usa o Agente de operações para coletar métricas do Prometheus, as seguintes condições se aplicam:

  • O número e a cardinalidade das métricas emitidas pelo aplicativo são controlados por você. Não há um conjunto selecionado de métricas. A quantidade de dados que você ingere é determinada pela configuração do aplicativo Prometheus e pelo receptor do Prometheus do agente de operações.

  • As métricas são ingeridas no Cloud Monitoring como métricas prometheus.googleapis.com. Essas métricas são classificadas como um tipo de métrica "personalizada" quando ingeridas no Cloud Monitoring e estão sujeitas às cotas e limites de métricas personalizadas.

  • Projete e crie os painéis do Cloud Monitoring necessários com base no conjunto de métricas que está sendo ingerido e nas necessidades do seu negócio. Para informações sobre como criar painéis, consulte Painéis e gráficos.

  • Os preços da ingestão de métrica são baseados no número de amostras ingeridas. Para estimar seus custos ao usar o receptor do Prometheus, determine o número de amostras que você provavelmente coletará durante um ciclo de faturamento. A estimativa se baseia nos seguintes fatores:

    • Número de métricas escalares. Cada valor é uma amostra
    • Número de métricas de distribuição cada histograma conta como (2 + número de buckets no histograma).
    • Frequência de amostragem de cada métrica
    • Número de hosts usados para amostragem nas métricas

    Para mais informações sobre como contar amostras e estimar custos, consulte Exemplos de preços com base em amostras ingeridas.

Pré-requisitos

Para coletar métricas do Prometheus usando o receptor do Prometheus, instale o Agente de operações versão 2.25.0 ou posterior.

O receptor do agente de operações requer um endpoint que emita métricas do Prometheus. Portanto, o aplicativo precisa fornecer esse endpoint diretamente ou usar uma biblioteca ou exportador do Prometheus para expor um endpoint. Muitas bibliotecas e frameworks de linguagem, como Spring e DropWizard, ou aplicativos como StatsD, DogStatsD e Graphite, que emitem métricas não Prometheus, podem usar bibliotecas de cliente do Prometheus ou exportadores para emitir métricas no estilo Prometheus. Por exemplo, para emitir métricas do Prometheus, faça o seguinte:

Quando as métricas do Prometheus são emitidas por um aplicativo, diretamente ou usando uma biblioteca ou exportador, elas podem ser coletadas por um agente de operações configurado com um receptor do Prometheus.

Configurar o agente de operações

O modelo de configuração do Agente de operações geralmente envolve definir o seguinte:

  • Receptores: que determinam quais métricas são coletadas.
  • Processadores: que descrevem como o agente de operações pode modificar as métricas.
  • Pipelines: vinculam receptores e processadores a um serviço.

A configuração para ingerir métricas do Prometheus é um pouco diferente: nenhum processador é invocado.

Configuração para métricas do Prometheus

A configuração do agente de operações para ingerir métricas do Prometheus difere da configuração normal da seguinte maneira:

  • Não crie um processador de agente de operações para as métricas do Prometheus. O receptor do Prometheus é compatível com quase todas as opções de configuração especificadas pela especificação scrape_config do Prometheus, incluindo novas opções de rotulagem.

    Em vez de usar um processador do agente de operações, qualquer processamento de métricas é feito usando as seções relabel_configs e metric_relabel_configs da configuração da paisagem, conforme especificado no receptor do Prometheus. Para mais informações, consulte Como rotular novamente: como modificar os dados que estão sendo coletados.

  • O pipeline do Prometheus é definido apenas em termos do receptor do Prometheus. Você não especifica nenhum processador. Também não é possível usar qualquer receptor que não seja o Prometheus no pipeline para as métricas do Prometheus.

A maior parte da configuração do receptor é a especificação de opções de scrape-config. Ao omitir essas opções para agilizar, você verá a estrutura de uma configuração do agente de operações que usa um receptor do Prometheus. Especifique os valores de RECEIVER_ID e PIPELINE_ID.

metrics:
  receivers:
    RECEIVER_ID:
      type: prometheus
      config:
        scrape_configs:
          [... omitted for brevity ...]

  service:
    pipelines:
      PIPELINE_ID:
        receivers: [RECEIVER_ID]

A seção a seguir descreve o receptor do Prometheus em mais detalhes. Para um exemplo funcional de um receptor e um pipeline, consulte Adicionar o receptor e o pipeline do agente de operações.

O receptor do Prometheus

Para especificar um receptor para as métricas do Prometheus, crie um receptor de métricas do tipo prometheus e especifique um conjunto de opções scrape_config. O receptor é compatível com todas as opções do scrape_config do Prometheus, exceto:

  • As seções de descoberta de serviços, *_sd_config.
  • A configuração honor_labels.

Portanto, é possível copiar as configurações de raspagem de dados e usá-las para o agente de operações com pouca ou nenhuma modificação.

A estrutura completa do receptor do Prometheus é mostrada abaixo:

metrics:
  receivers:
    prom_application:
      type: prometheus
      config:
        scrape_configs:
          - job_name: 'STRING' # must be unique across all Prometheus receivers
              scrape_interval: # duration, like 10m or 15s
              scrape_timeout:  # duration, like 10m or 15s
              metrics_path: # resource path for metrics, default = /metrics
              honor_timestamps: # boolean, default = false
              scheme: # http or https, default = http
              params:
                - STRING: STRING
              basic_auth:
                username: STRING
                password: SECRET
                password_file: STRING
              authorization:
                type: STRING # default = Bearer
                credentials: SECRET
                credentials_file: FILENAME

              oauth2: OAUTH2 # See Prometheus oauth2
              follow_redirects: # boolean, default = true
              enable_http2: # boolean, default = true
              tls_config: TLS_CONFIG # See Prometheus tls_config
              proxy_url: STRING

              static_configs:
                STATIC_CONFIG # See Prometheus static_config
              relabel_configs:
                RELABEL_CONFIG # See Prometheus relabel_config
              metric_relabel_configs:
                METRIC_RELABEL_CONFIGS # See Prometheus metric_relabel_configs

Para ver exemplos de como redefinir configurações, consulte Configuração extra do receptor.

Exemplo: configurar o agente de operações para o Prometheus

Nesta seção, mostramos um exemplo de como configurar o agente de operações para coletar métricas do Prometheus em um aplicativo. Este exemplo usa o exportador JSON fornecido pela comunidade do Prometheus (json_exporter), que expõe métricas do Prometheus na porta 7979.

A configuração do exemplo requer os seguintes recursos, que talvez você precise instalar:

  • git
  • curl
  • make
  • python3
  • Linguagem Go, versão 1.19 ou mais recente

Criar ou configurar o aplicativo

Para obter e executar o exportador JSON, use o seguinte procedimento:

  1. Clone o repositório json_exporter e verifique o exportador executando os seguintes comandos:

    git clone https://github.com/prometheus-community/json_exporter.git

cd json_exporter

git checkout v0.5.0

  2. Crie o exportador executando o seguinte comando:

    make build

  3. Inicie o servidor HTTP Python executando o seguinte comando:

    python3 -m http.server 8000 &

  4. Inicie o exportador JSON executando o seguinte comando:

    ./json_exporter --config.file examples/config.yml &

  5. Consulte o exportador JSON para verificar se ele está executando e expondo métricas na porta 7979:

    curl "http://localhost:7979/probe?module=default&target=http://localhost:8000/examples/data.json"

    Se a consulta for bem-sucedida, você verá uma saída semelhante a esta:

    # HELP example_global_value Example of a top-level global value scrape in the json
# TYPE example_global_value untyped
example_global_value{environment="beta",location="planet-mars"} 1234
# HELP example_value_active Example of sub-level value scrapes from a json
# TYPE example_value_active untyped
example_value_active{environment="beta",id="id-A"} 1
example_value_active{environment="beta",id="id-C"} 1
# HELP example_value_boolean Example of sub-level value scrapes from a json
# TYPE example_value_boolean untyped
example_value_boolean{environment="beta",id="id-A"} 1
example_value_boolean{environment="beta",id="id-C"} 0
# HELP example_value_count Example of sub-level value scrapes from a json
# TYPE example_value_count untyped
example_value_count{environment="beta",id="id-A"} 1
example_value_count{environment="beta",id="id-C"} 3

    Nesta saída, as strings como example_value_active são os nomes das métricas, com rótulos e valores entre chaves. O valor dos dados segue o conjunto de rótulos.

Adicionar o pipeline e o receptor do agente de operações

Para configurar o agente de operações para ingerir métricas do aplicativo Exportador JSON, você precisa modificar a configuração do agente para adicionar um pipeline e um pipeline do Prometheus. Para o exemplo JSON Exporter, use o seguinte procedimento:

  1. Edite o arquivo de configuração do agente de operações, /etc/google-cloud-ops-agent/config.yaml, e adicione as seguintes entradas de receptor e pipeline do Prometheus:

    metrics:
  receivers:
    prometheus:
        type: prometheus
        config:
          scrape_configs:
            - job_name: 'json_exporter'
              scrape_interval: 10s
              metrics_path: /probe
              params:
                module: [default]
                target: [http://localhost:8000/examples/data.json]
              static_configs:
                - targets: ['localhost:7979']
  service:
    pipelines:
      prometheus_pipeline:
        receivers:
          - prometheus

    Se você já tiver outras entradas de configuração nesse arquivo, adicione o receptor e o pipeline do Prometheus às entradas metrics e service. Para mais informações, consulte Configurações de métricas.

    Para ver exemplos de como reinserir as configurações no receptor, consulte Configuração extra do receptor.

Reiniciar o agente de operações

Para aplicar as alterações de configuração, reinicie o Agente de operações.

LINUX

  1. Para reiniciar o agente, execute o seguinte comando na instância:

    sudo service google-cloud-ops-agent restart

  2. Para confirmar se o agente foi reiniciado, execute o seguinte comando e verifique se os componentes "Metrics Agent" e "Logging Agent" foram iniciados:

    sudo systemctl status google-cloud-ops-agent"*"

Windows

  1. Conecte-se à sua instância usando o RDP ou uma ferramenta semelhante e faça login no Windows.

  2. Abra um terminal do PowerShell com privilégios de administrador. Para isso, clique com o botão direito do mouse no ícone do PowerShell e selecione Executar como administrador.

  3. Para reiniciar o agente, execute o seguinte comando do PowerShell:

    Restart-Service google-cloud-ops-agent -Force

  4. Para confirmar se o agente foi reiniciado, execute o seguinte comando e verifique se os componentes "Metrics Agent" e "Logging Agent" foram iniciados:

    Get-Service google-cloud-ops-agent*

Métricas do Prometheus no Cloud Monitoring

É possível usar as ferramentas fornecidas pelo Cloud Monitoring com os dados coletados pelo receptor do Prometheus. Por exemplo, é possível criar gráficos para os dados usando o Metrics Explorer, conforme descrito em Console do Google Cloud para Monitoring. Veja nas seções a seguir as ferramentas de consulta disponíveis no Cloud Monitoring com o Metrics Explorer:

É possível criar painéis do Cloud Monitoring e políticas de alertas para suas métricas. Para informações sobre painéis e os tipos de gráficos que podem ser usados, consulte Painéis e gráficos. Para informações sobre políticas de alertas, consulte Como usar políticas de alertas.

Também é possível ver as métricas em outras interfaces, como a IU do Prometheus e o Grafana. Para informações sobre como configurar essas interfaces, consulte as seções a seguir na documentação do Google Cloud Managed Service para Prometheus:

Usar o PromQL

O PromQL é a linguagem de consulta recomendada para métricas ingeridas usando o receptor do Prometheus.

A maneira mais simples de verificar se os dados do Prometheus estão sendo ingeridos é usar a página do Metrics Explorer do Cloud Monitoring no Console do Google Cloud:

  1. No Console do Google Cloud, acesse a página do  Metrics Explorer:

    Acesse o Metrics explorer

    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

  2. Na barra de ferramentas do painel do criador de consultas, selecione o botão  MQL ou  PromQL.

  3. Verifique se PromQL está selecionado na opção de ativar/desativar Idioma. A alternância de idiomas está na mesma barra de ferramentas que permite formatar sua consulta.

  4. Digite a consulta a seguir no Editor e clique em Executar consulta: 

    up

Se os dados estiverem sendo ingeridos, você verá um gráfico como este:

Gráfico do Metrics Explorer para a métrica do json-exporter.

Se você estiver executando o exemplo de exportador JSON, também poderá emitir consultas como as seguintes:

  • Consulte todos os dados de uma métrica exportada específica pelo nome, por exemplo:

    example_value_count

    Veja a seguir um gráfico para o example_value_count, incluindo rótulos definidos pelo aplicativo JSON Exporter e adicionados pelo agente de operações:

    Gráfico do Metrics Explorer para a métrica json-exporter example_value_count.

  • Consultar dados de uma métrica exportada originada em um namespace específico. O valor do rótulo namespace é o ID da instância do Compute Engine, um número longo como 5671897148133813325, atribuído à VM. Uma consulta é semelhante a esta:

    example_value_count{namespace="INSTANCE_ID"}

  • Consultar dados que correspondam a uma expressão regular específica. O exportador JSON emite métricas com um rótulo id que tem valores como id-A, id-B, id-C. Para filtrar as métricas com um rótulo id correspondente a esse padrão, use a seguinte consulta:

    example_value_count{id=~"id.*"}

Para mais informações sobre como usar o PromQL no Metrics Explorer e no Cloud Monitoring, consulte PromQL no Cloud Monitoring.

Usar MQL

Para visualizar os dados do Prometheus como uma série temporal do Cloud Monitoring e criar gráficos e painéis, também é possível usar as interfaces orientadas por menu ou MQL. Veja a seguir uma consulta simples no Metrics Explorer:

  1. No Console do Google Cloud, acesse a página do  Metrics Explorer:

    Acesse o Metrics explorer

    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.

  2. Especifique os dados que aparecerão no gráfico. Além de usar a guia PromQL descrita anteriormente, também é possível usar o MQL.

    • Para usar a MQL, faça o seguinte:

      1. Na barra de ferramentas do painel do criador de consultas, selecione o botão  MQL ou  PromQL.
      2. Verifique se MQL está selecionado na opção de ativar/desativar MQL. A alternância de idiomas está na mesma barra de ferramentas que permite formatar sua consulta.

      3. Digite a seguinte consulta:

        fetch prometheus_target::prometheus.googleapis.com/up/gauge

      4. Selecione Executar consulta.

    • Para usar a interface orientada por menu, faça o seguinte:

      1. No campo Resource type, digite "prometheus" para filtrar a lista e selecione Prometheus Target.

      2. No campo Metric, digite "up/" para filtrar a lista, depois selecione prometheus/up/gauge.

O gráfico resultante de qualquer uma dessas consultas mostra os mesmos dados do gráfico do exemplo PromQL.

O recurso prometheus_target

No Cloud Monitoring, os dados de série temporal são gravados em um tipo de recurso monitorado. Para métricas do Prometheus, o tipo de recurso monitorado é prometheus_target. As consultas de monitoramento de métricas do Prometheus que não estão escritas em PromQL precisam especificar esse tipo de recurso.

O recurso prometheus_target tem os seguintes rótulos, que podem ser usados para filtrar e manipular os dados consultados:

  • project_id: o identificador do projeto do Google Cloud, como my-project, em que o agente de operações está em execução.
  • location: a região do Google Cloud ou da AWS em que o Agente de operações está em execução. Por exemplo, us-east1-a (Google Cloud) ou aws:us-east-1a (AWS).
  • cluster: sempre __gce__ para as métricas do Prometheus coletadas usando o agente de operações.
  • namespace: o ID da instância do Compute Engine da VM em que o agente de operações está sendo executado.
  • job: o valor do campo job_name na configuração do receptor.
  • instance: o rótulo da instância do destino do Prometheus, retirado da configuração do receptor. O padrão é o destino.

Os valores desses rótulos são definidos durante a coleta. Os valores dos rótulos namespace, location e cluster são imutáveis. Se as métricas coletadas do aplicativo também tiverem esses rótulos, o agente de operações prefixará os rótulos coletados com a string exported_.

Ver diagnósticos e uso de métricas no Cloud Monitoring

A página Gerenciamento de métricas do Cloud Monitoring fornece informações que podem ajudar a controlar o valor gasto em métricas sujeitas a cobrança, sem afetar a observabilidade. A página Gerenciamento de métricas mostra as seguintes informações:

  • Volumes de ingestão para faturamento baseado em byte e amostra, em domínios de métricas e para métricas individuais.
  • Dados sobre rótulos e cardinalidade de métricas.
  • Número de leituras de cada métrica.
  • Uso de métricas em políticas de alertas e painéis personalizados.
  • Taxa de erros de gravação de métrica.

Você também pode usar o Gerenciamento de métricas para excluir métricas desnecessárias, eliminando o custo de ingestão delas.

Para visualizar a página Gerenciamento de métricas, faça o seguinte:

  1. No console do Google Cloud, acesse a página  Gerenciamento de métricas:

    Acesse os Gerenciamento de métricas

    Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoramento.

  2. Na barra de ferramentas, selecione a janela de tempo. Por padrão, a página Gerenciamento de métricas exibe informações sobre as métricas coletadas no dia anterior.

Para mais informações sobre a página Gerenciamento de métricas, consulte Ver e gerenciar o uso de métricas.

Nova identificação: como modificar os dados que estão sendo copiados

Você pode usar a nova rotulagem para modificar o conjunto de rótulos do destino de raspagem ou as métricas dele antes do destino ser coletado. Se você tiver várias etapas em uma configuração de nova rotulagem, elas serão aplicadas na ordem em que aparecerem no arquivo de configuração.

O agente de operações cria um conjunto de metarrótulos (rótulos com o prefixo __meta_ na string). Esses metarrótulos registram informações sobre a instância do Compute Engine na qual o agente de operações está em execução. Os rótulos com o prefixo da string __, incluindo os metarrótulos, ficam disponíveis somente durante a nova rotulagem. É possível usar a nova rotulagem para capturar os valores desses rótulos em rótulos copiados.

A nova rotulagem de métrica é aplicada a amostras. Essa é a última etapa antes da ingestão. Use a remarcação de métrica para descartar séries temporais que não são necessárias. O descarte dessas séries temporais reduz o número de amostras ingeridas, o que pode reduzir custos.

Para mais informações sobre a nova rotulagem, consulte a documentação do Prometheus para relabel_config e metric_relabel_configs.

Metarrótulos do Compute Engine disponíveis durante a nova rotulagem

Quando o agente de operações raspa as métricas, ele inclui um conjunto de metarrótulos com valores baseados na configuração da VM do Compute Engine em que o agente está sendo executado. É possível usar esses rótulos e a seção relabel_configs do receptor do Prometheus para adicionar outros metadados às métricas sobre a VM de que foram ingeridos. Para ver um exemplo, consulte Configuração adicional do receptor.

Os seguintes metarrótulos estão disponíveis em destinos para uso na seção relabel_configs:

  • __meta_gce_instance_id: o ID numérico da instância do Compute Engine (local)
  • __meta_gce_instance_name: o nome da instância do Compute Engine (local). O Agente de operações coloca automaticamente esse valor no rótulo instance_name mutável nas métricas.
  • __meta_gce_machine_type: URL completo ou parcial do tipo de máquina da instância. O agente de operações coloca automaticamente esse valor no rótulo machine_type mutável nas métricas.
  • __meta_gce_metadata_NAME: cada item de metadados da instância
  • __meta_gce_network: o URL da rede da instância
  • __meta_gce_private_ip: o endereço IP particular da instância
  • __meta_gce_interface_ipv4_NAME: endereço IPv4 de cada interface nomeada
  • __meta_gce_project: o projeto do Google Cloud em que a instância está em execução (local)
  • __meta_gce_public_ip: o endereço IP público da instância, se houver
  • __meta_gce_tags: lista separada por vírgulas de tags de instância
  • __meta_gce_zone: o URL da zona do Compute Engine em que a instância está em execução

Os valores desses rótulos são definidos quando o agente de operações é iniciado. Se você modificar os valores, precisará reiniciar o agente de operações para atualizá-los.

Configuração extra do receptor

Nesta seção, você verá exemplos que usam as seções relabel_configs e metric_relabel_configs do receptor do Prometheus para modificar o número e a estrutura das métricas ingeridas. Esta seção também inclui uma versão modificada do receptor para o exemplo de exportador JSON que usa as opções de nova rotulagem.

Adicionar metadados da VM

É possível usar a seção relabel_configs para adicionar rótulos às métricas. Por exemplo, o comando a seguir usa um metarrótulo, __meta_gce_zone, fornecido pelo Agente de operações para criar um rótulo de métrica, zone, que é preservado após a nova rotulagem, porque zone não tem o prefixo __.

Para uma lista de metarrótulos disponíveis, consulte Metarrótulos do Compute Engine disponíveis durante a nova rotulagem. Alguns dos meta rótulos são renomeados para você pela configuração padrão do Agente de operações.

relabel_configs:
  - source_labels: [__meta_gce_zone]
    regex: '(.+)'
    replacement: '${1}'
    target_label: zone

O receptor do Prometheus mostrado em Exemplo: configurar o agente de operações do Prometheus inclui a adição desse rótulo.

Remover métricas

Use a seção metrics_relabel_configs para liberar as métricas que você não quer ingerir. Esse padrão é útil para contenção de custos. Por exemplo, é possível usar o padrão a seguir para liberar qualquer métrica com um nome que corresponda a METRIC_NAME_REGEX_1 ou METRIC_NAME_REGEX_2:

metric_relabel_configs:
  - source_labels: [ __name__ ]
    regex: 'METRIC_NAME_REGEX_1'
    action: drop
  - source_labels: [ __name__ ]
    regex: 'METRIC_NAME_REGEX_2'
    action: drop

Adicionar rótulos estáticos

É possível usar a seção metrics_relabel_configs para adicionar rótulos estáticos a todas as métricas ingeridas pelo receptor do Prometheus. É possível usar o padrão a seguir para adicionar os rótulos staticLabel1 e staticLabel2 a todas as métricas ingeridas:

metric_relabel_configs:
  - source_labels: [ __address__ ]
    action: replace
    replacement: 'STATIC_VALUE_1'
    target_label: staticLabel1
  - source_labels: [ __address__ ]
    action: replace
    replacement: 'STATIC_VALUE_2'
    target_label: staticLabel2

A versão a seguir do receptor do Prometheus para o exemplo de exportador JSON usa esses padrões de configuração para fazer o seguinte:

  • Defina o rótulo zone com o valor do metarrótulo __meta_gce_zone fornecido pelo agente de operações.
  • Libere a métrica example_global_value do exportador.
  • Adicione o rótulo staticLabel com o valor "Um valor estático" a todas as métricas ingeridas.
metrics:
  receivers:
    prometheus:
        type: prometheus
        config:
          scrape_configs:
            - job_name: 'json_exporter'
              scrape_interval: 10s
              metrics_path: /probe
              params:
                module: [default]
                target: [http://localhost:8000/examples/data.json]
              static_configs:
                - targets: ['localhost:7979']
              relabel_configs:
                - source_labels: [__meta_gce_zone]
                  regex: '(.+)'
                  replacement: '${1}'
                  target_label: zone
              metric_relabel_configs:
                - source_labels: [ __name__ ]
                  regex: 'example_global_value'
                  action: drop
                - source_labels: [ __address__ ]
                  action: replace
                  replacement: 'A static value'
                  target_label: staticLabel