Monitorear Elasticsearch en Kubernetes con OpenTelemetry

Monitoree sus clústeres de Elasticsearch en Kubernetes desplegando el OpenTelemetry Collector con descubrimiento automático de pods. Esta integración utiliza el elasticsearchreceiver y el receivercreator para descubrir y monitorear automáticamente los pods de Elasticsearch sin configuración manual.

Para empezar, seleccione la distribución del recopilador que mejor se adapte a su entorno de Kubernetes:

Puede elegir entre dos distribuciones del recopilador:

NRDOT: Distribución de New Relic de OpenTelemetry
OTel Collector Contrib: OpenTelemetry Collector estándar con componentes aportados por la comunidad

Opciones de instalación

Seleccione la distribución del recopilador que se ajuste a sus necesidades:

Importante

¡El soporte de NRDOT para el monitoreo de Elasticsearch en Kubernetes llegará pronto! ¡Manténgase al tanto de las actualizaciones!

Antes de que empieces

Antes de desplegar el OTel Collector Contrib en Kubernetes, asegúrese de tener:

Privilegios de acceso requeridos:

Tu New Relic
Acceso a su clúster de Kubernetes con kubectl
Privilegios de administrador de clúster de Elasticsearch con privilegio de clúster monitor o manage (consulte la documentación de privilegios de seguridad de Elasticsearch para obtener detalles)
Requisitos del sistema:
Versión 7.16 o superior de Elasticsearch - Esta integración requiere un clúster moderno de Elasticsearch
Clúster de Kubernetes - Un clúster de Kubernetes en ejecución donde Elasticsearch está desplegado
Helm 3.0 o superior - Helm instalado en su sistema
Conectividad de red - HTTPS saliente (puerto 443) al endpoint de ingesta OTLPde New Relic
Requisitos del pod de Elasticsearch:
Etiquetas de pod (Obligatorio) - Cada pod de Elasticsearch debe tener la etiqueta app: elasticsearch para que funcione el descubrimiento automático. Sin esta etiqueta, el colector no detectará ni monitoreará sus pods.
Importante
Cómo agregar etiquetas a los pods de Elasticsearch:
Si utiliza un StatefulSet o un Deployment para Elasticsearch, agregue la etiqueta en la plantilla del pod:
apiVersion: apps/v1 kind: StatefulSet metadata: name: elasticsearch spec: template: metadata: labels: app: elasticsearch # Required for auto-discovery spec: containers: - name: elasticsearch image: docker.elastic.co/elasticsearch/elasticsearch:8.x.x
Para los pods existentes sin etiquetas, actualice su StatefulSet/Deployment y reinicie los pods:
bash
```
$kubectl label pods -l <your-existing-selector> app=elasticsearch -n <namespace>
```
Puede verificar que las etiquetas estén configuradas correctamente:
bash
```
$kubectl get pods -n <namespace> --show-labels
```

Crear secreto de Kubernetes para credenciales

Crea un secreto de Kubernetes para almacenar tus credenciales de New Relic de forma segura:

Cree el espacio de nombres:
bash
```
$kubectl create namespace newrelic
```

Cree el secreto:

bash

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

Actualice los valores:

Reemplace YOUR_LICENSE_KEY_HERE con su clave de licencia de New Relic real
Reemplace https://otlp.nr-data.net:4318 con el endpoint de su región (consulte la documentación del endpoint OTLP)
Reemplace 100 con el límite de memoria deseado en MiB para el colector (predeterminado: 100 MiB). Ajuste según las necesidades de su entorno

Configurar el monitoreo de Elasticsearch

Cree un archivo values.yaml para configurar el OpenTelemetry Collector para el monitoreo de Elasticsearch:

Sugerencia

Personalice para su entorno: Actualice los siguientes valores en la configuración:

Cambios requeridos:

Regla de etiquetas de Pod - La regla labels["app"] == "elasticsearch" debe coincidir con las etiquetas de su Pod. Si sus pods de Elasticsearch usan etiquetas diferentes (p. ej., app: es-cluster), actualice la regla según corresponda:
```
rule: type == "pod" && labels["app"] == "es-cluster"
```
Nombre del clúster - Reemplace elasticsearch-cluster por un nombre único para identificar su clúster en New Relic. Este nombre se utilizará para crear e identificar sus entidades de Elasticsearch en la UI de New Relic. Elige un nombre que sea único en tu cuenta de New Relic (p. ej., prod-es-k8s, staging-elasticsearch)
Cambios opcionales:
Puerto - Actualice 9200 si Elasticsearch se ejecuta en un puerto diferente
Autenticación - Agregue credenciales si su clúster de Elasticsearch está protegido

mode: deployment

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

command:
  name: otelcol-contrib

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 200m
    memory: 256Mi

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: NEW_RELIC_MEMORY_LIMIT_MIB
    valueFrom:
      secretKeyRef:
        name: newrelic-licenses
        key: NEW_RELIC_MEMORY_LIMIT_MIB
  - name: K8S_CLUSTER_NAME
    value: "elasticsearch-cluster"

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

config:
    extensions:
      health_check:
        endpoint: 0.0.0.0:13133
      k8s_observer:
        auth_type: serviceAccount
        observe_pods: true
        observe_nodes: true

    receivers:
      receiver_creator/elasticsearch:
        watch_observers: [k8s_observer]
        receivers:
          elasticsearch:
            rule: type == "pod" && labels["app"] == "elasticsearch"
            config:
              endpoint: 'http://`endpoint`:9200'
              collection_interval: 30s
              metrics:
                elasticsearch.os.cpu.usage:
                  enabled: true
                elasticsearch.cluster.data_nodes:
                  enabled: true
                elasticsearch.cluster.health:
                  enabled: true
                elasticsearch.cluster.in_flight_fetch:
                  enabled: true
                elasticsearch.cluster.nodes:
                  enabled: true
                elasticsearch.cluster.pending_tasks:
                  enabled: true
                elasticsearch.cluster.shards:
                  enabled: true
                elasticsearch.cluster.state_update.time:
                  enabled: true
                elasticsearch.index.documents:
                  enabled: true
                elasticsearch.index.operations.merge.current:
                  enabled: true
                elasticsearch.index.operations.time:
                  enabled: true
                elasticsearch.node.cache.count:
                  enabled: true
                elasticsearch.node.cache.evictions:
                  enabled: true
                elasticsearch.node.cache.memory.usage:
                  enabled: true
                elasticsearch.node.shards.size:
                  enabled: true
                elasticsearch.node.cluster.io:
                  enabled: true
                elasticsearch.node.documents:
                  enabled: true
                elasticsearch.node.disk.io.read:
                  enabled: true
                elasticsearch.node.disk.io.write:
                  enabled: true
                elasticsearch.node.fs.disk.available:
                  enabled: true
                elasticsearch.node.fs.disk.total:
                  enabled: true
                elasticsearch.node.http.connections:
                  enabled: true
                elasticsearch.node.ingest.documents.current:
                  enabled: true
                elasticsearch.node.ingest.operations.failed:
                  enabled: true
                elasticsearch.node.open_files:
                  enabled: true
                elasticsearch.node.operations.completed:
                  enabled: true
                elasticsearch.node.operations.current:
                  enabled: true
                elasticsearch.node.operations.get.completed:
                  enabled: true
                elasticsearch.node.operations.time:
                  enabled: true
                elasticsearch.node.shards.reserved.size:
                  enabled: true
                elasticsearch.index.shards.size:
                  enabled: true
                elasticsearch.os.cpu.load_avg.1m:
                  enabled: true
                elasticsearch.os.cpu.load_avg.5m:
                  enabled: true
                elasticsearch.os.cpu.load_avg.15m:
                  enabled: true
                elasticsearch.os.memory:
                  enabled: true
                jvm.gc.collections.count:
                  enabled: true
                jvm.gc.collections.elapsed:
                  enabled: true
                jvm.memory.heap.max:
                  enabled: true
                jvm.memory.heap.used:
                  enabled: true
                jvm.memory.heap.utilization:
                  enabled: true
                jvm.threads.count:
                  enabled: true
                elasticsearch.index.segments.count:
                  enabled: true
                elasticsearch.index.operations.completed:
                  enabled: true
                elasticsearch.node.script.cache_evictions:
                  enabled: false
                elasticsearch.node.cluster.connections:
                  enabled: false
                elasticsearch.node.pipeline.ingest.documents.preprocessed:
                  enabled: false
                elasticsearch.node.thread_pool.tasks.queued:
                  enabled: false
                elasticsearch.cluster.published_states.full:
                  enabled: false
                jvm.memory.pool.max:
                  enabled: false
                elasticsearch.node.script.compilation_limit_triggered:
                  enabled: false
                elasticsearch.node.shards.data_set.size:
                  enabled: false
                elasticsearch.node.pipeline.ingest.documents.current:
                  enabled: false
                elasticsearch.cluster.state_update.count:
                  enabled: false
                elasticsearch.node.fs.disk.free:
                  enabled: false
                jvm.memory.nonheap.used:
                  enabled: false
                jvm.memory.pool.used:
                  enabled: false
                elasticsearch.node.translog.size:
                  enabled: false
                elasticsearch.node.thread_pool.threads:
                  enabled: false
                elasticsearch.cluster.state_queue:
                  enabled: false
                elasticsearch.node.translog.operations:
                  enabled: false
                elasticsearch.memory.indexing_pressure:
                  enabled: false
                elasticsearch.node.ingest.documents:
                  enabled: false
                jvm.classes.loaded:
                  enabled: false
                jvm.memory.heap.committed:
                  enabled: false
                elasticsearch.breaker.memory.limit:
                  enabled: false
                elasticsearch.indexing_pressure.memory.total.replica_rejections:
                  enabled: false
                elasticsearch.breaker.memory.estimated:
                  enabled: false
                elasticsearch.cluster.published_states.differences:
                  enabled: false
                jvm.memory.nonheap.committed:
                  enabled: false
                elasticsearch.node.translog.uncommitted.size:
                  enabled: false
                elasticsearch.node.script.compilations:
                  enabled: false
                elasticsearch.node.pipeline.ingest.operations.failed:
                  enabled: false
                elasticsearch.indexing_pressure.memory.limit:
                  enabled: false
                elasticsearch.breaker.tripped:
                  enabled: false
                elasticsearch.indexing_pressure.memory.total.primary_rejections:
                  enabled: false
                elasticsearch.node.thread_pool.tasks.finished:
                  enabled: false

    processors:
      memory_limiter:
        check_interval: 60s
        limit_mib: ${env:NEW_RELIC_MEMORY_LIMIT_MIB}
      cumulativetodelta: {}
      resource/cluster:
        attributes:
          - key: k8s.cluster.name
            value: "${env:K8S_CLUSTER_NAME}"
            action: insert
      resource/cluster_name_override:
        attributes:
          - key: elasticsearch.cluster.name
            value: "${env:K8S_CLUSTER_NAME}"
            action: upsert
      resourcedetection:
        detectors: [env, system]
        system:
          resource_attributes:
            host.name:
              enabled: true
            host.id:
              enabled: true
            os.type:
              enabled: true
      batch:
        timeout: 10s
        send_batch_size: 1024
      attributes/cardinality_reduction:
        actions:
          - key: process.pid
            action: delete
          - key: process.parent_pid
            action: delete
          - key: k8s.pod.uid
            action: delete
      transform/metadata_nullify:
        metric_statements:
          - context: metric
            statements:
              - set(description, "")
              - set(unit, "")

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

    service:
      extensions: [health_check, k8s_observer]
      pipelines:
        metrics/elasticsearch:
          receivers: [receiver_creator/elasticsearch]
          processors: [memory_limiter, resourcedetection, resource/cluster, resource/cluster_name_override, attributes/cardinality_reduction, cumulativetodelta, transform/metadata_nullify, batch]
          exporters: [otlphttp]

Sugerencia

Para clústeres de Elasticsearch protegidos: Si su clúster de Elasticsearch requiere autenticación, agregue las credenciales a la configuración del receptor:

receiver_creator/elasticsearch:
  watch_observers: [k8s_observer]
  receivers:
    elasticsearch:
      rule: type == "pod" && labels["app"] == "elasticsearch"
      config:
        endpoint: 'https://`endpoint`:9200'
        username: "your_elasticsearch_username"
        password: "your_elasticsearch_password"
        tls:
          insecure_skip_verify: false

Almacene las credenciales de forma segura utilizando secretos de Kubernetes en lugar de codificarlas directamente en el archivo de valores.

Instalar con Helm

Instale el OpenTelemetry Collector usando Helm con su configuración values.yaml:

bash

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

Verifique la implementación y la recopilación de datos

Verifique que el OpenTelemetry Collector se esté ejecutando y recopilando datos de Elasticsearch:

Verifique que los pods del recopilador se estén ejecutando:
bash
```
$kubectl get pods -n newrelic --watch
```
Debería ver pods con nombres como elasticsearch-otel-collector-<hash> en un estado Running.
Revise los logs del colector en busca de errores:
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector -f
```
Busque conexiones exitosas a los pods de Elasticsearch y New Relic. Si ve errores, consulte la guía de solución de problemas.

Ejecute una consulta NRQL en New Relic para confirmar que los datos están llegando (reemplace elasticsearch-cluster por el nombre de su clúster):

FROM Metric
SELECT *
WHERE metricName LIKE 'elasticsearch.%'
  AND instrumentation.provider = 'opentelemetry'
  AND k8s.cluster.name = 'elasticsearch-cluster'
SINCE 10 minutes ago

Sugerencia

Correlacione APM con Elasticsearch: Para conectar su aplicación APM y el clúster de Elasticsearch, incluya el atributo de recurso es.cluster.name="your-cluster-name" en sus métricas de APM. Esto permite la visibilidad entre servicios y una solución de problemas más rápida dentro de New Relic.

Resolución de problemas

Si encuentra problemas durante la instalación o no ve datos en New Relic, consulte nuestra completa guía de solución de problemas para obtener soluciones paso a paso a los problemas comunes.

Para problemas específicos de Kubernetes, como el descubrimiento de pods, los permisos RBAC o la conectividad de red, consulte la sección de resolución de problemas de Kubernetes.

Te ofrecemos esta traducción automática para facilitar la lectura.

Monitorear Elasticsearch en Kubernetes con OpenTelemetry

Opciones de instalación .css-21sua1{background:none;border:none;width:0;padding:0;}

Importante

Antes de que empieces

Importante

Crear secreto de Kubernetes para credenciales

Configurar el monitoreo de Elasticsearch

Sugerencia

Sugerencia

Instalar con Helm

Verifique la implementación y la recopilación de datos

Sugerencia

Resolución de problemas

Opciones de instalación