Instalar el Datadog Agent con el OpenTelemetry Collector integrado

Documentos > OpenTelemetry en Datadog > Datadog Agent con collector integrado > Instalar el Datadog Agent con el OpenTelemetry Collector integrado

This translation isn't up-to-date. For the latest English version, click here

Join the Preview!

El Datadog Agent con el OpenTelemetry Collector integrado está en fase previa. Para solicitar acceso, rellena este formulario.

Request Access

Información general

Sigue esta guía para instalar el Datadog Agent con el OpenTelemetry Collector utilizando Helm.

Si necesitas componentes de OpenTelemetry más allá de los que se proporcionan en el paquete predeterminado, consulta Uso de componentes de OpenTelemetry personalizados para traer tus propios componentes de Otel y ampliar las capacidades del Datadog Agent. Para ver la lista de los componentes incluidos por defecto, consulta Componentes incluidos.

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.
Busca o crea tu clave de aplicación Datadog.

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

Un clúster Kubernetes (v1.29 o posterior)
- Nota: Los entornos EKS Fargate no son compatibles
Helm (v3 o posterior)
Docker
kubectl

Instalar el Datadog Agent con el OpenTelemetry Collector

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 API de Datadog y las claves de aplicación

Obtén claves de API y claves de aplicación Datadog.
Almacena las claves como un secreto en Kubernetes:
```
kubectl create secret generic datadog-secret \
  --from-literal api-key=<DD_API_KEY> \
  --from-literal app-key=<DD_APP_KEY>
```
Sustituye <DD_API_KEY> y <DD_APP_KEY> por tus claves de aplicación y la API de Datadog reales.

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
         appSecret:
           secretName: datadog-secret
           keyName: app-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).

Cambia la imagen del Datadog Agent para utilizar compilaciones con el OpenTelemetry Collector integrado:

datadog-agent.yaml

  ...
  override:
    # Node Agent configuration
    nodeAgent:
      image:
        name: "gcr.io/datadoghq/agent:7.62.2-ot-beta"
        pullPolicy: Always

Esta guía utiliza un ejemplo de aplicación Java. El sufijo -jmx en la etiqueta (tag) de la imagen habilita las utilidades JMX. Para aplicaciones que no sean Java, utiliza 7.62.2-ot-beta en su lugar.
Para obtener más información, consulta la guía de la integración Autodiscovery y JMX.

Por defecto, la imagen del Agent se extrae de Google Artifact Registry (gcr.io/datadoghq). Si Artifact Registry no es accesible en la región de tu despliegue, utiliza otro registro.

Activa el OpenTelemetry Collector:

datadog-agent.yaml

  ...
  # Enable Features
  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.

Para anular explícitamente los puertos por defecto, utiliza el parámetro features.otelCollector.ports:

datadog-agent.yaml

  ...
  # Enable Features
  features:
    otelCollector:
      enabled: true
      ports:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http

Cuando configures los puertos 4317 y 4318, debes utilizar los nombres por defecto otel-grpc y otel-http respectivamente para evitar conflictos de puertos.

(Opcional) Habilita las funciones adicionales de Datadog:

La activación de estas funciones puede conllevar gastos adicionales. Consulta la página de precios y habla con tu CSM 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

Completed datadog-agent.yaml file

Your datadog-agent.yaml file should look something like this:

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
      appSecret:
        secretName: datadog-secret
        keyName: app-key

  override:
    # Node Agent configuration
    nodeAgent:
      image:
        name: "gcr.io/datadoghq/agent:7.62.2-ot-beta"
        pullPolicy: Always

  # 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

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 por defecto del values.yaml.

Configura la API de Datadog y los secretos de las claves de aplicación:

datadog-values.yaml

datadog:
  site: <DATADOG_SITE>
  apiKeyExistingSecret: datadog-secret
  appKeyExistingSecret: datadog-secret
  logLevel: info

Configura <DATADOG_SITE> como tu sitio Datadog. De lo contrario, por defecto será datadoghq.com, el sitio US1.

El valor del parámetro de nivel de log datadog.logLevel debe configurarse en minúsculas. Los niveles de logs válidos son: rastreo, depuración, información, advertencia, error, crítico, desactivado.

Cambia la etiqueta (tag) de la imagen del Datadog Agent para utilizar compilaciones con el OpenTelemetry Collector integrado:

datadog-values.yaml

agents:
  image:
    repository: gcr.io/datadoghq/agent
    tag: 7.62.2-ot-beta-jmx
    doNotCheckTag: true
...

Por defecto, la imagen del Agent se extrae de Google Artifact Registry (gcr.io/datadoghq). Si Artifact Registry no es accesible en la región de tu despliegue, [utiliza otro registro][4].

Habilita el recopilador 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

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 gastos adicionales. Consulta la página de precios y habla con tu CSM antes de continuar.

datadog-values.yaml

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

(Opcional) Reúne las etiquetas (labels) de los pods y utilízalas como etiquetas (tags) para fijarlas 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

Completed datadog-values.yaml file

Your datadog-values.yaml file should look something like this:

datadog-values.yaml

agents:
  image:
    repository: gcr.io/datadoghq/agent
    tag: 7.62.2-ot-beta-jmx
    doNotCheckTag: true

datadog:
  site: datadoghq.com
  apiKeyExistingSecret: datadog-secret
  appKeyExistingSecret: datadog-secret
  logLevel: info

  otelCollector:
    enabled: true
    ports:
      - containerPort: "4317"
        hostPort: "4317"
        name: otel-grpc
      - containerPort: "4318"
        hostPort: "4318"
        name: otel-http
  apm:
    portEnabled: true
    peer_tags_aggregation: true
    compute_stats_by_span_kind: 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. Este enfoque 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

  ...
  # 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}
          processors:
            infraattributes:
              cardinality: 2
            batch:
              timeout: 10s
          connectors:
            datadog/connector:
              traces:
                compute_top_level_by_span_kind: true
                peer_tags_aggregation: true
                compute_stats_by_span_kind: true
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes, batch]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes, batch]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes, batch]
                exporters: [debug, datadog]          

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.

Completed datadog-agent.yaml file

Completed datadog-agent.yaml with inline Collector configuration should look something like this:

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
      appSecret:
        secretName: datadog-secret
        keyName: app-key

  override:
    # Node Agent configuration
    nodeAgent:
      image:
        name: "gcr.io/datadoghq/agent:7.62.2-ot-beta"
        pullPolicy: Always

  # 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}
          processors:
            infraattributes:
              cardinality: 2
            batch:
              timeout: 10s
          connectors:
            datadog/connector:
              traces:
                compute_top_level_by_span_kind: true
                peer_tags_aggregation: true
                compute_stats_by_span_kind: true
          service:
            pipelines:
              traces:
                receivers: [otlp]
                processors: [infraattributes, batch]
                exporters: [debug, datadog, datadog/connector]
              metrics:
                receivers: [otlp, datadog/connector, prometheus]
                processors: [infraattributes, batch]
                exporters: [debug, datadog]
              logs:
                receivers: [otlp]
                processors: [infraattributes, batch]
                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:
  # 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}
    processors:
      infraattributes:
        cardinality: 2
      batch:
        timeout: 10s
    connectors:
      datadog/connector:
        traces:
          compute_top_level_by_span_kind: true
          peer_tags_aggregation: true
          compute_stats_by_span_kind: true
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes, batch]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes, batch]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes, batch]
          exporters: [debug, datadog]    

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

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
  características:
    otelCollector:
      activado: true
      puertos:
        - containerPort: 4317
          hostPort: 4317
          name: otel-grpc
        - containerPort: 4318
          hostPort: 4318
          name: otel-http
      conf:
        configMap:
          name: otel-agent-config-map

El Operator monta automáticamente otel-config.yaml desde el ConfigMap en el DaemonSet del OpenTelemetry Collector del Agent.

Completed datadog-agent.yaml file

Completed datadog-agent.yaml with Collector configuration defined as ConfigMap should look something like this:

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
      appSecret:
        secretName: datadog-secret
        keyName: app-key

  override:
    # Node Agent configuration
    nodeAgent:
      image:
        name: "gcr.io/datadoghq/agent:7.62.2-ot-beta"
        pullPolicy: Always

  # 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}
    processors:
      infraattributes:
        cardinality: 2
      batch:
        timeout: 10s
    connectors:
      datadog/connector:
        traces:
          compute_top_level_by_span_kind: true
          peer_tags_aggregation: true
          compute_stats_by_span_kind: true
    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [infraattributes, batch]
          exporters: [debug, datadog, datadog/connector]
        metrics:
          receivers: [otlp, datadog/connector, prometheus]
          processors: [infraattributes, batch]
          exporters: [debug, datadog]
        logs:
          receivers: [otlp]
          processors: [infraattributes, batch]
          exporters: [debug, datadog]    

El Helm chart 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}
processors:
  infraattributes:
    cardinality: 2
  batch:
    timeout: 10s
connectors:
  datadog/connector:
    traces:
      compute_top_level_by_span_kind: true
      peer_tags_aggregation: true
      compute_stats_by_span_kind: true
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [infraattributes, batch]
      exporters: [datadog, datadog/connector]
    metrics:
      receivers: [otlp, datadog/connector, prometheus]
      processors: [infraattributes, batch]
      exporters: [datadog]
    logs:
      receivers: [otlp]
      processors: [infraattributes, batch]
      exporters: [datadog]

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:
      compute_top_level_by_span_kind: true
      peer_tags_aggregation: true
      compute_stats_by_span_kind: true

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}

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

Esta acción despliega el Datadog Agent como un DaemonSet con el OpenTelemetry Collector integrado. 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 Gateway no es compatible.

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 de tu aplicación, siguiendo el patrón de despliegue del Agent. El patrón de despliegue Gateway no es compatible.

Deployment diagram

Envío de tu telemetría a Datadog

Para enviar tus datos de telemetría a Datadog:

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

Instrumentar la aplicación

Instrumenta tu aplicación utilizando la API OpenTelemetry.

Como ejemplo, puedes utilizar la aplicación Calendario de ejemplo que ya está instrumentada para ti.

Clona el repositorio opentelemetry-examples en tu dispositivo:

git clone https://github.com/DataDog/opentelemetry-examples.git

Ve al directorio /calendar:

cd opentelemetry-examples/apps/rest-services/java/calendar

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");
    ...
}

Configurar la aplicación

Para configurar tu contenedor de aplicación, asegúrate de que se utiliza el nombre de host del endpoint OTLP correcto. El Datadog Agent con el OpenTelemetry Collector se despliega como DaemonSet, por lo que es necesario apuntar al host actual.

El contenedor de la aplicación Calendario ya está configurado con la variable de entorno correcta OTEL_EXPORTER_OTLP_ENDPOINT como se define en el Helm chart:

Ve al archivo de manifiesto del despliegue de la aplicación Calendario:
```
./deploys/calendar/templates/deployment.yaml
```

Las siguientes variables de entorno configuran el endpoint OTLP:

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

En este ejemplo, la aplicación Calendario ya está configurada con el etiquetado unificado de servicios como se define en el Helm chart:

Ve al archivo de manifiesto del despliegue de la aplicación Calendario:
```
./deploys/calendar/templates/deployment.yaml
```

Las siguientes variables de entorno configuran el endpoint OTLP:

deployment.yaml

env:
  ...
  - name: OTEL_SERVICE_NAME
    value: {{ include "calendar.fullname" . }}
  - name: OTEL_K8S_NAMESPACE
    valueFrom:
      fieldRef:
        apiVersion: v1
        fieldPath: metadata.namespace
  - name: OTEL_K8S_NODE_NAME
    valueFrom:
      fieldRef:
        apiVersion: v1
        fieldPath: spec.nodeName
  - name: OTEL_K8S_POD_NAME
    valueFrom:
      fieldRef:
        apiVersion: v1
        fieldPath: metadata.name
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: 'grpc'
  - name: OTEL_RESOURCE_ATTRIBUTES
    value: >-
      service.name=$(OTEL_SERVICE_NAME),
      k8s.namespace.name=$(OTEL_K8S_NAMESPACE),
      k8s.node.name=$(OTEL_K8S_NODE_NAME),
      k8s.pod.name=$(OTEL_K8S_POD_NAME),
      k8s.container.name={{ .Chart.Name }},
      host.name=$(OTEL_K8S_NODE_NAME),
      deployment.environment=$(OTEL_K8S_NAMESPACE)      
   

Ejecutar la aplicación

Para empezar a generar y enviar datos de observabilidad a Datadog, necesitas desplegar la aplicación Calendario con el SDK de OpenTelemetry utilizando Helm.

Ejecuta el siguiente comando helm desde la carpeta calendar/:

helm upgrade -i <CALENDAR_RELEASE_NAME> ./deploys/calendar/

Este Helm chart despliega la aplicación Calendario de ejemplo como un ReplicaSet.
Para probar que la aplicación Calendario funciona correctamente, ejecuta el siguiente comando desde otra ventana de terminal:
```
curl localhost:9090/calendar
```
Comprueba que recibes una respuesta tal como:
```
{"date":"2024-12-30"}
```

Cada llamada a la aplicación Calendario tiene como resultado el reenvío de métricas, trazas y logs al backend Datadog.

Explorar datos de observabilidad en Datadog

Utiliza Datadog para explorar los datos de observabilidad de la aplicación Calendario de ejemplo.

Automatización de flotas

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

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 y tramos 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.

Métricas de tiempos de ejecución

Monitoriza las métricas de tiempo de ejecución (JVM) de tus aplicaciones.

Consulta métricas de JVM desde el dashboard de métricas de JVM

Métricas de estado del Collector

Consulta métricas del Collector incorporado para monitorizar el estado del Collector.

Componentes incluidos

De forma predeterminada, el Datadog Agent con collector integrado se entrega con los siguientes componentes del collector. También puedes ver la lista en formato YAML.

Receptores

Procesadores

Exportadores

Conectores

Extensiones

Referencias adicionales

Más enlaces, artículos y documentación útiles:

Uso de componentes personalizados de OpenTelemetry con el Datadog AgentDOCUMENTATION