Monitore o RabbitMQ hospedado no Kubernetes com OpenTelemetry

Monitore o RabbitMQ em execução em clusters Kubernetes usando o OpenTelemetry Collector com descoberta automática de pods. Este guia orienta você na implantação do coletor via Helm com detecção dinâmica de broker baseada no observador do Kubernetes.

Dica

Executando RabbitMQ em hosts Linux? Consulte o guia de instalação auto-hospedada para implantações em máquinas virtuais ou bare metal.

Como a integração funciona

Esta implantação nativa do Kubernetes fornece descoberta e monitoramento automáticos:

Principais componentes:

Observador do Kubernetes: Monitora continuamente os pods do RabbitMQ com base em seletores de rótulo
Criador de receptores: Cria dinamicamente receptores RabbitMQ para cada pod descoberto
Atribuição de recursos: Enriquece automaticamente as métricas com metadados do Kubernetes:
- k8s.cluster.name - Seu identificador de cluster
- k8s.namespace.name - Namespace do Pod
- k8s.pod.name - Nome do pod individual
- rabbitmq.deployment.name - Derivado do nome do pod

Modelo de implantação: O coletor é executado como um Deployment do Kubernetes (réplica única) com permissões RBAC para listar e observar pods em todos os namespaces. Quando novos pods do RabbitMQ são criados ou os existentes são removidos, o observador atualiza automaticamente a configuração do coletor.

Importante

O coletor requer permissões de get, list e watch nos pods para descobrir instâncias do RabbitMQ automaticamente.

Etapas de instalação

Siga estas etapas para implantar o OpenTelemetry Collector com monitoramento do RabbitMQ.

Antes de você começar

Certifique-se de que seu ambiente atenda a estes requisitos:

Verifique o endpoint de gerenciamento

Certifique-se de que os pods do RabbitMQ tenham o plugin de gerenciamento habilitado:

bash

$kubectl exec deploy/<your-rabbitmq-deployment> -n <rabbitmq-namespace> -- curl -I -u admin:password http://localhost:15672/api/overview

Você deve ver HTTP/1.1 200 OK na resposta.

Crie o arquivo de valores do Helm

Crie um arquivo chamado otel-collector-values.yaml. Esta configuração usa o receiver_creator com k8s_observer para descobrir automaticamente os pods do RabbitMQ.

Atualize estes espaços reservados:

my-rabbitmq-cluster: O nome do seu cluster Kubernetes
rabbitmq: O valor do rótulo app para seus pods do RabbitMQ
admin/password: Suas credenciais do RabbitMQ

15672: A porta da API de gerenciamento

opentelemetry-collector:
  mode: deployment

  image:
    repository: otel/opentelemetry-collector-contrib
    pullPolicy: IfNotPresent

  command:
    name: otelcol-contrib

  resources:
    limits:
      cpu: 500m
      memory: 300Mi
    requests:
      cpu: 100m
      memory: 100Mi

  extraEnvs:
    - name: NEWRELIC_LICENSE_KEY
      valueFrom:
        secretKeyRef:
          name: newrelic-licenses
          key: NEWRELIC_LICENSE_KEY
    - name: NEWRELIC_OTLP_ENDPOINT
      valueFrom:
        secretKeyRef:
          name: newrelic-licenses
          key: NEWRELIC_OTLP_ENDPOINT
    - name: K8S_NODE_NAME
      valueFrom:
        fieldRef:
          fieldPath: spec.nodeName
    - name: K8S_CLUSTER_NAME
      value: my-rabbitmq-cluster
    - name: RABBITMQ_USERNAME
      value: admin
    - name: RABBITMQ_PASSWORD
      value: password

  clusterRole:
    create: true
    rules:
      - apiGroups: [""]
        resources: ["pods", "nodes", "nodes/stats", "nodes/proxy"]
        verbs: ["get", "list", "watch"]
      - apiGroups: ["apps"]
        resources: ["replicasets", "deployments", "statefulsets"]
        verbs: ["get", "list", "watch"]

  clusterRoleBinding:
    name: ""

  config:
    extensions:
      health_check:
        endpoint: 0.0.0.0:13133

      k8s_observer:
        auth_type: serviceAccount
        observe_pods: true
        observe_nodes: false

    receivers:
      receiver_creator/rabbitmq:
        watch_observers: [k8s_observer]
        receivers:
          rabbitmq:
            # Discover pods with label "app=rabbitmq"
            # Adjust the label selector to match your RabbitMQ pods
            rule: type == "pod" && labels["app"] == "rabbitmq"
            config:
              endpoint: 'http://`endpoint`:15672'
              username: ${env:RABBITMQ_USERNAME}
              password: ${env:RABBITMQ_PASSWORD}
              collection_interval: 30s
              metrics:
                # Queue Metrics (essential for message flow and backlog)
                rabbitmq.consumer.count:
                  enabled: true
                rabbitmq.message.delivered:
                  enabled: true
                rabbitmq.message.published:
                  enabled: true
                rabbitmq.message.acknowledged:
                  enabled: true
                rabbitmq.message.dropped:
                  enabled: true
                rabbitmq.message.current:
                  enabled: true # Crucial for monitoring queue backlog, includes 'ready' and 'unacknowledged' states

                # Node Health Metrics (critical for server resource monitoring)
                rabbitmq.node.disk_free:
                  enabled: true
                rabbitmq.node.disk_free_limit:
                  enabled: true
                rabbitmq.node.disk_free_alarm:
                  enabled: true
                rabbitmq.node.mem_used:
                  enabled: true
                rabbitmq.node.mem_limit:
                  enabled: true
                rabbitmq.node.mem_alarm:
                  enabled: true
                rabbitmq.node.mem_used_details.rate:
                  enabled: true
                rabbitmq.node.fd_used:
                  enabled: true
                rabbitmq.node.fd_total:
                  enabled: true
                rabbitmq.node.sockets_used:
                  enabled: true
                rabbitmq.node.sockets_total:
                  enabled: true
                rabbitmq.node.proc_used:
                  enabled: true
                rabbitmq.node.proc_total:
                  enabled: true
                rabbitmq.node.uptime:
                  enabled: true
                rabbitmq.node.run_queue:
                  enabled: true
                rabbitmq.node.processors:
                  enabled: true
                rabbitmq.node.context_switches_details.rate:
                  enabled: true
                rabbitmq.node.gc_num_details.rate:
                  enabled: true
                rabbitmq.node.gc_bytes_reclaimed_details.rate:
                  enabled: true

                # I/O Metrics (important for understanding disk and network activity)
                rabbitmq.node.io_read_count_details.rate:
                  enabled: true
                rabbitmq.node.io_read_bytes_details.rate:
                  enabled: true
                rabbitmq.node.io_read_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_write_count_details.rate:
                  enabled: true
                rabbitmq.node.io_write_bytes_details.rate:
                  enabled: true
                rabbitmq.node.io_write_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_sync_count_details.rate:
                  enabled: true
                rabbitmq.node.io_sync_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_seek_count_details.rate:
                  enabled: true
                rabbitmq.node.io_seek_avg_time_details.rate:
                  enabled: true
                rabbitmq.node.io_reopen_count_details.rate:
                  enabled: true

                # Mnesia and Store Metrics (for internal database and message storage)
                rabbitmq.node.mnesia_ram_tx_count_details.rate:
                  enabled: true
                rabbitmq.node.mnesia_disk_tx_count_details.rate:
                  enabled: true
                rabbitmq.node.msg_store_read_count_details.rate:
                  enabled: true
                rabbitmq.node.msg_store_write_count_details.rate:
                  enabled: true
                rabbitmq.node.queue_index_write_count_details.rate:
                  enabled: true
                rabbitmq.node.queue_index_read_count_details.rate:
                  enabled: true

                # Connection/Channel/Queue Lifecycle Metrics
                rabbitmq.node.connection_created_details.rate:
                  enabled: true
                rabbitmq.node.connection_closed_details.rate:
                  enabled: true
                rabbitmq.node.channel_created_details.rate:
                  enabled: true
                rabbitmq.node.channel_closed_details.rate:
                  enabled: true
                rabbitmq.node.queue_declared_details.rate:
                  enabled: true
                rabbitmq.node.queue_created_details.rate:
                  enabled: true
                rabbitmq.node.queue_deleted_details.rate:
                  enabled: true

              resource_attributes:
                rabbitmq.server.endpoint: 'http://`endpoint`:15672'
                rabbitmq.port: '15672'

    processors:
      batch:
        send_batch_size: 1024
        timeout: 30s

      resource/cluster:
        attributes:
          - key: k8s.cluster.name
            value: ${env:K8S_CLUSTER_NAME}
            action: upsert

      transform/rabbitmq:
        metric_statements:
          - context: resource
            statements:
              # Create a display name combining Kubernetes metadata
              - set(attributes["rabbitmq.display.name"], Concat([
                  "server",
                  "k8s",
                  attributes["k8s.cluster.name"],
                  attributes["k8s.namespace.name"],
                  "pod",
                  attributes["k8s.pod.name"],
                  "rabbitmq",
                  attributes["rabbitmq.port"]
                ], ":"))
              # Use pod name as deployment name
              - set(attributes["rabbitmq.deployment.name"], attributes["k8s.pod.name"])

    exporters:
      otlphttp:
        endpoint: "${NEWRELIC_OTLP_ENDPOINT}"
        headers:
          api-key: "${NEWRELIC_LICENSE_KEY}"
        compression: gzip

    service:
      extensions: [health_check, k8s_observer]
      pipelines:
        metrics/rabbitmq:
          receivers: [receiver_creator/rabbitmq]
          processors: [batch, resource/cluster, transform/rabbitmq]
          exporters: [otlphttp]

Dica

Personalização do seletor de rótulos: Se seus pods RabbitMQ usam rótulos diferentes, atualize a linha rule. Por exemplo:

Pods do StatefulSet: type == "pod" && labels["app.kubernetes.io/name"] == "rabbitmq"
Implantações do Operador: type == "pod" && labels["app.kubernetes.io/component"] == "rabbitmq"
Execute kubectl get pods --show-labels -n <namespace> para visualizar os rótulos do seu pod.

Criar segredo do Kubernetes

Armazene suas credenciais do New Relic em um segredo do Kubernetes.

Selecione a região que corresponde à sua conta New Relic (verifique a URL do seu navegador quando estiver logado no New Relic):

bash

$kubectl create secret generic newrelic-licenses \
>  --from-literal=NEWRELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>  --from-literal=NEWRELIC_OTLP_ENDPOINT=https://otlp.nr-data.net:4318 \
>  --namespace newrelic

Substitua YOUR_LICENSE_KEY por sua chave de licença New Relic.

bash

$kubectl create secret generic newrelic-licenses \
>  --from-literal=NEWRELIC_LICENSE_KEY=YOUR_LICENSE_KEY \
>  --from-literal=NEWRELIC_OTLP_ENDPOINT=https://otlp.eu01.nr-data.net:4318 \
>  --namespace newrelic

Substitua YOUR_LICENSE_KEY por sua chave de licença New Relic.

Implantar com Helm

Adicione o repositório Helm do OpenTelemetry:

bash

$helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$helm repo update

Instale ou atualize o coletor:

bash

$helm upgrade --install rabbitmq-otel-collector \
>  open-telemetry/opentelemetry-collector \
>  --namespace newrelic \
>  --create-namespace \
>  --values otel-collector-values.yaml

Isso cria:

Uma implantação chamada rabbitmq-otel-collector no namespace newrelic
Uma ServiceAccount com permissões RBAC para monitorar pods
ConfigMaps contendo a configuração do coletor

Verifique a implantação e o fluxo de dados

Verifique se o pod do coletor está em execução:

bash

$kubectl get pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector

Resultado esperado:

NAME                                 READY   STATUS    RESTARTS   AGE
rabbitmq-otel-collector-6d8c5c5d8d-abc12   1/1     Running   0          2m

Visualize os logs do coletor para verificar a descoberta de pods:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic --tail=50

Procure mensagens indicando a descoberta de pods e a coleta de métricas bem-sucedidas:

INFO    k8sobserver/extension.go:150    Discovered pod {"kind": "pod", "name": "rabbitmq-0", "namespace": "default"}
INFO    RabbitmqReceiver                Successfully scraped rabbitmq metrics from pod rabbitmq-0

Verifique seus dados no New Relic:

Aguarde de 2 a 3 minutos para que os dados apareçam e, em seguida, execute esta consulta no construtor de consultas:

SELECT count(*)
FROM Metric
WHERE metricName LIKE 'rabbitmq.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = 'my-rabbitmq-cluster'
FACET k8s.pod.name, metricName
SINCE 10 minutes ago

Você deve ver métricas de cada pod do RabbitMQ com atributos do Kubernetes:

k8s.cluster.name - Seu identificador de cluster
k8s.namespace.name - Namespace do Pod
k8s.pod.name - Nome do pod individual
rabbitmq.deployment.name - Derivado do nome do pod

Dica

Se você não visualizar dados após 5 minutos, consulte a seção de solução de problemas abaixo.

Resolução de problemas

Se as métricas não aparecerem no New Relic após a implantação:

1. Verifique se o plugin de gerenciamento do RabbitMQ está habilitado:

bash

$kubectl exec <rabbitmq-pod> -n <namespace> -- rabbitmq-plugins list | grep management

Você deve ver [E*] rabbitmq_management indicando que está ativado.

2. Verifique os logs do pod do coletor:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic --tail=100

Procurar por:

Mensagens de descoberta de pods
Erros de autenticação (credenciais incorretas)
Erros de conexão (problemas de rede)
Erros de análise (problemas de configuração)

3. Verifique se o serviço RabbitMQ está acessível:

bash

$kubectl get svc -n <rabbitmq-namespace>

Certifique-se de que haja um serviço expondo a porta 15672.

4. Teste a API de gerenciamento de dentro do cluster:

bash

$kubectl run test-pod --image=curlimages/curl:latest --rm -it --restart=Never -- \
>  curl -I -u admin:password http://<rabbitmq-service>.<namespace>.svc.cluster.local:15672/api/overview

Deve retornar HTTP/1.1 200 OK.

5. Verifique as permissões RBAC:

bash

$kubectl auth can-i list pods --as=system:serviceaccount:newrelic:rabbitmq-otel-collector -n <rabbitmq-namespace>

Deve retornar yes. Caso contrário, verifique o ClusterRole e o ClusterRoleBinding.

Se o coletor não estiver descobrindo os pods do RabbitMQ automaticamente:

1. Verifique se o seletor de rótulos corresponde aos seus pods:

bash

$kubectl get pods --show-labels -n <rabbitmq-namespace>

Compare os rótulos com o rule no seu arquivo de valores do Helm.

2. Verifique os logs do k8s_observer:

bash

$kubectl logs deploy/rabbitmq-otel-collector -n newrelic | grep k8sobserver

Procure mensagens sobre pods descobertos.

3. Teste o seletor de rótulos:

bash

$kubectl get pods -l app=rabbitmq --all-namespaces

Isso deve listar seus pods do RabbitMQ. Se estiver vazio, seu seletor de rótulos está incorreto.

4. Verifique as permissões do ClusterRole:

bash

$kubectl describe clusterrole rabbitmq-otel-collector

Certifique-se de que ele tenha permissões de get, list e watch nos pods.

Padrões comuns de rótulos:

Implantações padrão: app=rabbitmq
StatefulSets: app.kubernetes.io/name=rabbitmq
Operadores: app.kubernetes.io/component=rabbitmq

Se você vir erros de conexão nos logs do coletor:

Verifique os endpoints de serviço:

bash

$kubectl get endpoints -n <rabbitmq-namespace>

Verifique se existem endpoints para o seu serviço RabbitMQ.

Verifique as políticas de rede: Certifique-se de que as políticas de rede permitam o tráfego do namespace newrelic para o seu namespace RabbitMQ.

Testar conectividade:

bash

$kubectl run test-pod --image=curlimages/curl:latest --rm -it --restart=Never -n newrelic -- \
>  curl http://<rabbitmq-service>.<namespace>.svc.cluster.local:15672/api/overview

Verifique a resolução de DNS:

bash

$kubectl run test-pod --image=busybox:latest --rm -it --restart=Never -n newrelic -- \
>  nslookup <rabbitmq-service>.<namespace>.svc.cluster.local

Se você vir avisos de alta cardinalidade no New Relic:

Filtrar por filas específicas: Se estiver monitorando muitas filas, considere filtrar apenas as críticas.

Aumentar intervalo de coleta:

receivers:
  receiver_creator/rabbitmq:
    receivers:
      rabbitmq:
        config:
          collection_interval: 60s # Increased from 30s

Use a agregação de métricas: Configure o processador de lote para agregar métricas antes da exportação.

Desative métricas menos críticas: Comente as métricas que você não precisa na configuração do receptor.

Dicas adicionais de otimização:

Use seletores de rótulo mais específicos para monitorar apenas pods de produção
Filtrar filas específicas por nome em vez de monitorar todas as filas
Aumente o collection_interval para reduzir pontos de dados
Considere usar a agregação de métricas no coletor

Se o pod do coletor estiver falhando:

Verifique os limites de recursos:

bash

$kubectl describe pod -n newrelic -l app.kubernetes.io/name=opentelemetry-collector

Procure pelo status OOMKilled. Se sim, aumente os limites de memória:

resources:
  limits:
    memory: 512Mi # Increased from 300Mi

Analise os logs de falha:

bash

$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector --previous

Verifique a sintaxe da configuração: Certifique-se de que sua configuração YAML é válida e está corretamente indentada.

Se você vir 401 Unauthorized erros:

Verifique se as credenciais nos valores do Helm correspondem à sua configuração do RabbitMQ:

bash

$kubectl exec <rabbitmq-pod> -n <namespace> -- rabbitmqctl list_users

Verifique se o usuário do RabbitMQ tem privilégios de administrador e certifique-se de que as credenciais não contenham caracteres especiais que precisem de escape.

Qual é o próximo?

Agora que você configurou o monitoramento do RabbitMQ, pode aprimorar sua observabilidade:

Explore seus dados:

Explore as métricas do RabbitMQ - Lista completa de métricas com exemplos de consulta NRQL

Aprimore o monitoramento:

Criar alertas - Configure alertas para profundidade de fila e integridade do pod
Construa dashboards - Crie dashboards personalizados para visualizar suas métricas do RabbitMQ

Esta tradução de máquina é fornecida para sua comodidade.

Monitore o RabbitMQ hospedado no Kubernetes com OpenTelemetry

Dica

Como a integração funciona

Importante

Etapas de instalação

Antes de você começar

Requisitos do cluster Kubernetes

Requisitos do RabbitMQ

Requisitos do New Relic

Verifique o endpoint de gerenciamento

Crie o arquivo de valores do Helm

Dica

Criar segredo do Kubernetes

Implantar com Helm

Verifique a implantação e o fluxo de dados

Dica

Resolução de problemas

Nenhum dado aparecendo no New Relic

Descoberta de Pod não funcionando

Erros de conexão

Avisos de alta cardinalidade

Pod do Coletor falhando ou reiniciando

Falhas de autenticação

Qual é o próximo?

Esta tradução de máquina é fornecida para sua comodidade.

Monitore o RabbitMQ hospedado no Kubernetes com OpenTelemetry

Dica

Como a integração funciona .css-21sua1{background:none;border:none;width:0;padding:0;}

Importante

Etapas de instalação

Antes de você começar

Requisitos do RabbitMQ

Requisitos do New Relic

Verifique o endpoint de gerenciamento

Crie o arquivo de valores do Helm

Dica

Criar segredo do Kubernetes

Implantar com Helm

Verifique a implantação e o fluxo de dados

Dica

Resolução de problemas

Nenhum dado aparecendo no New Relic

Descoberta de Pod não funcionando

Erros de conexão

Avisos de alta cardinalidade

Pod do Coletor falhando ou reiniciando

Falhas de autenticação

Qual é o próximo?

Como a integração funciona