RousselTMLEARNING

Observabilité

OpenTelemetry sur Kubernetes : Operator, auto-instrumentation et Collector

Déployer OpenTelemetry sur Kubernetes : modes de déploiement du Collector (DaemonSet, Deployment, sidecar, StatefulSet), OpenTelemetry Operator et ressources OpenTelemetryCollector et Instrumentation, auto-instrumentation par annotation, k8sattributes, Target Allocator et charts Helm.

1. Modes de déploiement du Collector #

Agent, gateway, sidecar.

Choisir #

Architecture OpenTelemetry sur Kubernetes
L'agent par nœud collecte et enrichit ; la gateway échantillonne, route et exporte.
ModeUsage typique
DaemonSet (agent)un Collector par nœud : réception OTLP locale, logs des pods, métriques kubelet et hôte, ajout des métadonnées Kubernetes
Deployment (gateway)point central : tail sampling, routage, authentification, export vers les backends
StatefulSetscraping Prometheus réparti avec le Target Allocator
Sidecarun Collector dans chaque pod : isolation forte, mais coûteux

2. L'OpenTelemetry Operator #

Gérer collecteurs et instrumentation par CRD.

Installer #

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.16.2/cert-manager.yaml
kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml
# ou : helm install opentelemetry-operator open-telemetry/opentelemetry-operator -n opentelemetry-operator-system --create-namespace

Un Collector #

apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata: { name: agent, namespace: observability }
spec:
  mode: daemonset
  config:
    receivers:
      otlp: { protocols: { grpc: { endpoint: 0.0.0.0:4317 }, http: { endpoint: 0.0.0.0:4318 } } }
    processors:
      memory_limiter: { check_interval: 1s, limit_percentage: 80, spike_limit_percentage: 25 }
      k8sattributes: {}
      batch: {}
    exporters:
      otlp: { endpoint: gateway-collector.observability:4317, tls: { insecure: true } }
    service:
      pipelines:
        traces: { receivers: [otlp], processors: [memory_limiter, k8sattributes, batch], exporters: [otlp] }

Auto-instrumentation #

Injection par l'Operator
Après une modification de la ressource Instrumentation, redémarrez les pods.
apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata: { name: defaut, namespace: shop }
spec:
  exporter: { endpoint: http://agent-collector.observability:4318 }
  propagators: [tracecontext, baggage]
  sampler: { type: parentbased_traceidratio, argument: "0.25" }
  resource: { addK8sUIDAttributes: true }
# puis, dans le template du pod :
metadata:
  annotations:
    instrumentation.opentelemetry.io/inject-java: "true"     # ou -python, -nodejs, -dotnet, -go

Au démarrage du pod, l'Operator ajoute un init container qui copie l'agent du langage, et positionne les variables OTEL_* (nom du service déduit du déploiement, attributs Kubernetes). Aucune modification de l'image n'est nécessaire.

Erreur Courante : L'injection n'a lieu qu'à la création du pod : après avoir ajouté l'annotation ou modifié la ressource Instrumentation, redémarrez les déploiements (kubectl rollout restart).

3. Métadonnées et métriques Kubernetes #

Enrichir et compléter.

k8sattributes et récepteurs #

ComposantApport
processeur k8sattributesajoute k8s.pod.name, k8s.namespace.name, k8s.deployment.name, k8s.node.name, labels et annotations à toutes les données
receiver kubeletstatsCPU, mémoire, réseau, volumes par pod et conteneur
receiver k8s_clusterétat des objets (déploiements, pods en échec, nœuds)
receiver k8sobjectsévénements Kubernetes sous forme de logs
Target Allocatorrépartit les cibles Prometheus entre plusieurs Collectors
Bonne Pratique : Le processeur k8sattributes a besoin de droits RBAC en lecture sur les pods, namespaces et ReplicaSets : l'Operator et le chart Helm les créent, une installation manuelle doit les ajouter.

Charts Helm #

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm install agent open-telemetry/opentelemetry-collector -n observability --create-namespace \
  --set mode=daemonset --set image.repository=otel/opentelemetry-collector-k8s \
  --set presets.kubernetesAttributes.enabled=true \
  --set presets.logsCollection.enabled=true \
  --set presets.kubeletMetrics.enabled=true

4. Exploiter en production #

Les points de vigilance.

Check-list #

  • memory_limiter en premier processeur et limites de ressources sur chaque Collector.
  • Gateway en plusieurs réplicas avec loadbalancing par TraceID si tail sampling.
  • Télémétrie interne des Collectors supervisée (refus, échecs d'envoi, file d'attente).
  • Versions de l'Operator, du Collector et des agents alignées et mises à jour ensemble.
  • Ressources Instrumentation par namespace pour adapter l'échantillonnage à chaque équipe.

Articles liés

Les concepts fondamentaux d'OpenTelemetry : signaux, ressources, contexte et maturité

Le vocabulaire indispensable d'OpenTelemetry : les quatre signaux, API et SDK, ressource et instrumentation s…

Collector OpenTelemetry : connecteurs, extensions et observabilité du Collector

Aller plus loin avec le Collector : connecteurs (spanmetrics, servicegraph, count, routing, failover), extens…

Les conventions sémantiques OpenTelemetry (semconv) : nommer la télémétrie

Comprendre et appliquer les conventions sémantiques OpenTelemetry : attributs de ressource, HTTP, bases de do…

Pour aller plus loin

Soutenir

♥ SOUTENIR

Soutenez RousselTM Learning

Les formations, articles, TP et attestations restent gratuits et sans publicité intrusive. Une contribution libre, du montant de votre choix, finance l’hébergement, les environnements de TP et l’écriture de nouveaux contenus.

Contribuer avec PayPal Montant libre · carte bancaire ou compte PayPalEn savoir plus
QR code PayPal
Ou scannez ce QR code avec votre téléphone

Merci, chaque contribution compte !