Istio Dynatrace : superviser le service mesh avec Dynatrace (Istio, traces et métriques)

Istio Dynatrace : exportez les traces Envoy en OTLP via le Collector, collectez les métriques istio_requests_total et suivez le mesh dans Dynatrace en DQL.
Istio Dynatrace : superviser le service mesh avec Dynatrace (Istio, traces et métriques)

Votre cluster Kubernetes tourne avec Istio : chaque requête traverse un proxy Envoy qui connaît sa latence, son code de retour et sa destination. Pourtant, pendant un incident, l’équipe ouvre Dynatrace et ne voit qu’une partie du chemin. Le couple Istio Dynatrace mérite mieux : ces données existent déjà dans le mesh, il suffit de les acheminer.

Le mesh est souvent le premier endroit où une dégradation devient visible : retries en cascade, mTLS refusé, timeout d’un sidecar. Sans ses traces ni ses métriques, le diagnostic repose sur des suppositions et le MTTR s’allonge.

Objectif de ce tutoriel : envoyer les spans des proxies Envoy en OTLP vers Dynatrace via un OpenTelemetry Collector, collecter les métriques standard d’Istio, puis vérifier le tout en DQL. Le contenu vaut pour Dynatrace SaaS et Dynatrace Managed (ingestion OTLP en Managed selon votre version ; les requêtes DQL supposent Grail, donc SaaS).

Istio Dynatrace : ce que le mesh peut fournir

Signal Source dans Istio Chemin vers Dynatrace
Traces (spans de proxy) Envoy, via un fournisseur OpenTelemetry déclaré dans la configuration du mesh OTLP vers le Collector, puis vers l’API OTLP de Dynatrace
Métriques Endpoint Prometheus des sidecars (istio_requests_total, istio_request_duration_milliseconds…) Scraping par le Collector ou par l’Operator Dynatrace (annotations)
Logs d’accès Logs d’accès Envoy Collecte de logs habituelle (OneAgent ou Fluent Bit)

Rappel important : les spans des proxies ne suffisent pas à reconstituer une trace complète. Chaque application doit propager les en-têtes de contexte (traceparent) de la requête entrante vers ses appels sortants, sinon chaque saut devient une trace isolée.

Prérequis

  • Istio installé avec istioctl (l’API telemetry.istio.io/v1 est disponible dans les versions récentes).
  • Un OpenTelemetry Collector dans le namespace observability, exposant OTLP gRPC sur 4317, comme dans le déploiement du Collector sur Kubernetes.
  • Un token API Dynatrace avec les scopes openTelemetryTrace.ingest et metrics.ingest, stocké dans un secret.
  • Des applications qui propagent le contexte W3C (instrumentation OpenTelemetry ou OneAgent).

Étape 1 : déclarer le Collector comme fournisseur de traces

Ajoutez un fournisseur d’extension OpenTelemetry dans la configuration du mesh :

cat <<EOF | istioctl install -y -f -
apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
spec:
  meshConfig:
    enableTracing: true
    extensionProviders:
    - name: otel-tracing
      opentelemetry:
        port: 4317
        service: otel-collector.observability.svc.cluster.local
EOF

Le nom otel-tracing est libre ; il sera référencé à l’étape suivante. Le champ service doit correspondre exactement au nom DNS du service du Collector.

Étape 2 : activer le traçage avec l’API Telemetry

Une ressource Telemetry dans le namespace racine d’Istio active le fournisseur pour tout le mesh :

apiVersion: telemetry.istio.io/v1
kind: Telemetry
metadata:
  name: mesh-tracing
  namespace: istio-system
spec:
  tracing:
  - providers:
    - name: otel-tracing
    randomSamplingPercentage: 10

randomSamplingPercentage fixe la part des requêtes tracées par le proxy. Commencez bas en production (1 à 10 %) et ajustez selon le volume. Si les applications décident déjà de l’échantillonnage, le proxy respecte la décision portée par l’en-tête entrant. Pour un échantillonnage plus fin, gardez la décision dans le Collector (voir le tail sampling).

Étape 3 : exporter vers Dynatrace depuis le Collector

Dans la configuration du Collector, ajoutez l’exporteur OTLP HTTP de Dynatrace et un récepteur Prometheus qui scrape les sidecars :

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
  prometheus:
    config:
      scrape_configs:
      - job_name: istio-sidecars
        scrape_interval: 30s
        metrics_path: /stats/prometheus
        kubernetes_sd_configs:
        - role: pod
        relabel_configs:
        - source_labels: [__meta_kubernetes_pod_container_name]
          regex: istio-proxy
          action: keep
        - source_labels: [__address__]
          regex: ([^:]+)(?::\d+)?
          replacement: $$1:15090
          target_label: __address__

processors:
  batch: {}
  cumulativetodelta: {}

exporters:
  otlphttp/dynatrace:
    endpoint: https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp
    headers:
      Authorization: "Api-Token ${env:DT_API_TOKEN}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/dynatrace]
    metrics:
      receivers: [prometheus]
      processors: [cumulativetodelta, batch]
      exporters: [otlphttp/dynatrace]

Lignes critiques : le port 15090 expose les statistiques Envoy au format Prometheus ; le $$ échappe le $ dans la configuration du Collector ; cumulativetodelta est nécessaire car Dynatrace attend des compteurs en delta via OTLP. En Managed, l’endpoint devient https://<domaine>/e/<env-id>/api/v2/otlp. Le compte de service du Collector doit avoir le droit de lister les pods.

Si vous préférez laisser l’Operator Dynatrace scraper, utilisez plutôt les annotations metrics.dynatrace.com/* décrites dans la collecte des métriques Prometheus sur Kubernetes. Ne combinez pas les deux méthodes sur les mêmes pods : les métriques seraient comptées deux fois.

Comment vérifier que ça fonctionne

  1. Générez du trafic, puis regardez les logs du Collector : kubectl -n observability logs deploy/otel-collector | grep -iE "error|refused" ne doit rien renvoyer.
  2. Vérifiez la présence des spans de proxy :
    fetch spans, from: -15m
    | filter isNotNull(istio.canonical_service)
    | summarize spans = count(), by: { istio.canonical_service }
    | sort spans desc

    Si l’attribut porte un autre nom dans votre version, inspectez un span brut avec fetch spans | limit 5.

  3. Contrôlez les métriques du mesh, ventilées par service et par code de retour :
    timeseries requêtes = sum(istio_requests_total), by: { destination_service, response_code }, from: -1h

    La part des séries en 5xx rapportée au total donne le SLI de taux d’erreur par service. Adaptez la clé de métrique au nom observé dans le navigateur de métriques : selon le chemin d’ingestion, un suffixe peut être ajouté.

Bonnes pratiques

  • Basez vos SLO sur les métriques du mesh côté serveur (reporter="destination") pour éviter de compter deux fois chaque requête.
  • Limitez la cardinalité : écartez les labels inutiles avant l’export plutôt que de stocker des millions de séries.
  • Gardez un taux d’échantillonnage connu et documenté ; un changement non annoncé fausse les comparaisons d’une semaine sur l’autre.
  • Surveillez le Collector lui-même : s’il tombe, le mesh devient muet.

Questions fréquentes

Le OneAgent ne suffit-il pas sans configurer Istio ?

Le OneAgent instrumente les processus applicatifs dans les pods et propage son propre contexte ; il voit donc les appels de service à service. Les spans et métriques d’Envoy ajoutent la vue du proxy (retries, mTLS, timeouts du sidecar). Le niveau de prise en charge native d’Envoy dépend de la version : vérifiez la documentation avant de dupliquer les signaux.

Pourquoi mes traces sont-elles coupées à chaque saut ?

Presque toujours parce qu’une application ne propage pas traceparent de l’appel entrant vers l’appel sortant. Le proxy crée bien ses spans, mais ne peut pas relier deux requêtes que l’application n’a pas reliées.

Ces étapes fonctionnent-elles en mode ambient ?

Le mode ambient remplace les sidecars par ztunnel et des proxies waypoint ; les ports et les sources de métriques diffèrent. Le principe (fournisseur OpenTelemetry, Collector, export OTLP) reste valable, mais adaptez le scraping à cette architecture.

Conclusion

Un fournisseur OpenTelemetry dans la configuration du mesh, une ressource Telemetry, un Collector qui scrape les sidecars et exporte en OTLP : le mesh Istio devient visible dans Dynatrace, avec des SLI fondés sur chaque requête. La prochaine cascade de retries se lira dans une trace, pas dans une supposition.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Options et attributs évoluent : vérifiez-les dans la documentation d’Istio et dans celle de Dynatrace.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Fluent Bit Dynatrace : envoyer les logs Kubernetes pas à pas

Fluent Bit Dynatrace : envoyer les logs Kubernetes pas à pas

Next Post
Dynatrace Application Security (AppSec) : scan des vulnérabilités à l'exécution

Dynatrace Application Security (AppSec) : scan des vulnérabilités à l’exécution

Related Posts