Metadata enrichment Kubernetes dans Dynatrace : namespaceSelector, règles et annotations

Metadata enrichment Kubernetes : activez-le dans la DynaKube, ciblez les namespaces avec namespaceSelector et propagez équipe et coûts sur logs et traces.
Metadata enrichment Kubernetes dans Dynatrace : namespaceSelector, règles et annotations

Un log arrive dans Dynatrace avec un nom de pod et un namespace, mais sans l’équipe propriétaire, sans centre de coût, sans contexte de sécurité. À 3 heures du matin, l’astreinte perd dix minutes à chercher à qui appartient le service. Le metadata enrichment Kubernetes de Dynatrace règle ce problème à la source : il recopie vos labels et annotations de namespace sur les logs, les spans, les métriques et les événements.

Objectif de ce guide : activer l’enrichissement dans la DynaKube, le limiter avec un namespaceSelector, transformer des labels existants en champs Dynatrace (dt.security_context, dt.cost.costcenter, dt.cost.product) et vérifier le résultat. Le paramètre DynaKube vaut pour Dynatrace SaaS et Dynatrace Managed ; les règles d’enrichissement centralisées et les champs Grail décrits plus bas relèvent de Dynatrace SaaS (Latest Dynatrace).

Si l’Operator n’est pas encore installé, commencez par le déploiement de Dynatrace Operator sur Kubernetes ou par le module de formation SaaS sur OneAgent et l’Operator.

Ce que fait le metadata enrichment Kubernetes

Le webhook de Dynatrace Operator intervient à la création de chaque pod d’un namespace sélectionné. Il pose sur le pod des annotations metadata.dynatrace.com/… et fournit des fichiers d’enrichissement (dans /var/lib/dynatrace/enrichment sous Unix) que OneAgent et les SDK peuvent lire. Les signaux émis par ce pod portent alors les mêmes attributs, quel que soit le chemin d’ingestion.

La documentation Dynatrace sur l’enrichissement Kubernetes liste les données concernées : traces distribuées sur Grail, métriques OneAgent, métriques de la plateforme Kubernetes, spans, métriques et logs collectés par l’OpenTelemetry Collector, logs du module de logs OneAgent, logs collectés par Fluent Bit, entités Kubernetes de Smartscape et événements Kubernetes. Le niveau de couverture varie selon la méthode choisie, comme on le verra à l’étape 4.

Trois usages reviennent :

  • Sécurité : dt.security_context sert de frontière dans les politiques d’accès aux données, plus fine que k8s.namespace.name ou k8s.cluster.name.
  • Coûts : dt.cost.costcenter et dt.cost.product alimentent la Cost Allocation de la licence DPS (voir la consommation de la licence DPS).
  • Routage et filtrage : des champs k8s.namespace.label.<clé> ou k8s.namespace.annotation.<clé> servent au choix de bucket, à la segmentation et au routage des problèmes.

À noter : Dynatrace a introduit un nouveau modèle de tagging pour Latest Dynatrace, qui remplace à terme cette approche. Depuis la version 1.344 de la plateforme, vous pouvez opter pour une configuration centrale au niveau cluster ou tenant ; l’approche décrite ici reste supportée.

Prérequis

  • Dynatrace Operator installé dans le cluster et une DynaKube appliquée.
  • kubectl avec les droits de modifier la DynaKube et de labelliser des namespaces.
  • Pour les règles centralisées : un environnement Dynatrace SaaS et l’accès aux réglages Settings.
  • Des labels ou annotations de namespace déjà porteurs de sens (équipe, département, domaine).

Activer le metadata enrichment Kubernetes dans la DynaKube

Étape 1 : choisir les namespaces avec namespaceSelector

Par défaut, l’Operator injecte dans tous les namespaces, sauf ceux préfixés par kube- ou openshift- et celui où il est installé. La documentation recommande de garder la main avec namespaceSelector. Labellisez d’abord les namespaces visés :

kubectl label namespace paiement dt-monitoring=true
kubectl label namespace catalogue dt-monitoring=true

Puis ajoutez le sélecteur dans la DynaKube :

apiVersion: dynatrace.com/v1beta6
kind: DynaKube
metadata:
  name: dynakube
  namespace: dynatrace
spec:
  apiUrl: https://<env-id>.live.dynatrace.com/api
  metadataEnrichment:
    enabled: true
    namespaceSelector:
      matchLabels:
        dt-monitoring: "true"

Les lignes critiques :

  • apiVersion: dynatrace.com/v1beta6 : version de l’API DynaKube pour Dynatrace Operator 1.8.0 et plus. Gardez celle que votre Operator accepte.
  • metadataEnrichment.enabled : false par défaut dans les versions récentes de l’API. Depuis Dynatrace Operator 1.9.0, l’enrichissement est activé implicitement pour les namespaces où l’injection OneAgent ou la configuration automatique des exporteurs OTLP est configurée, même si enabled vaut false.
  • namespaceSelector : un LabelSelector Kubernetes standard. Il n’agit que sur l’injection faite par le webhook, pas sur la supervision de l’API Kubernetes par l’ActiveGate.

Pour exclure plutôt qu’inclure, utilisez matchExpressions avec l’opérateur NotIn et le label posé par Kubernetes sur chaque namespace depuis la version 1.22 :

spec:
  metadataEnrichment:
    namespaceSelector:
      matchExpressions:
        - key: kubernetes.io/metadata.name
          operator: NotIn
          values:
            - batch-legacy

Appliquez avec kubectl apply -f dynakube.yaml. Le webhook n’agit qu’à la création des pods : redémarrez les déploiements concernés (kubectl rollout restart deployment -n paiement).

Étape 2 : transformer des labels en champs Dynatrace (SaaS)

C’est l’option recommandée par la documentation, car c’est la seule qui enrichit tous les signaux, y compris les métriques de la plateforme Kubernetes, les événements et les entités. Dans Dynatrace SaaS, allez dans Settings > Collect and capture > Kubernetes Telemetry Enrichment, puis Add rule :

  1. Choisissez Annotation ou Label dans Metadata type.
  2. Saisissez la clé du label ou de l’annotation de namespace dans Source.
  3. Pour garder la clé telle quelle, activez Enrich telemetry with label/annotation directly ; pour la renommer, désactivez cette option et choisissez un champ dans Target, par exemple dt.security_context.
  4. Enregistrez avec Save changes.
Règle Kubernetes Telemetry Enrichment : Metadata type Label, Source team, option Enrich telemetry with label/annotation directly désactivée, Target dt.security_context
Source : docs.dynatrace.com

Les mêmes règles existent sous forme de settings (schéma builtin:kubernetes.generic.metadata.enrichment), ce qui permet de les versionner :

"rules": [
  { "type": "Annotation", "source": "metadata.example.com/team", "target": "dt.security_context" },
  { "type": "Label", "source": "department", "target": "dt.cost.costcenter" },
  { "type": "Label", "source": "app/name", "target": "dt.cost.product" }
]

Deux contraintes à connaître : 20 règles au plus par périmètre de configuration, et jusqu’à 45 minutes avant que les règles soient prises en compte. Passé ce délai, redémarrez les pods. Si vous créez les règles avant de déployer la DynaKube, ce délai d’attente disparaît.

Étape 3 : annotations de pod ou de workload, en dernier recours

Quand un namespace ne peut pas porter de label, posez des annotations dédiées sur le pod ou, depuis Dynatrace Operator 1.11.0, sur le workload (l’Operator les propage à chaque pod créé) :

apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    metadata.dynatrace.com/dt.security_context: sre
    metadata.dynatrace.com/dt.cost.costcenter: it_services
    metadata.dynatrace.com/dt.cost.product: fin_app

Cette méthode a des limites documentées : les annotations de pod priment sur celles du workload, qui priment sur les règles centralisées ; hors des trois champs dt.security_context, dt.cost.costcenter et dt.cost.product, elle n’enrichit ni les métriques ni les événements Kubernetes. Surtout, ne la combinez pas avec les règles de l’étape 2 : la documentation signale des conflits possibles.

Étape 4 : propager l’enrichissement dans l’OpenTelemetry Collector

Sans OneAgent, les données OTLP passent souvent par un Collector. Le dépôt de la distribution Dynatrace du Collector (licence Apache 2.0) fournit un exemple qui lit les annotations posées par l’Operator avec le processeur k8sattributes, puis les déplie avec transform :

Extrait du fichier k8s_enrichment.yaml du dépôt dynatrace-otel-collector : le processeur k8sattributes extrait les annotations metadata.dynatrace.com du pod et le processeur transform fusionne leur contenu JSON dans les attributs de ressource

L’annotation metadata.dynatrace.com contient un objet JSON ; l’instruction merge_maps(…, ParseJSON(…), "upsert") le transforme en attributs de ressource, puis delete_key supprime l’annotation brute. Pour le reste de la configuration du Collector dans le cluster, voir le Collector OpenTelemetry sur Kubernetes.

Comment vérifier que ça fonctionne

  1. Vérifiez que le namespace porte bien le label attendu :
    kubectl get namespace paiement -o yaml | grep -A5 labels
  2. Vérifiez que le webhook a enrichi un pod recréé :
    kubectl -n paiement get pod <nom-du-pod> -o yaml | grep metadata.dynatrace.com

    Aucune annotation ? Le namespaceSelector ne correspond pas au namespace, ou le pod date d’avant la modification.

  3. En SaaS, ouvrez un Notebook et lancez :
    fetch logs, from: now() - 1h
    | filter isNotNull(dt.security_context)
    | summarize logs = count(), by: {k8s.namespace.name, dt.security_context}
    | sort logs desc

    Les namespaces enrichis doivent apparaître avec leur contexte de sécurité.

  4. En Managed, contrôlez les annotations au niveau des pods (points 1 et 2) ; les champs Grail et les règles centralisées ne s’y appliquent pas.

Bonnes pratiques

  • Une seule source de vérité : règles centralisées ou annotations dédiées, jamais les deux sur le même périmètre.
  • Un label de sécurité dédié par namespace, stable dans le temps, plutôt qu’un label applicatif qui change à chaque refonte.
  • namespaceSelector explicite : vous savez exactement où l’Operator injecte, et un nouveau namespace ne reçoit rien par surprise.
  • Prévoir les redémarrages : planifiez le rollout restart après le délai de 45 minutes, hors heures de pointe.
  • Aligner avec le tagging existant : les mêmes clés que dans vos tags et management zones évitent deux vocabulaires concurrents.

Questions fréquentes

Le metadata enrichment fonctionne-t-il avec Dynatrace Managed ?

Le paramètre .spec.metadataEnrichment et son namespaceSelector figurent dans la documentation DynaKube de Managed. Les règles Kubernetes Telemetry Enrichment et les champs comme dt.security_context pour les politiques Grail sont, eux, documentés pour Latest Dynatrace (SaaS).

Pourquoi mes nouveaux champs n’apparaissent-ils pas tout de suite ?

Les règles mettent jusqu’à 45 minutes à se propager, et le webhook n’agit qu’à la création des pods. Attendez, puis redémarrez les workloads.

Quelle différence avec le processeur k8sattributes ?

k8sattributes ajoute des métadonnées Kubernetes aux données qui traversent un Collector. Le metadata enrichment de Dynatrace couvre aussi OneAgent, Fluent Bit, les métriques et événements de la plateforme ; les deux se complètent, comme le montre l’exemple de l’étape 4. Pour le nommage des attributs, voir les attributs OpenTelemetry dans Dynatrace.

Conclusion

Le metadata enrichment Kubernetes transforme des labels déjà présents dans vos namespaces en champs exploitables pour l’accès, les coûts et le routage. Commencez par un namespace pilote avec un namespaceSelector, ajoutez une règle dt.security_context, vérifiez-la en DQL, puis élargissez. Chaque alerte arrive ensuite avec son propriétaire, et le MTTR y gagne.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de Dynatrace LLC. Les paramètres de la DynaKube et les réglages évoluent avec les versions de l’Operator : vérifiez-les dans la documentation officielle.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Grail vs Classic : ce qui change pour les permissions, les primary Grail tags et l'architecture

Grail vs Classic : ce qui change pour les permissions, les primary Grail tags et l’architecture

Next Post
Log ingestion API Dynatrace : envoyer, transférer et enrichir vos logs

Log ingestion API Dynatrace : envoyer, transférer et enrichir vos logs

Related Posts