Installer l'intégration OpenTelemetry Elasticsearch

Installez l'intégration New Relic Elasticsearch OpenTelemetry pour monitorer vos clusters Elasticsearch avec des protocoles standard de l'industrie. Ce guide vous explique comment configurer le collecteur OpenTelemetry pour collecter les métriques et les logs de votre infrastructure Elasticsearch et les envoyer à New Relic.

Pour installer l'intégration, suivez les étapes suivantes :

Avant de commencer - Vérifiez les exigences et les prérequis
Configurer le collecteur OpenTelemetry - Configurer la collecte de données
Définir les variables d'environnement - Configurer l'authentification
Trouver et utiliser les données - Visualisez vos données Elasticsearch dans New Relic
Configurer des alertes - Configurer un monitoring proactif

Étape 1 : Avant de commencer

Assurez-vous d'avoir :

Privilèges d'accès requis - Privilèges d'administrateur de cluster Elasticsearch et compte New Relic avec accès
Elasticsearch version 7.16 ou supérieure - Cette intégration nécessite un cluster Elasticsearch moderne
Monitorer ou gérer les privilèges du cluster - Si la sécurité est activée, vous avez besoin du privilège de monitoring ou de gestion du cluster. Consultez la documentation sur les privilèges de sécurité Elasticsearch pour plus de détails
Connectivité réseau - Connectivité HTTPS sortante (port 443) vers le point de terminaison d'ingestion OTLP de New Relic
OpenTelemetry Collector - Vous devez avoir un OpenTelemetry Collector installé et en cours d'exécution sur votre hôte pour monitorer Elasticsearch. Il existe deux distributions prises en charge :
- NRDOT (Recommandé) : Suivez le guide d'installation officiel de NRDOT pour installer le collecteur sur votre hôte.
- OTel Contrib : OpenTelemetry Collector Contrib installé et en cours d'exécution sur votre hôte. Installez via un paquet officiel (.deb ou .rpm) pour garantir que l'unité de service systemd est créée correctement.
Valeurs de configuration prêtes - Vous aurez besoin de deux valeurs clés pour la configuration :
- Point de terminaison Elasticsearch - Votre URL Elasticsearch réelle (remplacer https://localhost:9200)
- Nom du cluster - Un nom unique pour identifier votre cluster dans New Relic

Conseil

Nous recommandons vivement d'utiliser la NRDOT (New Relic Distribution of OpenTelemetry) plutôt que la version communautaire standard. En tant que composant appartenant à New Relic, il est :

Optimisé : Préconfiguré pour des performances maximales avec le backend New Relic.
Fiable : Testé de manière approfondie pour une stabilité et une sécurité de niveau entreprise.
Pris en charge : Bénéficie de l'assistance complète des équipes de support New Relic pour un dépannage plus rapide.

Étape 2 : Configurer le collecteur OpenTelemetry

Pour configurer la collecte de métriques et de logs depuis votre cluster Elasticsearch, créez ou mettez à jour le fichier de configuration /etc/nrdot-collector/config.yaml pour NRDOT ou /etc/otelcol-contrib/config.yaml pour Collector Contrib.

La configuration varie en fonction de votre configuration Elasticsearch et de vos exigences de monitoring. Choisissez la configuration appropriée ci-dessous :

Commencez ici si vous avez : Un cluster Elasticsearch non sécurisé sans authentification ni SSL.

Cette configuration collecte des métriques complètes à partir d'Elasticsearch et du système hôte sans authentification :

Important

Remplacez la valeur endpoint par le point de terminaison de votre cluster Elasticsearch et mettez à jour elasticsearch.cluster.name dans le bloc du processeur avec un nom unique pour identifier de manière unique votre cluster dans New Relic.

# =================================================================================================
# OpenTelemetry Collector Configuration for Elasticsearch and Host
# This configuration collects metrics and logs for a complete observability solution.
# =================================================================================================
# -------------------------------------------------------------------------------------------------
# Receivers
# Receivers define how data gets into the Collector. This config uses four receivers:
# - elasticsearch: to scrape metrics from the Elasticsearch API
# - hostmetrics: to collect system-level metrics from the host itself
# - filelog: to tail Elasticsearch log files
# -------------------------------------------------------------------------------------------------
receivers:
  elasticsearch:
    endpoint: "http://localhost: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
  hostmetrics:
    collection_interval: 60s # Recommended for cost savings and stability
    scrapers:
      cpu:
        metrics:
          # CPU Utilization and Time are the core metrics
          system.cpu.utilization: {enabled: true}
          system.cpu.time: {enabled: true}
      load:
        metrics:
          # Load Averages (used for system health dashboards)
          system.cpu.load_average.1m: {enabled: true}
          system.cpu.load_average.5m: {enabled: true}
          system.cpu.load_average.15m: {enabled: true}
      memory:
        metrics:
          # Memory Usage and Utilization
          system.memory.usage: {enabled: true}
          system.memory.utilization: {enabled: true}
      disk:
        metrics:
          # Disk I/O operations (throughput)
          system.disk.io: {enabled: true}
          system.disk.operations: {enabled: true}
      filesystem:
        metrics:
          # Filesystem usage (disk space capacity)
          system.filesystem.usage: {enabled: true}
          system.filesystem.utilization: {enabled: true} 
      network:
        # Since this was already working, keeping it simple is best.
        # But for completeness:
        metrics:
          system.network.io: {enabled: true}
          system.network.packets: {enabled: true}
      process:
           metrics:
             process.cpu.utilization:
               enabled: true
# -------------------------------------------------------------------------------------------------
# Processors
# -------------------------------------------------------------------------------------------------
processors:
  # used to prevent out of memory situations on the collector
  memory_limiter:
    check_interval: 60s
    limit_mib: ${env:NEW_RELIC_MEMORY_LIMIT_MIB:-100}
  cumulativetodelta: {}
  resource/cluster_name_override:
    attributes:
      # Use the actual cluster name defined in your Elasticsearch config
      - key: elasticsearch.cluster.name
        value: "<elasticsearch-cluster-name>" # <-- REPLACE THIS WITH A UNIQUE CLUSTER NAME TO UNIQUELY IDENTIFY YOUR CLUSTER IN NEW RELIC 
        action: upsert
  # This processor adds resource attributes to all telemetry data.
  # 'service.name' is crucial for creating an entity in New Relic.
  resourcedetection:
    detectors: [ system ]
    system:
      resource_attributes:
        host.name:
          enabled: true
        host.id:
          enabled: true
        os.type:
          enabled: true 
  # This processor batches data for more efficient sending.
  batch:
    timeout: 10s
    send_batch_size: 1024
  # 1. CARDINALITY REDUCTION: Drops volatile or redundant attributes
  attributes/cardinality_reduction:
    actions:
      # Filter out VOLATILE PROCESS IDS (High churn)
      - key: process.pid
        action: delete
      - key: process.parent_pid
        action: delete
  transform/metadata_nullify:
    # We use 'metric_statements' to run OTTL logic on the metric signal
    metric_statements:
      - context: metric  # <-- Targets the high-level Metric structure itself
        statements:
          # Sets the 'description' field to an empty string ("")
          - set(description, "")
          # Sets the 'unit' field to an empty string ("")
          - set(unit, "")      
exporters:
  # This exporter sends all data to New Relic via OTLP/HTTP.
  otlphttp:
    endpoint: ${env:NEWRELIC_OTLP_ENDPOINT}
    headers:
      api-key: ${env:NEWRELIC_LICENSE_KEY}
# -------------------------------------------------------------------------------------------------
# Service
# The service block defines the pipelines.
# -------------------------------------------------------------------------------------------------
service:
  pipelines:
    metrics/elasticsearch:
      receivers: [elasticsearch]
      processors: [memory_limiter, resourcedetection, resource/cluster_name_override, attributes/cardinality_reduction, cumulativetodelta, transform/metadata_nullify, batch]
      exporters: [otlphttp]
    metrics/host:
      receivers: [hostmetrics]
      processors: [memory_limiter, resourcedetection,batch]
      exporters: [otlphttp]

Utilisez ceci si vous avez : Un cluster Elasticsearch sécurisé avec authentification et/ou certificats SSL.

Ajoutez les informations d'identification d'authentification et la configuration SSL à la configuration de base ci-dessus :

receivers:
  elasticsearch:
    endpoint: "https://localhost:9200"
    username: "elastic"
    password: "your_password"
    tls:
      ca_file: "/etc/elasticsearch/certs/http_ca.crt"
      insecure_skip_verify: false
    collection_interval: 15s

Facultatif : Incluez ceci si vous souhaitez envoyer des fichiers logs Elasticsearch à New Relic en plus des métriques.

Ajoutez la configuration du récepteur filelog pour collecter et transférer les logs Elasticsearch. Assurez-vous que l'utilisateur exécutant le service de collecteur (par exemple, nrdot-collector ou otelcol-contrib) dispose d'un accès en lecture à vos fichiers logs Elasticsearch.

Si vous exécutez Elasticsearch sur Linux (hôte) :

receivers:
  filelog:
    include:
      - /var/log/elasticsearch/elasticsearch.log #Replace with path of the elasticsearch log file.
      - /var/log/elasticsearch/*.log             #We can send multiple log files using regex.

Si vous exécutez Elasticsearch dans Docker :

receivers:
  filelog:
    include:
      - /var/lib/docker/containers/*/*.log       # Replace with the container log file path. 
    operators:
      - type: move
        from: attributes.log
        to: body

Ajoutez le récepteur filelog dans le pipeline de service :

service:
  pipelines:
    logs:
      receivers: [filelog]
      processors: [resource/cluster_name_override]
      exporters: [otlphttp]

Facultatif : Incluez ceci si vous souhaitez taguer vos données avec des attributs personnalisés comme l'environnement, l'équipe ou la région.

Utilisez le processeur resource/static_override pour ajouter des balises de métadonnées personnalisées à toutes vos métriques :

processors:
  resource/static_override:
    attributes:
      - key: env
        value: "production"
        action: upsert
service:
  pipelines:
    metrics/elasticsearch:
      receivers: [elasticsearch]
      processors: [resourcedetection, resource/cluster_name_override, resource/static_override, attributes/cardinality_reduction, cumulativetodelta, transform/metadata_nullify, batch]
      exporters: [otlphttp]
    metrics/host:
      receivers: [hostmetrics]
      processors: [resourcedetection, resource/static_override, batch]
      exporters: [otlphttp]

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.

Étape 3 : Définir les variables d'environnement

Ajoutez la configuration suivante à /etc/systemd/system/nrdot-collector.service.d fichier, en veillant à ce que les variables d'environnement soient placées sous la section [Service] :

bash

$[Service]
$Environment="NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY_HERE"
$Environment="OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT"
$Environment="NEW_RELIC_MEMORY_LIMIT_MIB=COLLECTOR_MEMORY_LIMIT"

Pour appliquer ces modifications, rechargez le gestionnaire systemd et redémarrez le collecteur :

bash

$sudo systemctl daemon-reload
$sudo systemctl restart nrdot-collector.service

Ajoutez la configuration suivante à /etc/systemd/system/otelcol-contrib.service.d fichier, en veillant à ce que les variables d'environnement soient placées dans la section [Service] :

bash

$[Service]
$Environment="NEW_RELIC_LICENSE_KEY=YOUR_LICENSE_KEY_HERE"
$Environment="OTEL_EXPORTER_OTLP_ENDPOINT=YOUR_OTLP_ENDPOINT"
$Environment="NEW_RELIC_MEMORY_LIMIT_MIB=COLLECTOR_MEMORY_LIMIT"

Pour appliquer ces modifications, rechargez le gestionnaire systemd et redémarrez le collecteur :

bash

$sudo systemctl daemon-reload
$sudo systemctl restart otelcol-contrib.service

Étape 4 : Affichez vos données Elasticsearch

Une fois le collecteur en cours d'exécution et l'envoi de données, vous pouvez afficher vos métriques Elasticsearch dans New Relic :

Accédez à one.newrelic.com > Integrations & Agents
Rechercher Elasticsearch (OpenTelemetry)
Sous Dashboards, cliquez sur Elasticsearch OpenTelemetry Dashboard
Sélectionnez votre compte et cliquez sur View dashboard

Vous devriez voir des dashboards affichant l'état du cluster, les métriques de performance et l'utilisation des ressources.

Conseil

Vous ne voyez pas de données ? La collecte des données peut prendre quelques minutes. Si vous ne voyez pas de métriques après 10 minutes, consultez notre guide de dépannage.

Prochaines étapes avec vos données :

Explorer les métriques: toutes les métriques Elasticsearch sont stockées en tant que Metric types d'événements
Créer des requêtes personnalisées: utilisez NRQL pour créer des graphiques et des dashboards personnalisés
Configurer des alertes: passez à l'étape 5 pour configurer le monitoring proactif

Étape 5 : Configurer des alertes

Le monitoring proactif avec des alertes vous aide à détecter les problèmes avant qu'ils n'affectent vos utilisateurs. Pour créer des conditions d'alerte dans New Relic :

Accédez à one.newrelic.com > Alerts > Alert Conditions.
Cliquez sur Create condition.
Configurez l'alerte en utilisant le Guided mode ou le générateur de requêtes NRQL.

Les configurations d'alerte ci-dessous sont recommandées pour un monitoring Elasticsearch robuste :

Alertes essentielles (haute priorité)

Ces alertes monitorent les problèmes de santé critiques du cluster qui peuvent entraîner une perte de données ou des pannes de service :

Nom de l'alerte	Justification du seuil (exemple de condition)
Alerte Shards non attribués	La métrique `elasticsearch.cluster.shards` (où `state = 'unassigned'` ) est supérieure à 0 pendant au moins 5 minutes.
Alerte Nœuds de données sains	La métrique `elasticsearch.cluster.data_nodes` est inférieure à votre nombre de nœuds minimum requis pendant au moins 5 minutes.
Alerte Utilisation du tas trop élevée	Le pourcentage d'utilisation du tas (Utilisé/Max) est supérieur à 90 % pendant au moins 5 minutes.
Alerte de tâches en attente	La métrique `elasticsearch.cluster.pending_tasks` est supérieure à 5 pendant au moins 5 minutes.

Alertes de monitoring supplémentaires

Ces alertes aident à monitorer les problèmes de performance et d'exploitation :

Nom de l'alerte	Justification du seuil (exemple de condition)
Alerte de requête lente	Le 95e percentile de `elasticsearch.node.operations.time` est supérieur à 5 ms pendant au moins 2 minutes.
Shards en cours d'initialisation trop longs	La métrique `elasticsearch.cluster.shards` (où `state = 'initializing'` ) est supérieure à 0 pendant au moins 5 minutes.
Relocalisation des shards trop longue	La métrique `elasticsearch.cluster.shards` (où `state = 'relocating'` ) est supérieure à 0 pendant au moins 5 minutes.

Nom de l'alerte

Justification du seuil (exemple de condition)

Alerte de requête lente

Le 95e percentile de

elasticsearch.node.operations.time

est supérieur à 5 ms pendant au moins 2 minutes.

Shards en cours d'initialisation trop longs

La métrique

elasticsearch.cluster.shards

(où

state = 'initializing'

) est supérieure à 0 pendant au moins 5 minutes.

Relocalisation des shards trop longue

La métrique

elasticsearch.cluster.shards

(où

state = 'relocating'

) est supérieure à 0 pendant au moins 5 minutes.

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.

Cette traduction automatique est fournie pour votre commodité.

Installer l'intégration OpenTelemetry Elasticsearch

Étape 1 : Avant de commencer

Conseil

Étape 2 : Configurer le collecteur OpenTelemetry

Configuration des métriques de base

Important

Configuration de l'authentification et du SSL

Activer les logs (récepteur filelog)

Si vous exécutez Elasticsearch sur Linux (hôte) :

Si vous exécutez Elasticsearch dans Docker :

Ajoutez le récepteur filelog dans le pipeline de service :

Ajouter des métadonnées personnalisées

Conseil

Étape 3 : Définir les variables d'environnement

Étape 4 : Affichez vos données Elasticsearch

Conseil

Étape 5 : Configurer des alertes

Alertes essentielles (haute priorité)

Alertes de monitoring supplémentaires

Dépannage

Cette traduction automatique est fournie pour votre commodité.

Installer l'intégration OpenTelemetry Elasticsearch

Étape 1 : Avant de commencer .css-21sua1{background:none;border:none;width:0;padding:0;}

Conseil

Étape 2 : Configurer le collecteur OpenTelemetry

Configuration de l'authentification et du SSL

Activer les logs (récepteur filelog)

Ajouter des métadonnées personnalisées

Conseil

Étape 3 : Définir les variables d'environnement

Étape 4 : Affichez vos données Elasticsearch

Conseil

Étape 5 : Configurer des alertes

Alertes essentielles (haute priorité)

Alertes de monitoring supplémentaires

Dépannage

Étape 1 : Avant de commencer