Extraction de balises Kubernetes

Docs > Surveillance des conteneurs > Kubernetes > Extraction de balises Kubernetes

L’Agent Datadog peut automatiquement attribuer des balises aux métriques, traces et 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	Référence du propriétaire du pod	Le pod doit avoir un propriétaire
`kube_job`	Orchestrateur	Référence du propriétaire du pod	Le pod doit être attaché à un cronjob
`kube_job`	Faible	Référence du propriétaire du pod	Le pod doit être attaché à un job
`kube_replica_set`	Faible	Référence du 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	Référence du 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 du pod `app.kubernetes.io/instance`	L’étiquette du pod doit exister
`kube_app_version`	Faible	Étiquette du pod `app.kubernetes.io/version`	L’étiquette du pod doit exister
`kube_app_component`	Faible	Étiquette du pod `app.kubernetes.io/component`	L’étiquette du pod doit exister
`kube_app_part_of`	Faible	Étiquette du pod `app.kubernetes.io/part-of`	L’étiquette du pod doit exister
`kube_app_managed_by`	Faible	Étiquette du pod `app.kubernetes.io/managed-by`	L’étiquette du pod doit exister
`env`	Faible	Étiquette du pod `tags.datadoghq.com/env` ou variable d’environnement du conteneur (`DD_ENV` ou `OTEL_RESOURCE_ATTRIBUTES`)	Étiquetage de service unifié activé
`version`	Faible	Étiquette du pod `tags.datadoghq.com/version` ou variable d’environnement du conteneur (`DD_VERSION` ou `OTEL_RESOURCE_ATTRIBUTES`)	Étiquetage de service unifié activé
`service`	Faible	Étiquette du pod `tags.datadoghq.com/service` ou variable d’environnement du conteneur (`DD_SERVICE`, `OTEL_RESOURCE_ATTRIBUTES`, ou `OTEL_SERVICE_NAME`)	Étiquetage 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	Un 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 d’hôte

L’Agent peut attacher des informations sur l’environnement Kubernetes en tant qu’“étiquettes d’hôte”.

Étiquette	Cardinalité	Source	Exigence
`kube_cluster_name`	Faible	`DD_CLUSTER_NAME` intégration envvar ou fournisseur de cloud	`DD_CLUSTER_NAME` intégration envvar ou 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

Découverte automatique des étiquettes

À partir de l’Agent v6.10+, l’Agent peut découvrir automatiquement des balises à partir des annotations de Pod. Cela permet à l’Agent d’associer des balises à 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 de 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 l’Agent v7.17+, l’Agent peut découvrir automatiquement des étiquettes à partir des étiquettes Docker. Ce processus permet à l’Agent d’associer des étiquettes 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 l’Agent v7.77+, les annotations d’étiquettes prennent en charge les variables de modèle de découverte automatique pour un étiquetage 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 étiquettes à partir d’une configuration commune. Datadog recommande d’utiliser les options suivantes pour garantir un reporting cohérent entre l’étiquetage principal de l’Agent, le reporting KSM de l’Agent de Cluster et le reporting de l’Orchestrateur Explorer des deux Agents :

kubernetesResourcesLabelsAsTags
kubernetesResourcesAnnotationsAsTags

Ces options doivent être utilisées au lieu 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 les 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 de l’API	Configuration des ressources 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 qui s’y trouvent *.
Utilisez Datadog Agent 7.73+ pour employer des caractères génériques dans les règles d’extraction des tags de vos métriques KSM.

É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 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:
    kubernetesResourcesLabelsAsTags:
      <RESOURCE>:
        <LABEL>: <TAG_KEY>

Par exemple, pour extraire des é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 balise <TAG_KEY> dans Datadog, ajoutez la configuration suivante à votre fichier Helm datadog-values.yaml :

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

Par exemple, pour extraire des é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 balise <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 des é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 l’Agent 7.73.0 et plus, utilisez la configuration suivante pour ajouter toutes les étiquettes de ressource en tant que balises à vos métriques. Dans cet exemple, les noms de balises 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 des 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 balises

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

Pour extraire une annotation de ressource donnée <ANNOTATION> 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:
    kubernetesResourcesAnnotationsAsTags:
      <RESOURCE>:
        <ANNOTATION>: <TAG_KEY>

Par exemple, pour extraire des annotations de ressource 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 balise <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 ressource 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 balise <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 ressource 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 l’Agent 7.73.0 et plus, utilisez la configuration suivante pour ajouter toutes les annotations de ressource en tant que balises à vos métriques. Dans cet exemple, les noms de balises 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 balises des annotations de pod :

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

Configuration héritée

Étiquettes de nœud en tant que balises

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

À partir de l’Agent v6.0+, l’Agent peut collecter des étiquettes pour un nœud donné et les utiliser comme balises à 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 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:
    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 l’Agent v7.24.0 et plus, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes de nœud en tant que balises à vos métriques. Dans cet exemple, les noms de balises 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 balise <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 balise <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 balises

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

À partir de l’Agent v6.0+, l’Agent peut collecter des étiquettes pour un pod donné et les utiliser comme balises à 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 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:
    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 et 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 balise <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 et 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 balise <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 l’Agent v6.0 et supérieur, l’Agent peut collecter des annotations pour un pod donné et les utiliser comme tags à 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 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:
    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 et supérieur, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les annotations 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>_ :

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 tag <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 tag <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 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 namespace en tant que tags.

À partir de l’Agent 7.55.0 et supérieur, l’Agent peut collecter des étiquettes pour un namespace donné et les utiliser comme tags à attacher à toutes les métriques, traces et journaux émis par tous les pods dans ce namespace :

Pour extraire une étiquette de namespace donnée <NAMESPACE_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:
    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 et supérieur, utilisez la configuration de variable d’environnement suivante pour ajouter toutes les étiquettes de namespace 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>_ :

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 de namespace donnée <NAMESPACE_LABEL> et la transformer en clé de tag <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 de namespace donnée <NAMESPACE_LABEL> et la transformer en clé de tag <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 tags

À partir de la version 7.32+ de l’Agent, l’Agent peut collecter les variables d’environnement des conteneurs et les utiliser comme tags à 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 tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration DatadogAgent de votre Opérateur 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 tag <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 tag <TAG_KEY> dans Datadog, ajoutez la variable d’environnement suivante à l’Agent Datadog :

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

Par 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 tags

À partir de la version 7.33+ de l’Agent, l’Agent peut collecter les étiquettes de conteneur et les utiliser comme tags. L’agent attache les tags à toutes les métriques, traces et journaux associés au conteneur.

L’Agent peut générer des tags à 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 tag <TAG_KEY> dans Datadog, ajoutez la configuration suivante à la configuration DatadogAgent de votre Opérateur 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 tag <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 tag <TAG_KEY>, ajoutez la variable d’environnement suivante à l’Agent Datadog :

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

Par 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.