Skip to content
Learni
View all tutorials
Observabilité

Comment configurer Jaeger pour le tracing avancé en 2026

18 minADVANCED
OpenTelemetryTracingJaeger

Introduction

Jaeger est devenu l'outil de référence pour le tracing distribué dans les architectures microservices. En 2026, les exigences en matière d'observabilité exigent bien plus qu'un simple déploiement : il faut gérer le sampling intelligent, la corrélation multi-services et l'intégration avec les pipelines CI/CD. Ce tutoriel vous guide pas à pas pour mettre en place une solution production-ready. Vous apprendrez à instrumenter des applications Node.js/TypeScript, configurer des collecteurs haute performance et optimiser les coûts de stockage des traces. Chaque étape inclut des exemples concrets et fonctionnels que vous pouvez copier directement.

Prérequis

  • Docker et Docker Compose v2.20+
  • Connaissances solides en TypeScript et OpenTelemetry
  • Cluster Kubernetes (optionnel pour production)
  • Node.js 20+ et npm

Déploiement production avec Docker Compose

docker-compose.yml
version: '3.8'
services:
  jaeger-collector:
    image: jaegertracing/jaeger-collector:1.55
    environment:
      - COLLECTOR_OTLP_ENABLED=true
      - SPAN_STORAGE_TYPE=elasticsearch
    ports:
      - "14268:14268"
      - "4317:4317"
      - "4318:4318"
  jaeger-query:
    image: jaegertracing/jaeger-query:1.55
    environment:
      - SPAN_STORAGE_TYPE=elasticsearch
    ports:
      - "16686:16686"

Ce fichier déploie un collecteur et un query service Jaeger prêts pour la production. Le port 4317 gère l'OTLP gRPC et 4318 l'OTLP HTTP pour une ingestion moderne.

Vérification du déploiement

Lancez docker compose up -d. Accédez à l'interface Jaeger sur http://localhost:16686. Vérifiez que les services apparaissent bien dans le sélecteur de service.

Instrumentation OpenTelemetry avancée

src/tracing.ts
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';

const sdk = new NodeSDK({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'api-users',
    [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: 'production',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();

Ce module configure le SDK OpenTelemetry avec détection automatique des frameworks. Il envoie les traces vers le collecteur Jaeger via OTLP par défaut.

Configuration du sampling probabiliste

src/sampling.ts
import { ParentBasedSampler, TraceIdRatioBasedSampler } from '@opentelemetry/core';

const sampler = new ParentBasedSampler({
  root: new TraceIdRatioBasedSampler(0.1), // 10% des traces racines
});
// À passer dans les options du NodeSDK

Le sampling à 10 % réduit drastiquement le volume de données tout en conservant une vision représentative du trafic. Utilisez ParentBasedSampler pour respecter les décisions de sampling des services parents.

Ajout de tags et spans personnalisés

src/user-service.ts
import { trace } from '@opentelemetry/api';
const tracer = trace.getTracer('user-service');
export async function getUser(id: string) {
  const span = tracer.startSpan('getUser');
  span.setAttribute('user.id', id);
  span.setAttribute('user.tier', 'premium');
  try {
    return await db.findUser(id);
  } finally {
    span.end();
  }
}

Les attributs personnalisés permettent de filtrer et analyser les traces dans l'interface Jaeger. Toujours terminer le span dans un finally pour éviter les fuites.

Configuration du Collector avec Elasticsearch

collector-config.yml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
processors:
  probabilistic_sampler:
    hash_seed: 22
    sampling_percentage: 15
exporters:
  elasticsearch:
    endpoints: ["http://elasticsearch:9200"]
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [probabilistic_sampler]
      exporters: [elasticsearch]

Ce fichier de configuration avancé active le sampling au niveau du collecteur et stocke les traces dans Elasticsearch pour une rétention longue durée et des requêtes complexes.

Bonnes pratiques

  • Toujours propager le contexte de trace entre les services avec les headers W3C TraceContext
  • Utiliser des noms de span cohérents et hiérarchiques
  • Configurer des limites de taille de span pour éviter les traces trop volumineuses
  • Monitorer la latence du collecteur et la taille des queues
  • Versionner vos schémas d'attributs pour faciliter l'analyse historique

Erreurs courantes à éviter

  • Oublier d'activer OTLP sur le collecteur (port 4317/4318)
  • Définir un taux de sampling trop bas en environnement de test
  • Ne pas instrumenter les bases de données et files de messages
  • Ignorer les erreurs de connexion au backend de stockage

Pour aller plus loin

Découvrez nos formations complètes sur l'observabilité et le tracing distribué : https://learni-group.com/formations. Vous y apprendrez notamment l'intégration de Jaeger avec Grafana Tempo et l'analyse de traces avec OpenSearch.