OpenTelemetry를 사용하여 Kubernetes(Strimzi)에서 Kafka를 모니터링하세요.

OpenTelemetry Collector 구현하거나 배포하여 Strimzi 연산자를 사용하여 Kubernetes 에서 실행 중인 Kafka 클러스터를 모니터링합니다. 수집기는 Kafka 브로커를 자동으로 발견하고 포괄적인 정보를 수집합니다.

아키텍처

다음 다이어그램은 뉴렐릭에 대한 모델링 및 데이터 흐름을 보여줍니다.

Kubernetes Strimzi Kafka monitoring architecture with OpenTelemetry

설치 단계

Kafka 클러스터 모니터링을 설정하려면 다음 단계를 따르세요.

시작하기 전에

다음 사항을 확인하십시오:

뉴렐릭 계정
kubectl 액세스 권한이 있는 쿠버네티스 클러스터
Kafka 구현하다, Strimzi 연산자를통해 배포하다

Kafka JMX 메트릭을 위해 Kafka 클러스터를 구성합니다.

Strimzi Kafka 클러스터를 구성하여 Prometheus JMX Exporter를 통해 Kafka JMX 메트릭을 노출하십시오. 이 설정은 ConfigMap으로 구현되고 배포되며 Kafka 클러스터에서 참조됩니다.

1단계. JMX 메트릭 ConfigMap 생성

수집할 Kafka 메트릭을 정의하는 JMX Exporter 패턴이 포함된 ConfigMap을 생성합니다. kafka-jmx-config.yaml 으로 저장:

apiVersion: v1
kind: ConfigMap
metadata:
  name: kafka-jmx-metrics
  namespace: newrelic
data:
  kafka-metrics-config.yml: |
    startDelaySeconds: 0
    lowercaseOutputName: true
    lowercaseOutputLabelNames: true

    rules:
      # Cluster-level controller metrics
      - pattern: 'kafka.controller<type=KafkaController, name=GlobalTopicCount><>Value'
        name: kafka_cluster_topic_count
        type: GAUGE

      - pattern: 'kafka.controller<type=KafkaController, name=GlobalPartitionCount><>Value'
        name: kafka_cluster_partition_count
        type: GAUGE

      - pattern: 'kafka.controller<type=KafkaController, name=FencedBrokerCount><>Value'
        name: kafka_broker_fenced_count
        type: GAUGE

      - pattern: 'kafka.controller<type=KafkaController, name=PreferredReplicaImbalanceCount><>Value'
        name: kafka_partition_non_preferred_leader
        type: GAUGE

      - pattern: 'kafka.controller<type=KafkaController, name=OfflinePartitionsCount><>Value'
        name: kafka_partition_offline
        type: GAUGE

      - pattern: 'kafka.controller<type=KafkaController, name=ActiveControllerCount><>Value'
        name: kafka_controller_active_count
        type: GAUGE

      # Broker-level replica metrics
      - pattern: 'kafka.server<type=ReplicaManager, name=UnderMinIsrPartitionCount><>Value'
        name: kafka_partition_under_min_isr
        type: GAUGE

      - pattern: 'kafka.server<type=ReplicaManager, name=LeaderCount><>Value'
        name: kafka_broker_leader_count
        type: GAUGE

      - pattern: 'kafka.server<type=ReplicaManager, name=PartitionCount><>Value'
        name: kafka_partition_count
        type: GAUGE

      - pattern: 'kafka.server<type=ReplicaManager, name=UnderReplicatedPartitions><>Value'
        name: kafka_partition_under_replicated
        type: GAUGE

      - pattern: 'kafka.server<type=ReplicaManager, name=IsrShrinksPerSec><>Count'
        name: kafka_isr_operation_count
        type: COUNTER
        labels:
          operation: "shrink"

      - pattern: 'kafka.server<type=ReplicaManager, name=IsrExpandsPerSec><>Count'
        name: kafka_isr_operation_count
        type: COUNTER
        labels:
          operation: "expand"

      - pattern: 'kafka.server<type=ReplicaFetcherManager, name=MaxLag, clientId=Replica><>Value'
        name: kafka_max_lag
        type: GAUGE

      # Broker topic metrics (totals)
      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=MessagesInPerSec><>Count'
        name: kafka_message_count
        type: COUNTER

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=TotalFetchRequestsPerSec><>Count'
        name: kafka_request_count
        type: COUNTER
        labels:
          type: "fetch"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=TotalProduceRequestsPerSec><>Count'
        name: kafka_request_count
        type: COUNTER
        labels:
          type: "produce"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=FailedFetchRequestsPerSec><>Count'
        name: kafka_request_failed
        type: COUNTER
        labels:
          type: "fetch"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=FailedProduceRequestsPerSec><>Count'
        name: kafka_request_failed
        type: COUNTER
        labels:
          type: "produce"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec><>Count'
        name: kafka_network_io
        type: COUNTER
        labels:
          direction: "in"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=BytesOutPerSec><>Count'
        name: kafka_network_io
        type: COUNTER
        labels:
          direction: "out"

      # Per-topic metrics (only appear after traffic flows)
      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=MessagesInPerSec, topic=(.+)><>Count'
        name: kafka_prod_msg_count
        type: COUNTER
        labels:
          topic: "$1"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=BytesInPerSec, topic=(.+)><>Count'
        name: kafka_topic_io
        type: COUNTER
        labels:
          topic: "$1"
          direction: "in"

      - pattern: 'kafka.server<type=BrokerTopicMetrics, name=BytesOutPerSec, topic=(.+)><>Count'
        name: kafka_topic_io
        type: COUNTER
        labels:
          topic: "$1"
          direction: "out"

      # Request metrics
      - pattern: 'kafka.network<type=RequestMetrics, name=TotalTimeMs, request=(Produce|FetchConsumer|FetchFollower)><>99thPercentile'
        name: kafka_request_time_99p
        type: GAUGE
        labels:
          type: "$1"

      - pattern: 'kafka.network<type=RequestChannel, name=RequestQueueSize><>Value'
        name: kafka_request_queue
        type: GAUGE

      - pattern: 'kafka.server<type=DelayedOperationPurgatory, name=PurgatorySize, delayedOperation=(.+)><>Value'
        name: kafka_purgatory_size
        type: GAUGE
        labels:
          type: "$1"

      # Controller stats
      - pattern: 'kafka.controller<type=ControllerStats, name=LeaderElectionRateAndTimeMs><>Count'
        name: kafka_leader_election_rate
        type: COUNTER

      - pattern: 'kafka.controller<type=ControllerStats, name=UncleanLeaderElectionsPerSec><>Count'
        name: kafka_unclean_election_rate
        type: COUNTER

      # JVM Garbage Collection
      - pattern: 'java.lang<name=(.+), type=GarbageCollector><>CollectionCount'
        name: jvm_gc_collections_count
        type: COUNTER
        labels:
          name: "$1"

      # JVM Memory
      - pattern: 'java.lang<type=Memory><HeapMemoryUsage>max'
        name: jvm_memory_heap_max
        type: GAUGE

      - pattern: 'java.lang<type=Memory><HeapMemoryUsage>used'
        name: jvm_memory_heap_used
        type: GAUGE

      # JVM Threading and System
      - pattern: 'java.lang<type=Threading><>ThreadCount'
        name: jvm_thread_count
        type: GAUGE

      - pattern: 'java.lang<type=OperatingSystem><>SystemCpuLoad'
        name: jvm_system_cpu_utilization
        type: GAUGE

      # Broker uptime
      - pattern: 'java.lang<type=Runtime><>Uptime'
        name: kafka_broker_uptime
        type: GAUGE

      # Additional metrics — remove this section to reduce data ingest

      # Request latency: total count, 50th percentile, and average (99p kept above)
      - pattern: 'kafka.network<type=RequestMetrics, name=TotalTimeMs, request=(Produce|FetchConsumer|FetchFollower)><>Count'
        name: kafka_request_time_total
        type: COUNTER
        labels:
          type: "$1"

      - pattern: 'kafka.network<type=RequestMetrics, name=TotalTimeMs, request=(Produce|FetchConsumer|FetchFollower)><>50thPercentile'
        name: kafka_request_time_50p
        type: GAUGE
        labels:
          type: "$1"

      - pattern: 'kafka.network<type=RequestMetrics, name=TotalTimeMs, request=(Produce|FetchConsumer|FetchFollower)><>Mean'
        name: kafka_request_time_avg
        type: GAUGE
        labels:
          type: "$1"

      # Log flush metrics
      - pattern: 'kafka.log<type=LogFlushStats, name=LogFlushRateAndTimeMs><>Count'
        name: kafka_logs_flush_count
        type: COUNTER

      - pattern: 'kafka.log<type=LogFlushStats, name=LogFlushRateAndTimeMs><>50thPercentile'
        name: kafka_logs_flush_time_50p
        type: GAUGE

      - pattern: 'kafka.log<type=LogFlushStats, name=LogFlushRateAndTimeMs><>99thPercentile'
        name: kafka_logs_flush_time_99p
        type: GAUGE

      # JVM GC elapsed time
      - pattern: 'java.lang<name=(.+), type=GarbageCollector><>CollectionTime'
        name: jvm_gc_collections_elapsed
        type: COUNTER
        labels:
          name: "$1"

      # JVM Memory heap committed
      - pattern: 'java.lang<type=Memory><HeapMemoryUsage>committed'
        name: jvm_memory_heap_committed
        type: GAUGE

      # JVM class loading
      - pattern: 'java.lang<type=ClassLoading><>LoadedClassCount'
        name: jvm_class_count
        type: GAUGE

      # Additional JVM OS metrics
      - pattern: 'java.lang<type=OperatingSystem><>SystemLoadAverage'
        name: jvm_system_cpu_load_1m
        type: GAUGE

      - pattern: 'java.lang<type=OperatingSystem><>AvailableProcessors'
        name: jvm_cpu_count
        type: GAUGE

      - pattern: 'java.lang<type=OperatingSystem><>ProcessCpuLoad'
        name: jvm_cpu_recent_utilization
        type: GAUGE

      - pattern: 'java.lang<type=OperatingSystem><>OpenFileDescriptorCount'
        name: jvm_file_descriptor_count
        type: GAUGE

      # JVM Memory Pool
      - pattern: 'java.lang<type=MemoryPool, name=(.+)><Usage>used'
        name: jvm_memory_pool_used
        type: GAUGE
        labels:
          name: "$1"

      - pattern: 'java.lang<type=MemoryPool, name=(.+)><Usage>max'
        name: jvm_memory_pool_max
        type: GAUGE
        labels:
          name: "$1"

      - pattern: 'java.lang<type=MemoryPool, name=(.+)><CollectionUsage>used'
        name: jvm_memory_pool_used_after_last_gc
        type: GAUGE
        labels:
          name: "$1"

팁

메트릭 사용자 지정: 이 ConfigMap에는 Kafka 브로커, 토픽, 요청, 컨트롤러 및 JVM에 대한 포괄적인 메트릭이 포함되어 있습니다. Prometheus JMX Exporter 예제 및 Kafka MBean 문서를 참조하여 패턴을 추가하거나 수정할 수 있습니다. 추가 설정은 JMX Exporter 규칙 문서를 참조하십시오.

중요

지우개 스페이스 요구 사항: JMX 지표 ConfigMap과 Kafka 클러스터는 동일한 지우개 스페이스에 있어야 합니다. 이 가이드에서는 둘 다 newrelic 지우스페이스에 구현하다, 배포하다입니다.

ConfigMap을 적용합니다.

bash

$kubectl apply -f kafka-jmx-config.yaml

2단계. JMX Exporter를 사용하도록 Kafka 클러스터 업데이트

Strimzi Kafka 리소스가 메트릭 ConfigMap을 참조하도록 업데이트하세요.

apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: my-cluster
  namespace: newrelic
spec:
  kafka:
    version: X.X.X
    metricsConfig:
      type: jmxPrometheusExporter
      valueFrom:
        configMapKeyRef:
          name: kafka-jmx-metrics
          key: kafka-metrics-config.yml
    # ...rest of your Kafka configuration

변경 사항을 적용하세요. Strimzi는 Kafka 브로커를 순차적으로 재시작합니다.

bash

$kubectl apply -f kafka-cluster.yaml

롤링 재시작이 완료되면 각 Kafka 브로커는 9404 포트에서 Prometheus 메트릭을 노출합니다.

구현하다, 배포하다 OpenTelemetry Collector

Kafka 클러스터를 모니터링하기 위한 OpenTelemetry Collector 구현하다, 배포합니다. 원하는 설치 방법을 선택하세요.

Helm 설치 방법은 Kubernetes 에서 구현하다, 배포하다 OpenTelemetry Collector 에 권장되는 접근 방식입니다.

1단계. 뉴렐릭 자격 증명 시크릿 생성

뉴렐릭 클러스터 키 및 OTLP 엔드포인트가 포함된 Kubernetes 시크릿을 생성하세요. 귀하의 뉴렐릭 지역에 맞는 포인트를 선택하세요:

bash

$kubectl create secret generic newrelic-otlp-secret \
>  --namespace newrelic \
>  --from-literal=NEW_RELIC_LICENSE_KEY='your-license-key-here' \
>  --from-literal=NEW_RELIC_OTLP_ENDPOINT='https://otlp.nr-data.net:4317'

bash

$kubectl create secret generic newrelic-otlp-secret \
>  --namespace newrelic \
>  --from-literal=NEW_RELIC_LICENSE_KEY='your-license-key-here' \
>  --from-literal=NEW_RELIC_OTLP_ENDPOINT='https://otlp.eu01.nr-data.net:4317'

팁

다른 엔드포인트 설정에 대해서는 OTLP 엔드포인트 구성을 참조하세요.

2단계. 수집기 설정이 포함된 values.yaml 생성

OpenTelemetry Collector 설정 전체 내용이 포함된 values.yaml 파일을 생성하세요. NRDOT과 OpenTelemetry 수집기 모두 동일한 설정을 사용하고 동일한 Kafka 모니터링 기능을 제공합니다. 원하는 수집기 이미지를 선택하세요:

NRDOT 은 뉴릭에서 지원하는 OpenTelemetry Collector 배포판으로, 뉴릭에 대한 완벽한 지원을 제공합니다. 자세한 내용은 NRDOT Collector GitHub 저장소를 참조하세요.

다음 내용으로 values.yaml 생성하세요:

# Deployment mode
mode: deployment
replicaCount: 1

# Use NRDOT collector image
image:
  repository: newrelic/nrdot-collector
  tag: "latest"
  pullPolicy: Always

# Service account configuration
serviceAccount:
  create: true
  name: otel-collector

# RBAC for Kubernetes service discovery
clusterRole:
  create: true
  rules:
    - apiGroups: [""]
      resources: ["pods", "nodes"]
      verbs: ["get", "list", "watch"]

# Pod security context
podSecurityContext:
  runAsNonRoot: true
  runAsUser: 10001

# Container security context
securityContext:
  allowPrivilegeEscalation: false
  readOnlyRootFilesystem: true
  capabilities:
    drop:
      - ALL

# Resource limits
resources:
  requests:
    memory: 512Mi
    cpu: 250m
  limits:
    memory: 1Gi
    cpu: 500m

# Load environment variables from secret
extraEnvsFrom:
  - secretRef:
      name: newrelic-otlp-secret

# Disable unused default ports
ports:
  jaeger-compact:
    enabled: false
  jaeger-thrift:
    enabled: false
  jaeger-grpc:
    enabled: false
  zipkin:
    enabled: false

# OpenTelemetry Collector Configuration
config:
  receivers:
    # Disable default receivers not needed in NRDOT
    jaeger: null
    zipkin: null

    kafkametrics/cluster:
      brokers:
        # TODO#1: Replace with your Kafka bootstrap service
        - "my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9092"
      collection_interval: 30s
      protocol_version: 2.0.0
      scrapers:
        - brokers
        - topics
        - consumers
      # Exclude internal Kafka topics (prefixed with __) at the source
      topic_match: "^[^_].*$"
      metrics:
        kafka.topic.min_insync_replicas:
          enabled: true
        kafka.topic.replication_factor:
          enabled: true
        kafka.partition.replicas:
          enabled: false
        kafka.partition.oldest_offset:
          enabled: false
        kafka.partition.current_offset:
          enabled: false

    prometheus/kafka-jmx:
      config:
        scrape_configs:
          - job_name: 'kafka-jmx-metrics'
            scrape_interval: 30s
            kubernetes_sd_configs:
              - role: pod
                namespaces:
                  names:
                    # TODO#2: Replace with the namespace where your Kafka cluster is deployed
                    - newrelic
            relabel_configs:
              # Filter for Kafka broker pods
              - source_labels: [__meta_kubernetes_pod_label_strimzi_io_name]
                action: keep
                # TODO#3: Replace with your Strimzi Kafka cluster name followed by '-kafka'
                regex: my-cluster-kafka

              - source_labels: [__meta_kubernetes_pod_label_strimzi_io_cluster]
                action: keep
                # TODO#4: Replace with your Strimzi Kafka cluster name
                regex: my-cluster

              # Extract broker ID from pod name
              - source_labels: [__meta_kubernetes_pod_name]
                target_label: broker.id
                regex: '.*-(\\d+)$'
                replacement: '$1'

              # Set scrape target to pod IP on port 9404
              - source_labels: [__meta_kubernetes_pod_ip]
                target_label: __address__
                replacement: '$1:9404'

  exporters:
    # New Relic OTLP exporter
    otlp/backend:
      endpoint: ${NEW_RELIC_OTLP_ENDPOINT}
      tls:
        insecure: false
      sending_queue:
        num_consumers: 12
        queue_size: 5000
      retry_on_failure:
        enabled: true
      headers:
        api-key: ${NEW_RELIC_LICENSE_KEY}

  processors:
    # Batch processor for efficient export
    batch/export:
      send_batch_size: 1024
      timeout: 30s

    # Memory limiter to prevent OOM
    memory_limiter:
      limit_percentage: 80
      spike_limit_percentage: 30
      check_interval: 1s

    # Transform metric naming conventions
    transform/metric-naming:
      metric_statements:
        - context: metric
          statements:
            - replace_pattern(name, "_", ".")
            - replace_pattern(name, "\\.load\\.1", ".load_1")
            - replace_pattern(name, "\\.recent\\.util", ".recent_util")
            - replace_pattern(name, "file\\.descriptor\\.count", "file_descriptor.count")
            - replace_pattern(name, "\\.memory\\.pool\\.used\\.bytes$", ".memory.pool.used")
            - replace_pattern(name, "\\.memory\\.pool\\.max\\.bytes$", ".memory.pool.max")
            - replace_pattern(name, "\\.memory\\.pool\\.collection\\.used\\.bytes$", ".memory.pool.used_after_last_gc")
            - replace_pattern(name, "\\.non\\.preferred\\.leader", ".non_preferred_leader")
            - replace_pattern(name, "\\.under\\.min\\.isr", ".under_min_isr")
            - replace_pattern(name, "\\.under\\.replicated", ".under_replicated")
            - replace_pattern(name, "\\.total$", "") where name != "kafka.request.time.total"
        - context: datapoint
          statements:
            - set(attributes["name"], attributes["gc"]) where attributes["gc"] != nil
            - delete_key(attributes, "gc") where attributes["gc"] != nil
            - set(attributes["name"], attributes["pool"]) where attributes["pool"] != nil
            - delete_key(attributes, "pool") where attributes["pool"] != nil

    # Add cluster name to all metrics
    resource/cluster-name:
      attributes:
        - key: kafka.cluster.name
          # TODO#5: Replace with your Kafka cluster name (used to identify and filter metrics in New Relic)
          value: my-cluster
          action: upsert

    # Remove broker.id for cluster-level metrics
    transform/remove_broker_id:
      metric_statements:
        - context: datapoint
          statements:
            - delete_key(attributes, "broker.id")

    # Filter out scrape overhead metrics
    filter/scrape-overhead:
      metrics:
        exclude:
          match_type: regexp
          metric_names:
            - "^jmx_.*"
            - "^process_.*"
            - "^jvm_buffer_pool_.*"
            - "^jvm_threads_.*"
            - "^jvm_classes_.*"
            - "^jvm_memory_(heap|non_heap)_(committed|init|max|used)_bytes$"
            - "^jvm_compilation_.*"
            - "^jvm_(runtime|info).*"
            - "^jvm_memory_pool_(allocated_bytes_total|committed_bytes|init_bytes|collection_(committed|init|max)_bytes)$"

    # Include only cluster-level metrics for cluster pipeline
    filter/include_cluster_metrics:
      metrics:
        include:
          match_type: regexp
          metric_names:
            - "^kafka\\.partition\\.offline$"
            - "^kafka\\.(leader|unclean)\\.election\\.rate$"
            - "^kafka\\.partition\\.non_preferred_leader$"
            - "^kafka\\.broker\\.fenced\\.count$"
            - "^kafka\\.cluster\\.partition\\.count$"
            - "^kafka\\.cluster\\.topic\\.count$"

    # Exclude cluster-level metrics from broker pipeline
    filter/exclude_cluster_metrics:
      metrics:
        exclude:
          match_type: regexp
          metric_names:
            - "^kafka\\.partition\\.offline$"
            - "^kafka\\.(leader|unclean)\\.election\\.rate$"
            - "^kafka\\.partition\\.non_preferred_leader$"
            - "^kafka\\.broker\\.fenced\\.count$"
            - "^kafka\\.cluster\\.partition\\.count$"
            - "^kafka\\.cluster\\.topic\\.count$"

    # Remove unnecessary attributes
    transform/remove_attributes:
      metric_statements:
        - context: metric
          statements:
            - set(description, "") where description != ""
            - set(unit, "") where unit != ""
        - context: resource
          statements:
            - delete_key(attributes, "server.address")
            - delete_key(attributes, "server.port")
            - delete_key(attributes, "service.instance.id")
            - delete_key(attributes, "host.name")
            - delete_key(attributes, "k8s.pod.uid")
            - delete_key(attributes, "url.scheme")

    # Aggregate partition metrics to topic level
    metricstransform/topic-aggregation:
      transforms:
        - include: kafka.partition.replicas_in_sync
          action: insert
          new_name: kafka.partition.replicas_in_sync.total
          operations:
            - action: aggregate_labels
              label_set: [topic]
              aggregation_type: sum
        - include: kafka.partition.replicas
          action: insert
          new_name: kafka.partition.replicas.total
          operations:
            - action: aggregate_labels
              label_set: [topic]
              aggregation_type: sum

    # Filter out original partition replicas metric
    filter/exclude_partition_replicas_metric:
      metrics:
        exclude:
          match_type: strict
          metric_names:
            - kafka.partition.replicas_in_sync

    # Filter internal Kafka topics as a safety net (topic_match handles the receiver side)
    filter/internal_topics:
      metrics:
        datapoint:
          - 'attributes["topic"] != nil and IsMatch(attributes["topic"], "^__.*")'

    # Convert cumulative to delta metrics
    cumulativetodelta:

    groupbyattrs/cluster:
      keys: [kafka.cluster.name]

    metricstransform/cluster_max:
      transforms:
        - include: "kafka\\.partition\\.offline|kafka\\.leader\\.election\\.rate|kafka\\.unclean\\.election\\.rate|kafka\\.partition\\.non_preferred_leader|kafka\\.broker\\.fenced\\.count|kafka\\.cluster\\.partition\\.count|kafka\\.cluster\\.topic\\.count"
          match_type: regexp
          action: update
          operations:
            - action: aggregate_labels
              aggregation_type: max
              label_set: []

  service:
    pipelines:
      # Suppress default pipelines — only custom Kafka metrics pipelines are used
      traces: null
      logs: null
      metrics: null

      # Broker-level metrics from Prometheus JMX scraping
      metrics/broker:
        receivers:
          - prometheus/kafka-jmx
        processors:
          - resource/cluster-name
          - filter/scrape-overhead
          - transform/metric-naming
          - transform/remove_attributes
          - filter/exclude_cluster_metrics
          - memory_limiter
          - cumulativetodelta
          - batch/export
        exporters:
          - otlp/backend

      # Cluster-level metrics from Prometheus JMX scraping
      metrics/cluster/prometheus:
        receivers:
          - prometheus/kafka-jmx
        processors:
          - resource/cluster-name
          - filter/scrape-overhead
          - transform/metric-naming
          - transform/remove_attributes
          - filter/include_cluster_metrics
          - transform/remove_broker_id
          - memory_limiter
          - cumulativetodelta
          - groupbyattrs/cluster
          - metricstransform/cluster_max
          - batch/export
        exporters:
          - otlp/backend

      # Cluster-level metrics from Kafka metrics receiver
      metrics/cluster/kafkametrics:
        receivers:
          - kafkametrics/cluster
        processors:
          - resource/cluster-name
          - filter/internal_topics
          - transform/remove_attributes
          - metricstransform/topic-aggregation
          - filter/exclude_partition_replicas_metric
          - memory_limiter
          - cumulativetodelta
          - batch/export
        exporters:
          - otlp/backend

구성 매개변수

다음 표에서는 주요 설정 시위에 대해 설명합니다.

매개변수	설명
`config.receivers.kafkametrics/cluster.brokers`	사용자의 Kafka 부트스트랩 서비스로 교체하십시오.
`config.receivers.prometheus/kafka-jmx.config.scrape_configs[0].kubernetes_sd_configs[0].namespaces.names`	Kafka 클러스터가 배포된 네임스페이스로 교체하십시오.
`config.receivers.prometheus/kafka-jmx.config.scrape_configs[0].relabel_configs[strimzi_io_name].regex`	Strimzi Kafka 클러스터 이름으로 교체한 후 그 뒤에 `-kafka`
`config.receivers.prometheus/kafka-jmx.config.scrape_configs[0].relabel_configs[strimzi_io_cluster].regex`	사용자의 Strimzi Kafka 클러스터 이름으로 바꾸십시오.
`config.processors.resource/cluster-name.attributes[kafka.cluster.name].value`	Kafka 클러스터 이름으로 바꿉니다(이는 뉴렐릭에서 메트릭을 식별하고 필터링하는 데 사용됩니다)
`resources.limits` 그리고 `resources.requests`	워크로드 요구 사항에 따라 조정하십시오.

유연성을 극대화하고 공급업체 비종속 구현, 배포를 위해 커뮤니티 OpenTelemetry Collector 사용하세요.

다음 내용으로 values.yaml 생성하세요:

# Deployment mode
mode: deployment
replicaCount: 1

# Use contrib image for kafkametrics receiver
image:
  repository: otel/opentelemetry-collector-contrib
  tag: "latest"
  pullPolicy: Always

# Service account configuration
serviceAccount:
  create: true
  name: otel-collector

# RBAC for Kubernetes service discovery
clusterRole:
  create: true
  rules:
    - apiGroups: [""]
      resources: ["pods", "nodes"]
      verbs: ["get", "list", "watch"]

# Pod security context
podSecurityContext:
  runAsNonRoot: true
  runAsUser: 10001

# Container security context
securityContext:
  allowPrivilegeEscalation: false
  readOnlyRootFilesystem: true
  capabilities:
    drop:
      - ALL

# Resource limits
resources:
  requests:
    memory: 512Mi
    cpu: 250m
  limits:
    memory: 1Gi
    cpu: 500m

# Load environment variables from secret
extraEnvsFrom:
  - secretRef:
      name: newrelic-otlp-secret

# OpenTelemetry Collector Configuration
config:
  receivers:
    # Kafka metrics receiver for cluster-level metrics
    kafkametrics/cluster:
      brokers:
        # TODO#1: Replace with your Kafka bootstrap service
        - "my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9092"
      collection_interval: 30s
      protocol_version: 2.0.0
      scrapers:
        - brokers
        - topics
        - consumers
      # Exclude internal Kafka topics (prefixed with __) at the source
      topic_match: "^[^_].*$"
      metrics:
        kafka.topic.min_insync_replicas:
          enabled: true
        kafka.topic.replication_factor:
          enabled: true
        kafka.partition.replicas:
          enabled: false
        kafka.partition.oldest_offset:
          enabled: false
        kafka.partition.current_offset:
          enabled: false

    # Prometheus receiver for JMX metrics from Kafka brokers
    prometheus/kafka-jmx:
      config:
        scrape_configs:
          - job_name: 'kafka-jmx-metrics'
            scrape_interval: 30s
            kubernetes_sd_configs:
              - role: pod
                namespaces:
                  names:
                    # TODO#2: Replace with the namespace where your Kafka cluster is deployed
                    - newrelic
            relabel_configs:
              # Filter for Kafka broker pods
              - source_labels: [__meta_kubernetes_pod_label_strimzi_io_name]
                action: keep
                # TODO#3: Replace with your Strimzi Kafka cluster name followed by '-kafka'
                regex: my-cluster-kafka

              - source_labels: [__meta_kubernetes_pod_label_strimzi_io_cluster]
                action: keep
                # TODO#4: Replace with your Strimzi Kafka cluster name
                regex: my-cluster

              # Extract broker ID from pod name
              - source_labels: [__meta_kubernetes_pod_name]
                target_label: broker.id
                regex: '.*-(\\d+)$'
                replacement: '$1'

              # Set scrape target to pod IP on port 9404
              - source_labels: [__meta_kubernetes_pod_ip]
                target_label: __address__
                replacement: '$1:9404'

  exporters:
    # New Relic OTLP exporter
    otlp/backend:
      endpoint: ${NEW_RELIC_OTLP_ENDPOINT}
      tls:
        insecure: false
      sending_queue:
        num_consumers: 12
        queue_size: 5000
      retry_on_failure:
        enabled: true
      headers:
        api-key: ${NEW_RELIC_LICENSE_KEY}

  processors:
    # Batch processor for efficient export
    batch/export:
      send_batch_size: 1024
      timeout: 30s

    # Memory limiter to prevent OOM
    memory_limiter:
      limit_percentage: 80
      spike_limit_percentage: 30
      check_interval: 1s

    # Transform metric naming conventions
    transform/metric-naming:
      metric_statements:
        - context: metric
          statements:
            - replace_pattern(name, "_", ".")
            - replace_pattern(name, "\\.load\\.1", ".load_1")
            - replace_pattern(name, "\\.recent\\.util", ".recent_util")
            - replace_pattern(name, "file\\.descriptor\\.count", "file_descriptor.count")
            - replace_pattern(name, "\\.memory\\.pool\\.used\\.bytes$", ".memory.pool.used")
            - replace_pattern(name, "\\.memory\\.pool\\.max\\.bytes$", ".memory.pool.max")
            - replace_pattern(name, "\\.memory\\.pool\\.collection\\.used\\.bytes$", ".memory.pool.used_after_last_gc")
            - replace_pattern(name, "\\.non\\.preferred\\.leader", ".non_preferred_leader")
            - replace_pattern(name, "\\.under\\.min\\.isr", ".under_min_isr")
            - replace_pattern(name, "\\.under\\.replicated", ".under_replicated")
            - replace_pattern(name, "\\.total$", "") where name != "kafka.request.time.total"
        - context: datapoint
          statements:
            - set(attributes["name"], attributes["gc"]) where attributes["gc"] != nil
            - delete_key(attributes, "gc") where attributes["gc"] != nil
            - set(attributes["name"], attributes["pool"]) where attributes["pool"] != nil
            - delete_key(attributes, "pool") where attributes["pool"] != nil

    # Add cluster name to all metrics
    resource/cluster-name:
      attributes:
        - key: kafka.cluster.name
          # TODO#5: Replace with your Kafka cluster name (used to identify and filter metrics in New Relic)
          value: my-cluster
          action: upsert

    # Remove broker.id for cluster-level metrics
    transform/remove_broker_id:
      metric_statements:
        - context: datapoint
          statements:
            - delete_key(attributes, "broker.id")

    # Filter out scrape overhead metrics
    filter/scrape-overhead:
      metrics:
        exclude:
          match_type: regexp
          metric_names:
            - "^jmx_.*"
            - "^process_.*"
            - "^jvm_buffer_pool_.*"
            - "^jvm_threads_.*"
            - "^jvm_classes_.*"
            - "^jvm_memory_(heap|non_heap)_(committed|init|max|used)_bytes$"
            - "^jvm_compilation_.*"
            - "^jvm_(runtime|info).*"
            - "^jvm_memory_pool_(allocated_bytes_total|committed_bytes|init_bytes|collection_(committed|init|max)_bytes)$"

    # Include only cluster-level metrics for cluster pipeline
    filter/include_cluster_metrics:
      metrics:
        include:
          match_type: regexp
          metric_names:
            - "^kafka\\.partition\\.offline$"
            - "^kafka\\.(leader|unclean)\\.election\\.rate$"
            - "^kafka\\.partition\\.non_preferred_leader$"
            - "^kafka\\.broker\\.fenced\\.count$"
            - "^kafka\\.cluster\\.partition\\.count$"
            - "^kafka\\.cluster\\.topic\\.count$"

    # Exclude cluster-level metrics from broker pipeline
    filter/exclude_cluster_metrics:
      metrics:
        exclude:
          match_type: regexp
          metric_names:
            - "^kafka\\.partition\\.offline$"
            - "^kafka\\.(leader|unclean)\\.election\\.rate$"
            - "^kafka\\.partition\\.non_preferred_leader$"
            - "^kafka\\.broker\\.fenced\\.count$"
            - "^kafka\\.cluster\\.partition\\.count$"
            - "^kafka\\.cluster\\.topic\\.count$"

    # Remove unnecessary attributes
    transform/remove_attributes:
      metric_statements:
        - context: metric
          statements:
            - set(description, "") where description != ""
            - set(unit, "") where unit != ""
        - context: resource
          statements:
            - delete_key(attributes, "server.address")
            - delete_key(attributes, "server.port")
            - delete_key(attributes, "service.instance.id")
            - delete_key(attributes, "host.name")
            - delete_key(attributes, "k8s.pod.uid")
            - delete_key(attributes, "url.scheme")

    # Aggregate partition metrics to topic level
    metricstransform/topic-aggregation:
      transforms:
        - include: kafka.partition.replicas_in_sync
          action: insert
          new_name: kafka.partition.replicas_in_sync.total
          operations:
            - action: aggregate_labels
              label_set: [topic]
              aggregation_type: sum
        - include: kafka.partition.replicas
          action: insert
          new_name: kafka.partition.replicas.total
          operations:
            - action: aggregate_labels
              label_set: [topic]
              aggregation_type: sum

    # Filter out original partition replicas metric
    filter/exclude_partition_replicas_metric:
      metrics:
        exclude:
          match_type: strict
          metric_names:
            - kafka.partition.replicas_in_sync

    # Filter internal Kafka topics as a safety net (topic_match handles the receiver side)
    filter/internal_topics:
      metrics:
        datapoint:
          - 'attributes["topic"] != nil and IsMatch(attributes["topic"], "^__.*")'

    # Convert cumulative to delta metrics
    cumulativetodelta:

    groupbyattrs/cluster:
      keys: [kafka.cluster.name]

    metricstransform/cluster_max:
      transforms:
        - include: "kafka\\.partition\\.offline|kafka\\.leader\\.election\\.rate|kafka\\.unclean\\.election\\.rate|kafka\\.partition\\.non_preferred_leader|kafka\\.broker\\.fenced\\.count|kafka\\.cluster\\.partition\\.count|kafka\\.cluster\\.topic\\.count"
          match_type: regexp
          action: update
          operations:
            - action: aggregate_labels
              aggregation_type: max
              label_set: []

  service:
    pipelines:
      # Override default pipelines to only use custom Kafka metrics pipelines
      traces: null
      logs: null
      metrics: null

      # Broker-level metrics from Prometheus JMX scraping
      metrics/broker:
        receivers:
          - prometheus/kafka-jmx
        processors:
          - resource/cluster-name
          - filter/scrape-overhead
          - transform/metric-naming
          - transform/remove_attributes
          - filter/exclude_cluster_metrics
          - memory_limiter
          - cumulativetodelta
          - batch/export
        exporters:
          - otlp/backend

      # Cluster-level metrics from Prometheus JMX scraping
      metrics/cluster/prometheus:
        receivers:
          - prometheus/kafka-jmx
        processors:
          - resource/cluster-name
          - filter/scrape-overhead
          - transform/metric-naming
          - transform/remove_attributes
          - filter/include_cluster_metrics
          - transform/remove_broker_id
          - memory_limiter
          - cumulativetodelta
          - groupbyattrs/cluster
          - metricstransform/cluster_max
          - batch/export
        exporters:
          - otlp/backend

      # Cluster-level metrics from Kafka metrics receiver
      metrics/cluster/kafkametrics:
        receivers:
          - kafkametrics/cluster
        processors:
          - resource/cluster-name
          - filter/internal_topics
          - transform/remove_attributes
          - metricstransform/topic-aggregation
          - filter/exclude_partition_replicas_metric
          - memory_limiter
          - cumulativetodelta
          - batch/export
        exporters:
          - otlp/backend

설정 파라미터: 위의 NRDOT 옵션과 동일한 파라미터입니다. 리소스 제한을 포함한 자세한 내용은 설정 파라미터 표를 참조하십시오.

고급 설정 옵션에 대해서는 다음 수신기 설명서 페이지를 참조하십시오.

Prometheus 수신기 문서 - 추가 수신기 설정 옵션

Kafka 지표 수신기 문서 - 추가 Kafka 지표 설정

3단계. Helm으로 OpenTelemetry Collector 설치

Helm 저장소를 추가하고 values.yaml 파일을 사용하여 OpenTelemetry Collector를 설치하세요.

bash

$helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
$helm upgrade kafka-monitoring open-telemetry/opentelemetry-collector \
>  --install \
>  --namespace newrelic \
>  --create-namespace \
>  -f values.yaml

4단계. 배포 확인:

bash

$# Check pod status
$kubectl get pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$
$# View logs to verify metrics collection
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector --tail=50

포트 9404의 Kafka 브로커에서 스크래핑이 성공적으로 완료되었음을 나타내는 로그를 확인할 수 있습니다.

매니페스트 설치 방식은 Helm을 사용하지 않고도 Kubernetes 리소스를 직접 제어할 수 있도록 해줍니다.

1단계. 뉴렐릭 자격 증명 시크릿 생성

뉴렐릭 클러스터 키 및 OTLP 엔드포인트가 포함된 Kubernetes 시크릿을 생성하세요. 귀하의 뉴렐릭 지역에 맞는 포인트를 선택하세요:

bash

$kubectl create secret generic newrelic-otlp-secret \
>  --namespace newrelic \
>  --from-literal=NEW_RELIC_LICENSE_KEY='your-license-key-here' \
>  --from-literal=NEW_RELIC_OTLP_ENDPOINT='https://otlp.nr-data.net:4317'

bash

$kubectl create secret generic newrelic-otlp-secret \
>  --namespace newrelic \
>  --from-literal=NEW_RELIC_LICENSE_KEY='your-license-key-here' \
>  --from-literal=NEW_RELIC_OTLP_ENDPOINT='https://otlp.eu01.nr-data.net:4317'

팁

다른 엔드포인트 설정에 대해서는 OTLP 엔드포인트 구성을 참조하세요.

2단계. 매니페스트 파일 생성

원하는 수집기를 위한 Kubernetes 매니페스트 파일을 생성하세요. 두 수집기 모두 동일한 설정을 사용하며 이미지만 다릅니다.

수집기 옵션을 선택하고 필요한 파일 세 개를 생성하세요.

1단계. collector-rbac.yaml생성 - Kubernetes API 접근을 위한 RBAC 설정:

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: otel-collector
  namespace: newrelic
  labels:
    app: otel-collector
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: otel-collector
  labels:
    app: otel-collector
rules:
- apiGroups: [""]
  resources: ["pods", "nodes"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: otel-collector
  labels:
    app: otel-collector
subjects:
- kind: ServiceAccount
  name: otel-collector
  namespace: newrelic
roleRef:
  kind: ClusterRole
  name: otel-collector
  apiGroup: rbac.authorization.k8s.io

2단계. collector-configmap.yaml생성 - OpenTelemetry Collector 설정:

---
apiVersion: v1
kind: ConfigMap
metadata:
name: otel-collector-config
namespace: newrelic
labels:
app: otel-collector
data:
otel-collector-config.yaml: |
receivers:
  kafkametrics/cluster:
    brokers:
      # TODO#1: Replace with your Kafka bootstrap service
      - "my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9092"
    collection_interval: 30s
    protocol_version: 2.0.0
    scrapers:
      - brokers
      - topics
      - consumers
    # Exclude internal Kafka topics (prefixed with __) at the source
    topic_match: "^[^_].*$"
    metrics:
      kafka.topic.min_insync_replicas:
        enabled: true
      kafka.topic.replication_factor:
        enabled: true
      kafka.partition.replicas:
        enabled: false
      kafka.partition.oldest_offset:
        enabled: false
      kafka.partition.current_offset:
        enabled: false

  prometheus/kafka-jmx:
    config:
      scrape_configs:
        - job_name: 'kafka-jmx-metrics'
          scrape_interval: 30s
          kubernetes_sd_configs:
            - role: pod
              namespaces:
                names:
                  # TODO#2: Replace with the namespace where your Kafka cluster is deployed
                  - kafka
          relabel_configs:
            - source_labels: [__meta_kubernetes_pod_label_strimzi_io_name]
              action: keep
              # TODO#3: Replace with your Strimzi Kafka cluster name followed by '-kafka'
              regex: my-cluster-kafka
            - source_labels: [__meta_kubernetes_pod_label_strimzi_io_cluster]
              action: keep
              # TODO#4: Replace with your Strimzi Kafka cluster name
              regex: my-cluster
            - source_labels: [__meta_kubernetes_pod_name]
              target_label: broker.id
              regex: '.*-(\\d+)$'
              replacement: '$1'
            - source_labels: [__meta_kubernetes_pod_ip]
              target_label: __address__
              replacement: '$1:9404'

exporters:
  otlp/backend:
    endpoint: ${NEW_RELIC_OTLP_ENDPOINT}
    tls:
      insecure: false
    sending_queue:
      num_consumers: 12
      queue_size: 5000
    retry_on_failure:
      enabled: true
    headers:
      api-key: ${NEW_RELIC_LICENSE_KEY}

processors:
  batch/export:
    send_batch_size: 1024
    timeout: 30s
  memory_limiter:
    limit_percentage: 80
    spike_limit_percentage: 30
    check_interval: 1s
  transform/metric-naming:
    metric_statements:
    - context: metric
      statements:
      - replace_pattern(name, "_", ".")
      - replace_pattern(name, "\\.load\\.1", ".load_1")
      - replace_pattern(name, "\\.recent\\.util", ".recent_util")
      - replace_pattern(name, "file\\.descriptor\\.count", "file_descriptor.count")
      - replace_pattern(name, "\\.memory\\.pool\\.used\\.bytes$", ".memory.pool.used")
      - replace_pattern(name, "\\.memory\\.pool\\.max\\.bytes$", ".memory.pool.max")
      - replace_pattern(name, "\\.memory\\.pool\\.collection\\.used\\.bytes$", ".memory.pool.used_after_last_gc")
      - replace_pattern(name, "\\.non\\.preferred\\.leader", ".non_preferred_leader")
      - replace_pattern(name, "\\.under\\.min\\.isr", ".under_min_isr")
      - replace_pattern(name, "\\.under\\.replicated", ".under_replicated")
      - replace_pattern(name, "\\.total$", "") where name != "kafka.request.time.total"
    - context: datapoint
      statements:
      - set(attributes["name"], attributes["gc"]) where attributes["gc"] != nil
      - delete_key(attributes, "gc") where attributes["gc"] != nil
      - set(attributes["name"], attributes["pool"]) where attributes["pool"] != nil
      - delete_key(attributes, "pool") where attributes["pool"] != nil
  resource/cluster-name:
    attributes:
    - key: kafka.cluster.name
      # TODO#5: Replace with your Kafka cluster name (used to identify and filter metrics in New Relic)
      value: my-cluster
      action: upsert
  transform/remove_broker_id:
    metric_statements:
    - context: datapoint
      statements:
      - delete_key(attributes, "broker.id")
  filter/scrape-overhead:
    metrics:
      exclude:
        match_type: regexp
        metric_names:
        - "^jmx_.*"
        - "^process_.*"
        - "^jvm_buffer_pool_.*"
        - "^jvm_threads_.*"
        - "^jvm_classes_.*"
        - "^jvm_memory_(heap|non_heap)_(committed|init|max|used)_bytes$"
        - "^jvm_compilation_.*"
        - "^jvm_(runtime|info).*"
        - "^jvm_memory_pool_(allocated_bytes_total|committed_bytes|init_bytes|collection_(committed|init|max)_bytes)$"
  filter/include_cluster_metrics:
    metrics:
      include:
        match_type: regexp
        metric_names:
        - "^kafka\\.partition\\.offline$"
        - "^kafka\\.(leader|unclean)\\.election\\.rate$"
        - "^kafka\\.partition\\.non_preferred_leader$"
        - "^kafka\\.broker\\.fenced\\.count$"
        - "^kafka\\.cluster\\.partition\\.count$"
        - "^kafka\\.cluster\\.topic\\.count$"
  filter/exclude_cluster_metrics:
    metrics:
      exclude:
        match_type: regexp
        metric_names:
        - "^kafka\\.partition\\.offline$"
        - "^kafka\\.(leader|unclean)\\.election\\.rate$"
        - "^kafka\\.partition\\.non_preferred_leader$"
        - "^kafka\\.broker\\.fenced\\.count$"
        - "^kafka\\.cluster\\.partition\\.count$"
        - "^kafka\\.cluster\\.topic\\.count$"
  transform/remove_attributes:
    metric_statements:
    - context: metric
      statements:
      - set(description, "") where description != ""
      - set(unit, "") where unit != ""
    - context: resource
      statements:
      - delete_key(attributes, "server.address")
      - delete_key(attributes, "server.port")
      - delete_key(attributes, "service.instance.id")
      - delete_key(attributes, "host.name")
      - delete_key(attributes, "k8s.pod.uid")
      - delete_key(attributes, "url.scheme")
  metricstransform/topic-aggregation:
    transforms:
    - include: kafka.partition.replicas_in_sync
      action: insert
      new_name: kafka.partition.replicas_in_sync.total
      operations:
      - action: aggregate_labels
        label_set: [topic]
        aggregation_type: sum
    - include: kafka.partition.replicas
      action: insert
      new_name: kafka.partition.replicas.total
      operations:
      - action: aggregate_labels
        label_set: [topic]
        aggregation_type: sum
  filter/exclude_partition_replicas_metric:
    metrics:
      exclude:
        match_type: strict
        metric_names:
        - kafka.partition.replicas_in_sync
  # Filter internal Kafka topics as a safety net (topic_match handles the receiver side)
  filter/internal_topics:
    metrics:
      datapoint:
        - 'attributes["topic"] != nil and IsMatch(attributes["topic"], "^__.*")'
  cumulativetodelta:

  groupbyattrs/cluster:
    keys: [kafka.cluster.name]

  metricstransform/cluster_max:
    transforms:
      - include: "kafka\\.partition\\.offline|kafka\\.leader\\.election\\.rate|kafka\\.unclean\\.election\\.rate|kafka\\.partition\\.non_preferred_leader|kafka\\.broker\\.fenced\\.count|kafka\\.cluster\\.partition\\.count|kafka\\.cluster\\.topic\\.count"
        match_type: regexp
        action: update
        operations:
          - action: aggregate_labels
            aggregation_type: max
            label_set: []

service:
  pipelines:
    metrics/broker:
      receivers: [prometheus/kafka-jmx]
      processors:
        - resource/cluster-name
        - filter/scrape-overhead
        - transform/metric-naming
        - transform/remove_attributes
        - filter/exclude_cluster_metrics
        - memory_limiter
        - cumulativetodelta
        - batch/export
      exporters: [otlp/backend]
    metrics/cluster/prometheus:
      receivers: [prometheus/kafka-jmx]
      processors:
        - resource/cluster-name
        - filter/scrape-overhead
        - transform/metric-naming
        - transform/remove_attributes
        - filter/include_cluster_metrics
        - transform/remove_broker_id
        - memory_limiter
        - cumulativetodelta
        - groupbyattrs/cluster
        - metricstransform/cluster_max
        - batch/export
      exporters: [otlp/backend]
    metrics/cluster/kafkametrics:
      receivers: [kafkametrics/cluster]
      processors:
        - resource/cluster-name
        - filter/internal_topics
        - transform/remove_attributes
        - metricstransform/topic-aggregation
        - filter/exclude_partition_replicas_metric
        - memory_limiter
        - cumulativetodelta
        - batch/export
      exporters: [otlp/backend]

3단계. collector-deployment.yaml생성 - OpenTelemetry Collector 배포:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: otel-collector
  namespace: newrelic
  labels:
    app: otel-collector
spec:
  replicas: 1
  selector:
    matchLabels:
      app: otel-collector
  template:
    metadata:
      labels:
        app: otel-collector
    spec:
      serviceAccountName: otel-collector
      containers:
      - name: otel-collector
        image: newrelic/nrdot-collector:latest
        command:
        - "/nrdot-collector"
        - "--config=/conf/otel-collector-config.yaml"
        env:
        - name: NEW_RELIC_LICENSE_KEY
          valueFrom:
            secretKeyRef:
              name: newrelic-otlp-secret
              key: NEW_RELIC_LICENSE_KEY
        - name: NEW_RELIC_OTLP_ENDPOINT
          valueFrom:
            secretKeyRef:
              name: newrelic-otlp-secret
              key: NEW_RELIC_OTLP_ENDPOINT
        - name: GOGC
          value: "80"
        resources:
          limits:
            cpu: "1000m"
            memory: "1Gi"
          requests:
            cpu: "200m"
            memory: "512Mi"
        volumeMounts:
        - name: config
          mountPath: /conf
      volumes:
      - name: config
        configMap:
          name: otel-collector-config
          items:
          - key: otel-collector-config.yaml
            path: otel-collector-config.yaml

구성 매개변수

다음 표에서는 주요 설정 시위에 대해 설명합니다.

매개변수	설명
`receivers.kafkametrics/cluster.brokers`	사용자의 Kafka 부트스트랩 서비스로 교체하십시오.
`receivers.prometheus/kafka-jmx.config.scrape_configs[0].kubernetes_sd_configs[0].namespaces.names`	Kafka 클러스터가 배포된 네임스페이스로 교체하십시오.
`receivers.prometheus/kafka-jmx.config.scrape_configs[0].relabel_configs[strimzi_io_name].regex`	Strimzi Kafka 클러스터 이름으로 교체한 후 그 뒤에 `-kafka`
`receivers.prometheus/kafka-jmx.config.scrape_configs[0].relabel_configs[strimzi_io_cluster].regex`	사용자의 Strimzi Kafka 클러스터 이름으로 바꾸십시오.
`processors.resource/cluster-name.attributes[kafka.cluster.name].value`	Kafka 클러스터 이름으로 바꿉니다(이는 뉴렐릭에서 메트릭을 식별하고 필터링하는 데 사용됩니다)

공급업체 비종속 구현, 배포를 위해 커뮤니티 OpenTelemetry Collector 사용하세요.

1단계. collector-rbac.yaml생성 - 위의 NRDOT 옵션과 동일합니다(RBAC 설정은 동일합니다).

2단계. collector-configmap.yaml생성 - 위의 NRDOT 옵션과 동일합니다(설정은 동일합니다).

3단계. collector-deployment.yaml생성 - OpenTelemetry Collector 배포(이미지만 다름):

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: otel-collector
  namespace: newrelic
  labels:
    app: otel-collector
spec:
  replicas: 1
  selector:
    matchLabels:
      app: otel-collector
  template:
    metadata:
      labels:
        app: otel-collector
    spec:
      serviceAccountName: otel-collector
      containers:
      - name: otel-collector
        image: otel/opentelemetry-collector-contrib:latest
        command:
        - "/otelcol-contrib"
        - "--config=/conf/otel-collector-config.yaml"
        env:
        - name: NEW_RELIC_LICENSE_KEY
          valueFrom:
            secretKeyRef:
              name: newrelic-otlp-secret
              key: NEW_RELIC_LICENSE_KEY
        - name: NEW_RELIC_OTLP_ENDPOINT
          valueFrom:
            secretKeyRef:
              name: newrelic-otlp-secret
              key: NEW_RELIC_OTLP_ENDPOINT
        - name: GOGC
          value: "80"
        resources:
          limits:
            cpu: "1000m"
            memory: "1Gi"
          requests:
            cpu: "200m"
            memory: "512Mi"
        volumeMounts:
        - name: config
          mountPath: /conf
      volumes:
      - name: config
        configMap:
          name: otel-collector-config
          items:
          - key: otel-collector-config.yaml
            path: otel-collector-config.yaml

설정 파라미터: 위의 NRDOT 옵션과 동일한 파라미터입니다. 자세한 내용은 설정 파라미터 테이블을 참조하세요.

고급 설정 옵션에 대해서는 다음 수신기 설명서 페이지를 참조하십시오.

Prometheus 수신기 문서 - 추가 수신기 설정 옵션

Kafka 지표 수신기 문서 - 추가 Kafka 지표 설정

3단계. 매니페스트 배포

Kubernetes 매니페스트를 구현에 적용하고 OpenTelemetry Collector 배포합니다.

bash

$# Create namespace if it doesn't exist
$kubectl create namespace newrelic --dry-run=client -o yaml | kubectl apply -f -
$
$# Apply RBAC configuration
$kubectl apply -f collector-rbac.yaml
$
$# Apply ConfigMap
$kubectl apply -f collector-configmap.yaml
$
$# Apply Deployment
$kubectl apply -f collector-deployment.yaml

4단계. 배포 확인:

bash

$# Check pod status
$kubectl get pods -n newrelic -l app=otel-collector
$
$# View logs to verify metrics collection
$kubectl logs -n newrelic -l app=otel-collector --tail=50

포트 9404의 Kafka 브로커에서 스크래핑이 성공적으로 완료되었음을 나타내는 로그를 확인할 수 있습니다.

(선택사항) 제작자 또는 소비자를 위해

중요

언어 지원: 자바 애플리케이션은 OpenTelemetry 자바 에이전트를 사용하여 기본적으로 Kafka 클라이언트 계측을 지원합니다.

Kafka 프로듀서 및 소비자 애플리케이션에서 애플리케이션 수준 텔레메트리를 수집하려면 OpenTelemetry 자바 에이전트를 사용하십시오.

당신의 Kafka를 편집하세요

init 컨테이너를 사용하여 런타임에 OpenTelemetry 자바 에이전트를 다운로드하세요:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kafka-producer-app
spec:
  template:
    spec:
      initContainers:
      - name: download-java-agent
        image: busybox:latest
        command:
        - sh
        - -c
        - |
          wget -O /otel-auto-instrumentation/opentelemetry-javaagent.jar \
          https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
        volumeMounts:
        - name: otel-auto-instrumentation
          mountPath: /otel-auto-instrumentation

      containers:
      - name: app
        image: your-kafka-app:latest
        env:
        - name: JAVA_TOOL_OPTIONS
          value: >-
            -javaagent:/otel-auto-instrumentation/opentelemetry-javaagent.jar
            -Dotel.service.name=order-process-service
            -Dotel.resource.attributes=kafka.cluster.name=my-cluster
            -Dotel.exporter.otlp.endpoint=http://localhost:4317
            -Dotel.exporter.otlp.protocol=grpc
            -Dotel.metrics.exporter=otlp
            -Dotel.traces.exporter=otlp
            -Dotel.logs.exporter=otlp
            -Dotel.instrumentation.kafka.experimental-span-attributes=true
            -Dotel.instrumentation.messaging.experimental.receive-telemetry.enabled=true
            -Dotel.instrumentation.kafka.producer-propagation.enabled=true
            -Dotel.instrumentation.kafka.enabled=true
        volumeMounts:
        - name: otel-auto-instrumentation
          mountPath: /otel-auto-instrumentation

      volumes:
      - name: otel-auto-instrumentation
        emptyDir: {}

구성 매개변수

다음 표에서는 주요 설정 시위에 대해 설명합니다.

매개변수	설명
`service.name`	`order-process-service` 생산자 또는 소비자 애플리케이션에 대한 고유한 이름으로 바꾸십시오.
`kafka.cluster.name`	`my-cluster` 수집기 설정에 사용된 것과 동일한 클러스터 이름으로 바꾸세요.
`otlp.endpoint`	엔드포인트 `http://localhost:4317` 는 수집기가 동일한 파드에서 사이드카로 실행 중이거나 localhost를 통해 액세스할 수 있다고 가정합니다.

팁

위의 설정은 텔레메트리를 OpenTelemetry Collector 로 보냅니다. 망원경을 수집기로 보내야 하는 경우 3단계 에 설명된 대로 다음 설정을 사용하여 구현하고 배포합니다.

OTLP 수신기와 파이프라인을 수집기 설정에 추가하여 HTML 버전리의 HTML 소스를 받으십시오.

1단계. receivers 섹션에 추가:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: "0.0.0.0:4317"

  # ... existing receivers (prometheus/kafka-jmx, kafkametrics/cluster)

2단계. exporters 섹션에 추가:

exporters:
  otlp/backend:
    endpoint: ${NEW_RELIC_OTLP_ENDPOINT}
    headers:
      api-key: ${NEW_RELIC_LICENSE_KEY}

  # ... existing exporters

3단계. service.pipelines 섹션에 추가:

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlp/backend]

    metrics:
      receivers: [otlp]
      exporters: [otlp/backend]

    logs:
      receivers: [otlp]
      exporters: [otlp/backend]

    # ... existing pipelines (metrics/broker, metrics/cluster/prometheus, metrics/cluster/kafkametrics)

이를 통해 수집기가 원본 Kafka 클라이언트로부터 로그, 로그, 트레이스 등을 수신하여 브로커 지표와 함께 뉴렐릭으로 전달할 수 있습니다.

자바 에이전트는 코드 변경 없이 즉시 사용 가능한 Kafka 계측 을 제공하여 다음을 캡처합니다:

요청 지연시간
처리량 지표
오류율
분산 추적

고급 설정에 대해서는 Kafka 측정, 로그 문서를 참조하세요.

(선택 사항) Kafka 브로커 로그 전달

Kafka 브로커 로그를 수집하여 뉴렐릭으로 전송하려면, 수집기 설정에 filelog 수신기를 추가하세요.

values.yaml 수집기 설정에 다음을 추가하십시오:

1단계. receivers 섹션에 추가:

receivers:
  # ... existing receivers ...

  # File log receiver for Kafka broker logs
  filelog/kafka_broker_0:
    include:
      - /var/log/kafka/server.log
    start_at: end
    multiline:
      line_start_pattern: '^\['
    resource:
      broker.id: "0"
      kafka.cluster.name: ${env:KAFKA_CLUSTER_NAME}

2단계. 서비스 섹션에 로그 파이프라인 추가:

service:
  pipelines:
    # ... existing pipelines ...

    logs/broker:
      receivers: [filelog/kafka_broker_0]
      processors: [memory_limiter, batch/export]
      exporters: [otlp/backend]

구성 매개변수

다음 표에서는 주요 설정 시위에 대해 설명합니다.

매개변수	설명
`filelog/kafka_broker_0.include`	`/var/log/kafka/server.log` 을(를) 브로커 파드 내의 실제 Kafka 로그 경로로 업데이트하세요. Strimzi의 경우, 로그는 일반적으로 stdout에 기록됩니다 ― 이를 파일로 리디렉션하려면 Strimzi 로그 설정 을 사용하거나 대신 사이드카 로그 수집기를 사용하세요.
`filelog/kafka_broker_0.resource.broker.id`	`broker.id` 리소스 속성은 로그를 특정 브로커 메트릭 및 엔티티와 연관시킵니다.
다중 브로커 수신기	여러 브로커를 사용하는 경우, 각 브로커 ID를 사용하여 별도의 `filelog` 수신기(예: `filelog/kafka_broker_1`, `filelog/kafka_broker_2`)를 생성하십시오.
`filelog/kafka_broker_0.multiline.line_start_pattern`	`multiline` 패턴은 로그가 `[` (으)로 시작한다고 가정합니다 ― 로그 형식이 다르면 조정하세요.
로그 볼륨	로그인 포워딩을 활성화하기 전에 로그 볼륨 및 수집 비용을 고려하십시오.
참조	전체 설정 옵션에 대한 자세한 내용 은 파일로그 수신기 설명서를참조하십시오.

3단계. Helm 릴리스 업그레이드:

bash

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

Kafka 브로커 로그는 다음 두 곳에서 확인할 수 있습니다.

브로커 부분: 특정 브로커와 상관 관계가 있는 로그를 보려면 뉴렐릭의 Kafka 브로커 부분으로 이동하세요.
로그 UI: 다음과 같은 필터가 포함된 로그 UI 사용하여 모든 Kafka 로그를 쿼리합니다. kafka.cluster.name = 'my-cluster'
NRQL을 사용하여 로그를 쿼리할 수도 있습니다.
```
FROM Log SELECT * WHERE kafka.cluster.name = 'my-kafka-cluster'
```

데이터 찾기

몇 분 후 Kafka 데이터가 뉴렐릭에 나타납니다. 뉴렐릭 UI의 여러 뷰에서 Kafka 데이터를 탐색하는 방법에 대한 자세한 지침은 데이터 찾기 를 참조하세요.

다음 표는 각 신호 유형이 저장되는 위치를 요약합니다. 아래의 모든 쿼리에서 my-kafka-cluster 을(를) KAFKA_CLUSTER_NAME 값으로 바꾸십시오:

시그널	이벤트 유형	포함 사항
메트릭	`Metric`	브로커, 토픽, 파티션, 소비자 그룹 및 JVM 메트릭
로그	`Log`	생산자 및 소비자 애플리케이션의 로그(OTel 자바 에이전트를 통해) 및 선택적 로그 포워딩 단계를 통해 수집된 브로커 로그
트레이스	`Span`	토픽 전반에 걸친 메시지당 `publish` 및 `receive` 작업을 포함하는 생산자 및 소비자 스팬

메트릭

브로커, 토픽, 파티션, 소비자 그룹 및 JVM 메트릭은 Metric 이벤트 유형에 저장됩니다. my-kafka-cluster 을(를) KAFKA_CLUSTER_NAME 값으로 교체합니다:

FROM Metric SELECT * WHERE kafka.cluster.name = 'my-kafka-cluster' SINCE 30 minutes ago

로그

OpenTelemetry 자바 에이전트로 계측된 생산자 및 소비자 애플리케이션의 로그와 선택적 로그 포워딩 단계를 통해 수집된 브로커 로그는 Log 이벤트 유형에 저장됩니다:

FROM Log SELECT * WHERE kafka.cluster.name = 'my-kafka-cluster' SINCE 30 minutes ago

트레이스

OpenTelemetry 자바 에이전트로 계측된 생산자 또는 소비자 애플리케이션을 배포하는 경우, 생산자 및 소비자 스팬은 Span 이벤트 유형에 저장됩니다:

FROM Span SELECT * WHERE kafka.cluster.name = 'my-kafka-cluster' SINCE 30 minutes ago

예시

Strimzi Kafka 사용자 지정 리소스, JMX Exporter 설정, OTel Collector 설정 및 샘플 생산자/소비자 애플리케이션이 포함된 완전하게 작동하는 예제는 뉴렐릭 OpenTelemetry 예제 저장소에서 확인할 수 있습니다.

문제점 해결

1. 수집기 디버그 로그 활성화: 설정 문제를 해결하기 위해 자세한 로깅을 추가합니다.

Helm 구현, 배포의 경우 values.yaml 을 업데이트합니다.

config:
  service:
    telemetry:
      logs:
        level: "debug"  # Enable detailed collector internal logs

매니페스트 구현을 위해 수집기 ConfigMap을 편집합니다.

bash

$kubectl edit configmap -n newrelic otel-collector-config

service: 아래에 텔레메트리 섹션을 추가합니다.

service:
  telemetry:
    logs:
      level: "debug"
  pipelines:
    # ... existing pipelines ...

2. 디버그 내보내기 추가: 뉴렐릭으로 보내기 전에 수집기 로그에서 지표 보기

설정에 다음을 추가하세요:

exporters:
  debug:
    verbosity: detailed

  otlp/backend:
    endpoint: ${NEW_RELIC_OTLP_ENDPOINT}
    headers:
      api-key: ${NEW_RELIC_LICENSE_KEY}

service:
  pipelines:
    metrics/broker:
      receivers: [prometheus/kafka-jmx]
      processors: [resource/cluster-name, filter/scrape-overhead, transform/metric-naming, transform/remove_attributes, filter/exclude_cluster_metrics, memory_limiter, cumulativetodelta, batch/export]
      exporters: [debug, otlp/backend]  # Add debug exporter

그런 다음 수집기를 다시 시작하고 로그를 확인하십시오.

bash

$# Restart collector
$kubectl rollout restart deployment -n newrelic otel-collector
$
$# View logs with metric output
$kubectl logs -n newrelic -l app=otel-collector -f

중요: 로그 오버플로를 방지하려면 프로덕션 환경에서 디버그 익스포터를 제거하십시오.

1. 파드 상태 및 이벤트 확인:

bash

$# Check pod status
$# For Helm:
$kubectl get pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$# For Manifest:
$kubectl get pods -n newrelic -l app=otel-collector
$
$# View detailed pod description
$# For Helm:
$kubectl describe pod -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$# For Manifest:
$kubectl describe pod -n newrelic -l app=otel-collector
$
$# Check recent logs
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector --previous --tail=50
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector --previous --tail=50

일반적인 문제점 및 해결책:

2. 잘못된 설정: ConfigMap YAML 구문의 유효성을 검사합니다.

bash

$# For manifest deployments, check ConfigMap
$kubectl get configmap -n newrelic otel-collector-config -o yaml
$
$# Validate YAML syntax
$kubectl get configmap -n newrelic otel-collector-config -o yaml | kubectl apply --dry-run=client -f -
$
$# For Helm deployments, check the values
$helm get values <release-name> -n newrelic

3. RBAC 권한: 서비스 계정에 적절한 클러스터 역할 바인딩이 있는지 확인합니다.

bash

$# Check ServiceAccount
$kubectl get serviceaccount -n newrelic otel-collector
$
$# Check ClusterRole and ClusterRoleBinding
$kubectl get clusterrole otel-collector -o yaml
$kubectl get clusterrolebinding otel-collector -o yaml

4. 리소스 제약 조건: 파드가 OOMKilled 상태인지 또는 리소스 제한에 도달했는지 확인합니다.

bash

$# Check resource usage
$# For Helm:
$kubectl top pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$# For Manifest:
$kubectl top pods -n newrelic -l app=otel-collector
$
$# Check for resource limits
$# For Helm:
$kubectl describe pod -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep -A 5 "Limits\|Requests"
$# For Manifest:
$kubectl describe pod -n newrelic -l app=otel-collector | grep -A 5 "Limits\|Requests"

5. 비밀번호를 찾을 수 없음: 뉴럴릭 자격 증명과 비밀번호가 존재하는지 확인하십시오.

bash

$# Check if secret exists
$kubectl get secret -n newrelic newrelic-otlp-secret
$
$# Verify secret has required keys
$kubectl get secret -n newrelic newrelic-otlp-secret -o jsonpath='{.data}' | jq 'keys'

1. JMX Exporter 활성화 여부 확인: Strimzi Kafka 리소스에 JMX Exporter가 구성되어 있는지 확인하십시오.

bash

$# Check Kafka resource configuration for JMX Exporter
$kubectl get kafka -n kafka -o yaml | grep -A 10 jmxPrometheusExporter
$
$# Should show something like:
$# jmxPrometheusExporter:
$#   lowercaseOutputName: true

2. JMX 익스포터 포트 확인: 익스포터가 9404 포트에서 수신 대기 중인지 확인합니다.

bash

$# Check if port 9404 is exposed on Kafka pods
$kubectl get pods -n kafka -l strimzi.io/name=<cluster-name>-kafka -o yaml | grep -A 3 "containerPort: 9404"
$
$# Test connectivity from collector pod
$# For Helm:
$kubectl exec -it -n newrelic deployment/kafka-monitoring-opentelemetry-collector -- sh -c "curl -s http://<kafka-pod-ip>:9404/metrics" | head -10
$# For Manifest:
$kubectl exec -it -n newrelic deployment/otel-collector -- sh -c "curl -s http://<kafka-pod-ip>:9404/metrics" | head -10

3. Prometheus 수신기가 메트릭을 수집할 수 있는지 확인합니다.

bash

$# Check collector logs for Prometheus scraping
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep -i "prometheus\|scrape"
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector | grep -i "prometheus\|scrape"
$
$# Look for successful scrape messages or errors
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep "prometheus/kafka-jmx"
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector | grep "prometheus/kafka-jmx"

4. Kubernetes 서비스 검색 확인: 파드 레이블이 relabel_configs와 일치하는지 확인합니다.

bash

$# Verify Kafka pod labels
$kubectl get pods -n kafka -l strimzi.io/name=<cluster-name>-kafka --show-labels
$
$# Should include labels like:
$# strimzi.io/cluster=<cluster-name>
$# strimzi.io/name=<cluster-name>-kafka

5. 수동 스크래핑 테스트: 메트릭이 사용 가능한지 확인합니다.

bash

$# Get Kafka broker pod IP
$kubectl get pods -n kafka -o wide
$
$# Curl metrics endpoint
$# For Helm:
$kubectl exec -it -n newrelic deployment/kafka-monitoring-opentelemetry-collector -- curl http://<kafka-pod-ip>:9404/metrics
$# For Manifest:
$kubectl exec -it -n newrelic deployment/otel-collector -- curl http://<kafka-pod-ip>:9404/metrics

6. Kafkametrics 수신기 오류를 확인하십시오.

bash

$# Look for kafkametrics connection issues
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep "kafkametrics"
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector | grep "kafkametrics"
$
$# Common errors:
$# - Connection refused: Check broker address is correct
$# - Timeout: Check network policies allow access
$# - Authentication failed: Remove TLS configuration if using plaintext

1. 리소스 사용량 모니터링:

bash

$# Check current memory usage
$# For Helm:
$kubectl top pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$# For Manifest:
$kubectl top pods -n newrelic -l app=otel-collector
$
$# Watch memory usage over time
$# For Helm:
$watch kubectl top pods -n newrelic -l app.kubernetes.io/name=opentelemetry-collector
$# For Manifest:
$watch kubectl top pods -n newrelic -l app=otel-collector

2. 모니터링 대상 주제 축소: 필수적인 주제만 수집하도록 제한

# In your values.yaml (Helm) or ConfigMap (manifest), add topic filtering:
receivers:
  kafkametrics/cluster:
    brokers:
      - "my-cluster-kafka-bootstrap.kafka.svc.cluster.local:9092"
    collection_interval: 30s
    scrapers:
      - brokers
      - topics  # Consider removing if not needed
      - consumers  # Consider removing if not needed
    topic_match: "^(important-topic-1|important-topic-2)$"  # Filter specific topics

3. 수집 빈도 줄이기: 수집 간격을 늘려 수집 횟수를 줄입니다.

receivers:
  kafkametrics/cluster:
    collection_interval: 60s  # Increase from 30s to 60s

  prometheus/kafka-jmx:
    config:
      scrape_configs:
        - job_name: 'kafka-jmx-metrics'
          scrape_interval: 60s  # Increase from 30s to 60s

4. 일괄 처리 최적화: 일괄 처리기 설정을 조정합니다.

processors:
  batch/export:
    timeout: 60s  # Increase from 30s
    send_batch_size: 512  # Reduce from 1024

5. 메모리 제한 조정: 메모리 제한 프로세서를 조정합니다.

processors:
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75  # Reduce from 80
    spike_limit_percentage: 20  # Reduce from 30

6. 리소스 제한 업데이트: Helm 구현, 배포, 값 업데이트의 경우.yaml

resources:
  requests:
    memory: 512Mi
    cpu: 250m
  limits:
    memory: 1Gi  # Adjust as needed
    cpu: 500m

매니페스트 구현, 배포의 경우 구현, 배포를 직접 업데이트합니다.

bash

$kubectl patch deployment -n newrelic otel-collector --patch '
$spec:
$  template:
$    spec:
$      containers:
$      - name: otel-collector
$        resources:
$          limits:
$            memory: "1Gi"
$          requests:
$            memory: "512Mi"
$'

7. 변경 후 수집기를 다시 시작하십시오.

bash

$# For Helm:
$kubectl rollout restart deployment -n newrelic kafka-monitoring-opentelemetry-collector
$# For Manifest:
$kubectl rollout restart deployment -n newrelic otel-collector

1. 네트워크 연결 확인: 수집기가 Kafka 브로커에 도달할 수 있는지 확인합니다.

bash

$# Get Kafka broker pod IPs
$kubectl get pods -n kafka -l strimzi.io/kind=Kafka -o wide
$
$# Test connectivity from collector pod
$# For Helm:
$kubectl exec -it -n newrelic deployment/kafka-monitoring-opentelemetry-collector -- curl -m 5 http://<kafka-pod-ip>:9404/metrics | head -20
$# For Manifest:
$kubectl exec -it -n newrelic deployment/otel-collector -- curl -m 5 http://<kafka-pod-ip>:9404/metrics | head -20

2. JMX Exporter 실행 여부 확인: Kafka 브로커에서 JMX Exporter가 활성화되어 있는지 확인합니다.

bash

$# Check Kafka pod for JMX Exporter container
$kubectl get pods -n kafka -o yaml | grep -A 5 "jmx-exporter"
$
$# Check if port 9404 is listening
$kubectl exec -n kafka <kafka-pod-name> -- netstat -tlnp | grep :9404
$
$# Or test from within the pod
$kubectl exec -n kafka <kafka-pod-name> -- curl -s localhost:9404/metrics | head

3. relabel_configs가 레이블과 일치하는지 확인: Prometheus 수신기가 Kafka를 검색할 수 있는지 확인합니다.

bash

$# Verify pod labels match the relabel_configs in your configuration
$kubectl get pods -n kafka -l strimzi.io/kind=Kafka --show-labels
$
$# Should show labels like:
$# strimzi.io/cluster=my-cluster
$# strimzi.io/name=my-cluster-kafka

4. 라벨스페이스 설정 확인: Prometheus 수신기가 올바른 라벨스페이스를 찾고 있는지 확인하세요.

# In your configuration, verify namespace matches where Kafka is deployed
receivers:
  prometheus/kafka-jmx:
    config:
      scrape_configs:
        - job_name: 'kafka-jmx-metrics'
          kubernetes_sd_configs:
            - role: pod
              namespaces:
                names:
                  - kafka  # Must match your Kafka namespace

5. RBAC 권한 확인: ClusterRole이 파드 검색을 허용하는지 확인합니다.

bash

$# Check ClusterRole has pod list/watch permissions
$kubectl get clusterrole otel-collector -o yaml | grep -A 3 "pods"
$
$# Should include:
$# - apiGroups: [""]
$#   resources: ["pods", "nodes"]
$#   verbs: ["get", "list", "watch"]

6. 스크래핑 타임아웃 늘리기: 메트릭 엔드포인트의 응답 속도가 느린 경우

receivers:
  prometheus/kafka-jmx:
    config:
      scrape_configs:
        - job_name: 'kafka-jmx-metrics'
          scrape_interval: 30s
          scrape_timeout: 20s  # Increase from default 10s

7. 스크래핑 세부 정보를 확인하려면 수집기 로그를 확인하세요.

bash

$# View Prometheus receiver logs
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep "prometheus/kafka-jmx"
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector | grep "prometheus/kafka-jmx"
$
$# Look for discovered targets
$# For Helm:
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector | grep -i "target\|scrape"
$# For Manifest:
$kubectl logs -n newrelic -l app=otel-collector | grep -i "target\|scrape"

1. 필터 프로세서 확인: 의도치 않게 메트릭을 필터링하고 있지 않은지 확인하십시오.

# Review your filter configurations:
processors:
  filter/scrape-overhead:
    metrics:
      exclude:
        match_type: regexp
        metric_names:
          - "^jmx_.*"  # These are excluded
          - "^process_.*"
          - "^jvm_.*"

2. Kafka JMX 메트릭 이름이 변환됩니다. OpenTelemetry 표준을 준수하기 위해 밑줄이 점으로 대체됩니다.

설정은 JMX Exporter(1단계에서 정의됨)의 이름을 OpenTelemetry 의미 규칙에 맞게 자동으로 변환합니다. 예를 들어:

kafka_topic_io 되다 kafka.topic.io
kafka_broker_leader_count 되다 kafka.broker.leader.count

뉴렐릭에서 '도'를 검색할 때는 밑줄 대신 점을 사용하여 변환된 이름을 사용하세요.

# This transformation is applied automatically:
processors:
  transform/metric-naming:
    metric_statements:
      - context: metric
        statements:
          - replace_pattern(name, "_", ".")

3. 상세 로깅 활성화: 어떤 메트릭이 처리되는지 정확하게 확인하세요.

exporters:
  debug:
    verbosity: detailed

service:
  pipelines:
    metrics/broker:
      exporters: [debug, otlp/backend]

4. 지표 이름에 대한 쿼리 뉴렐릭: 실제로 수신되는 지표가 무엇인지 확인합니다.

FROM Metric SELECT uniques(metricName)
WHERE kafka.cluster.name = 'my-cluster'
SINCE 1 hour ago

설정에는 포괄적인 예측을 위한 Additional metrics [추가 지표] 섹션이 포함되어 있습니다. 이를 제거해도 핵심 뉴렐릭 UI 기능에는 영향을 미치지 않습니다. 즉, 브로커 상태, 소비자 지연, 클러스터 개요 및 JVM 대시보드는 모두 계속 작동합니다.

1. JMX ConfigMap에서 추가 메트릭 섹션을 제거합니다.

kafka-jmx-config.yaml ConfigMap에서 이 주석 아래의 모든 내용(rules: 목록의 끝까지)을 삭제하세요.

# Additional metrics — remove this section to reduce data ingest

  # Request latency: total count, 50th percentile, and average (99p kept above)
  - pattern: 'kafka.network<type=RequestMetrics...'
  ...

ConfigMap을 편집한 후 적용하고 Kafka 브로커를 재시작하여 변경 사항을 적용하십시오.

bash

$kubectl apply -f kafka-jmx-config.yaml
$kubectl rollout restart statefulset -n kafka <kafka-cluster-name>-kafka

2. Kafkametrics 수신기에서 소비자 오프셋 메트릭을 비활성화합니다.

수집기 설정에서 kafkametrics/cluster 수신자 metrics 섹션에 추가하세요.

receivers:
  kafkametrics/cluster:
    # ...existing config...
    metrics:
      kafka.consumer_group.offset:
        enabled: false
      kafka.consumer_group.offset_sum:
        enabled: false

소비자 지연 지표(kafka.consumer_group.lag, kafka.consumer_group.lag_sum)는 활성화된 상태로 유지됩니다. 이는 뉴렐릭 Kafka UI 소비자 모니터링 뷰에 사용하는 것입니다.

다음 단계

Kafka 메트릭 살펴보기 - 전체 메트릭 참조 자료를 확인하세요
맞춤형 대시보드 만들기 - Kafka 데이터에 대한 시각화 구축
알림 설정 ― 소비자 지연 및 과소 복제된 파티션과 같은 중요한 메트릭을 모니터합니다

사용자의 편의를 위해 제공되는 기계 번역입니다.

OpenTelemetry를 사용하여 Kubernetes(Strimzi)에서 Kafka를 모니터링하세요.

아키텍처 .css-21sua1{background:none;border:none;width:0;padding:0;}

설치 단계

시작하기 전에

Kafka JMX 메트릭을 위해 Kafka 클러스터를 구성합니다.

팁

중요

구현하다, 배포하다 OpenTelemetry Collector

EU 지역

팁

NRDOT Collector 사용(권장)

OpenTelemetry Collector 사용

미국 지역

EU 지역

팁

NRDOT Collector 사용(권장)

OpenTelemetry Collector 사용

(선택사항) 제작자 또는 소비자를 위해

중요

당신의 Kafka를 편집하세요

팁

텔레메트리의 Collector 설정

(선택 사항) Kafka 브로커 로그 전달

로그 수집 구성

뉴렐릭에서 내 로그인 찾기

데이터 찾기

메트릭

로그

트레이스

예시

문제점 해결

디버그 로깅 활성화

Collector 파드 시작 안 됨

Kafka 메트릭이 수집되지 않았습니다.

높은 메모리 사용량

프로메테우스 스크래핑 오류

일부 지표가 누락되었습니다.

데이터 수집 줄이기

다음 단계

아키텍처