Instalar el recolector DDOT como un DaemonSet de Kubernetes

Documentos > OpenTelemetry en Datadog > Enviar datos de OpenTelemetry a Datadog > Distribución de Datadog del Colector de OpenTelemetry > Install > Instalar el recolector DDOT como un DaemonSet de Kubernetes

Resumen

Sigue esta guía para desplegar la Datadog Distribution of OpenTelemetry (DDOT) Collector como un DaemonSet de Kubernetes utilizando Helm o Datadog Operator.

¿Necesitas componentes adicionales de OpenTelemetry? Si necesitas componentes adicionales a los incluidos en el paquete predeterminado, sigue Utiliza componentes personalizados de OpenTelemetry para extender las capacidades de Datadog Agent. Para una lista de componentes incluidos por defecto, consulta componentes del recolector de OpenTelemetry.

Requisitos

Para completar esta guía, necesitas lo siguiente:

Cuenta de Datadog:

Crea una cuenta de Datadog si no tienes una.
Encuentra o crea tu clave de API de Datadog.

Software: Instala y configura lo siguiente en tu máquina:

Un clúster de Kubernetes (v1.29+)
Helm (v3+)
kubectl

Red: When using the Datadog SDK with OpenTelemetry API support, telemetry is routed to different components depending on the signal source. Ensure the following ports are accessible on your Datadog Agent or Collector:

Signal Source	Protocol	Port	Destination Component
OTel Metrics and Logs API	OTLP (gRPC/HTTP)	4317 / 4318	Datadog Agent OTLP Receiver or DDOT Collector
Datadog Tracing	Datadog trace intake	8126 (TCP)	Datadog Trace Agent
Runtime Metrics	DogStatsD	8125 (UDP)	DogStatsD Server

Instala Datadog Agent con OpenTelemetry Collector

Esta instalación es necesaria para las configuraciones de Datadog SDK + DDOT y OpenTelemetry SDK + DDOT. Aunque el SDK de Datadog implementa la API de OpenTelemetry, aún requiere el recolector DDOT para procesar y enviar métricas y registros OTLP.

Selecciona el método de instalación

Elige uno de los siguientes métodos de instalación:

Operador de Datadog: Un enfoque nativo de Kubernetes que reconcilia y mantiene automáticamente tu configuración de Datadog. Informa el estado de despliegue, salud y errores en su estado de Recurso Personalizado, y limita el riesgo de mala configuración gracias a opciones de configuración de nivel superior.
Helm chart: Una forma sencilla de desplegar el Agente de Datadog. Proporciona capacidades de versionado, retroceso y plantillas, haciendo que los despliegues sean consistentes y más fáciles de replicar.

Instala el Operador de Datadog

Puedes instalar el Datadog Operator en tu clúster usando el Helm chart del Datadog Operator:

helm repo add datadog https://helm.datadoghq.com
helm repo update
helm install datadog-operator datadog/datadog-operator

Agrega el Repositorio de Helm de Datadog

Para agregar el repositorio de Datadog a tus repositorios de Helm:

helm repo add datadog https://helm.datadoghq.com
helm repo update

Configura la clave de API de Datadog

Obtén la clave de API de Datadog.
Almacena la clave de API como un secreto de Kubernetes:
```
kubectl create secret generic datadog-secret \
  --from-literal api-key=<DD_API_KEY>
```
Reemplaza <DD_API_KEY> con tu clave de API de Datadog real.

Configura Datadog Agent

Después de implementar el Datadog Operator, crea el recurso DatadogAgent que activa la implementación del Datadog Agent, Cluster Agent y Runners de Cluster Checks (si se utilizan) en tu clúster de Kubernetes. El Datadog Agent se implementa como un DaemonSet, ejecutando un pod en cada nodo de tu clúster.

Utiliza el archivo datadog-agent.yaml para especificar tu configuración de despliegue DatadogAgent

datadog-agent.yaml

   apiVersion: datadoghq.com/v2alpha1
   kind: DatadogAgent
   metadata:
     name: datadog
   spec:
     global:
       clusterName: <CLUSTER_NAME>
       site: <DATADOG_SITE>
       credentials:
         apiSecret:
           secretName: datadog-secret
           keyName: api-key

Reemplaza <CLUSTER_NAME> con un nombre para tu clúster.
Reemplaza <DATADOG_SITE> con tu sitio de Datadog. Tu sitio es . (Asegúrate de que se seleccione el DATADOG SITE correcto a la derecha.)

Habilite el recolector de OpenTelemetry:

datadog-agent.yaml

  # Enable Features
  features:
    otelCollector:
      enabled: true

Datadog Operator vincula automáticamente el recolector de OpenTelemetry a los puertos 4317 (nombrado otel-grpc) y 4318 (nombrado otel-http) por defecto.

(Opcional) Habilita características adicionales de Datadog:

Habilitar estas características puede incurrir en cargos adicionales. Revisa la página de precios y habla con tu Gerente de Éxito del Cliente antes de continuar.

datadog-agent.yaml

  # Enable Features
  features:
  ...
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true

Al habilitar características adicionales de Datadog, siempre utiliza los archivos de configuración de Datadog Agent o del recolector de OpenTelemetry en lugar de depender de las variables de entorno de Datadog.

Nota: A partir de Datadog Operator v1.22.0, el contenedor DDOT utiliza la imagen ddot-collector en lugar de la imagen de Datadog Agent -full.

Al sobrescribir la etiqueta de imagen del Datadog Agent de nodo, utiliza una etiqueta >= 7.67.0 para que el contenedor OTel sea programado (la imagen ddot-collector solo es compatible con >= 7.67.0).
La imagen ddot-collector no tiene variante -full. Si necesitas una imagen -full, establece spec.override.nodeAgent.image.name como una imagen completa de Datadog Agent (por ejemplo, registry.datadoghq.com/agent:7.72.1-full).

Utiliza un archivo YAML para especificar los parámetros del Helm chart para el Datadog Agent chart.

Crea un archivo datadog-values.yaml vacío:

touch datadog-values.yaml

Los parámetros no especificados utilizan los valores predeterminados de values.yaml.

Configura el secreto de la clave de API de Datadog:

datadog-values.yaml

datadog:
  site: <DATADOG_SITE>
  apiKeyExistingSecret: datadog-secret

Establece <DATADOG_SITE> en tu sitio de Datadog. De lo contrario, se establece en datadoghq.com, el sitio US1.

Habilita el recolector de OpenTelemetry y configura los puertos esenciales:

datadog-values.yaml

datadog:
  ...
  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317" # default port for OpenTelemetry gRPC receiver.
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318" # default port for OpenTelemetry HTTP receiver
        hostPort: "4318"
        name: otel-http

Establece el hostPort para exponer el puerto del contenedor a la red externa. Esto permite configurar el exportador OTLP para apuntar a la dirección IP del nodo donde se asigna Datadog Agent.

Si no deseas exponer el puerto, puedes utilizar el servicio de Datadog Agent en su lugar:

Elimina el hostPort entradas de tu datadog-values.yaml archivo.

En el archivo de despliegue de tu aplicación (deployment.yaml), configura el exportador OTLP para usar el servicio de Datadog Agent:

env:
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: 'http://<SERVICE_NAME>.<SERVICE_NAMESPACE>.svc.cluster.local'
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: 'grpc'

(Opcional) Habilita características adicionales de Datadog:

Habilitar estas características puede incurrir en cargos adicionales. Revisa la página de precios y habla con tu Gerente de Éxito del Cliente antes de continuar.

datadog-values.yaml

datadog:
  ...
  apm:
    portEnabled: true
    peer_service_aggregation: true
  orchestratorExplorer:
    enabled: true
  processAgent:
    enabled: true
    processCollection: true

Al habilitar características adicionales de Datadog, siempre utilice los archivos de configuración del Agente de Datadog o del recolector de OpenTelemetry en lugar de depender de las variables de entorno de Datadog.

(Opcional) Recopilar etiquetas de pod y usarlas como etiquetas para adjuntar a métricas, trazas y registros:

Las métricas personalizadas pueden afectar la facturación. Consulte la página de facturación de métricas personalizadas para más información.

datadog-values.yaml

datadog:
  ...
  podLabelsAsTags:
    app: kube_app
    release: helm_release

Archivo datadog-values.yaml completado

Tu datadog-values.yaml archivo debería verse algo así:

datadog-values.yaml

datadog:
  site: datadoghq.com
  apiKeyExistingSecret: datadog-secret

  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317"
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318"
        hostPort: "4318"
        name: otel-http
  apm:
    portEnabled: true
    peer_service_aggregation: true
  orchestratorExplorer:
    enabled: true
  processAgent:
    enabled: true
    processCollection: true

  podLabelsAsTags:
    app: kube_app
    release: helm_release
   

Configura el recolector de OpenTelemetry

Datadog Operator proporciona una configuración de muestra del OpenTelemetry Collector que puedes usar como punto de partida. Si necesitas modificar esta configuración, Datadog Operator admite dos formas de proporcionar una configuración personalizada de OpenTelemetry Collector:

Configuración en línea: Agrega tu configuración personalizada del OpenTelemetry Collector directamente en el campo features.otelCollector.conf.configData.
Configuración basada en ConfigMap: Almacena la configuración de tu OpenTelemetry Collector en un ConfigMap y haz referencia a ella en el campo features.otelCollector.conf.configMap. Este enfoque te permite mantener la configuración del Collector desacoplada del recurso DatadogAgent.

Configuración en línea del Collector

En el fragmento a continuación, la configuración del Collector se coloca directamente bajo el parámetro features.otelCollector.conf.configData:

datadog-agent.yaml

  ...
  # Enable Features
  features:
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configData: |-
          receivers:
            prometheus:
              config:
                scrape_configs:
                  - job_name: "otelcol"
                    scrape_interval: 10s
                    static_configs:
                      - targets:
                          - 0.0.0.0:8888
            otlp:
              protocols:
                grpc:
                  endpoint: 0.0.0.0:4317
                http:
                  endpoint: 0.0.0.0:4318
          exporters:
            debug:
              verbosity: detailed
            datadog:
              api:
                key: ${env:DD_API_KEY}
                site: ${env:DD_SITE}
              sending_queue:
                batch:
                  flush_timeout: 10s
          processors:
            infraattributes:
              cardinality: 2
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog]

For the infraattributes processor to add Kubernetes tags, your telemetry must include the container.id resource attribute. This is often, but not always, added by OTel SDK auto-instrumentation.

If your tags are missing, see the troubleshooting guide for details on how to add this attribute.

Cuando apliques el archivo datadog-agent.yaml que contiene este recurso DatadogAgent, el Operador monta automáticamente la configuración del Collector en el DaemonSet del Agente.

Archivo datadog-agent.yaml completado con configuración del Collector en línea

El datadog-agent.yaml completado con configuración del Collector en línea debería verse algo así:

datadog-agent.yaml

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    clusterName: <CLUSTER_NAME>
    site: <DATADOG_SITE>
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  # Enable Features
  features:
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configData: |-
          receivers:
            prometheus:
              config:
                scrape_configs:
                  - job_name: "datadog-agent"
                    scrape_interval: 10s
                    static_configs:
                      - targets:
                          - 0.0.0.0:8888
            otlp:
              protocols:
                grpc:
                  endpoint: 0.0.0.0:4317
                http:
                  endpoint: 0.0.0.0:4318
          exporters:
            debug:
              verbosity: detailed
            datadog:
              api:
                key: ${env:DD_API_KEY}
                site: ${env:DD_SITE}
              sending_queue:
                batch:
                  flush_timeout: 10s
          processors:
            infraattributes:
              cardinality: 2
          connectors:
            datadog/connector:
              traces:
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes]
                exporters: [debug, datadog]

Configuración del Collector basada en ConfigMap

Para configuraciones más complejas o que se actualizan con frecuencia, almacenar la configuración del Collector en un ConfigMap puede simplificar el control de versiones.

Crea un ConfigMap que contenga la configuración del Collector:

configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
  namespace: system
data:
  # must be named otel-config.yaml
  otel-config.yaml: |-
    receivers:
      prometheus:
        config:
          scrape_configs:
            - job_name: "datadog-agent"
              scrape_interval: 10s
              static_configs:
                - targets:
                    - 0.0.0.0:8888
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
    exporters:
      debug:
        verbosity: detailed
      datadog:
        api:
          key: ${env:DD_API_KEY}
          site: ${env:DD_SITE}
        sending_queue:
          batch:
            flush_timeout: 10s
    processors:
      infraattributes:
        cardinality: 2
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

El campo para la configuración del Collector en el ConfigMap debe llamarse otel-config.yaml.

Referencia el ConfigMap otel-agent-config-map en tu recurso DatadogAgent usando el parámetro features.otelCollector.conf.configMap:

datadog-agent.yaml

  ...
  # Enable Features
  features:
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configMap:
          name: otel-agent-config-map

El Operador monta automáticamente otel-config.yaml del ConfigMap en el DaemonSet del Collector de OpenTelemetry del Agente.

Archivo datadog-agent.yaml completado con la configuración del Collector en el ConfigMap

El datadog-agent.yaml completado con la configuración del Collector definida como ConfigMap debería verse algo así:

datadog-agent.yaml

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    clusterName: <CLUSTER_NAME>
    site: <DATADOG_SITE>
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  # Enable Features
  features:
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configMap:
          name: otel-agent-config-map
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
  namespace: system
data:
  # must be named otel-config.yaml
  otel-config.yaml: |-
    receivers:
      prometheus:
        config:
          scrape_configs:
            - job_name: "datadog-agent"
              scrape_interval: 10s
              static_configs:
                - targets:
                    - 0.0.0.0:8888
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
    exporters:
      debug:
        verbosity: detailed
      datadog:
        api:
          key: ${env:DD_API_KEY}
          site: ${env:DD_SITE}
        sending_queue:
          batch:
            flush_timeout: 10s
    processors:
      infraattributes:
        cardinality: 2
    connectors:
      datadog/connector:
        traces:
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes]
          exporters: [debug, datadog]

El Helm chart de Datadog ofrece una configuración de ejemplo del Collector de OpenTelemetry que puedes utilizar como punto de partida. Esta sección te guía a través de las canalizaciones predefinidas y los componentes de OpenTelemetry incluidos.

Esta es la configuración completa del Collector de OpenTelemetry en otel-config.yaml:

otel-config.yaml

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: "otelcol"
          scrape_interval: 10s
          static_configs:
            - targets: ["0.0.0.0:8888"]
  otlp:
    protocols:
      grpc:
         endpoint: 0.0.0.0:4317
      http:
         endpoint: 0.0.0.0:4318
exporters:
  debug:
    verbosity: detailed
  datadog:
    api:
      key: ${env:DD_API_KEY}
      site: ${env:DD_SITE}
    sending_queue:
      batch:
        flush_timeout: 10s
processors:
  infraattributes:
    cardinality: 2
connectors:
  datadog/connector:
    traces:
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [datadog, datadog/connector]
    metrics:
      receivers: [otlp, datadog/connector, prometheus]
      processors: [infraattributes]
      exporters: [datadog]
    logs:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [datadog]

For the infraattributes processor to add Kubernetes tags, your telemetry must include the container.id resource attribute. This is often, but not always, added by OTel SDK auto-instrumentation.

If your tags are missing, see the troubleshooting guide for details on how to add this attribute.

Componentes clave

Para enviar datos de telemetría a Datadog, los siguientes componentes están definidos en la configuración:

Diagrama que representa el patrón de despliegue del Agente

Conector de Datadog

El conector de Datadog calcula las métricas de trazas de APM de Datadog.

otel-config.yaml

connectors:
  datadog/connector:
    traces:

Exportador de Datadog

El exportador de Datadog exporta trazas, métricas y registros a Datadog.

otel-config.yaml

exporters:
  datadog:
    api:
      key: ${env:DD_API_KEY}
      site: ${env:DD_SITE}
    sending_queue:
      batch:
        flush_timeout: 10s

Nota: Si key no está especificado o se establece como un secreto, o si site no está especificado, el sistema utiliza valores de la configuración principal del Agente. Por defecto, el Agente principal establece el sitio en datadoghq.com (US1).

Receptor de Prometheus

El receptor de Prometheus recopila métricas de salud del OpenTelemetry Collector para la canalización de métricas.

otel-config.yaml

receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: "otelcol"
          scrape_interval: 10s
          static_configs:
            - targets: ["0.0.0.0:8888"]

Para más información, consulte la documentación de Métricas de Salud del Collector.

Despliegue el Agente con el OpenTelemetry Collector

Despliega el Datadog Agent con el archivo de configuración:

kubectl apply -f datadog-agent.yaml

Esto despliega el Datadog Agent como un DaemonSet con el DDOT OpenTelemetry Collector. El Collector se ejecuta en el mismo servidor que tu aplicación, siguiendo el Agent deployment pattern. El patrón de despliegue del Gateway está en vista previa; para instrucciones de instalación, sigue la guía de instalación del Gateway de DDOT en Kubernetes.

Para instalar o actualizar el Datadog Agent con OpenTelemetry Collector en tu entorno de Kubernetes, usa uno de los siguientes comandos de Helm:

Para la configuración predeterminada del OpenTelemetry Collector:

helm upgrade -i <RELEASE_NAME> datadog/datadog -f datadog-values.yaml

Para la configuración personalizada del OpenTelemetry Collector:

helm upgrade -i <RELEASE_NAME> datadog/datadog \
  -f datadog-values.yaml \
  --set-file datadog.otelCollector.config=otel-config.yaml

Este comando te permite especificar tu propio archivo otel-config.yaml.

Reemplaza <RELEASE_NAME> por el nombre de la release de Helm que estás utilizando.

Puedes ver advertencias durante el proceso de despliegue. Puedes ignorar estas advertencias.

Este Helm chart despliega el Datadog Agent como un DaemonSet con el OpenTelemetry Collector. El Collector se despliega en el mismo servidor que tu aplicación, siguiendo el Agent deployment pattern. El patrón de despliegue del Gateway está en vista previa; para instrucciones de instalación, sigue la guía de instalación del Gateway de DDOT en Kubernetes.

Diagrama de despliegue

Diagrama que representa el patrón de despliegue del Agent.

Envía tu telemetría a Datadog

Para enviar tus datos de telemetría a Datadog:

Instrumenta tu aplicación
Configura la aplicación
Correlaciona los datos de observabilidad
Ejecuta tu aplicación

Instrumenta la aplicación

Instrumenta tu aplicación usando la API de OpenTelemetry.

Ejemplo de aplicación instrumentada con la API de OpenTelemetry

Como ejemplo, puedes usar la aplicación de muestra de Calendario que ya está instrumentada para ti. El siguiente código instrumenta el método CalendarService.getDate() utilizando las anotaciones y la API de OpenTelemetry:

CalendarService.java

@WithSpan(kind = SpanKind.CLIENT)
public String getDate() {
    Span span = Span.current();
    span.setAttribute("peer.service", "random-date-service");
    ...
}

Configura la aplicación

Tu contenedor de aplicación debe enviar datos al DDOT Collector en el mismo servidor. Dado que el Collector se ejecuta como un DaemonSet, necesitas especificar el servidor local como el punto de conexión de OTLP.

Si la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT no está ya configurada, añádela al archivo de manifiesto de despliegue de tu aplicación:

deployment.yaml

env:
  ...
  - name: HOST_IP
    valueFrom:
     fieldRef:
        fieldPath: status.hostIP
  - name: OTLP_GRPC_PORT
    value: "4317"
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: 'http://$(HOST_IP):$(OTLP_GRPC_PORT)'
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: 'grpc'
   

Correlaciona los datos de observabilidad

unified service tagging une los datos de observabilidad en Datadog para que puedas navegar a través de métricas, trazas y registros con etiquetas consistentes.

En entornos contenedorizados, establece env, service y version usando las variables de entorno de Atributos de Recursos de OpenTelemetry. El DDOT Collector detecta esta configuración de etiquetado y la aplica a los datos que recopila de los contenedores.

Añade las siguientes variables de entorno al manifiesto de despliegue de tu aplicación:

deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <SERVICE>
spec:
  template:
    spec:
      containers:
      - name: <SERVICE>
        env:
          - name: OTEL_SERVICE_NAME
            value: "<SERVICE>"
          - name: OTEL_RESOURCE_ATTRIBUTES
            value: "service.version=<VERSION>,deployment.environment.name=<ENV>"

Alternativamente, puedes usar etiquetas específicas de Kubernetes de Datadog para configurar el etiquetado de servicio unificado. No uses ambos enfoques, ya que esto crea etiquetas duplicadas.

Ejecuta la aplicación

Vuelve a implementar tu aplicación para aplicar los cambios realizados en el manifiesto de implementación. Una vez que la configuración actualizada esté activa, la Etiquetación de Servicio Unificada estará completamente habilitada para tus métricas, trazas y registros.

Explora los datos de observabilidad en Datadog

Utiliza Datadog para explorar los datos de observabilidad de tu aplicación.

Fleet Automation

Explora la configuración de tu Datadog Agent y Collector.

Monitoreo de contenedores en vivo

Monitorea la salud de tu contenedor utilizando las capacidades de Container Monitoring en vivo.

Monitorea la salud de tu contenedor desde la página de Contenedores.

Salud de nodos de infraestructura

Visualiza métricas de tiempo de ejecución e infraestructura para observar, monitorear y medir el rendimiento de tus nodos.

Visualiza métricas de tiempo de ejecución e infraestructura desde la Host List.

Logs

Visualiza registros para monitorear y solucionar problemas de las operaciones de la aplicación y del sistema.

Visualiza registros desde el Log Explorer.

Trazas

Visualiza trazas y tramos para observar el estado y rendimiento de las solicitudes procesadas por tu aplicación, con métricas de infraestructura correlacionadas en la misma traza.