Instalar el DDOT Collector como DaemonSet de Kubernetes

Documentos > OpenTelemetry en Datadog > Enviar datos de OpenTelemetry a Datadog > Datadog Distribution of OpenTelemetry Collector > Install > Instalar el DDOT Collector como DaemonSet de Kubernetes

Información general

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

¿Necesitas componentes adicionales de OpenTelemetry? Si necesitas otros componentes adicionales que no están incluidos en el paquete por defecto, consulta la sección Uso de componentes personalizados de OpenTelemetry para ampliar las funciones del Datadog Agent. Para obtener una lista de los componentes incluidos por defecto, consulta Componentes del OpenTelemetry Collector.

Requisitos

Para completar esta guía, necesitas lo siguiente:

Cuenta de Datadog:

Crea una cuenta en Datadog , si no tienes una.
Busca o crea tu clave de API Datadog.

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

Un clúster Kubernetes (v1.29 o posterior)
- Nota: Los entornos EKS Fargate y GKE Autopilot no son compatibles.
Helm (v3 o posterior)
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

Instalar el Datadog Agent con el OpenTelemetry Collector

Esta instalación es necesaria para las siguientes configuraciones de Datadog: SDK + DDOT y SDK OpenTelemetry + DDOT. Aunque el SDK Datadog implementa la API OpenTelemetry, sigue necesitando que el DDOT Collector procese y reenvíe métricas y logs de OTLP.

Seleccionar el método de instalación

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

Datadog Operator: Un enfoque nativo en Kubernetes que automáticamente reconcilia y mantiene tu configuración de Datadog. Informa el estado del despliegue, el estado y los errores en su estado de recurso personalizado, y limita el riesgo de configuración errónea gracias a las opciones de configuración de nivel superior.
Helm chart: Una forma sencilla de desplegar el Datadog Agent. Proporciona capacidades de versionado, reversión y plantillas, haciendo que los despliegues sean consistentes y más fáciles de replicar.

Instalar el Datadog Operator

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

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

Añadir el repositorio de Datadog Helm

Para añadir el repositorio de Datadog a tus repositorios de Helm:

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

Configurar la clave de API Datadog

Obtener la clave de API Datadog.
Guarda la clave de API como secreto de Kubernetes:
```
kubectl create secret generic datadog-secret \
  --from-literal api-key=<DD_API_KEY>
```
Sustituye <DD_API_KEY> por tu clave de API real de Datadog.

Configurar el Datadog Agent

Después de desplegar el Datadog Operator, crea el recurso DatadogAgent que activa el despliegue del Datadog Agent, el Cluster Agent y los ejecutores de checks de clústeres (si se utilizan) en tu clúster Kubernetes. El Datadog Agent se despliega como un DaemonSet, ejecutando un pod en cada nodo de tu clúster.

Utiliza el archivo datadog-agent.yaml para especificar la configuración de tu despliegue de 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

Sustituye <CLUSTER_NAME> por un nombre para tu clúster.
Sustituye <DATADOG_SITE> por tu sitio Datadog. Tu sitio es . (Asegúrate de seleccionar el SITIO DATADOG correcto a la derecha).

Activa el OpenTelemetry Collector:

datadog-agent.yaml

  # Activar funciones
  features:
    otelCollector:
      enabled: true

El Datadog Operator vincula automáticamente el OpenTelemetry Collector con los puertos 4317 (llamado otel-grpc) y 4318 (llamado otel-http) por defecto.

(Opcional) Habilita las funciones adicionales de Datadog:

La activación de estas funciones puede conllevar cargos adicionales. Consulta la página de precios y habla con tu asesor de clientes antes de continuar.

datadog-agent.yaml

  # Activar funciones
  features:
  ...
    apm:
      enabled: true
    orchestratorExplorer:
      enabled: true
    processDiscovery:
      enabled: true
    liveProcessCollection:
      enabled: true
    usm:
      enabled: true
    clusterChecks:
      enabled: true

Cuando actives funciones adicionales de Datadog, utiliza siempre los archivos de configuración de Datadog o del OpenTelemetry Collector en lugar de depender de las variables de entorno de Datadog.

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

Cuando sustituyas la etiqueta (tag) de imagen del Agent de nodo, utiliza una etiqueta (tag) >= 7.67.0 para que se programe el contenedor de OTel (la imagen ddot-collector solo se admite en >= 7.67.0).
La imagen ddot-collector no tiene la variante -full. Si necesitas una imagen -full, configura spec.override.nodeAgent.image.name como imagen del Agent completa (por ejemplo, gcr.io/datadoghq/agent:7.72.1-full).

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

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 Datadog:

datadog-values.yaml

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

Configura <DATADOG_SITE> como tu sitio Datadog. De lo contrario, en forma predeterminada será datadoghq.com, el sitio US1.

Activa el OpenTelemetry Collector y configura los puertos esenciales:

datadog-values.yaml

datadog:
  ...
  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317" # puerto por defecto para el receptor gRPC de OpenTelemetry.
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318" # puerto por defecto para el receptor HTTP de OpenTelemetry
        hostPort: "4318"
        name: otel-http

Configura el hostPort para exponer el puerto del contenedor a la red externa. Esto permite configurar el exportador OTLP para que apunte a la dirección IP del nodo donde está asignado el Datadog Agent.

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

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

En el archivo de despliegue de tu aplicación (deployment.yaml), configura el exportador OTLP para utilizar el servicio del 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 las funciones adicionales de Datadog:

La activación de estas funciones puede conllevar cargos adicionales. Consulta la página de precios y habla con tu asesor de clientes antes de continuar.

datadog-values.yaml

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

Cuando actives funciones adicionales de Datadog, utiliza siempre los archivos de configuración de Datadog o del OpenTelemetry Collector en lugar de depender de las variables de entorno de Datadog.

(Opcional) Recopila etiquetas (labels) de pods y utilízalas como etiquetas (tags) para adjuntarlas a métricas, trazas (traces) y logs:

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

datadog-values.yaml

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

Archivo datadog-values.yaml completo

Tu archivo datadog-values.yaml debería tener el siguiente aspecto:

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
   

Configurar el OpenTelemetry Collector

El Datadog Operator proporciona un ejemplo de configuración del OpenTelemetry Collector que puedes utilizar como punto de partida. Si necesitas modificar esta configuración, el Datadog Operator tiene dos formas de proporcionar una configuración personalizada del Collector:

Configuración en línea: Añade tu configuración personalizada del Collector directamente en el campo features.otelCollector.conf.configData.
Configuración basada en ConfigMap: Almacena tu configuración del Collector en un ConfigMap y haz referencia a ella en el campo features.otelCollector.conf.configMap. Esta estrategia te permite mantener tu configuración del Collector desacoplada del recurso DatadogAgent.

Configuración en línea del Collector

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

datadog-agent.yaml

  ...
  # Activar funciones
  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.

Al aplicar el archivo datadog-agent.yaml que contiene este recurso DatadogAgent, el Operator monta automáticamente la configuración del Collector en el DaemonSet del Agent.

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

El archivo datadog-agent.yaml completo con configuración del Collector en línea debería tener el siguiente aspecto:

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

  # Activar funciones
  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 tu configuración del Collector:

configmap.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-agent-config-map
  namespace: system
data:
  # debe llamarse 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 de configuración del Collector en el ConfigMap debe llamarse otel-config.yam.

Haz referencia al ConfigMap otel-agent-config-map en tu recurso DatadogAgent utilizando el parámetro features.otelCollector.conf.configMap:

datadog-agent.yaml

  ...
  # Activar funciones
  funciones:
    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 Operator se monta automáticamente otel-config.yaml desde el ConfigMap en el DaemonSet del OpenTelemetry Collector del Agent.

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

El archivo datadog-agent.yaml con configuración del Collector definido como ConfigMap debería tener el siguiente aspecto:

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

  # Activar funciones
  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:
  # debe llamarse 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 gráfico de Helm de Datadog proporciona un ejemplo de configuración del OpenTelemetry Collector que puedes utilizar como punto de partida. Esta sección te guiará a través de los pipelines predefinidos y los componentes de OpenTelemetry incluidos.

Esta es la configuración completa del OpenTelemetry Collector 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, se definen los siguientes componentes en la configuración:

Diagrama que describe el patrón de despliegue del Agent

Conector de Datadog

El Conector de Datadog calcula métricas de rastreo de Datadog APM.

otel-config.yaml

connectors:
  datadog/connector:
    traces:

Exportador de Datadog

El Exportador de Datadog exporta trazas, métricas y logs 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 no se especifica key o se define para un secreto, o si no se especifica site, el sistema utiliza los valores de la configuración del Agent principal. Por defecto, el Agent principal establece su sitio en datadoghq.com (US1).

Receptor Prometheus

El Receptor Prometheus recopila métricas del estado del OpenTelemetry Collector para el pipeline 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 obtener más información, consulta la documentación de las métricas de estado del Collector.

Despliegue del Agent 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 host que tu aplicación, siguiendo el patrón de despliegue del Agent. El patrón de despliegue de la puerta de enlace está en vista previa. Para consultar las instrucciones de instalación, consulta la guía de instalación de la puerta de enlace DDOT Kubernetes.

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

Para una configuración por defecto del OpenTelemetry Collector:

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

Para una 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.

Sustituye <RELEASE_NAME> por el nombre de la versión de Helm que estés utilizando.

Es posible que aparezcan advertencias durante el proceso de despliegue. Estas advertencias pueden ignorarse.

Este Helm chart despliega el Datadog Agent con el OpenTelemetry Collector como un DaemonSet. El Collector se despliega en el mismo host que tu aplicación, siguiendo el patrón de despliegue del Agent. El patrón de despliegue de la puerta de enlace está en vista Previa. Para consultar las instrucciones de instalación, consulta la guía de instalación de la puerta de enlace DDOT Kubernetes.

Diagrama de despliegue

Diagrama que representa el modelo de despliegue del Agent

Envía tu telemetría a Datadog

Para enviar tus datos de telemetría a Datadog:

Instrumenta tu solicitud
Configurar la aplicación
Correlacionar datos de observabilidad
Ejecutar tu aplicación

Instrumentar la aplicación

Instrumenta tu aplicación utilizando la API OpenTelemetry.

Ejemplo de aplicación instrumentada con la API OpenTelemetry

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

CalendarService.java

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

Configurar la aplicación

Tu contenedor de aplicaciones debe enviar datos al DDOT Collector en el mismo host. Dado que el Collector se ejecuta como DaemonSet, debes especificar el host local como endpoint de OTLP.

Si aún no se ha definido la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT, 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'
   

Correlacionar los datos de observabilidad

El etiquetado unificado de servicios une los datos de observabilidad en Datadog para que puedas recorrer métricas, trazas y logs con etiquetas (tags) coherentes.

En entornos en contenedores, configura env, service y version utilizando 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>"

También puedes utilizar etiquetas (labels) de Kubernetes específicas de Datadog para configurar el etiquetado unificado de servicios. No utilices ambas estrategias, ya que esto crea etiquetas (tags) duplicadas.

Ejecutar la aplicación

Vuelve a desplegar tu aplicación para aplicar los cambios realizados en el manifiesto de despliegue. Una vez que la configuración actualizada esté activa, el etiquetado unificado de servicios estará totalmente activado para tus métricas, trazas y logs.

Explorar datos de observabilidad en Datadog

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

Automatización de flotas

Explora tu configuración del Datadog Agent y del Collector.

Consulta tu configuración del Datadog Agent y del Collector desde la página de Fleet Automation.

Monitorización de contenedores en directo

Monitoriza el estado de tu contenedor utilizando las funciones de monitorización de contenedores en directo.

Monitoriza el estado de tu contenedor desde la página Contenedores.

Estado del nodo de la infraestructura

Consulta métricas de tiempo de ejecución y de infraestructura para visualizar, monitorizar y medir el rendimiento de tus nodos.

Consulta métricas de tiempo ejecución y de infraestructura desde la lista de hosts.

Logs

Consulta los logs para monitorizar y solucionar problemas de funcionamiento de la aplicación y el sistema.

Trazas

Consulta trazas (traces) y tramos (spans) para visualizar el estado y el rendimiento de las solicitudes procesadas por tu aplicación, con métricas de infraestructura correlacionadas en la misma traza.