Traces distribuées avec Jaeger et Grafana 7

Préambule

Dans le cadre de cet article, nous allons traiter essentiellement de traces et de métrologie.

Je rappelle que la métrologie, ainsi que les traces distribuées peuvent largement vous aider à troubleshooter et donc d’améliorer les performances et la stabilité de vos applicatifs.

Couplé à un APM, on peut sans nul doute trouver ce qui ne tourne pas rond ou en tout cas mettre le doigts sur des éléments clés avec l’expérience.

Traces vs Log vs Métriques : pour quels objectifs ?

Traces : suivre l’activité du bout en bout, savoir par où on passe, en combien de temps, etc.

Métriques : bénéficier des indicateurs liés à la performance, sécurité, état de santé, etc. pour nous permettre d’avoir un oeil sur des composants précis

Logs : rechercher les erreurs

Supervision : en général pour les besoins de l’équipe d’exploitation en production, escalader en cas d’incidents critique

Pourquoi la métrologie n’est pas suffisante ?

La métrologie est rarement implémentée de bout en bout, sauf si on y est fortement sensibilisé, que l’on utilise de bons framework (par exemple ou Micrometer ou Qarkus), ou si on est dans une approche orienté SRE/DevOps depuis quelque temps déjà.

NB : Souvent malheureusement on voit dans des prods classiques (qui ne sont pas encore orienté DevOps, ou Cloud) les outils d’exploitations comme la dernière roue du carrosse et synonyme de perte de temps (toute ressemblance avec des faits réels ne serait que pure et fortuite coïncidence).

Heureusement nous sommes là pour justement combler ce trou dans la raquette et ceux dés la phase de développement, que l’on soit DevOps ou pas d’ailleurs.

Quels sont les avantages de coupler la métrologie et les traces ?

Avoir des KPI c’est bien, suivre le parcours utilisateur de bout en bout c’est mieux. Ne confondez pas le Real User Monitoring avec le tracing même si certains outils implémentent les deux.

Les composants de notre POC

  • Traefik : load balancer, reverse proxy, supporte de nombreux providers (Consul, Docker, K8S, Redis, etc.)

Ainsi que des fonctionnalités permettant de faire du rate limiting, gestion de prefixes, buffering, authentification, redirections, etc.

  • Consul : service discovery, clé-valeur distribué, il expose une API Rest, on peut l’interroger via le DNS facilement en plus d’avoir une fonctionnalité d’health check
  • Grafana : frontend permettant de créer des dashboards, avec une multitude de sources de données (Prometheus, Graphite, InfluxDB, Jaeger, Cloudwatch, etc.
  • Jaeger : tracing (OpenTelemetry)
  • Prometheus : Métrologie OpenMetrics

Contexte

Nous avons une application Web de démo écrite en GO, développée par Jaeger. Celle-ci embarque des API, mais aussi les librairies OpenTelemetry, des logs verbeux, nous permettant de l’utiliser facilement avec Jaeger. Cette application sera exposée via Traefik et déclarée dans Consul.

Pourquoi un article sur ces technos qui sont vues et revues ?

Je voulais tester Grafana 7 avec la datasource Jaeger ! Etant un fan de Grafana depuis les premiéres releases, je me devais de faire ça rapidement et de vous le partager. Une des fonctionnalités phare que j’attendais était la datasource Jaeger mais aussi leur nouveau moteur de création de dashboard.

Comment ?

J’ai crée un compose file simpliste (non prod ready), que je vous partage sur mon Gitlab

Déploiement

On lance simplement le compose-file Sur Grafana, on créer une nouvelle source de données en sélectionnant le type Jaeger et on met en URL http://jaeger:16686 On navigue un peu sur l’application de démo et basta cosi on aura les traces.

Comment ça marche ?

Métrologie : Traefik est configuré de façon à exposer ses métriques via Prometheus, pareil pour les métriques internes à Consul, les services crées dans Consul sont automatiquement ajoutés (c’est pas magique il faut que l’application expose ses métriques en format OpenMetrics). Prometheus découvre automatiquement ses targets via Consul.

Traces : on a configuré Traefik pour utiliser Jaeger, l’application de démo est compatible Jaeger (comprendre elle possède les librairies Jaeger, et elle expose un tas d’endpoints en natif).

Traefik - Configuration de la métrologie

Afin que Traefik expose ses métriques, il faut lui créer un entrypoint et activer sa métrologie interne.

[entryPoints.metrics]
  address = ":8082"

[metrics]
  [metrics.prometheus]
  addEntryPointsLabels = true
  addServicesLabels = true
  entryPoint = "metrics"

Consul couplé à Prometheus

On peut coupler les deux composants très simplement en configurant un scraper Consul dans Prometheus. Dans la configuration ci-dessous, nous lui indiquons comment contacter Consul, et nous effectuons un relabels pour gagner en lisibilité. Ceci afin que nous ayons les dimensions sous Prometheus (service, job, datacenter, etc.)

scrape_configs:
  - job_name: Consul
    consul_sd_configs:
      - {datacenter: dc1, server: 'CONSUL_FQDN:8500'}
    relabel_configs:
      - source_labels: [__meta_consul_service]
        regex:         '^consul$'
        action: drop
      - source_labels: [__meta_consul_node]
        target_label: instance
      - source_labels: [__meta_consul_service]
        target_label: job
      - source_labels: [__meta_consul_dc]
        target_label: datacenter
      - source_labels: [__meta_consul_tags]
        separator: ":"
        regex: .*,exporter-([0-9]+),.* 
        target_label: __exporter_port
        replacement: ${1} 
      - source_labels: [__meta_consul_address,__exporter_port]
        separator: ":"
        target_label: __address__
        replacement: ${1}

De plus on déclare à Prometheus le consul_exporter pour avoir les métriques internes à Consul

- job_name: exporterConsul
    static_configs:
      - targets: ['CONSUL_FQDN:9107']

Jaeger

Jaeger peut être couplé à Traefik, pour cela il faut lui communiquer les informations suivantes dans le traefik.toml:

[tracing]
  [tracing.jaeger]
  samplingServerURL = "http://JAEGER_FQDN:5778/sampling"
  samplingType = "const"
  localAgentHostPort = "jaeger:6831"

Comment l’application exposée via Traefik fait pour créer ces traces dans Jaeger ?

Via l’instrumentation, généralement des librairies pour exposer en format OpenTelemetry

Résultats

Consul

Consul

Prometheus

Prometheus

Traefik

traefik

Application de démo HotRod

app-demo

Jaeger

Jaeger

Grafana

Grafana 7

Grossièrement, on a pu avoir dans ce cas pratique un aperçu de :

  • l’exposition des métriques des applications déclarées dans Consul dans Prometheus
  • l’exposition des métriques Traefik dans Prometheus
  • Traces via Jaeger, consultable directement dans Grafana 7.X

Ce n’est dans notre cas qu’un aperçu des innombrables possibilités, on peut aller bien plus loin notamment sur la partie métriques, et encore plus avec les traces distribuées.

Conclusion

Le POC est fonctionnel de Grafana 7 avec Jaeger. Agréablement surpris, comme souvent avec Grafana vous allez dire. La nouvelle mouture est très puissante, mais elle demande un petit temps d’adaptation pour les habitués aux versions antérieures.