Benchmarking d'Elasticsearch : Outils et techniques pour la validation des performances

Étalonnage (Benchmarking) d'Elasticsearch : Outils et techniques pour la validation des performances

Une validation des performances efficace est cruciale pour tout déploiement Elasticsearch. Que vous optimisiez la vitesse d'indexation, la latence des requêtes ou le débit global du cluster, un étalonnage robuste fournit les données objectives nécessaires pour confirmer que vos efforts d'ajustement sont fructueux. Sans un étalonnage approprié, les améliorations de performance peuvent être subjectives et des problèmes critiques peuvent passer inaperçus.

Cet article vous guidera à travers le processus d'étalonnage d'Elasticsearch, couvrant les outils essentiels, les méthodologies pour concevoir des tests de charge reproductibles, et les métriques clés à surveiller. En comprenant ces principes, vous pourrez mesurer et valider avec confiance les améliorations de performance, garantissant que votre cluster Elasticsearch fonctionne à son efficacité maximale.

Pourquoi l'étalonnage est essentiel

L'étalonnage est plus que la simple exécution de quelques requêtes. C'est un processus systématique de mesure des performances de votre cluster Elasticsearch sous diverses charges de travail. Voici pourquoi il est indispensable :

Mesure Objective : Fournit des données quantifiables pour évaluer les performances. Au lieu de deviner, vous savez exactement à quel point un changement effectué est plus rapide ou plus lent.
Identification des goulots d'étranglement : Aide à identifier les zones spécifiques du système qui entravent les performances, telles que les requêtes lentes, les nœuds surchargés ou une indexation inefficace.
Validation des Optimisations : Crucial pour confirmer que les changements apportés lors de l'ajustement des performances (par exemple, les paramètres d'index, l'allocation des shards, les mises à niveau matérielles) ont l'effet souhaité.
Planification de la Capacité : Informe les décisions concernant la mise à l'échelle de votre cluster en comprenant ses limites actuelles et son comportement sous une charge croissante.
Tests de Régression : Garantit que les nouveaux déploiements de code ou les changements de configuration n'impactent pas négativement les performances.

Métriques clés à surveiller

Lors de l'étalonnage, concentrez-vous sur les métriques qui reflètent directement l'expérience utilisateur et la santé du système. Celles-ci peuvent généralement être classées comme suit :

Métriques d'indexation

Débit d'indexation : Le nombre de documents indexés par seconde. Plus c'est élevé, mieux c'est généralement.
Latence d'indexation : Le temps nécessaire pour qu'un document devienne interrogeable après avoir été indexé. Moins c'est élevé, mieux c'est.
Impact de l'intervalle de rafraîchissement : Comment les changements apportés au paramètre refresh_interval affectent la vitesse d'indexation et la visibilité des recherches.

Métriques de recherche

Débit de recherche : Le nombre de requêtes de recherche traitées par seconde.
Latence de recherche : Le temps nécessaire pour répondre à une requête de recherche. Ceci est souvent ventilé en :
- Latence totale : Temps de bout en bout.
- Latence de requête : Temps passé à exécuter la requête de recherche elle-même.
- Latence de récupération (Fetch Latency) : Temps passé à récupérer les documents réels.
Hits par seconde : Le nombre de documents retournés par les requêtes de recherche par seconde.

Métriques de santé du cluster

Utilisation du CPU : Un CPU élevé peut indiquer des requêtes ou une indexation inefficaces.
Utilisation de la mémoire : Cruciale pour le tas (heap) JVM et le cache du système de fichiers OS.
E/S disque : Les goulots d'étranglement ici peuvent affecter gravement l'indexation et la recherche.
Trafic réseau : Important dans les environnements distribués.
Utilisation du tas JVM : Surveille l'activité de ramasse-miettes (garbage collection), qui peut provoquer des pauses.

Outils d'étalonnage populaires pour Elasticsearch

Plusieurs outils peuvent aider à simuler la charge et à mesurer les performances d'Elasticsearch. Le choix du bon outil dépend de vos besoins spécifiques et de votre expertise technique.

1. Rally

Rally est l'outil d'étalonnage officiel d'Elasticsearch. Il est puissant, flexible et conçu pour simuler des charges de travail utilisateur réalistes.

Caractéristiques principales :

Définition de la charge de travail : Permet de définir des tâches complexes d'indexation et de recherche à l'aide du DSL de Rally.
Génération de données : Peut générer des données synthétiques ou utiliser des jeux de données existants.
Collecte de métriques : Rassemble des métriques de performance détaillées pendant les exécutions de tests.
Intégration : Fonctionne de manière transparente avec Elasticsearch et OpenSearch.

Exemple : Exécuter un étalonnage de recherche de base avec Rally

Tout d'abord, assurez-vous que Rally est installé et configuré pour se connecter à votre cluster Elasticsearch. Vous pouvez définir une tâche dans un fichier JSON, par exemple my_search_task.json :

{
  "challenge": "my_custom_search_challenge",
  "clients": [
    {
      "current-version": "@version"
    }
  ],
  "tasks": [
    {
      "name": "search_some_data",
      "description": "Exécuter une requête de recherche simple.",
      "operation": {
        "operation-type": "search",
        "index": "logs-*",
        "body": {
          "query": {
            "match": {
              "message": "error"
            }
          }
        }
      }
    }
  ]
}

Ensuite, vous pouvez exécuter cette tâche en utilisant la commande esrally :

esrally --challenge-file=my_search_task.json --target-hosts=localhost:9200 --challenge-name=my_custom_search_challenge

Rally exécutera la requête de recherche spécifiée plusieurs fois, collectera des métriques telles que la latence et le débit de recherche, et fournira un rapport détaillé.

2. Logstash avec le plugin d'étalonnage

Bien qu'il s'agisse principalement d'un outil ETL, Logstash peut être utilisé pour une génération de charge de base, en particulier pour l'indexation.

Caractéristiques principales :

Plugins d'entrée : Peut simuler l'ingestion de données provenant de diverses sources.
Plugins de sortie : Le plugin de sortie elasticsearch est utilisé pour envoyer des données à Elasticsearch.
Filtrage : Permet la transformation des données avant l'indexation.

Exemple : Simulation d'une charge d'indexation

Vous pouvez configurer un pipeline Logstash pour générer des données aléatoires et les envoyer à Elasticsearch :

logstash_indexer.conf :

input {
  generator {
    count => 1000000
    type => "event"
  }
}

filter {
  mutate {
    add_field => {
      "timestamp" => "%{+YYYY-MM-dd'T'HH:mm:ss.SSSZ}"
      "message" => "Ceci est un message de log de test %{random}"
    }
    remove_field => ["random", "host"]
  }
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "logstash-benchmark-%{+YYYY.MM.dd}"
    # Envisagez d'utiliser l'API bulk pour de meilleures performances
    # Envisagez de définir document_id pour les mises à jour si nécessaire
  }
}

Exécutez Logstash avec cette configuration :

bin/logstash -f logstash_indexer.conf

Surveillez les logs Elasticsearch et Logstash, ainsi que les métriques du cluster, pour évaluer les performances.

3. Scripts personnalisés (Python, Java, etc.)

Pour des scénarios très spécifiques ou complexes, l'écriture de scripts personnalisés à l'aide des clients Elasticsearch est une option viable.

Caractéristiques principales :

Flexibilité maximale : Adaptez la génération de charge précisément aux modèles de requêtes et aux besoins d'indexation de votre application.
Bibliothèques clientes : Elasticsearch fournit des bibliothèques clientes officielles pour de nombreux langages populaires (Python, Java, Go, .NET, etc.).

Exemple : Script Python pour la charge de recherche

from elasticsearch import Elasticsearch
import time
import threading

# Configurez votre connexion Elasticsearch
ES_HOST = "localhost:9200"
es = Elasticsearch([ES_HOST])

# Définissez votre requête de recherche
SEARCH_QUERY = {
    "query": {
        "match": {
            "content": "example data"
        }
    }
}

NUM_THREADS = 10
QUERIES_PER_THREAD = 100

results = []

def perform_search():
    for _ in range(QUERIES_PER_THREAD):
        start_time = time.time()
        try:
            response = es.search(index="my-index-*", body=SEARCH_QUERY, size=10)
            end_time = time.time()
            results.append({
                "latency": (end_time - start_time) * 1000, # en millisecondes
                "success": True,
                "hits": response['hits']['total']['value']
            })
        except Exception as e:
            end_time = time.time()
            results.append({
                "latency": (end_time - start_time) * 1000,
                "success": False,
                "error": str(e)
            })
        time.sleep(0.1) # Petit délai entre les requêtes

threads = []
for i in range(NUM_THREADS):
    thread = threading.Thread(target=perform_search)
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

# Analyser les résultats
successful_searches = [r for r in results if r['success']]
failed_searches = [r for r in results if not r['success']]

if successful_searches:
    avg_latency = sum(r['latency'] for r in successful_searches) / len(successful_searches)
    total_hits = sum(r['hits'] for r in successful_searches)
    print(f"Latence moyenne : {avg_latency:.2f} ms")
    print(f"Total des hits : {total_hits}")
    print(f"Recherches réussies : {len(successful_searches)}")
else:
    print("Aucune recherche réussie effectuée.")

if failed_searches:
    print(f"Recherches échouées : {len(failed_searches)}")
    for r in failed_searches:
        print(f"  - Erreur : {r['error']} (Latence : {r['latency']:.2f} ms)")

Ce script utilise le client elasticsearch-py de Python pour simuler des requêtes de recherche concurrentes et mesurer leur latence.

Concevoir des tests de charge reproductibles

Pour obtenir des résultats significatifs, vos tests de charge doivent être reproductibles et représentatifs de vos modèles d'utilisation réels.

1. Définir des charges de travail réalistes

Indexation : Quel est le taux d'ingestion des données ? Quelle est la taille et la complexité des documents ? Effectuez-vous une indexation par lot (bulk) ou une indexation document par document ?
Recherche : Quels sont les types de requêtes typiques (par exemple, match, term, range, agrégations) ? Quelle est la complexité de ces requêtes ? Quelle est la concurrence attendue ?
Distribution des données : Comment vos données sont-elles distribuées sur les index et les shards ? Utilisez une distribution de données similaire à la production si possible.

2. Établir une base de référence (Baseline)

Avant d'apporter des modifications, exécutez l'outil d'étalonnage choisi pour établir une performance de référence. Cette référence est votre point de comparaison pour mesurer l'impact des optimisations.

3. Isoler les variables

Effectuez un seul changement à la fois. Si vous testez plusieurs optimisations, exécutez les étalonnages après chaque modification individuelle. Cela vous aide à comprendre quel changement spécifique a conduit à une amélioration (ou une dégradation) des performances.

4. Environnement cohérent

Assurez-vous que l'environnement de test est aussi cohérent que possible entre les exécutions de l'étalonnage. Cela inclut :

Matériel : Utilisez les mêmes nœuds avec des spécifications identiques.
Logiciel : Utilisez la même version d'Elasticsearch, les mêmes paramètres JVM et les mêmes configurations OS.
Réseau : Maintenez des conditions réseau cohérentes.
Données : Utilisez le même jeu de données ou la même méthode de génération de données.

5. Durée de test et période de préchauffage suffisantes

Période de préchauffage (Warm-up) : Laissez le cluster se préchauffer avant de commencer les mesures. Cela implique d'exécuter une charge initiale pour permettre aux caches de se remplir et à la JVM de se stabiliser.
Durée du test : Exécutez les tests suffisamment longtemps pour capturer des moyennes significatives et tenir compte des comportements système transitoires. Des tests courts peuvent être trompeurs.

6. Surveiller les ressources système

Surveillez toujours les ressources système (CPU, RAM, E/S disque, Réseau) à la fois sur les nœuds Elasticsearch et sur les nœuds clients exécutant les outils d'étalonnage. Cela aide à corréler les métriques de performance avec l'utilisation des ressources et à identifier les goulots d'étranglement.

Bonnes pratiques pour l'étalonnage

Automatiser : Intégrez l'étalonnage dans votre pipeline CI/CD pour détecter les régressions tôt.
Commencer simple : Commencez par des étalonnages d'indexation et de recherche de base avant de passer à des scénarios complexes.
Comprendre vos données : La nature de vos données (taille des documents, types de champs) a un impact significatif sur les performances.
Considérer la stratégie d'indexation : Testez différents paramètres de refresh_interval, translog et de dimensionnement des shards.
Optimiser les requêtes : Assurez-vous que vos requêtes de recherche sont efficaces. Utilisez l'API profile pour analyser les requêtes lentes.
Surveiller la JVM : Portez une attention particulière aux logs de ramasse-miettes et à l'utilisation du tas (heap).

Conclusion

L'étalonnage d'Elasticsearch est un processus itératif qui nécessite une planification minutieuse, les bons outils et une approche systématique. En tirant parti d'outils comme Rally, en concevant des tests de charge reproductibles et en se concentrant sur les indicateurs de performance clés, vous pouvez obtenir des informations approfondies sur le comportement de votre cluster. Ces données objectives sont inestimables pour valider les améliorations de performance, identifier les goulots d'étranglement et garantir que votre déploiement Elasticsearch répond à ses exigences exigeantes.