Monitorer Elasticsearch sur Kubernetes avec OpenTelemetry

Monitorez vos clusters Elasticsearch dans Kubernetes en déployant le collecteur OpenTelemetry avec la découverte automatique des pods. Cette intégration utilise le elasticsearchreceiver et le receivercreator pour découvrir et monitorer automatiquement les pods Elasticsearch sans configuration manuelle.

Pour commencer, sélectionnez la distribution du collecteur qui correspond le mieux à votre environnement Kubernetes :

Vous pouvez choisir entre trois options de collecteur :

NRDOT : Distribution New Relic d'OpenTelemetry
OTel Collector Contrib : Collecteur OpenTelemetry standard avec des composants issus de la communauté
Récepteur Prometheus : pour les environnements exécutant déjà un exportateur Prometheus Elasticsearch

Options d'installation

Choisissez la distribution du collecteur qui correspond à vos besoins :

Avant de commencer

Avant de déployer le collecteur NRDOT sur Kubernetes, assurez-vous d'avoir :

Privilèges d'accès requis :

Votre New Relic
Accès kubectl à votre cluster Kubernetes
Privilèges d'administration de cluster Elasticsearch avec le privilège de cluster monitor ou manage (voir la documentation sur les privilèges de sécurité Elasticsearch pour plus de détails)
Configuration requise :
Elasticsearch version 7.16 ou supérieure - Cette intégration nécessite un cluster Elasticsearch moderne
Cluster Kubernetes - Un cluster Kubernetes en cours d'exécution où Elasticsearch est déployé
Connectivité réseau - HTTPS sortant (port 443) vers le point de terminaison d'ingestion OTLPde New Relic
Prérequis du pod Elasticsearch :
Étiquettes de pod (Requis) - Chaque pod Elasticsearch doit avoir l'étiquette app: elasticsearch pour que la découverte automatique fonctionne. Sans ce label, le collecteur ne détectera ni ne monitorera vos pods.
Important
Comment ajouter des étiquettes aux pods Elasticsearch :
Si vous utilisez un StatefulSet ou un Deployment pour Elasticsearch, ajoutez l'étiquette dans le modèle de 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
Pour les pods existants sans étiquettes, mettez à jour votre StatefulSet/Deployment et redémarrez les pods :
bash
```
$kubectl label pods -l <your-existing-selector> app=elasticsearch -n <namespace>
```
Vous pouvez vérifier que les étiquettes sont correctement définies :
bash
```
$kubectl get pods -n <namespace> --show-labels
```

Choisissez votre méthode d'installation

Vous pouvez installer le Collector NRDOT à l'aide de manifestes Kubernetes ou de charts Helm. Choisissez la méthode qui correspond le mieux à votre workflow :

Installation via manifeste :

Plus de contrôle sur les ressources Kubernetes individuelles
Nécessite de terminer d'abord l'installation de base du manifeste Kubernetes OpenTelemetry
Idéal pour les déploiements personnalisés
Installation Helm :
Déploiement plus simple avec une seule commande
Plus facile à gérer et à mettre à niveau
Idéal pour les déploiements standards
Passez à l'étape suivante pour obtenir des instructions détaillées sur la méthode de votre choix.

Installer et configurer le Collector NRDOT

Terminez l'installation de base du manifeste Kubernetes OpenTelemetry

Avant de configurer le monitoring Elasticsearch, terminez l’installation de base du manifeste Kubernetes OpenTelemetry.

Mettre à jour l'image du collecteur vers NRDOT

Dans les fichiers deployment.yaml et daemonset.yaml de votre répertoire local rendered, mettez à jour l'image vers :

image: newrelic/nrdot-collector:latest

Configurer le monitoring d'Elasticsearch [#nrdot-configure-es]

Mettez à jour le deployment-configmap.yaml pour le monitoring d'Elasticsearch.

Vous avez deux options :

Option 1 : remplacer tous les composants OpenTelemetry existants (recommandé pour le monitoring d'Elasticsearch uniquement)

Remplacez tout le contenu de deployment-configmap.yaml par la configuration spécifique à Elasticsearch :

apiVersion: v1
kind: ConfigMap
metadata:
  name: nr-k8s-otel-collector-deployment-config
data:
  config.yaml: |
    extensions:
      health_check:
        endpoint: 0.0.0.0:13133
      k8s_observer:
        auth_type: serviceAccount
        observe_pods: true
        observe_nodes: true

    receivers:
      jaeger: null
      zipkin: null
      prometheus: null
      otlp: null
      receiver_creator/elasticsearch:
        watch_observers: [k8s_observer]
        receivers:
          elasticsearch:
            rule: type == "pod" && labels["app"] == "elasticsearch"
            config:
              endpoint: 'http://`endpoint`:9200'
              collection_interval: 15s
              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: {}
      attributes/cluster_state_aggregate:
        include:
          match_type: strict
          metric_names:
            - elasticsearch.cluster.state_update.time
        actions:
          - key: type
            action: delete
          - key: state
            action: delete
      filter/critical_operations:
        metrics:
          datapoint:
            - 'attributes["operation"] == "query" or attributes["operation"] == "index" or attributes["operation"] == "get" or attributes["operation"] == "merge" or attributes["operation"] == nil'
      resource/cluster:
        attributes:
          - key: k8s.cluster.name
            value: "elasticsearch-cluster"
            action: insert
      resource/cluster_name_override:
        attributes:
          - key: elasticsearch.cluster.name
            value: "elasticsearch-cluster"
            action: upsert
      resourcedetection:
        detectors: [env, system]
        system:
          resource_attributes:
            host.name:
              enabled: true
            host.id:
              enabled: false
            os.type:
              enabled: true
      batch:
        timeout: 30s
        send_batch_size: 2048
        send_batch_max_size: 4096
      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:
      otlp_http:
        endpoint: "${env:NEWRELIC_OTLP_ENDPOINT}"
        headers:
          api-key: "${env:NEWRELIC_LICENSE_KEY}"
        compression: gzip
        timeout: 30s
        retry_on_failure:
          enabled: true
          initial_interval: 5s
          max_interval: 30s
          max_elapsed_time: 300s

    service:
      extensions: [health_check, k8s_observer]
      pipelines:
        traces: null
        logs: null
        metrics: null
        metrics/elasticsearch:
          receivers: [receiver_creator/elasticsearch]
          processors: [memory_limiter, resourcedetection, resource/cluster, resource/cluster_name_override, attributes/cardinality_reduction, filter/critical_operations, attributes/cluster_state_aggregate, cumulativetodelta, transform/metadata_nullify, batch]
          exporters: [otlp_http]

Option 2 : fusionner avec la configuration existante (en cas de monitoring de plusieurs services)

Ajoutez le récepteur et les processeurs Elasticsearch à votre configuration existante. Reportez-vous aux sections ci-dessus et fusionnez-les avec votre deployment-configmap.yaml actuel.

Conseil

Personnalisez pour votre environnement :

Modifications requises :

Règle de label de pod - La règle labels["app"] == "elasticsearch" doit correspondre à vos labels de pod
Nom du cluster - Remplacez elasticsearch-cluster dans resource/cluster et resource/cluster_name_override par le nom unique de votre cluster
Modifications facultatives :
Port - Mettez à jour 9200 si Elasticsearch s'exécute sur un port différent
Authentification - Ajoutez des identifiants si votre cluster Elasticsearch est sécurisé (voir l’exemple ci-dessous)

Pour les clusters Elasticsearch sécurisés :

receivers:
  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

Appliquer les manifestes mis à jour [#nrdot-apply-manifests]

Appliquez les manifestes mis à jour et redémarrez le déploiement :

bash

$kubectl apply -n newrelic -R -f rendered
$kubectl rollout restart deployment nr-k8s-otel-collector-deployment -n newrelic

Créer un secret Kubernetes pour les identifiants

Créez un secret Kubernetes pour stocker vos identifiants New Relic en toute sécurité :

Créer l'espace de noms :
bash
```
$kubectl create namespace newrelic
```

Créez le secret :

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

Mettre à jour les valeurs :

Remplacez YOUR_LICENSE_KEY_HERE par votre clé de licence New Relic
Remplacez https://otlp.nr-data.net:4318 par l'endpoint de votre région (consultez la documentation sur les endpoints OTLP)

Remplacez 100 par la limite de mémoire souhaitée en MiB pour le collecteur

Configurer le monitoring d'Elasticsearch

Créez un fichier values.yaml pour le monitoring d'Elasticsearch du Collector NRDOT :

mode: deployment

image:
  repository: newrelic/nrdot-collector
  tag: latest
  pullPolicy: IfNotPresent

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

ports: {}

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:
    jaeger: null
    zipkin: null
    prometheus: null
    otlp: null
    receiver_creator/elasticsearch:
      watch_observers: [k8s_observer]
      receivers:
        elasticsearch:
          rule: type == "pod" && labels["app"] == "elasticsearch"
          config:
            endpoint: 'http://`endpoint`:9200'
            collection_interval: 15s
            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: {}
    attributes/cluster_state_aggregate:
      include:
        match_type: strict
        metric_names:
          - elasticsearch.cluster.state_update.time
      actions:
        - key: type
          action: delete
        - key: state
          action: delete
    filter/critical_operations:
      metrics:
        datapoint:
          - 'attributes["operation"] == "query" or attributes["operation"] == "index" or attributes["operation"] == "get" or attributes["operation"] == "merge" or attributes["operation"] == nil'
    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: 30s
      send_batch_size: 2048
      send_batch_max_size: 4096
    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:
    otlp_http:
      endpoint: "${env:NEWRELIC_OTLP_ENDPOINT}"
      headers:
        api-key: "${env:NEWRELIC_LICENSE_KEY}"
      compression: gzip
      timeout: 30s
      retry_on_failure:
        enabled: true
        initial_interval: 5s
        max_interval: 30s
        max_elapsed_time: 300s

  service:
    extensions: [health_check, k8s_observer]
    pipelines:
      traces: null
      logs: null
      metrics: null
      metrics/elasticsearch:
        receivers: [receiver_creator/elasticsearch]
        processors: [memory_limiter, resourcedetection, resource/cluster, resource/cluster_name_override, attributes/cardinality_reduction, filter/critical_operations, attributes/cluster_state_aggregate, cumulativetodelta, transform/metadata_nullify, batch]
        exporters: [otlp_http]

Conseil

Personnalisez pour votre environnement :

Modifications requises :

Règle de label de pod - Mettez à jour labels["app"] == "elasticsearch" pour correspondre à vos labels de pod
Nom du cluster - Remplacez elasticsearch-cluster dans extraEnvs.K8S_CLUSTER_NAME par le nom unique de votre cluster
Modifications facultatives :
Port - Mettez à jour 9200 si Elasticsearch s'exécute sur un port différent
Authentification - Ajoutez des identifiants si sécurisé (voir ci-dessous)

Pour les clusters Elasticsearch sécurisés :

receivers:
  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

Installer avec Helm [#nrdot-helm-install]

Installez le Collector NRDOT à l'aide de Helm avec votre configuration values.yaml :

bash

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

Vérifier le déploiement et la collecte de données

Vérifiez que le collecteur NRDOT est en cours d'exécution et collecte les données Elasticsearch :

Vérifiez que les pods du collecteur sont en cours d'exécution :
bash
```
$kubectl get pods -n newrelic --watch
```
Pour l'installation du manifeste : Vous devriez voir des pods avec des noms tels que nr-k8s-otel-collector-deployment-<hash> à l'état Running.
Pour l'installation de Helm : vous devriez voir des pods avec des noms tels que elasticsearch-nrdot-collector-<hash> à l'état Running.
Vérifiez les logs du collecteur pour détecter d'éventuelles erreurs :
Pour l'installation via manifeste :
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=nr-k8s-otel-collector -f
```
Pour l'installation Helm :
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector -f
```
Recherchez les connexions réussies aux pods Elasticsearch et à New Relic. Si vous rencontrez des erreurs, consultez le guide de dépannage.

Exécutez une requête NRQL dans New Relic pour confirmer que les données arrivent (remplacez elasticsearch-cluster par le nom de votre cluster) :

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

Avant de commencer

Avant de déployer l'OTel Collector Contrib sur Kubernetes, assurez-vous d'avoir :

Privilèges d'accès requis :

Votre New Relic
Accès kubectl à votre cluster Kubernetes
Privilèges d'administration de cluster Elasticsearch avec le privilège de cluster monitor ou manage (voir la documentation sur les privilèges de sécurité Elasticsearch pour plus de détails)
Configuration requise :
Elasticsearch version 7.16 ou supérieure - Cette intégration nécessite un cluster Elasticsearch moderne
Cluster Kubernetes - Un cluster Kubernetes en cours d'exécution où Elasticsearch est déployé
Helm 3.0 ou version ultérieure - Helm installé sur votre système
Connectivité réseau - HTTPS sortant (port 443) vers le point de terminaison d'ingestion OTLPde New Relic
Prérequis du pod Elasticsearch :
Étiquettes de pod (Requis) - Chaque pod Elasticsearch doit avoir l'étiquette app: elasticsearch pour que la découverte automatique fonctionne. Sans ce label, le collecteur ne détectera ni ne monitorera vos pods.
Important
Comment ajouter des étiquettes aux pods Elasticsearch :
Si vous utilisez un StatefulSet ou un Deployment pour Elasticsearch, ajoutez l'étiquette dans le modèle de 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
Pour les pods existants sans étiquettes, mettez à jour votre StatefulSet/Deployment et redémarrez les pods :
bash
```
$kubectl label pods -l <your-existing-selector> app=elasticsearch -n <namespace>
```
Vous pouvez vérifier que les étiquettes sont correctement définies :
bash
```
$kubectl get pods -n <namespace> --show-labels
```

Créer un secret Kubernetes pour les identifiants

Créez un secret Kubernetes pour stocker vos identifiants New Relic en toute sécurité :

Créer l'espace de noms :
bash
```
$kubectl create namespace newrelic
```

Créez le secret :

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

Mettre à jour les valeurs :

Remplacez YOUR_LICENSE_KEY_HERE par votre clé de licence New Relic
Remplacez https://otlp.nr-data.net:4318 par l'endpoint de votre région (consultez la documentation sur les endpoints OTLP)
Remplacez 100 par la limite de mémoire souhaitée en MiB pour le collecteur (par défaut : 100 MiB). Ajustez en fonction des besoins de votre environnement

Configurer le monitoring d'Elasticsearch

Créez un fichier values.yaml pour configurer le collecteur OpenTelemetry pour le monitoring d'Elasticsearch :

Conseil

Personnalisez pour votre environnement : Mettez à jour les valeurs suivantes dans la configuration :

Modifications requises :

Règle de label de Pod - La règle labels["app"] == "elasticsearch" doit correspondre à vos labels de Pod. Si vos pods Elasticsearch utilisent des labels différents (par ex. app: es-cluster), mettez à jour la règle en conséquence :
```
rule: type == "pod" && labels["app"] == "es-cluster"
```
Nom du cluster - Remplacez elasticsearch-cluster par un nom unique pour identifier votre cluster dans New Relic. Ce nom sera utilisé pour créer et identifier vos entités Elasticsearch dans l'interface utilisateur New Relic. Choisissez un nom unique dans votre compte New Relic (par ex. prod-es-k8s, staging-elasticsearch)
Modifications facultatives :
Port - Mettez à jour 9200 si Elasticsearch s'exécute sur un port différent
Authentification - Ajoutez des identifiants si votre cluster Elasticsearch est sécurisé

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]

Conseil

Pour les clusters Elasticsearch sécurisés : si votre cluster Elasticsearch nécessite une authentification, ajoutez les identifiants à la configuration du récepteur :

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

Stockez les identifiants de manière sécurisée à l'aide de secrets Kubernetes plutôt que de les coder en dur dans le fichier de valeurs.

Installer avec Helm

Installez le Collecteur OpenTelemetry à l'aide de Helm avec votre configuration 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

Vérifier le déploiement et la collecte de données

Vérifiez que l'OpenTelemetry Collector est en cours d'exécution et collecte les données Elasticsearch :

Vérifiez que les pods du collecteur sont en cours d'exécution :
bash
```
$kubectl get pods -n newrelic --watch
```
Vous devriez voir des pods avec des noms tels que elasticsearch-otel-collector-<hash> à l'état Running.
Vérifiez les logs du collecteur pour détecter d'éventuelles erreurs :
bash
```
$kubectl logs -n newrelic -l app.kubernetes.io/name=opentelemetry-collector -f
```
Recherchez les connexions réussies aux pods Elasticsearch et à New Relic. Si vous rencontrez des erreurs, consultez le guide de dépannage.

Exécutez une requête NRQL dans New Relic pour confirmer que les données arrivent (remplacez elasticsearch-cluster par le nom de votre cluster) :

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

Utilisez cette approche si vous avez déjà un exportateur Prometheus Elasticsearch en cours d’exécution dans votre cluster Kubernetes, ou si vous migrez depuis une stack de monitoring basée sur Prometheus.

Conseil

Recommandé : si vous n'avez pas déjà un exportateur Prometheus en cours d'exécution, utilisez plutôt les onglets NRDOT Collector ou OTel Collector Contrib. Ils se connectent directement à l'API Elasticsearch sans nécessiter de composant exportateur supplémentaire.

Déployer l'exportateur Elasticsearch

Si l'exportateur n'est pas déjà en cours d'exécution, déployez-le à l'aide de Helm :

bash

$helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
$helm repo update
$
$helm install elasticsearch-exporter prometheus-community/prometheus-elasticsearch-exporter \
>  --namespace monitoring \
>  --create-namespace \
>  --set es.uri=http://elasticsearch.default.svc.cluster.local:9200

Remplacez elasticsearch.default.svc.cluster.local:9200 par l'adresse de votre service Elasticsearch.

Vérifiez que l'exportateur est en cours d'exécution :

bash

$kubectl get pods -n monitoring -l app=prometheus-elasticsearch-exporter

Créer le secret d'identifiants

bash

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

Remplacez YOUR_NEWRELIC_LICENSE_KEY par votre .

Conseil

Pour les comptes UE, utilisez NEWRELIC_OTLP_ENDPOINT=https://otlp.eu01.nr-data.net:4318

Créer la ConfigMap du collecteur

Créez un ConfigMap avec la configuration du collecteur. Cela fonctionne avec les images de conteneur NRDOT (newrelic/nrdot-collector) et Collecteur Otel Contrib (otel/opentelemetry-collector-contrib). La configuration récupère les métriques de l'exportateur Elasticsearch et traduit les noms de métrique Prometheus en noms compatibles avec OpenTelemetry qui alimentent le dashboard Elasticsearch de New Relic.

Enregistrez ce qui suit sous otel-collector-prometheus-es.yaml et appliquez avec kubectl apply -f otel-collector-prometheus-es.yaml:

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-collector-prometheus-es
  namespace: monitoring
data:
  config.yaml: |
    receivers:
      prometheus/elasticsearch:
        config:
          scrape_configs:
            - job_name: 'elasticsearch'
              scrape_interval: 15s
              static_configs:
                - targets: ['elasticsearch-exporter-prometheus-elasticsearch-exporter.monitoring.svc.cluster.local:9114']

    processors:
      memory_limiter:
        check_interval: 60s
        limit_mib: 100

      metricstransform/prom_to_otel:
        transforms:
          - include: ^elasticsearch_cluster_health_number_of_data_nodes$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.data_nodes
          - include: ^elasticsearch_cluster_health_status$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.health
            operations:
              - action: update_label
                label: color
                new_label: status
          - include: ^elasticsearch_cluster_health_number_of_in_flight_fetch$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.in_flight_fetch
          - include: ^elasticsearch_cluster_health_number_of_nodes$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.nodes
          - include: ^elasticsearch_cluster_health_number_of_pending_tasks$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.pending_tasks
          - include: ^elasticsearch_cluster_health_active_shards$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.shards
            operations:
              - action: add_label
                new_label: state
                new_value: active
          - include: ^elasticsearch_cluster_health_unassigned_shards$
            match_type: regexp
            action: update
            new_name: elasticsearch.cluster.shards
            operations:
              - action: add_label
                new_label: state
                new_value: unassigned
          - include: ^elasticsearch_indices_docs$
            match_type: regexp
            action: insert
            new_name: elasticsearch.node.documents
            operations:
              - action: add_label
                new_label: state
                new_value: active
          - include: ^elasticsearch_indices_docs$
            match_type: regexp
            action: insert
            new_name: elasticsearch.index.documents
            operations:
              - action: add_label
                new_label: state
                new_value: active
              - action: add_label
                new_label: aggregation
                new_value: primary_shards
              - action: add_label
                new_label: elasticsearch.index.name
                new_value: _all
          - include: ^elasticsearch_indices_fielddata_evictions$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.cache.evictions
            operations:
              - action: add_label
                new_label: cache_name
                new_value: fielddata
          - include: ^elasticsearch_indices_query_cache_evictions$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.cache.evictions
            operations:
              - action: add_label
                new_label: cache_name
                new_value: query
          - include: ^elasticsearch_transport_rx_size_bytes_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.cluster.io
            operations:
              - action: add_label
                new_label: direction
                new_value: received
          - include: ^elasticsearch_transport_tx_size_bytes_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.cluster.io
            operations:
              - action: add_label
                new_label: direction
                new_value: sent
          - include: ^elasticsearch_filesystem_data_available_bytes$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.fs.disk.available
          - include: ^elasticsearch_filesystem_data_size_bytes$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.fs.disk.total
          - include: ^elasticsearch_indices_indexing_index_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.completed
            operations:
              - action: add_label
                new_label: operation
                new_value: index
          - include: ^elasticsearch_indices_search_query_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.completed
            operations:
              - action: add_label
                new_label: operation
                new_value: query
          - include: ^elasticsearch_indices_get_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.completed
            operations:
              - action: add_label
                new_label: operation
                new_value: get
          - include: ^elasticsearch_indices_merges_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.completed
            operations:
              - action: add_label
                new_label: operation
                new_value: merge
          - include: ^elasticsearch_indices_indexing_index_time_seconds_total$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.time
            operations:
              - action: add_label
                new_label: operation
                new_value: index
              - action: experimental_scale_value
                experimental_scale: 1000
          - include: ^elasticsearch_indices_search_query_time_seconds$
            match_type: regexp
            action: update
            new_name: elasticsearch.node.operations.time
            operations:
              - action: add_label
                new_label: operation
                new_value: query
              - action: experimental_scale_value
                experimental_scale: 1000
          - include: ^elasticsearch_os_cpu_percent$
            match_type: regexp
            action: update
            new_name: elasticsearch.os.cpu.usage
          - include: ^elasticsearch_jvm_gc_collection_seconds_count$
            match_type: regexp
            action: update
            new_name: jvm.gc.collections.count
          - include: ^elasticsearch_jvm_memory_max_bytes$
            match_type: regexp
            action: update
            new_name: jvm.memory.heap.max
          - include: ^elasticsearch_jvm_memory_used_bytes$
            match_type: regexp
            action: update
            new_name: jvm.memory.heap.used
          - include: ^elasticsearch_thread_pool_threads_count$
            match_type: regexp
            action: update
            new_name: jvm.threads.count
            operations:
              - action: aggregate_labels
                label_set: [name, cluster]
                aggregation_type: sum
          - include: ^elasticsearch_indices_segments_count$
            match_type: regexp
            action: update
            new_name: elasticsearch.index.segments.count

      filter/allowed_metrics:
        metrics:
          include:
            match_type: strict
            metric_names:
              - elasticsearch.cluster.data_nodes
              - elasticsearch.cluster.health
              - elasticsearch.cluster.in_flight_fetch
              - elasticsearch.cluster.nodes
              - elasticsearch.cluster.pending_tasks
              - elasticsearch.cluster.shards
              - elasticsearch.index.documents
              - elasticsearch.index.segments.count
              - elasticsearch.node.cache.evictions
              - elasticsearch.node.cluster.io
              - elasticsearch.node.documents
              - elasticsearch.node.fs.disk.available
              - elasticsearch.node.fs.disk.total
              - elasticsearch.node.operations.completed
              - elasticsearch.node.operations.time
              - elasticsearch.os.cpu.usage
              - jvm.gc.collections.count
              - jvm.memory.heap.max
              - jvm.memory.heap.used
              - jvm.threads.count

      transform/rename_node_name:
        metric_statements:
          - context: datapoint
            statements:
              - set(attributes["elasticsearch.node.name"], attributes["name"]) where attributes["name"] != nil
              - delete_key(attributes, "name") where attributes["elasticsearch.node.name"] != nil

      groupbyattrs/node:
        keys:
          - elasticsearch.node.name
          - elasticsearch.cluster.name

      cumulativetodelta: {}

      resource/cluster_name_override:
        attributes:
          - key: elasticsearch.cluster.name
            value: "<elasticsearch-cluster-name>"
            action: upsert

      transform/scope_override:
        metric_statements:
          - context: scope
            statements:
              - set(name, "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/elasticsearchreceiver")
              - set(version, "")

      resourcedetection:
        detectors: [env]
        env:
          resource_attributes:
            host.name:
              enabled: true

      batch:
        timeout: 30s
        send_batch_size: 2048
        send_batch_max_size: 4096

      attributes/cardinality_reduction:
        actions:
          - key: process.pid
            action: delete
          - key: process.parent_pid
            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}
        compression: gzip
        timeout: 30s
        retry_on_failure:
          enabled: true
          initial_interval: 5s
          max_interval: 30s
          max_elapsed_time: 300s

    service:
      pipelines:
        metrics/elasticsearch:
          receivers: [prometheus/elasticsearch]
          processors:
            - memory_limiter
            - metricstransform/prom_to_otel
            - filter/allowed_metrics
            - transform/rename_node_name
            - groupbyattrs/node
            - transform/scope_override
            - resourcedetection
            - resource/cluster_name_override
            - attributes/cardinality_reduction
            - cumulativetodelta
            - transform/metadata_nullify
            - batch
          exporters: [otlphttp]

Remplacez les valeurs suivantes dans la configuration :

<elasticsearch-cluster-name>: le nom de votre cluster Elasticsearch
elasticsearch-exporter-prometheus-elasticsearch-exporter.monitoring.svc.cluster.local:9114: l'adresse du service Kubernetes de votre exportateur

Déployer le collecteur

Déployez le collecteur en utilisant l'image NRDOT ou Collecteur Otel Contrib. Mettez à jour le champ image ci-dessous selon votre choix :

NRDOT : newrelic/nrdot-collector:latest

Collecteur OTel Contrib : otel/opentelemetry-collector-contrib:latest

Enregistrez ce qui suit sous otel-collector-deployment.yaml et appliquez avec kubectl apply -f otel-collector-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: otel-collector-elasticsearch
  namespace: monitoring
  labels:
    app: otel-collector-elasticsearch
spec:
  replicas: 1
  selector:
    matchLabels:
      app: otel-collector-elasticsearch
  template:
    metadata:
      labels:
        app: otel-collector-elasticsearch
    spec:
      containers:
        - name: otel-collector
          image: otel/opentelemetry-collector-contrib:latest
          args:
            - "--config=/etc/otel/config.yaml"
          env:
            - name: NEWRELIC_LICENSE_KEY
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: NEWRELIC_LICENSE_KEY
            - name: NEWRELIC_OTLP_ENDPOINT
              valueFrom:
                secretKeyRef:
                  name: newrelic-credentials
                  key: NEWRELIC_OTLP_ENDPOINT
          volumeMounts:
            - name: config
              mountPath: /etc/otel
          resources:
            requests:
              memory: "128Mi"
              cpu: "100m"
            limits:
              memory: "256Mi"
              cpu: "500m"
      volumes:
        - name: config
          configMap:
            name: otel-collector-prometheus-es

Vérifier le déploiement

Vérifiez que le pod du collecteur est en cours d'exécution :
bash
```
$kubectl get pods -n monitoring -l app=otel-collector-elasticsearch
```

Vérifiez les logs du collecteur :

bash

$kubectl logs -n monitoring -l app=otel-collector-elasticsearch -f

Vérifiez les données dans New Relic :

FROM Metric SELECT count(*)
WHERE metricName LIKE 'elasticsearch.%'
AND elasticsearch.cluster.name = '<elasticsearch-cluster-name>'
SINCE 10 minutes ago

Conseil

Corréler APM avec Elasticsearch: pour connecter votre application APM et votre cluster Elasticsearch, incluez l'attribut de ressource es.cluster.name="your-cluster-name" dans vos métriques APM. Cela permet une visibilité inter-services et un dépannage plus rapide au sein de New Relic.

Dépannage

Si vous rencontrez des problèmes lors de l'installation ou si vous ne voyez pas de données dans New Relic, consultez notre guide de dépannage complet pour obtenir des solutions étape par étape aux problèmes courants.

Pour les problèmes spécifiques à Kubernetes, tels que la découverte de pods, les permissions RBAC ou la connectivité réseau, reportez-vous à la section de dépannage Kubernetes.

Cette traduction automatique est fournie pour votre commodité.

Monitorer Elasticsearch sur Kubernetes avec OpenTelemetry

Options d'installation

Avant de commencer

Important

Choisissez votre méthode d'installation

Installer et configurer le Collector NRDOT

Installation via manifeste

Terminez l'installation de base du manifeste Kubernetes OpenTelemetry

Mettre à jour l'image du collecteur vers NRDOT

Configurer le monitoring d'Elasticsearch [#nrdot-configure-es]

Conseil

Appliquer les manifestes mis à jour [#nrdot-apply-manifests]

Installation Helm

Créer un secret Kubernetes pour les identifiants

Configurer le monitoring d'Elasticsearch

Conseil

Installer avec Helm [#nrdot-helm-install]

Vérifier le déploiement et la collecte de données

Avant de commencer

Important

Créer un secret Kubernetes pour les identifiants

Configurer le monitoring d'Elasticsearch

Conseil

Conseil

Installer avec Helm

Vérifier le déploiement et la collecte de données

Conseil

Déployer l'exportateur Elasticsearch

Créer le secret d'identifiants

Conseil

Créer la ConfigMap du collecteur

ConfigMap complet du récepteur Prometheus

Déployer le collecteur

Vérifier le déploiement

Conseil

Dépannage

Cette traduction automatique est fournie pour votre commodité.

Monitorer Elasticsearch sur Kubernetes avec OpenTelemetry

Options d'installation .css-21sua1{background:none;border:none;width:0;padding:0;}

Avant de commencer

Important

Choisissez votre méthode d'installation

Installer et configurer le Collector NRDOT

Installation Helm

Vérifier le déploiement et la collecte de données

Avant de commencer

Important

Créer un secret Kubernetes pour les identifiants

Configurer le monitoring d'Elasticsearch

Conseil

Conseil

Installer avec Helm

Vérifier le déploiement et la collecte de données

Conseil

Déployer l'exportateur Elasticsearch

Créer le secret d'identifiants

Conseil

Créer la ConfigMap du collecteur

ConfigMap complet du récepteur Prometheus

Déployer le collecteur

Vérifier le déploiement

Conseil

Dépannage

Options d'installation