TP : OpenTelemetry Operator et auto-instrumentation sur Kubernetes avec correction

Ce que vous allez apprendre dans ce TP

• Installer l'Operator
• Déclarer Collector et Instrumentation
• Instrumenter par annotation

Introduction #

Ce que vous allez apprendre dans cette section

• Installer l'Operator
• Déclarer Collector et Instrumentation
• Instrumenter par annotation

Contexte. L'équipe plateforme veut que toutes les applications du cluster produisent des traces sans que chaque équipe modifie ses images. Vous validez l'approche par l'Operator.

Prérequis : Docker, kubectl et kind  ·  Durée estimée : 50 min

Une application instrumentée sans modification d'image, dont les spans arrivent dans un Collector géré par l'Operator.

Mise en place #

Étapes guidées, avec leur correction.

1. 1. Préparer le cluster

   Pourquoi ? L'Operator utilise des webhooks d'admission dont les certificats sont gérés par cert-manager.

   Créez un cluster kind, installez cert-manager puis l'Operator, et attendez qu'ils soient disponibles.
   Voir la correction

   kind create cluster --name otel
   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.16.2/cert-manager.yaml
   kubectl wait --for=condition=Available deploy --all -n cert-manager --timeout=180s
   kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml
   kubectl wait --for=condition=Available deploy --all -n opentelemetry-operator-system --timeout=180s
   kubectl get crd | grep opentelemetry

2. 2. Déclarer un Collector

   Pourquoi ? Le Collector est décrit comme une ressource Kubernetes : l'Operator crée Deployment, Service et ConfigMap.

   Créez un namespace demo et une ressource OpenTelemetryCollector en mode deployment avec un receiver OTLP, k8sattributes et l'exportateur debug.
   Voir la correction

   kubectl create namespace demo
   cat <<'EOF' | kubectl apply -f -
   apiVersion: opentelemetry.io/v1beta1
   kind: OpenTelemetryCollector
   metadata: { name: demo, namespace: demo }
   spec:
     mode: deployment
     config:
       receivers:
         otlp: { protocols: { grpc: { endpoint: 0.0.0.0:4317 }, http: { endpoint: 0.0.0.0:4318 } } }
       processors:
         k8sattributes: {}
         batch: {}
       exporters:
         debug: { verbosity: detailed }
       service:
         pipelines:
           traces: { receivers: [otlp], processors: [k8sattributes, batch], exporters: [debug] }
   EOF
   kubectl -n demo get pods,svc     # demo-collector

3. 3. Déclarer l'instrumentation

   Pourquoi ? La ressource Instrumentation centralise exportateur, propagateurs et échantillonnage pour tout un namespace.

   Créez une ressource Instrumentation qui envoie en OTLP/HTTP vers le Collector, avec les propagateurs tracecontext et baggage et un échantillonnage à 100 %.
   Voir la correction

   cat <<'EOF' | kubectl apply -f -
   apiVersion: opentelemetry.io/v1alpha1
   kind: Instrumentation
   metadata: { name: defaut, namespace: demo }
   spec:
     exporter: { endpoint: http://demo-collector.demo:4318 }
     propagators: [tracecontext, baggage]
     sampler: { type: parentbased_always_on }
   EOF
   kubectl -n demo get instrumentation

4. 4. Instrumenter une application par annotation

   Pourquoi ? L'annotation suffit : l'Operator injecte l'agent Python au démarrage du pod, sans modifier l'image.

   Déployez une petite application Flask dans une image Python standard avec l'annotation instrumentation.opentelemetry.io/inject-python, puis observez l'init container et les variables OTEL_* injectés.
   Voir la correction

   cat <<'EOF' | kubectl apply -f -
   apiVersion: apps/v1
   kind: Deployment
   metadata: { name: catalogue, namespace: demo }
   spec:
     replicas: 1
     selector: { matchLabels: { app: catalogue } }
     template:
       metadata:
         labels: { app: catalogue }
         annotations: { instrumentation.opentelemetry.io/inject-python: "true" }
       spec:
         containers:
           - name: app
             image: python:3.12-slim
             command: ["sh", "-c"]
             args:
               - pip install flask >/dev/null && python -c "from flask import Flask; a=Flask('catalogue'); a.get('/')(lambda: 'ok'); a.run(host='0.0.0.0', port=8080)"
             ports: [{ containerPort: 8080 }]
   EOF
   kubectl -n demo rollout status deploy/catalogue --timeout=180s
   kubectl -n demo get pod -l app=catalogue -o jsonpath='{.items[0].spec.initContainers[*].name}{"\n"}'
   kubectl -n demo exec deploy/catalogue -- env | grep ^OTEL_

5. 5. Vérifier les spans

   Pourquoi ? L'exportateur debug affiche les spans reçus avec les attributs Kubernetes ajoutés par k8sattributes.

   Générez quelques requêtes avec un port-forward, puis cherchez dans les logs du Collector le span GET /, service.name et k8s.pod.name.
   Voir la correction

   kubectl -n demo port-forward deploy/catalogue 8080:8080 &
   for i in $(seq 1 5); do curl -s localhost:8080/ ; done ; kill %1
   kubectl -n demo logs deploy/demo-collector | grep -E 'Name +: GET|service.name|k8s.pod.name' | head

6. 6. Faire évoluer et nettoyer

   Pourquoi ? Modifier la ressource Instrumentation n'affecte que les pods recréés : il faut redémarrer les déploiements.

   Passez l'échantillonnage à 10 %, redémarrez le déploiement, vérifiez la nouvelle valeur de OTEL_TRACES_SAMPLER_ARG, puis supprimez le cluster.
   Voir la correction

   kubectl -n demo patch instrumentation defaut --type merge -p '{"spec":{"sampler":{"type":"parentbased_traceidratio","argument":"0.1"}}}'
   kubectl -n demo rollout restart deploy/catalogue && kubectl -n demo rollout status deploy/catalogue
   kubectl -n demo exec deploy/catalogue -- env | grep SAMPLER
   kind delete cluster --name otel

Niveau de difficulté : ●●●○○ (3/5)