Pular para o conteúdo

Prometheus Relabel Tester · Observabilidade

Testar relabel_configs do Prometheus — antes que as suas regras descartem as suas métricas.

Quer testar os relabel_configs do Prometheus sem subir nada para produção? Cole as suas regras e alguns labels de exemplo, e acompanhe quais labels sobrevivem, são reescritos ou fazem um target ser descartado — com a mesma semântica de regex ancorada, expansão de $1 e hashmod MD5 que o Prometheus usa. Na hora, no seu navegador. Sem instalação, sem cadastro.

Roda no seu navegador — nada do que você cola sai desta página. Como comprovamos isso

Roda no seu navegador Sem cadastro Igual à semântica do Prometheus Atualizado em 29 de jul. de 2026

Testador de relabeling do Prometheus online

relabel_configs
label sets

Runs entirely in your browser — nothing is uploaded. One label set per block; separate sets with a blank line. Press Esc to release focus from an editor.

Results

Load an example or paste relabel rules and label sets, then run to see which labels survive, change, or get dropped.

A lacuna

O relabeling falha em silêncio.

Um relabel_config errado não dá erro — ele simplesmente descarta em silêncio as métricas que você esperava, ou mantém as que você queria silenciar. As regras parecem simples, mas a semântica é cheia de arestas: a regex é totalmente ancorada, um replace com valor vazio apaga o label, e hashmod depende de um hash exato baseado em MD5.

A única forma de ter certeza é rodar as regras — mas iterar contra um Prometheus ao vivo é lento, e ler a referência de configuração raramente diz o que os seus labels vão virar. Aqui você pode simular as regras de relabel do Prometheus contra os seus labels de exemplo e confirmar o resultado em segundos — veja a vida de um label para entender o porquê.

Ele modela cada ação — replace, keep, drop, labelmap, hashmod e mais — sem nada para instalar e nada enviado.

Veja todas as ações na referência de ações, ou experimente o playground ao vivo acima.

O pipeline

Como funciona.

Cinco passos determinísticos rodam de ponta a ponta em cada conjunto de labels — todos dentro da aba do seu navegador, toda vez.

  1. Analisa as regras.

    O seu YAML de relabel_configs é analisado em uma lista de regras, com cada campo recebendo o padrão exatamente como o Prometheus faz — separator ";", regex "(.*)", replacement "$1", action "replace".

  2. Lê os labels.

    Cada bloco de linhas key=value vira um conjunto de labels. Os valores entre aspas preservam suas vírgulas e espaços; linhas em branco separam os targets.

  3. Une e ancora.

    Para cada regra, os valores de source_labels são unidos com o separator, e a regex é ancorada como ^(?:regex)$ antes de casar — do jeito que o engine real faz.

  4. Aplica em ordem.

    As regras rodam de cima para baixo; cada uma enxerga a saída da anterior. O replace expande $1/${1}, o hashmod usa MD5, e o keep/drop pode remover o target inteiro.

  5. Mostra o diff.

    Para cada conjunto você recebe os labels finais com marcações de adicionado/alterado, uma lista dos labels removidos e um aviso claro quando um target foi descartado — e por qual regra.

Referência de ações

Cada ação de relabel, modelada.

O tester implementa o conjunto completo de ações de relabel_config com comportamento idêntico ao do Prometheus. Aqui está o que cada uma faz.

  • replace

    Une source_labels com o separator; se a regex ancorada casar, expande $1/${1} no replacement e define target_label. Uma expansão vazia APAGA o label.

  • keep / drop

    keep remove o target inteiro a menos que a origem unida case com a regex; drop o remove quando ela casa. Ambos decidem se a série é scraped ou armazenada.

  • keepequal / dropequal

    Sem regex. Comparam o valor de origem unido com o valor atual de target_label; keepequal mantém apenas na igualdade, dropequal descarta na igualdade.

  • hashmod

    Define target_label como md5(origem unida) % modulus — os últimos 8 bytes do MD5 lidos como um uint64 big-endian. Usa a mesma receita MD5 do Prometheus, para um sharding horizontal estável.

  • labelmap

    Para todo label cujo NOME case com a regex, define um novo label nomeado pelo replacement expandido com o valor daquele label — ex.: __meta_kubernetes_pod_label_(.+) → $1.

  • labeldrop / labelkeep

    labeldrop remove todo label cujo NOME case com a regex; labelkeep remove todo label cujo NOME NÃO case. Usados para podar metadados de descoberta.

  • lowercase / uppercase

    Define target_label com o valor de origem unido em minúsculas ou maiúsculas. Útil para normalizar labels de descoberta com caixa inconsistente.

Regras de exemplo

relabel_configs
# Promote a Kubernetes pod label, then drop a noisy metric.
- action: labelmap
  regex: __meta_kubernetes_pod_label_(.+)

- source_labels: [__name__]
  action: drop
  regex: go_gc_.*

Os padrões batem com o Prometheus: source_labels: [], separator: ";", regex: "(.*)", replacement: "$1", action: replace. Veja o guia de relabeling para mais contexto.

O mesmo engine alimenta tanto relabel_configs quanto metric_relabel_configs — o Prometheus aplica semântica de relabeling idêntica a cada um.

Continue

Acertou os labels? Agora confira as queries e o roteamento.

O relabeling molda as séries; o que você faz em seguida é consultar e alertar sobre elas. Destrinche uma query com o explicador de PromQL, ou confirme que um alerta cai no lugar certo com o testador de rotas do Alertmanager — ambos rodam inteiramente no seu navegador, assim como este.

FAQ

Suas perguntas, respondidas.

Toque em uma pergunta para expandir a resposta.

Os dois usam exatamente a mesma sintaxe e a mesma semântica de relabeling — o que muda é o estágio do pipeline em que rodam. relabel_configs roda antes do scrape, sobre os labels de descoberta de cada target (os __meta_*), e decide o que será scraped e com quais labels. metric_relabel_configs roda depois do scrape, sobre cada amostra já coletada, e é onde você descarta métricas barulhentas ou reescreve nomes. Como a semântica é idêntica, você pode colar qualquer um dos dois aqui: o mesmo engine trata os dois do mesmo jeito.

Cole uma lista YAML de regras em um painel e um ou mais conjuntos de labels de exemplo no outro, clique em Run e leia o resultado: os labels finais, quais foram adicionados, alterados ou removidos, e se o target inteiro foi descartado. É a forma mais rápida de confirmar que uma regra de relabel se comporta como você imagina antes de enviá-la para uma scrape config — sem precisar iterar contra um Prometheus ao vivo. Como tudo roda no navegador, você pode colar com segurança scrape configs internas com metadados privados.

Quase sempre por causa da regex totalmente ancorada. O Prometheus envolve cada regex de relabel como ^(?:sua-regex)$, então um keep só mantém o target se o valor de origem unido casar com o padrão inteiro, não só com uma parte dele. Uma regex de api NÃO casa com um valor de api-server, então o target cai. Cole as suas regras e os labels do target aqui: o tester aplica a mesma ancoragem, marca o target descartado e mostra a regra e a ação exatas que o removeram, para você ver por que o seu target do Prometheus está sendo descartado no relabel.

As duas decidem se a série será scraped ou armazenada, com base na regex ancorada aplicada à origem unida — mas em sentidos opostos. keep mantém o target apenas quando a regex casa e descarta todo o resto; drop faz o contrário: descarta quando a regex casa e mantém o resto. Um exemplo de relabel com keep e drop: use keep com regex no __name__ para guardar só um conjunto de métricas, ou drop com regex go_gc_.* para podar séries internas. As variantes keepequal e dropequal não usam regex — comparam a origem unida com o valor atual de target_label e decidem pela igualdade.

É o ponto e vírgula (";"). Quando uma regra lista vários source_labels, o Prometheus une os valores deles com o separator antes de aplicar a regex; se você não definir um separator, o padrão é ";". Então com source_labels: [job, instance] o valor unido fica algo como api;10.0.0.1:9090, e é esse texto que a regex precisa casar. O tester aplica o mesmo padrão, então você pode confirmar exatamente qual string a sua regex está vendo.

O hashmod une os source_labels com o separator, calcula o MD5 do resultado (o mesmo md5.Sum que o Prometheus usa), lê os últimos 8 bytes desse digest como um inteiro de 64 bits big-endian e armazena hash % modulus no target_label. Este tester reproduz exatamente essa receita, então os valores de shard que ele produz batem com o Prometheus byte a byte. Isso permite verificar uma configuração de sharding horizontal — hashmod para um label temporário, depois keep no shard que é seu — antes de colocá-la em produção.

Enquanto o replace opera sobre o valor de um label, o labelmap opera sobre os NOMES dos labels: para todo label cujo nome case com a regex, ele cria um novo label nomeado pelo replacement expandido, copiando o valor. É a clássica passagem de __meta_kubernetes_pod_label_(.+) para um label simples $1. As ações irmãs labeldrop e labelkeep também trabalham sobre nomes — labeldrop remove todo label cujo nome case; labelkeep remove todo label cujo nome NÃO case. O tester roda as três contra os nomes de label reais do seu conjunto.

Não. O tester roda 100% no lado do cliente. As suas regras de relabel e os conjuntos de labels são analisados e avaliados dentro da aba do seu navegador — nada é enviado para um servidor, e não há conta nem cadastro. Você pode colar com segurança scrape configs internas, incluindo metadados privados de targets e nomes de labels.

More free, private DevOps tools.

O Prometheus Relabel Tester é uma ferramenta dentro do OpsCanopy — uma copa crescente de validadores, conversores e testadores baseados em navegador que nunca tocam um servidor.

Começando com Kubernetes?  Leia o guia de Kubernetes →

39 ferramentas gratuitas, todas capazes de funcionar offline — o opscanopy.com não exige cadastro e não envia nada.

Ferramentas relacionadas: o explicador de PromQL e o testador de rotas do Alertmanager. Explore o diretório completo de ferramentas.

Não é afiliado, endossado nem patrocinado pelo projeto Prometheus ou pela Cloud Native Computing Foundation. Prometheus é usado aqui apenas de forma descritiva para identificar o formato relabel_configs que esta ferramenta modela.