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:
Você tem experiência no uso do Prometheus, depende do padrão do Prometheus e entende como fatores como intervalo de coleta e cardinalidade podem afetar seus custos. Para mais informações, consulte Como escolher o receptor do Prometheus.
O software que você está monitorando ainda não faz parte do conjunto de integrações de agentes de operações.
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.comselecionadas 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:
- Os usuários do Spring podem usar a biblioteca Spring Metrics.
- Os usuários do StatsD podem usar o pacote
statsd_exporter. - Os usuários do Graphite podem usar o
pacote
graphite_exporter.
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_configdo 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_configsemetric_relabel_configsda 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:
gitcurlmakepython3- 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:
Clone o repositório
json_exportere 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
Crie o exportador executando o seguinte comando:
make build
Inicie o servidor HTTP Python executando o seguinte comando:
python3 -m http.server 8000 &
Inicie o exportador JSON executando o seguinte comando:
./json_exporter --config.file examples/config.yml &
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"} 3Nesta saída, as strings como
example_value_activesã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:
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: - prometheusSe você já tiver outras entradas de configuração nesse arquivo, adicione o receptor e o pipeline do Prometheus às entradas
metricseservice. 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
Para reiniciar o agente, execute o seguinte comando na instância:
sudo service google-cloud-ops-agent restart
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
Conecte-se à sua instância usando o RDP ou uma ferramenta semelhante e faça login no Windows.
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.
Para reiniciar o agente, execute o seguinte comando do PowerShell:
Restart-Service google-cloud-ops-agent -Force
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:
-
No Console do Google Cloud, acesse a página do leaderboard Metrics Explorer:
Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.
Na barra de ferramentas do painel do criador de consultas, selecione o botão code MQL ou code PromQL.
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.
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:
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:
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 como5671897148133813325, 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
idque tem valores comoid-A,id-B,id-C. Para filtrar as métricas com um rótuloidcorrespondente 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:
-
No Console do Google Cloud, acesse a página do leaderboard Metrics Explorer:
Se você usar a barra de pesquisa para encontrar essa página, selecione o resultado com o subtítulo Monitoring.
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:
- Na barra de ferramentas do painel do criador de consultas, selecione o botão code MQL ou code PromQL.
- 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.
Digite a seguinte consulta:
fetch prometheus_target::prometheus.googleapis.com/up/gauge
Selecione Executar consulta.
Para usar a interface orientada por menu, faça o seguinte:
No campo Resource type, digite "prometheus" para filtrar a lista e selecione Prometheus Target.
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, comomy-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) ouaws: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 campojob_namena 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 faturáveis, 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 o que elimina o custo de ingestão.
Para visualizar a página Gerenciamento de métricas, faça o seguinte:
-
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.
- 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ótuloinstance_namemutá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ótulomachine_typemutá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
zonecom o valor do metarrótulo__meta_gce_zonefornecido pelo agente de operações. - Libere a métrica
example_global_valuedo exportador. - Adicione o rótulo
staticLabelcom 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