Extraction de tags dans Kubernetes

Docs > Surveillance des conteneurs > Kubernetes > Extraction de tags dans Kubernetes

Cette traduction n'est pas à jour. Pour consulter la dernière version en anglais, cliquez ici

L’Agent Datadog peut automatiquement attribuer des balises aux métriques, aux traces et aux journaux émis par un pod (ou un conteneur individuel au sein d’un pod) en fonction des étiquettes ou des annotations.

Balises prêtes à l’emploi

La liste des balises attribuées automatiquement dépend de la configuration de cardinalité de l’Agent. Cardinalité des balises est ajoutée avant l’ingestion et peut avoir un impact sur la facturation, car différentes configurations de cardinalité influencent le nombre de métriques émises.

Balise	Cardinalité	Source	Exigence
`container_id`	Élevé	État du pod	N/A
`display_container_name`	Élevé	État du pod	N/A
`pod_name`	Orchestrateur	Métadonnées du pod	N/A
`oshift_deployment`	Orchestrateur	Annotation du pod `openshift.io/deployment.name`	L’environnement OpenShift et l’annotation du pod doivent exister
`kube_ownerref_name`	Orchestrateur	Propriétaire du pod	Le pod doit avoir un propriétaire
`kube_job`	Orchestrateur	Propriétaire du pod	Le pod doit être attaché à un cronjob
`kube_job`	Faible	Propriétaire du pod	Le pod doit être attaché à un job
`kube_replica_set`	Faible	Propriétaire du pod	Le pod doit être attaché à un ensemble de réplicas
`kube_service`	Faible	Découverte de service Kubernetes	Le pod est derrière un service Kubernetes
`kube_daemon_set`	Faible	Propriétaire du pod	Le pod doit être attaché à un DaemonSet
`kube_container_name`	Faible	État du pod	N/A
`kube_namespace`	Faible	Métadonnées du pod	N/A
`kube_app_name`	Faible	Étiquette du pod `app.kubernetes.io/name`	L’étiquette du pod doit exister
`kube_app_instance`	Faible	Étiquette de pod `app.kubernetes.io/instance`	L’étiquette de pod doit exister
`kube_app_version`	Faible	Étiquette de pod `app.kubernetes.io/version`	L’étiquette de pod doit exister
`kube_app_component`	Faible	Étiquette de pod `app.kubernetes.io/component`	L’étiquette de pod doit exister
`kube_app_part_of`	Faible	Étiquette de pod `app.kubernetes.io/part-of`	L’étiquette de pod doit exister
`kube_app_managed_by`	Faible	Étiquette de pod `app.kubernetes.io/managed-by`	L’étiquette de pod doit exister
`env`	Faible	Étiquette de pod `tags.datadoghq.com/env` ou variable d’environnement de conteneur (`DD_ENV` ou `OTEL_RESOURCE_ATTRIBUTES`)	Tagging de service unifié activé
`version`	Faible	Étiquette de pod `tags.datadoghq.com/version` ou variable d’environnement de conteneur (`DD_VERSION` ou `OTEL_RESOURCE_ATTRIBUTES`)	Tagging de service unifié activé
`service`	Faible	Étiquette de pod `tags.datadoghq.com/service` ou variable d’environnement de conteneur (`DD_SERVICE`, `OTEL_RESOURCE_ATTRIBUTES`, ou `OTEL_SERVICE_NAME`)	Tagging de service unifié activé
`pod_phase`	Faible	État du pod	N/A
`oshift_deployment_config`	Faible	Annotation du pod `openshift.io/deployment-config.name`	L’environnement OpenShift et l’annotation du pod doivent exister
`kube_ownerref_kind`	Faible	Référence du propriétaire du pod	Le pod doit avoir un propriétaire
`kube_deployment`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un déploiement
`kube_argo_rollout`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un déploiement argo
`kube_replication_controller`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un contrôleur de réplication
`kube_stateful_set`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un statefulset
`persistentvolumeclaim`	Faible	Spécification du pod	Un PVC doit être attaché au pod
`kube_cronjob`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un cronjob
`image_name`	Faible	Spécification du pod	N/A
`short_image`	Faible	Spécification du pod	N/A
`image_tag`	Faible	Spécification du pod	N/A
`eks_fargate_node`	Faible	Spécification du pod	Environnement EKS Fargate
`kube_runtime_class`	Faible	Spécification du pod	Le pod doit être attaché à une classe d’exécution
`gpu_vendor`	Faible	Spécification du pod	Le conteneur doit être attaché à une ressource GPU
`image_id`	Faible	ID de l’image du conteneur	N/A
`kube_autoscaler_kind`	Faible	Type d’autoscaler Kubernetes	L’autoscaler Kubernetes doit être utilisé
`kube_priority_class`	Faible	Classe de priorité du pod	Le pod doit avoir une classe de priorité définie
`kube_qos`	Faible	Classe de qualité de service du pod	N/A

Étiquette hôte

L’Agent peut ajouter des informations sur l’environnement Kubernetes sous la forme de tags de host.

Étiquette	Cardinalité	Source	Exigence
`kube_cluster_name`	Faible	`DD_CLUSTER_NAME` variable d’environnement ou intégration du fournisseur de cloud	`DD_CLUSTER_NAME` variable d’environnement ou intégration du fournisseur de cloud activée
`kube_node_role`	Faible	Étiquette de nœud `node-role.kubernetes.io/<role>`	L’étiquette de nœud doit exister
`kube_node`	Faible	`NodeName` champ dans les spécifications d’un pod
`orch_cluster_id`	Faible	Métadonnées du cluster orchestrateur	Environnement orchestrateur
`kube_distribution`	Faible	Étiquettes de nœud et NodeSystemInfo

Autodécouverte des tags

À partir de l’Agent v6.10+, l’Agent peut autodécouvrir des étiquettes à partir des annotations de pod. Cela permet à l’Agent d’associer des étiquettes à toutes les données émises par l’ensemble des pods ou un conteneur individuel au sein de ce pod.

En tant que meilleure pratique dans les environnements conteneurisés, Datadog recommande d’utiliser un étiquetage de service unifié pour aider à unifier les étiquettes. L’étiquetage de service unifié relie la télémétrie Datadog grâce à l’utilisation de trois étiquettes standard : env, service et version. Pour apprendre à configurer votre environnement avec un étiquetage unifié, référez-vous à la documentation dédiée à l’étiquetage de service unifié.

Pour appliquer une étiquette <TAG_KEY>:<TAG_VALUE> à toutes les données émises par un pod donné et collectées par l’Agent, utilisez l’annotation suivante sur votre pod :

annotations:
  ad.datadoghq.com/tags: '{"<TAG_KEY>": "<TAG_VALUE>","<TAG_KEY_1>": "<TAG_VALUE_1>"}'

Si vous souhaitez appliquer une étiquette <TAG_KEY>:<TAG_VALUE> à un conteneur individuel <CONTAINER_NAME> au sein d’un pod, utilisez l’annotation suivante sur votre pod :

annotations:
  ad.datadoghq.com/<CONTAINER_NAME>.tags: '{"<TAG_KEY>": "<TAG_VALUE>","<TAG_KEY_1>": "<TAG_VALUE_1>"}'

À partir de la version 7.17+ de l’Agent, celui-ci peut découvrir automatiquement des balises à partir des étiquettes Docker. Ce processus permet à l’Agent d’associer des balises personnalisées à toutes les données émises par un conteneur, sans modifier la configuration de l’Agent.

com.datadoghq.ad.tags: '["<TAG_KEY>:TAG_VALUE", "<TAG_KEY_1>:<TAG_VALUE_1>"]'

À partir de la version 7.77+ de l’Agent, les annotations de balises prennent en charge les variables de modèle d’autodécouverte pour un balisage dynamique basé sur les métadonnées d’exécution. À l’exception de %%env_<VAR>%%, toutes les variables de modèle sont prises en charge.

annotations:
  ad.datadoghq.com/tags: '{"pod_ip":"%%host%%","pod_name":"%%kube_pod_name%%","namespace":"%%kube_namespace%%"}'
  ad.datadoghq.com/nginx.tags: '{"container_port":"%%port_80%%"}'

Extraction d’étiquettes

À partir de la version 7.64+, l’Agent et l’Agent de Cluster peuvent être configurés pour collecter des étiquettes et des annotations à partir des ressources Kubernetes et les utiliser comme balises à partir d’une configuration commune. Datadog recommande d’utiliser les options suivantes pour garantir un reporting cohérent entre l’étiquetage de base de l’Agent, le reporting KSM de l’Agent de Cluster et le reporting Orchestrator Explorer des deux Agents :

kubernetesResourcesLabelsAsTags
kubernetesResourcesAnnotationsAsTags

Ces options doivent être utilisées à la place des anciennes options de l’Agent podLabelsAsTags, nodeLabelsAsTags, namespaceLabelsAsTags, et de tout remplacement de configuration KSM.

Ces configurations font référence au type de ressource de l’objet à partir duquel extraire des métadonnées. Chaque type de ressource doit être spécifié au format resourceType.apiGroup, où resourceType est le nom au pluriel de la ressource. Les ressources dans le groupe API vide (par exemple, les pods et les nœuds) peuvent être spécifiées en utilisant uniquement le nom resourceType.

Par exemple, exécutez kubectl api-resources pour récupérer cette information :

Nom	Version API	Configuration de ressource Datadog
pods	v1	pods
nœuds	v1	nœuds
espaces de noms	v1	espaces de noms
déploiements	apps/v1	déploiements.apps
rôles	rbac.authorization.k8s.io/v1	rôles.rbac.authorization.k8s.io

Notes :

Les tags ne se propagent pas entre la charge de travail et les ressources enfants. Par exemple, les étiquettes sur un déploiement ne sont pas automatiquement appliquées aux journaux de ses Pods enfants. Pour taguer les données des Pods, configurez l’extraction des étiquettes directement sur les Pods.
Les tags se propagent de l’espace de noms vers les pods et les conteneurs à l’intérieur de ceux-ci.
Utilisez Datadog Agent 7.73+ pour utiliser des jokers dans les règles d’extraction des tags pour vos métriques KSM.

Les étiquettes des ressources Kubernetes en tant que tags

Cette option est utilisée pour extraire une étiquette donnée sur vos ressources Kubernetes et l’envoyer en tant que tag Datadog.

Pour extraire une étiquette de ressource donnée <LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    kubernetesResourcesLabelsAsTags:
      <RESOURCE>:
        <LABEL>: <TAG_KEY>

Par exemple, pour extraire les étiquettes de ressource des nœuds, des pods et des déploiements :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    kubernetesResourcesLabelsAsTags:
      nodes:
        kubernetes.io/arch: arch
      pods:
        role: pod_role
      deployments.apps:
        team: kube_team

Pour extraire une étiquette de ressource donnée <LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  kubernetesResourcesLabelsAsTags:
    <RESOURCE>:
      <LABEL>: <TAG_KEY>

Par exemple, pour extraire les étiquettes de ressource des nœuds, des pods et des déploiements :

datadog:
  kubernetesResourcesLabelsAsTags:
    nodes:
      kubernetes.io/arch: arch
    pods:
      role: pod_role
    deployments.apps:
      team: kube_team

Pour extraire une étiquette de ressource donnée <LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à à la fois vos conteneurs Agent et Cluster Agent.

- name: DD_KUBERNETES_RESOURCES_LABELS_AS_TAGS
  value: '{"<RESOURCE>":{"<LABEL>":"<TAG_KEY>"}}'

Par exemple, pour extraire les étiquettes de ressource des nœuds, des pods et des déploiements :

- name: DD_KUBERNETES_RESOURCES_LABELS_AS_TAGS
  value: '{"deployments.apps":{"team":"kube_team"},"nodes":{"kubernetes.io/arch":"arch"},"pods":{"role":"pod_role"}}'

Pour Agent 7.73.0+, utilisez la configuration suivante pour ajouter toutes les étiquettes de ressource en tant que tags à vos métriques. Dans cet exemple, les noms des tags sont préfixés par <PREFIX>_ :

    #(...)
    kubernetesResourcesLabelsAsTags:
      pods:
        "*": <PREFIX>_%%label%%

Notes : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Fusion avec les configurations héritées

Cette option de configuration est fusionnée avec d’autres configurations définies dans podLabelsAsTags, namespaceLabelsAsTags et nodeLabelsAsTags. En cas de conflit, kubernetesResourcesLabelsAsTags a la priorité lors de la fusion des configurations.

Par exemple, si vous avez les configurations suivantes :

datadog:
  kubernetesResourcesLabelsAsTags:
    pods:
      label-1: tag-a
      label-2: tag-b

  podLabelsAsTags:
    label-2: legacy-tag-c
    label-3: legacy-tag-d

Le mappage suivant est utilisé pour extraire des balises des étiquettes de pod :

label-1: tag-a
label-2: tag-b
label-3: legacy-tag-d

Annotations des ressources Kubernetes en tant que tags

Cette option extrait une annotation spécifiée de vos ressources Kubernetes et l’envoie en tant que tag Datadog.

Pour extraire une annotation de ressource donnée <ANNOTATION> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    kubernetesResourcesAnnotationsAsTags:
      <RESOURCE>:
        <ANNOTATION>: <TAG_KEY>

Par exemple, pour extraire des annotations de ressources des nœuds, des pods et des déploiements :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    kubernetesResourcesAnnotationsAsTags:
      nodes:
        kubernetes.io/arch: arch
      pods:
        role: pod_role
      deployments.apps:
        team: kube_team

Pour extraire une annotation de ressource donnée <ANNOTATION> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  kubernetesResourcesAnnotationsAsTags:
    <RESOURCE>:
      <ANNOTATION>: <TAG_KEY>

Par exemple, pour extraire des annotations de ressources des nœuds, des pods et des déploiements :

datadog:
  kubernetesResourcesAnnotationsAsTags:
    nodes:
      kubernetes.io/arch: arch
    pods:
      role: pod_role
    deployments.apps:
      team: kube_team

Pour extraire une annotation de ressource donnée <ANNOTATION> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à à la fois vos conteneurs Agent et Cluster Agent.

- name: DD_KUBERNETES_RESOURCES_ANNOTATIONS_AS_TAGS
  value: '{"<RESOURCE>":{"<ANNOTATION>":"<TAG_KEY>"}}'

Par exemple, pour extraire des annotations de ressources des nœuds, des pods et des déploiements :

- name: DD_KUBERNETES_RESOURCES_ANNOTATIONS_AS_TAGS
  value: '{"deployments.apps":{"team":"kube_team"},"nodes":{"kubernetes.io/arch":"arch"},"pods":{"role":"pod_role"}}'

Pour Agent 7.73.0+, utilisez la configuration suivante pour ajouter toutes les annotations de ressources en tant que tags à vos métriques. Dans cet exemple, les noms des tags sont préfixés par <PREFIX>_ :

    #(...)
    kubernetesResourcesAnnotationsAsTags:
      pods:
        "*": <PREFIX>_%%annotation%%

Notes : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Cette option de configuration est fusionnée avec d’autres configurations définies dans podAnnotationsAsTags. En cas de conflit, kubernetesResourcesAnnotationsAsTags a la priorité lors de la fusion des configurations.

Par exemple, si vous avez les configurations suivantes :

datadog:
  kubernetesResourcesAnnotationsAsTags:
    pods:
      annotation-1: tag-a
      annotation-2: tag-b

  podAnnotationsAsTags:
    annotation-2: legacy-tag-c
    annotation-3: legacy-tag-d

Le mappage suivant est utilisé pour extraire des tags des annotations de pod :

annotation-1: tag-a
annotation-2: tag-b
annotation-3: legacy-tag-d

Configuration pour les anciennes versions

Étiquettes de nœud en tant que tags

Si vous êtes sur la version de l’agent 7.58.0+, il est conseillé d’utiliser les étiquettes des ressources Kubernetes en tant que tags pour configurer les étiquettes en tant que tags.

À partir de l’Agent v6.0+, l’Agent peut collecter des étiquettes pour un nœud donné et les utiliser comme tags à attacher à toutes les métriques, traces et journaux émis associés à ce host dans Datadog :

Pour extraire une étiquette de nœud donnée <NODE_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    nodeLabelsAsTags:
      <NODE_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    nodeLabelsAsTags:
      kubernetes.io/arch: arch

Pour Agent v7.24.0+, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes de nœud en tant que tags à vos métriques. Dans cet exemple, les noms des tags sont préfixés par <PREFIX>_ :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    nodeLabelsAsTags:
      "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics before version 7.73

Pour extraire une étiquette de nœud donnée <NODE_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  nodeLabelsAsTags:
    <NODE_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

datadog:
  nodeLabelsAsTags:
    kubernetes.io/arch: arch

datadog:
  nodeLabelsAsTags:
    "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics before version 7.73

Pour extraire une étiquette de nœud donnée <NODE_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_KUBERNETES_NODE_LABELS_AS_TAGS='{"<NODE_LABEL>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

DD_KUBERNETES_NODE_LABELS_AS_TAGS='{"kubernetes.io/arch":"arch"}'

DD_KUBERNETES_NODE_LABELS_AS_TAGS='{"*":"<PREFIX>_%%label%%"}' # Note: wildcards do not work for KSM metrics before version 7.73

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Étiquettes de pod en tant que tags

Si vous utilisez la version de l’agent 7.58.0 ou supérieure, il est conseillé d’utiliser les étiquettes des ressources Kubernetes en tant que tags pour configurer les étiquettes de pod en tant que tags.

À partir de la version 6.0 de l’Agent, l’Agent peut collecter des étiquettes pour un pod donné et les utiliser comme tags à attacher à toutes les métriques, traces et journaux émis par ce pod :

Pour extraire une étiquette de pod donnée <POD_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podLabelsAsTags:
      <POD_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podLabelsAsTags:
      app: kube_app

Pour l’Agent v7.24.0 ou supérieur, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes de pod en tant que tags à vos métriques. Dans cet exemple, les noms des tags sont préfixés par <PREFIX>_ :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podLabelsAsTags:
      "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics before version 7.73

Pour extraire une étiquette de pod donnée <POD_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  podLabelsAsTags:
    <POD_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

datadog:
  podLabelsAsTags:
    app: kube_app

Pour l’Agent v7.24.0 ou supérieur, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes de pod en tant que tags à vos métriques, sauf celles de KSM (kubernetes_state.*). Dans cet exemple, les noms des tags sont préfixés par <PREFIX>_ :

datadog:
  podLabelsAsTags:
    "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics

Pour extraire une étiquette de pod donnée <POD_LABEL> et la transformer en clé de tag <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_KUBERNETES_POD_LABELS_AS_TAGS='{"<POD_LABEL>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

DD_KUBERNETES_POD_LABELS_AS_TAGS='{"app":"kube_app"}'

DD_KUBERNETES_POD_LABELS_AS_TAGS='{"*":"<PREFIX>_%%label%%"}'

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Annotations de pod en tant que tags

Si vous utilisez la version de l’agent 7.58.0 ou supérieure, il est conseillé d’utiliser les étiquettes des ressources Kubernetes en tant que tags pour configurer les annotations de pod en tant que tags.

À partir de la version 6.0 de l’Agent, l’Agent peut collecter des annotations pour un pod donné et les utiliser comme balises à attacher à toutes les métriques, traces et journaux émis par ce pod :

Pour extraire une annotation de pod donnée <POD_ANNOTATION> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la DatadogAgent configuration de votre opérateur dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podAnnotationsAsTags:
      <POD_ANNOTATION>: <TAG_KEY>

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podAnnotationsAsTags:
      app: kube_app

Pour l’Agent v7.24.0 ou supérieur, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les annotations de pod en tant que balises à vos métriques, sauf celles de KSM (kubernetes_state.*). Dans cet exemple, les noms des balises sont préfixés par <PREFIX>_ :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    podAnnotationsAsTags:
      "*": <PREFIX>_%%annotation%% # Note: wildcards do not work for KSM metrics

Pour extraire une annotation de pod donnée <POD_ANNOTATION> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  podAnnotationsAsTags:
    <POD_ANNOTATION>: <TAG_KEY>

Par exemple, vous pourriez configurer :

datadog:
  podAnnotationsAsTags:
    app: kube_app

datadog:
  podAnnotationsAsTags:
    "*": <PREFIX>_%%annotation%% # Note: wildcards do not work for KSM metrics

Pour extraire une annotation de pod donnée <POD_ANNOTATION> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_KUBERNETES_POD_ANNOTATIONS_AS_TAGS='{"<POD_ANNOTATION>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

DD_KUBERNETES_POD_ANNOTATIONS_AS_TAGS='{"app":"kube_app"}'

DD_KUBERNETES_POD_ANNOTATIONS_AS_TAGS='{"*":"<PREFIX>_%%annotation%%"}'

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Étiquettes de namespace en tant que balises

Si vous utilisez la version de l’Agent 7.58.0 ou supérieure, il est conseillé d’utiliser les étiquettes des ressources Kubernetes en tant que balises pour configurer les étiquettes de namespace en tant que balises.

À partir de l’Agent 7.55.0+, l’Agent peut collecter des étiquettes pour un espace de noms donné et les utiliser comme balises à attacher à toutes les métriques, traces et journaux émis par tous les pods dans cet espace de noms :

Pour extraire une étiquette d’espace de noms donnée <NAMESPACE_LABEL> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    namespaceLabelsAsTags:
      <NAMESPACE_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    namespaceLabelsAsTags:
      app: kube_app

Pour l’Agent v7.24.0+, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes d’espace de noms en tant que balises à vos métriques, sauf celles de KSM (kubernetes_state.*). Dans cet exemple, les noms des balises sont préfixés par <PREFIX>_ :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    namespaceLabelsAsTags:
      "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics

Pour extraire une étiquette d’espace de noms donnée <NAMESPACE_LABEL> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  namespaceLabelsAsTags:
    <NAMESPACE_LABEL>: <TAG_KEY>

Par exemple, vous pourriez configurer :

datadog:
  namespaceLabelsAsTags:
    app: kube_app

datadog:
  namespaceLabelsAsTags:
    "*": <PREFIX>_%%label%% # Note: wildcards do not work for KSM metrics

Pour extraire une étiquette d’espace de noms donnée <NAMESPACE_LABEL> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_KUBERNETES_NAMESPACE_LABELS_AS_TAGS='{"<NAMESPACE_LABEL>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

DD_KUBERNETES_NAMESPACE_LABELS_AS_TAGS='{"app":"kube_app"}'

DD_KUBERNETES_NAMESPACE_LABELS_AS_TAGS='{"*":"<PREFIX>_%%label%%"}'

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Consultez la page de facturation des métriques personnalisées pour plus d’informations.

Variables d’environnement de conteneur en tant que balises

À partir de l’Agent v7.32+, l’Agent peut collecter des variables d’environnement de conteneur et les utiliser comme balises à attacher à toutes les métriques, traces et journaux correspondant au conteneur. Les conteneurs docker et containerd sont tous deux pris en charge :

Pour extraire une variable d’environnement donnée <ENV_VAR> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      env:
        - name: DD_CONTAINER_ENV_AS_TAGS
          value: '{"<ENV_VAR>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      env:
        - name: DD_CONTAINER_ENV_AS_TAGS
          value: '{"app":"kube_app"}'

Pour extraire une variable d’environnement donnée <ENV_VAR> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  env:
    - name: DD_CONTAINER_ENV_AS_TAGS
      value: '{"<ENV_VAR>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

datadog:
  env:
    - name: DD_CONTAINER_ENV_AS_TAGS
      value: '{"app":"kube_app"}'

Pour extraire une variable d’environnement donnée <ENV_VAR> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_CONTAINER_ENV_AS_TAGS='{"<ENV_VAR>": "<TAG_KEY>"}'

Exemple :

DD_CONTAINER_ENV_AS_TAGS='{"app":"kube_app"}'

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Voir Facturation des métriques personnalisées pour plus de détails.

Étiquettes de conteneur en tant que balises

À partir de l’Agent v7.33+, l’Agent peut collecter des étiquettes de conteneur et les utiliser comme balises. L’agent attache les balises à toutes les métriques, traces et journaux associés au conteneur.

L’Agent peut générer des balises à partir des étiquettes de conteneur pour les conteneurs docker et containerd. Dans le cas de containerd, la version minimale prise en charge est v1.5.6, car les versions précédentes ne propagent pas correctement les étiquettes.

Pour extraire une étiquette de conteneur donnée <CONTAINER_LABEL> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration de votre opérateur DatadogAgent dans datadog-agent.yaml :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      env:
        - name: DD_CONTAINER_LABELS_AS_TAGS
          value: '{"<CONTAINER_LABEL>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      env:
        - name: DD_CONTAINER_LABELS_AS_TAGS
          value: '{"app":"kube_app"}'

Pour extraire une étiquette de conteneur donnée <CONTAINER_LABEL> et la transformer en clé de balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

datadog:
  env:
    - name: DD_CONTAINER_LABELS_AS_TAGS
      value: '{"<CONTAINER_LABEL>": "<TAG_KEY>"}'

Par exemple, vous pourriez configurer :

datadog:
  env:
    - name: DD_CONTAINER_LABELS_AS_TAGS
      value: '{"app":"kube_app"}'

Pour extraire une étiquette de conteneur donnée <CONTAINER_LABEL> et la transformer en clé de balise <TAG_KEY>, ajoutez la variable d’environnement suivante à l’Agent Datadog :

DD_CONTAINER_LABELS_AS_TAGS='{"<CONTAINER_LABEL>":"<TAG_KEY>"}'

Exemple :

DD_CONTAINER_LABELS_AS_TAGS='{"app":"kube_app"}'

Remarque : Les métriques personnalisées peuvent avoir un impact sur la facturation. Voir Facturation des métriques personnalisées pour plus de détails.