Skip to content
Learni
Voir tous les tutoriels
Observabilité

Comment déployer Jaeger pour le tracing distribué en 2026

18 minINTERMEDIATE
OpenTelemetryTracingJaeger
Read in English

Introduction

Jaeger est un système de tracing distribué open source conçu pour surveiller les architectures microservices complexes. Il permet de visualiser le parcours complet d'une requête à travers plusieurs services, d'identifier les latences et les goulets d'étranglement. En 2026, son intégration avec OpenTelemetry en fait l'outil de référence pour l'observabilité. Ce tutoriel vous guide pas à pas dans le déploiement d'une instance production-ready, l'instrumentation de vos applications et la configuration avancée du sampling. Vous apprendrez à éviter les pièges courants et à optimiser les coûts de stockage des traces.

Prérequis

  • Docker et Docker Compose installés
  • Connaissances de base en Kubernetes (optionnel)
  • Application Node.js ou Python instrumentable
  • Accès à un cluster ou environnement local
  • Notions de base sur OpenTelemetry

Déploiement avec Docker Compose

docker-compose.yml
version: '3.8'
services:
  jaeger-all-in-one:
    image: jaegertracing/all-in-one:1.53
    ports:
      - "16686:16686"
      - "14268:14268"
      - "4317:4317"
      - "4318:4318"
    environment:
      - COLLECTOR_OTLP_ENABLED=true
    restart: unless-stopped

Ce fichier déploie l'image all-in-one de Jaeger avec les ports OTLP activés pour recevoir les traces OpenTelemetry. Il expose l'interface UI sur le port 16686 et le collector sur 4317/4318.

Configuration du Collector

jaeger-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
processors:
  batch:
    timeout: 1s
    send_batch_size: 1024
exporters:
  jaeger:
    endpoint: jaeger-collector:14250
    tls:
      insecure: true
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [jaeger]

Cette configuration active le récepteur OTLP, applique un batching pour optimiser les envois et exporte vers le stockage Jaeger. Le batching réduit la charge réseau et les coûts de stockage.

Instrumentation OpenTelemetry Node.js

tracing.ts
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';

const exporter = new OTLPTraceExporter({
  url: 'http://localhost:4317',
});
const sdk = new NodeSDK({
  traceExporter: exporter,
  instrumentations: [getNodeAutoInstrumentations()],
});
sdk.start();

Ce code initialise le SDK OpenTelemetry avec l'exportateur gRPC vers Jaeger. Il active l'instrumentation automatique des modules Node.js courants sans modification manuelle du code métier.

Instrumentation Python

tracing.py
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
provider = TracerProvider()
processor = BatchSpanProcessor(OTLPSpanExporter(endpoint="http://localhost:4317"))
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

Ce script Python configure le provider de traces et utilise le processeur batch pour envoyer les spans vers le collector Jaeger via gRPC. Le batching est essentiel en production.

Déploiement Kubernetes

jaeger-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: jaeger
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jaeger
  template:
    metadata:
      labels:
        app: jaeger
    spec:
      containers:
      - name: jaeger
        image: jaegertracing/all-in-one:1.53
        env:
        - name: COLLECTOR_OTLP_ENABLED
          value: "true"
        ports:
        - containerPort: 16686

Ce manifest Kubernetes déploie Jaeger en mode all-in-one. Pour la production, séparez le collector, l'agent et le query service avec des volumes persistants pour le stockage des traces.

Bonnes pratiques

  • Toujours activer le batch processing pour réduire la charge réseau
  • Configurer des taux de sampling adaptés (probabiliste ou rate limiting)
  • Utiliser des tags et des attributs cohérents pour faciliter la recherche
  • Monitorer les métriques du collector (queue, erreurs d'export)
  • Séparer les environnements dev et prod avec des instances distinctes

Erreurs courantes à éviter

  • Oublier d'activer COLLECTOR_OTLP_ENABLED en production
  • Ne pas configurer de limites de rétention des traces (stockage illimité)
  • Instrumenter sans contexte de trace propagé entre services
  • Ignorer les erreurs de connexion au collector (perte silencieuse de traces)

Pour aller plus loin

Approfondissez vos compétences avec nos formations dédiées à l'observabilité et au tracing distribué sur Learni Group.