Aller au contenu principal

Jaeger

Overview​

Jaeger, c'est le système de distributed tracing open-source développé par Uber qui pense que comprendre ce qui se passe dans tes microservices, c'est mieux que deviner. Il trace les requêtes à travers tous tes services pour te donner une vue complète de ce qui se passe, combien de temps ça prend, et où ça coince. Si tu as des microservices et que tu veux débugger efficacement, c'est parfait.

Jaeger est maintenant un projet CNCF (Cloud Native Computing Foundation) et implémente le standard OpenTracing. Architecture scalable avec sampling intelligent, stockage multiple (Cassandra, Elasticsearch, Kafka), UI web intuitive pour explorer les traces. Compatible avec OpenTelemetry depuis la v2.

Jaeger se distingue par sa maturité (utilisé en production chez Uber depuis des années), son interface utilisateur excellente (explorer les traces, c'est du plaisir), et sa compatibilité avec les standards (OpenTracing, OpenTelemetry, tout y passe).

Informations essentielles​

PropriétéValeur
Site officielhttps://www.jaegertracing.io/
Repositoryhttps://github.com/jaegertracing/jaeger
LicenceApache 2.0
OrganisationCNCF (Cloud Native Computing Foundation)
LangageGo
StockageCassandra, Elasticsearch, Kafka, Memory, BadgerDB

Fonctionnalités principales​

Distributed Tracing complet​

  • Traçage des requêtes à travers les microservices
  • Corrélation automatique des spans parent-enfant
  • Support des opérations asynchrones et parallèles
  • Mesure de latence bout-en-bout
  • Détection des goulots d'étranglement

Interface utilisateur avancée​

  • Exploration visuelle des traces
  • Timeline interactive des spans
  • Comparaison de traces similaires
  • Recherche par tags, services, opérations
  • Graphiques de dépendances entre services

Sampling intelligent​

  • Sampling adaptatif basé sur le trafic
  • Stratégies par service ou opération
  • Sampling probabiliste et par débit
  • Remote sampling configuration
  • Head-based et tail-based sampling

Architecture scalable​

  • Composants découplés (agent, collector, query, UI)
  • Support multi-tenant
  • Haute disponibilité avec clustering
  • Intégration Kubernetes native
  • Métriques et monitoring intégrés

Cas d'usage​

  • Debugging microservices : Tracer les problèmes dans les architectures distribuées
  • Optimisation performance : Identifier les services lents et goulots d'étranglement
  • Monitoring SLA : Mesurer les latences bout-en-bout
  • Dépendances services : Comprendre les interactions entre microservices
  • Root cause analysis : Analyser les causes racines des incidents

Installation​

Via Docker Compose (all-in-one)​

version: '3'
services:
  jaeger:
    image: jaegertracing/all-in-one:latest
    ports:
      - "16686:16686"    # UI
      - "14268:14268"    # HTTP collector
      - "6831:6831/udp"  # Agent compact thrift
      - "6832:6832/udp"  # Agent binary thrift
    environment:
      - COLLECTOR_OTLP_ENABLED=true

Via Helm (Kubernetes)​

helm repo add jaegertracing https://jaegertracing.github.io/helm-charts
helm install jaeger jaegertracing/jaeger \
  --set storage.type=elasticsearch \
  --set elasticsearch.host=elasticsearch.default.svc.cluster.local

Via Jaeger Operator (Kubernetes)​

apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: simple-prod
spec:
  strategy: production
  storage:
    type: elasticsearch
    elasticsearch:
      nodeCount: 3
      redundancyPolicy: SingleRedundancy

Utilisation basique​

Configuration application (Go)​

import (
    "github.com/opentracing/opentracing-go"
    "github.com/jaegertracing/jaeger-client-go/config"
)

func initJaeger(service string) (opentracing.Tracer, io.Closer) {
    cfg := config.Configuration{
        ServiceName: service,
        Sampler: &config.SamplerConfig{
            Type:  "const",
            Param: 1,
        },
        Reporter: &config.ReporterConfig{
            LogSpans: true,
            LocalAgentHostPort: "localhost:6831",
        },
    }
    tracer, closer, _ := cfg.NewTracer()
    opentracing.SetGlobalTracer(tracer)
    return tracer, closer
}

Instrumentation avec OpenTelemetry (Python)​

from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Configuration
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Export vers Jaeger
jaeger_exporter = JaegerExporter(
    agent_host_name="localhost",
    agent_port=6831,
)

span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)

# Utilisation
with tracer.start_as_current_span("my-operation"):
    # Votre code applicatif ici
    pass

Requêtes via API​

# Recherche de traces par service
curl "http://localhost:16686/api/traces?service=my-service&limit=20"

# Recherche avec filtres
curl "http://localhost:16686/api/traces?service=my-service&operation=my-operation&start=1609459200000000&end=1609545600000000"

# Liste des services
curl "http://localhost:16686/api/services"

Avantages​

  • ✅ Maturité prouvée : utilisé en production chez Uber et d'autres grandes entreprises, c'est du solide
  • ✅ Interface excellente : UI intuitive pour explorer les traces, c'est un plaisir à utiliser
  • ✅ Standards compatibles : OpenTracing et OpenTelemetry, tu n'es pas enfermé
  • ✅ CNCF project : projet officiel avec gouvernance et support communautaire, c'est pérenne
  • ✅ Scaling prouvé : architecture testée à grande échelle, ça scale vraiment

Limitations​

  • Configuration initiale peut être complexe pour les débutants : mais la doc est bien faite
  • Overhead de performance avec sampling élevé : mais le sampling intelligent gère ça
  • Stockage peut devenir volumineux sur gros volumes : mais les stratégies de retention existent

Alternatives​

  • Zipkin : Alternative similaire, plus simple mais moins de fonctionnalités
  • AWS X-Ray : Solution managed AWS (propriétaire)
  • Datadog APM : Solution SaaS enterprise (propriétaire)
  • New Relic : Solution SaaS enterprise (propriétaire)

Ressources​