Monitorer Elasticsearch auto-hébergé avec OpenTelemetry

Monitorez votre cluster Elasticsearch auto-hébergé en installant le collecteur OpenTelemetry directement sur des serveurs ou des machines virtuelles. New Relic propose des options de déploiement flexibles pour répondre à votre configuration d'infrastructure et à vos exigences de monitoring.

Vous pouvez choisir entre deux distributions de collecteur :

NRDOT : Distribution New Relic d'OpenTelemetry
OTel Collector Contrib : Collecteur OpenTelemetry standard avec des composants issus de la communauté

Options d'installation

Choisissez la distribution du collecteur qui correspond à vos besoins :

Important

La prise en charge du monitoring Elasticsearch par NRDOT arrive bientôt ! Restez à l'écoute pour les mises à jour !

Avant de commencer

Avant de configurer l'OTel Collector Contrib, assurez-vous d'avoir :

Privilèges d'accès requis :

Votre New Relic
Privilèges root ou sudo sur la machine hôte
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
Connectivité réseau - HTTPS sortant (port 443) vers le point de terminaison d'ingestion OTLPde New Relic
Valeurs de configuration prêtes :
Point de terminaison Elasticsearch - L'URL de votre cluster Elasticsearch (par ex. http://localhost:9200)
Nom du cluster - Un identifiant unique pour votre cluster dans New Relic
Important
Vous devez avoir installé OpenTelemetry Collector Contrib sur votre hôte avant de continuer. Nous recommandons l'installation via les paquets officiels (.deb ou .rpm) pour garantir que l'unité de service systemd est créée correctement.

Configurer le monitoring d'Elasticsearch

Une fois l'OTel Collector Contrib installé, remplacez le fichier de configuration par défaut du collecteur par la configuration du monitoring Elasticsearch. Cela activera la collecte des métriques Elasticsearch. Les métriques et les logs de l'hôte sont facultatifs et peuvent être ajoutés séparément.

Le fichier de configuration se trouve à : /etc/otelcol-contrib/config.yaml

Conseil

Sauvegardez votre configuration par défaut : Avant de modifier le fichier de configuration, créez une copie de sauvegarde pour conserver les paramètres par défaut :

bash

$sudo cp /etc/otelcol-contrib/config.yaml /etc/otelcol-contrib/config.yaml.backup

Pour configurer le collecteur :

Ouvrez le fichier de configuration avec un éditeur de texte en utilisant les privilèges root ou sudo :
bash
```
$sudo nano /etc/otelcol-contrib/config.yaml
```

Supprimez tout le contenu existant et remplacez-le par la configuration suivante pour le monitoring d'Elasticsearch :

Important

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

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
processors:
  memory_limiter:
    check_interval: 60s
    limit_mib: ${env:NEW_RELIC_MEMORY_LIMIT_MIB:-100}
  cumulativetodelta: {}
  resource/cluster_name_override:
    attributes:
      - key: elasticsearch.cluster.name
        value: "<elasticsearch-cluster-name>"
        action: upsert
  resourcedetection:
    detectors: [ 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
  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:
  pipelines:
    metrics/elasticsearch:
      receivers: [elasticsearch]
      processors: [memory_limiter, resourcedetection, resource/cluster_name_override, attributes/cardinality_reduction, cumulativetodelta, transform/metadata_nullify, batch]
      exporters: [otlphttp]

(Facultatif) Pour un Elasticsearch sécurisé avec authentification et SSL, modifiez la configuration du récepteur :

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

(Facultatif) Pour collecter les métriques de l'hôte, ajoutez le récepteur hostmetrics :

receivers:
  hostmetrics:
    collection_interval: 60s
    scrapers:
      cpu:
        metrics:
          system.cpu.utilization: {enabled: true}
          system.cpu.time: {enabled: true}
      load:
        metrics:
          system.cpu.load_average.1m: {enabled: true}
          system.cpu.load_average.5m: {enabled: true}
          system.cpu.load_average.15m: {enabled: true}
      memory:
        metrics:
          system.memory.usage: {enabled: true}
          system.memory.utilization: {enabled: true}
      disk:
        metrics:
          system.disk.io: {enabled: true}
          system.disk.operations: {enabled: true}
      filesystem:
        metrics:
          system.filesystem.usage: {enabled: true}
          system.filesystem.utilization: {enabled: true}
      network:
        metrics:
          system.network.io: {enabled: true}
          system.network.packets: {enabled: true}
      process:
        metrics:
          process.cpu.utilization:
            enabled: true

Et ajoutez aux pipelines de service :

service:
  pipelines:
    metrics/host:
      receivers: [hostmetrics]
      processors: [memory_limiter, resourcedetection, batch]
      exporters: [otlphttp]

(Facultatif) Pour collecter les logs Elasticsearch, ajoutez le récepteur filelog. Assurez-vous que l'utilisateur exécutant le service du collecteur (otelcol-contrib) dispose d'un accès en lecture à vos fichiers de logs Elasticsearch :

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

receivers:
  filelog:
    include:
      - /var/log/elasticsearch/elasticsearch.log
      - /var/log/elasticsearch/*.log

Si vous exécutez Elasticsearch dans Docker :

receivers:
  filelog:
    include:
      - /var/lib/docker/containers/*/*.log
    operators:
      - type: move
        from: attributes.log
        to: body

Et ajoutez aux pipelines de service :

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

(Facultatif) Pour ajouter des tags de métadonnées personnalisés à vos métriques, utilisez le processeur resource/static_override :

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

Enregistrez le fichier de configuration.
Définissez les variables d'environnement :
Créer un répertoire de remplacement systemd :
bash
```
$sudo mkdir -p /etc/systemd/system/otelcol-contrib.service.d
```
Créez le fichier de configuration de l'environnement :
bash
```
$cat <<EOF | sudo tee /etc/systemd/system/otelcol-contrib.service.d/environment.conf
$[Service]
$Environment="NEWRELIC_OTLP_ENDPOINT=https://otlp.nr-data.net:4318"
$Environment="NEWRELIC_LICENSE_KEY=YOUR_LICENSE_KEY_HERE"
$Environment="NEW_RELIC_MEMORY_LIMIT_MIB=100"
$EOF
```
Mettez à jour la configuration avec vos valeurs :
- Remplacez https://otlp.nr-data.net:4318 par le point de terminaison de votre région
- Remplacez YOUR_LICENSE_KEY_HERE par votre clé de licence New Relic
- 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
Redémarrez l'OTel Collector Contrib pour appliquer les modifications :
bash
```
$sudo systemctl daemon-reload
$sudo systemctl restart otelcol-contrib.service
```

Vérifier la collecte de données

Vérifiez que l'OTel Collector Contrib est en cours d'exécution et collecte des données sans erreur :

Vérifier le statut du service du collecteur :
bash
```
$sudo systemctl status otelcol-contrib.service
```
Monitorez les logs du collecteur pour détecter d'éventuelles erreurs :
bash
```
$sudo journalctl -u otelcol-contrib.service -f
```
Recherchez les connexions réussies à Elasticsearch et New Relic. Si vous rencontrez des erreurs, consultez le guide de dépannage.

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.

Afficher vos données Elasticsearch

Une fois que le collecteur est en cours d'exécution et envoie des données, vous pouvez explorer vos métriques Elasticsearch, créer des requêtes personnalisées et configurer des dashboards de monitoring dans New Relic.

Pour des informations détaillées sur l'accès à vos données, l'écriture de requêtes NRQL et la configuration d'alertes, consultez Rechercher et interroger les données Elasticsearch.

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é.

Monitorer Elasticsearch auto-hébergé avec OpenTelemetry

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

Important

Avant de commencer

Important

Configurer le monitoring d'Elasticsearch

Conseil

Important

Vérifier la collecte de données

Conseil

Afficher vos données Elasticsearch

Dépannage

Options d'installation