Instalar el recopilador de DDOT como puerta de enlace en Kubernetes

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

Esta guía asume que tienes conocimientos del despliegue del recopilador de DDOT como DaemonSet. Para obtener más información, consulta Instalar el recopilador de DDOT como DaemonSet en Kubernetes.

Información general

El recopilador de OpenTelemetry puede desplegarse de varias formas. El patrón daemonset es un despliegue frecuente en el que una instancia del recopilador se ejecuta en cada nodo Kubernetes junto con el Datadog Agent principal.

Diagrama de arquitectura de un patrón daemonset del recopilador de OpenTelemetry. Un clúster Kubernetes contiene tres nodos. En cada nodo, una aplicación instrumentada con OpenTelemetry envía datos de OTLP a un DaemonSet del Agent local. El DaemonSet del Agent envía a continuación estos datos directamente al backend Datadog.

El patrón de puerta de enlace proporciona una opción de despliegue adicional que utiliza un servicio de recopilador centralizado e independiente. Esta capa de puerta de enlace puede realizar acciones como el muestreo basado en el seguimiento, la agregación, el filtrado y el enrutamiento, antes de exportar los datos a uno o más backends como Datadog. Actúa como punto central para la gestión y la aplicación de políticas de observabilidad.

Diagrama de arquitectura de un patrón de puerta de enlace del recopilador de OpenTelemetry. Las aplicaciones envían datos de OTLP a DaemonSets del Agent local que se ejecutan en cada nodo. Los DaemonSets reenvían estos datos a un balanceador de carga central, que los distribuye a un despliegue de pods del recopilador de puerta de enlace. Estos pods de puerta de enlace a continuación procesan y envían los datos de telemetría a Datadog.

Al activar la puerta de enlace:

Un despliegue Kubernetes (<RELEASE_NAME>-datadog-otel-agent-gateway-deployment) gestiona pods del recopilador de puerta de enlace independiente.
Un servicio Kubernetes (<RELEASE_NAME>-datadog-otel-agent-gateway) expone los pods de puerta de enlace y proporciona un balanceo de carga.
Los pods del recopilador de DaemonSet existentes están configurados por defecto para enviar tus datos de telemetría al servicio de puerta de enlace en lugar de directamente a Datadog.

Requisitos

Antes de empezar, asegúrate de tener lo siguiente:

Cuenta de Datadog:
- Una cuenta de Datadog.
- Tu clave de API de Datadog.
Software:
- Un clúster Kubernetes (v1.29 o posterior). EKS Fargate y GKE Autopilot no son compatibles.
- Helm (v3 o posterior).
- Datadog Helm chart versión 3.160.1 o posterior o Datadog Operator versión 1.23.0 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

Instalación y configuración

Esta guía muestra cómo configurar la puerta de enlace del recopilador de DDOT utilizando el Datadog Operator o Helm chart.

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 recopilador de DDOT procese y reenvíe métricas y logs de OTLP.

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

Datadog Operator: Estrategia nativa de Kubernetes que concilia y conserva automáticamente tu configuración de Datadog. Informa del estado del despliegue, de la salud y de los errores en su estado de recurso personalizado, y limita el riesgo de configuraciones incorrectas gracias a opciones de configuración de alto nivel.
Helm chart: Forma sencilla de desplegar el Datadog Agent. Proporciona capacidades de versionado, rollback y plantillas, lo que hace que los despliegues sean consistentes y más fáciles de replicar.

Instalar el Datadog Operator o Helm

Si aún no has instalado el Datadog Operator, puedes instalarlo 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

Para obtener más información, consulta la documentación del Datadog Operator.

Si aún no has añadido el repositorio Helm de Datadog, añádelo ahora:

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

Para obtener más información sobre las opciones de configuración de Helm, consulta el README Helm chart de Datadog.

Despliegue de la puerta de enlace con un DaemonSet

Para empezar, activa tanto la puerta de enlace como el recopilador de DaemonSet en tu recurso DatadogAgent. Esta es la configuración más frecuente.

Crea un archivo llamado datadog-agent.yaml:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    # Activar el recopilador en el DaemonSet del Agent
    otelCollector:
      enabled: true

    # Activar el despliegue de la puerta de enlace independiente
    otelAgentGateway:
      enabled: true

  override:
    otelAgentGateway:
      # Número de réplicas
      replicas: 3
      # Controlar el posicionamiento de pods de puerta de enlace
      nodeSelector:
        gateway: "true"

Aplica la configuración:

kubectl apply -f datadog-agent.yaml

Para empezar, activa tanto la puerta de enlace como el recopilador de DaemonSet en tu recurso values.yaml. Esta es la configuración más frecuente.

# values.yaml
targetSystem: "linux"
datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  # Activar el recopilador en el DaemonSet del Agent
  otelCollector:
    enabled: true

# Activar el despliegue de la puerta de enlace independiente
otelAgentGateway:
  enabled: true
  replicas: 3
  nodeSelector:
    # Ejemplo de selector de posicionamiento de pods de puerta de enlace en nodos específicos
    gateway: "true"

En este caso, el recopilador de DaemonSet utiliza una configuración por defecto que envía datos de OTLP al servicio Kubernetes de la puerta de enlace:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318
exporters:
  debug:
    verbosity: detailed
  otlphttp:
    endpoint: http://<release>-datadog-otel-agent-gateway:4318
    tls:
      insecure: true
    sending_queue:
      batch:
        flush_timeout: 10s
processors:
  infraattributes:
    cardinality: 2
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]
      exporters: [otlphttp, datadog/connector]
    metrics:
      receivers: [otlp, datadog/connector]
      processors: [infraattributes]
      exporters: [otlphttp]
    logs:
      receivers: [otlp]
      processors: [infraattributes]
      exporters: [otlphttp]

El recopilador de puerta de enlace utiliza una configuración por defecto que escucha en los puertos de servicio y envía datos a Datadog:

receivers:
  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}
    sending_queue:
      batch:
        flush_timeout: 10s
processors:
extension:
  datadog:
    api:
      key: ${env:DD_API_KEY}
    deployment_type: gateway
service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [datadog]
    metrics:
      receivers: [otlp]
      exporters: [datadog]
    logs:
      receivers: [otlp]
      exporters: [datadog]

Para usuarios de Helm: Configura otelAgentGateway.affinity o otelAgentGateway.nodeSelector para controlar el posicionamiento de los pods y ajusta otelAgentGateway.replicas para escalar la puerta de enlace.
Para usuarios del Operator: Utiliza override.otelAgentGateway.affinity, override.otelAgentGateway.nodeSelector y override.otelAgentGateway.replicas para esos parámetros.

Despliegue de una puerta de enlace independiente

Si ya dispones de un despliegue de DaemonSet, puedes desplegar la puerta de enlace de forma independiente desactivando otros componentes:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog-gateway
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true

  override:
    otelAgentGateway:
      # Número de réplicas
      replicas: 3
      # Controlar el posicionamiento de pods de puerta de enlace
      nodeSelector:
        gateway: "true"

    # Desactivar el DaemonSet del Agent
    nodeAgent:
      disabled: true
    # Desactivar el Cluster Agent
    clusterAgent:
      disabled: true

Después de desplegar la puerta de enlace, debes actualizar la configuración de los recopiladores de DaemonSet existentes para enviar datos al nuevo endpoint del servicio de puerta de enlace (por ejemplo, http://datadog-gateway-otel-agent-gateway:4318).

Si ya dispones de un despliegue de DaemonSet, puedes desplegar la puerta de enlace de forma independiente.

# values.yaml
targetSystem: "linux"
fullnameOverride: "gw-only"
agents:
  enabled: false
clusterAgent:
  enabled: false
datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
otelAgentGateway:
  enabled: true
  replicas: 3
  nodeSelector:
    gateway: "true"

Después de desplegar la puerta de enlace, debes actualizar la configuración de tus recopiladores DaemonSet existentes para enviar datos al nuevo endpoint del servicio de puerta de enlace (por ejemplo, http://gw-only-otel-agent-gateway:4318).

Personalización de las configuraciones del recopilador

Puedes personalizar la configuración del recopilador de puerta de enlace utilizando ConfigMaps. Crea un ConfigMap con tu configuración personalizada:

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-gateway-config
data:
  otel-gateway-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
          http:
            endpoint: "0.0.0.0:4318"
    exporters:
      datadog:
        api:
          key: ${env:DD_API_KEY}
      sending_queue:
        batch:
          flush_timeout: 10s
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [datadog]
        metrics:
          receivers: [otlp]
          exporters: [datadog]
        logs:
          receivers: [otlp]
          exporters: [datadog]

A continuación, menciónalo en tu recurso DatadogAgent:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true
      # Mencionar el ConfigMap personalizado
      config:
        configMap:
          name: otel-gateway-config

  override:
    otelAgentGateway:
      replicas: 3

Para ConfigMaps de varios elementos o configuración en línea, consulta los ejemplos de Datadog Agent.

Puedes anular las configuraciones por defecto de los recopiladores DaemonSet y puerta de enlace utilizando los valores datadog.otelCollector.config y otelAgentGateway.config, respectivamente.

# values.yaml
targetSystem: "linux"
fullnameOverride: "my-gw"
datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  # Activar y configurar el recopilador de DaemonSet
  otelCollector:
    enabled: true
    config: |
      receivers:
        otlp:
          protocols:
            grpc:
              endpoint: "localhost:4317"
      exporters:
        otlp:
          endpoint: http://my-gw-otel-agent-gateway:4317
          tls:
            insecure: true
      service:
        pipelines:
          traces:
            receivers: [otlp]
            exporters: [otlp]
          metrics:
            receivers: [otlp]
            exporters: [otlp]
          logs:
            receivers: [otlp]
            exporters: [otlp]

# Activar y configurar el recopilador de puerta de enlace
otelAgentGateway:
  enabled: true
  replicas: 3
  nodeSelector:
    gateway: "true"
  ports:
    - containerPort: 4317
      name: "otel-grpc"
  config: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    exporters:
      datadog:
        api:
          key: ${env:DD_API_KEY}
        sending_queue:
          batch:
            flush_timeout: 10s
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [datadog]
        metrics:
          receivers: [otlp]
          exporters: [datadog]
        logs:
          receivers: [otlp]
          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.

Si configuras fullnameOverride, el nombre de servicio Kubernetes de la puerta de enlace se convierte en -otel-agent-gateway. Los puertos definidos en otelAgentGateway.ports están expuestos en este servicio. Asegúrate de que estos puertos coinciden con la configuración del receptor OTLP en la configuración de la puerta de enlace y del exportador OTLP en el DaemonSet.

Las configuraciones de ejemplo utilizan TLS inseguro por simplicidad. Sigue las instrucciones de OTel configtls si quieres activar TLS.

Opciones avanzadas de configuración

El Datadog Operator proporciona opciones de configuración adicionales para la puerta de enlace del Agent de OTel en override.otelAgentGateway (NO features.otelAgentGateway, excepto featureGates):

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true

      # Puertas de funciones del recopilador de OTel (configuración específica de la función)
      featureGates: "telemetry.UseLocalHostAsDefaultMetricsAddress"

  override:
    otelAgentGateway:
      # Número de réplicas
      replicas: 3

      # Selector de nodo para el posicionamiento de pods
      nodeSelector:
        kubernetes.io/os: linux
        gateway: "true"

      # Configuración de afinidades
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - datadog-otel-agent-gateway
              topologyKey: kubernetes.io/hostname

      # Tolerancias de nodos contaminados
      tolerations:
      - key: "dedicated"
        operator: "Equal"
        value: "otel-gateway"
        effect: "NoSchedule"

      # Clase de prioridad para la programación
      priorityClassName: high-priority

      # Variables de entorno
      env:
      - name: OTEL_LOG_LEVEL
        value: "info"

      # Variables de entorno de ConfigMaps or secretos
      envFrom:
      - configMapRef:
          name: otel-gateway-config

      # Imagen personalizada (opcional)
      image:
        name: ddot-collector
        tag: "7.77.0"
        pullPolicy: IfNotPresent

      # Contexto de seguridad a nivel de pod
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
        fsGroup: 1000

      # Configurar recursos
      containers:
        otel-agent:
          resources:
            requests:
              cpu: 200m
              memory: 512Mi
            limits:
              cpu: 500m
              memory: 1Gi

      # Etiquetas (labels) y anotaciones adicionales
      labels:
        team: observability
      annotations:
        prometheus.io/scrape: "true"

Para ver una referencia completa de todas las opciones disponibles, consulta la documentación de configuración de Datadog Agent v2alpha1.

Para despliegues basados en Helm, muchas de estas opciones de configuración avanzadas pueden configurarse directamente en el archivo values.yaml en la sección otelAgentGateway. Para ver una referencia completa, consulta el README Helm chart de Datadog.

Casos de uso avanzados

Muestreo del seguimiento con el exportador de balanceos de carga

Un caso de uso primario de la puerta de enlace es el muestreo basado en el seguimiento. Para garantizar que todos los tramos (spans) de una traza (trace) determinada sean procesados por el mismo pod de puerta de enlace, utiliza el exportador de balanceos de carga en tus recopiladores de DaemonSet. Este exportador enruta de forma consistente los tramos en función de una clave, como traceID.

El recopilador de DaemonSet está configurado con el exportador de loadbalancing, que utiliza el resolver del servicio Kubernetes para detectar y enrutar datos a pods de puerta de enlace. El recopilador de puerta de enlace utiliza el procesador de tail_sampling para muestrear trazas en función de políticas definidas antes de exportarlas a Datadog.

Nota: Se requieren permisos de configuración del control de acceso basado en roles (RBAC) para el resolver de k8s en el exportador de balanceos de carga.

Crea un ConfigMap para la configuración del recopilador de DaemonSet con el exportador de balanceos de carga:

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-daemonset-config
data:
  otel-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "localhost:4317"
    exporters:
      loadbalancing:
        routing_key: "traceID"
        protocol:
          otlp:
            tls:
              insecure: true
        resolver:
          k8s:
            service: datadog-otel-agent-gateway
            ports:
              - 4317
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [loadbalancing]

Crea un ConfigMap para la configuración del recopilador de puerta de enlace con el muestreo del seguimiento:

apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-gateway-tailsampling-config
data:
  otel-gateway-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    processors:
      tail_sampling:
        decision_wait: 10s
        policies:
          # Añadir tus políticas de muestreo aquí
          - name: sample-errors
            type: status_code
            status_code:
              status_codes: [ERROR]
          - name: sample-slow-traces
            type: latency
            latency:
              threshold_ms: 1000
    connectors:
      datadog/connector:
    exporters:
      datadog:
        api:
          key: ${env:DD_API_KEY}
    service:
      pipelines:
        traces/sample:
          receivers: [otlp]
          processors: [tail_sampling]
          exporters: [datadog]
        traces:
          receivers: [otlp]
          exporters: [datadog/connector]
        metrics:
          receivers: [datadog/connector]
          exporters: [datadog]

Aplica la configuración del Datadog Agent:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelCollector:
      enabled: true
      # Mencionar la configuración personalizada del DaemonSet
      config:
        configMap:
          name: otel-daemonset-config
      # Permisos de RBAC para el resolver de k8s
      rbac:
        create: true

    otelAgentGateway:
      enabled: true
      # Mencionar la configuración personalizada de la puerta de enlace
      config:
        configMap:
          name: otel-gateway-tailsampling-config

  override:
    otelAgentGateway:
      replicas: 3

Crea un ClusterRole para que el DaemonSet acceda a los endpoints:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: otel-collector-k8s-resolver
rules:
- apiGroups: [""]
  resources: ["endpoints"] # para la v0.139.0 y anteriores
  verbs: ["get", "watch", "list"]
- apiGroups: ["discovery.k8s.io"]
  resources: ["endpointslices"] # para la v0.140.0 y posteriores
  verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: otel-collector-k8s-resolver
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: otel-collector-k8s-resolver
subjects:
- kind: ServiceAccount
  name: datadog-agent
  namespace: default

Para asegurarse de que las estadísticas de APM se calculan en el 100% de tus trazas antes del muestreo, el datadog/conector se ejecuta en un pipeline separado sin el procesador tail_sampling. El conector puede ejecutarse en el DaemonSet o en la capa de la puerta de enlace.

En la configuración de abajo:

El recopilador de DaemonSet (datadog.otelCollector) está configurado con el exportador deloadbalancing, que utiliza el resolver del servicio Kubernetes para detectar y enrutar datos a pods de puerta de enlace.
El recopilador de puerta de enlace (otelAgentGateway) utiliza el procesador de tail_sampling para muestrear trazas basadas en políticas definidas antes de exportarlas a Datadog.

# values.yaml
targetSystem: "linux"
fullnameOverride: "my-gw"
datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  otelCollector:
    enabled: true
    # Los permisos de RBAC son necesarios para el resolver de k8s en el exportador de balanceo de cargas
    rbac:
      create: true
      rules:
        - apiGroups: [""]
          resources: ["endpoints"] # para la v0.139.0 y anteriores
          verbs: ["get", "watch", "list"]
        - apiGroups: ["discovery.k8s.io"]
          resources: ["endpointslices"] # para la v0.140.0 y posteriores
          verbs: ["get", "watch", "list"]
    config: |
      receivers:
        otlp:
          protocols:
            grpc:
              endpoint: "localhost:4317"
      exporters:
        loadbalancing:
          routing_key: "traceID"
          protocol:
            otlp:
              tls:
                insecure: true
          resolver:
            k8s:
              service: my-gw-otel-agent-gateway
              ports:
                - 4317
      service:
        pipelines:
          traces:
            receivers: [otlp]
            exporters: [loadbalancing]

otelAgentGateway:
  enabled: true
  replicas: 3
  ports:
    - containerPort: 4317
      name: "otel-grpc"
  config: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    processors:
      tail_sampling:
        decision_wait: 10s
        policies: <Add your sampling policies here>
    connectors:
      datadog/connector:
    exporters:
      datadog:
        api:
          key: ${env:DD_API_KEY}
    service:
      pipelines:
        traces/sample:
          receivers: [otlp]
          processors: [tail_sampling]
          exporters: [datadog]
        traces:
          receivers: [otlp]
          exporters: [datadog/connector]
        metrics:
          receivers: [datadog/connector]
          exporters: [datadog]

Utilizar una imagen personalizada del recopilador

Para utilizar una imagen personalizada del recopilador para tu puerta de enlace, especifica el repositorio de imágenes y la etiqueta (tag). Si necesitas instrucciones sobre cómo crear imágenes personalizadas, consulta Uso de componentes personalizados de OpenTelemetry.

Nota: El Datadog Operator admite los siguientes formatos de nombre de imagen:

name - Nombre de imagen (por ejemplo, ddot-collector)
name:tag - Nombre de imagen con etiqueta (por ejemplo, ddot-collector:7.77.0)
registry/name:tag - Referencia completa de la imagen (por ejemplo, gcr.io/datadoghq/ddot-collector:7.77.0)

El formato del registro/nombre (sin etiqueta en el campo de nombre) no es compatible cuando se utiliza un campo de etiqueta diferente. Incluye la referencia completa de la imagen con etiqueta en el campo de nombre o utiliza el nombre de imagen con un campo de etiqueta diferente.

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true

  override:
    otelAgentGateway:
      image:
        name: <YOUR REPO>:<IMAGE TAG>

# values.yaml
targetSystem: "linux"
agents:
  enabled: false
clusterAgent:
  enabled: false
otelAgentGateway:
  enabled: true
  image:
    repository: <YOUR REPO>
    tag: <IMAGE TAG>
    doNotCheckTag: true
  ports:
    - containerPort: "4317"
      name: "otel-grpc"
  config: | <YOUR CONFIG>

Activar Autoscaling con Horizontal Pod Autoscaler (HPA)

La puerta de enlace del recopilador de DDOT admite el escalado automático con la función Kubernetes Horizontal Pod Autoscaler (HPA).

Nota: El Datadog Operator no gestiona directamente recursos HPA. Debes crear el recurso HPA por separado y configurarlo para que apunte al despliegue de la puerta de enlace del Agent de OpenTelemetry.

Crea un recurso HPA:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: datadog-otel-agent-gateway-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: datadog-otel-agent-gateway
  minReplicas: 2
  maxReplicas: 10
  metrics:
  # Intentar alcanzar un uso de CPU elevado para un mayor rendimiento
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 80
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 30
    scaleDown:
      stabilizationWindowSeconds: 60

Aplica la configuración del Datadog Agent con solicitudes/límites de recursos (necesario para HPA):

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true

  override:
    otelAgentGateway:
      replicas: 4  # Réplicas iniciales, HPA sustituirá en función de las métricas
      containers:
        otel-agent:
          resources:
            requests:
              cpu: 200m
              memory: 512Mi
            limits:
              cpu: 500m
              memory: 1Gi

Para activar HPA, configura otelAgentGateway.autoscaling:

# values.yaml
targetSystem: "linux"
agents:
  enabled: false
clusterAgent:
  enabled: false
otelAgentGateway:
  enabled: true
  ports:
    - containerPort: "4317"
      name: "otel-grpc"
  config: | <YOUR CONFIG>
  replicas: 4  # 4 réplicas para empezar y HPA puede sustituir en función de las métricas
  autoscaling:
    enabled: true
    minReplicas: 2
    maxReplicas: 10
    metrics:
      # Intentar alcanzar un uso de CPU elevado para un mayor rendimiento
      - type: Resource
        resource:
          name: cpu
          target:
            type: Utilization
            averageUtilization: 80
    behavior:
      scaleUp:
        stabilizationWindowSeconds: 30
      scaleDown:
        stabilizationWindowSeconds: 60

Puedes utilizar métricas de recursos (CPU o memoria), métricas personalizadas (pod u objeto Kubernetes) o métricas externas como entradas de escalado automático. Para las métricas de recursos, asegúrate de que el servidor de métricas Kubernetes se está ejecutando en tu clúster. Para métricas personalizadas o externas, considera configurar el proveedor de métricas del Datadog Cluster Agent.

Despliegue de una puerta de enlace de varias capas

Para escenarios avanzados, puedes desplegar varias capas de puerta de enlace para crear una cadena de procesamiento.

Despliega cada capa como un recurso DatadogAgent independiente, empezando por la última capa y trabajando hacia atrás.

Despliegue de la capa 1 (capa final): Esta capa recibe de la capa 2 y exporta a Datadog.

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog-gw-layer-1
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true
      config:
        configMap:
          name: gw-layer-1-config

  override:
    otelAgentGateway:
      replicas: 3
      nodeSelector:
        gateway: "gw-node-1"

    nodeAgent:
      disabled: true
    clusterAgent:
      disabled: true
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: gw-layer-1-config
data:
  otel-gateway-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    exporters:
      datadog:
        api:
          key: ${env:DD_API_KEY}
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [datadog]
        metrics:
          receivers: [otlp]
          exporters: [datadog]
        logs:
          receivers: [otlp]
          exporters: [datadog]

Despliegue de la capa 2 (capa intermedia): Esta capa recibe del DaemonSet y exporta a la capa 1.

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog-gw-layer-2
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelAgentGateway:
      enabled: true
      config:
        configMap:
          name: gw-layer-2-config

  override:
    otelAgentGateway:
      replicas: 3
      nodeSelector:
        gateway: "gw-node-2"

    nodeAgent:
      disabled: true
    clusterAgent:
      disabled: true
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: gw-layer-2-config
data:
  otel-gateway-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    exporters:
      otlp:
        endpoint: http://datadog-gw-layer-1-otel-agent-gateway:4317
        tls:
          insecure: true
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [otlp]
        metrics:
          receivers: [otlp]
          exporters: [otlp]
        logs:
          receivers: [otlp]
          exporters: [otlp]

Despliegue del DaemonSet: Configura el DaemonSet para exportar a la capa 2.

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiSecret:
        secretName: datadog-secret
        keyName: api-key

  features:
    otelCollector:
      enabled: true
      config:
        configMap:
          name: daemonset-layer2-config
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: daemonset-layer2-config
data:
  otel-config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "localhost:4317"
    exporters:
      otlp:
        endpoint: http://datadog-gw-layer-2-otel-agent-gateway:4317
        tls:
          insecure: true
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [otlp]
        metrics:
          receivers: [otlp]
          exporters: [otlp]
        logs:
          receivers: [otlp]
          exporters: [otlp]

Despliega cada capa como una versión separada de Helm, empezando por la última capa y trabajando hacia atrás.

Despliegue de la capa 1 (capa final): Esta capa recibe de la capa 2 y exporta a Datadog.

# layer-1-values.yaml
targetSystem: "linux"
fullnameOverride: "gw-layer-1"
agents:
  enabled: false
clusterAgent:
  enabled: false
otelAgentGateway:
  enabled: true
  replicas: 3
  nodeSelector:
    gateway: "gw-node-1"
  ports:
    - containerPort: "4317"
      hostPort: "4317"
      name: "otel-grpc"
  config: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    exporters:
      datadog:
        api:
          key: <API Key>
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [datadog]
        metrics:
          receivers: [otlp]
          exporters: [datadog]
        logs:
          receivers: [otlp]
          exporters: [datadog]

Despliegue de la capa 2 (capa intermedia): Esta capa recibe del DaemonSet y exporta a la capa 1.

# layer-2-values.yaml
targetSystem: "linux"
fullnameOverride: "gw-layer-2"
agents:
  enabled: false
clusterAgent:
  enabled: false
otelAgentGateway:
  enabled: true
  replicas: 3
  nodeSelector:
    gateway: "gw-node-2"
  ports:
    - containerPort: "4317"
      hostPort: "4317"
      name: "otel-grpc"
  config: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
    exporters:
      otlp:
        endpoint: http://gw-layer-1-otel-agent-gateway:4317
        tls:
          insecure: true
    service:
      pipelines:
        traces:
          receivers: [otlp]
          exporters: [otlp]
        metrics:
          receivers: [otlp]
          exporters: [otlp]
        logs:
          receivers: [otlp]
          exporters: [otlp]

Despliegue del DaemonSet: Configura el DaemonSet para exportar a la capa 2.

# daemonset-values.yaml
targetSystem: "linux"
datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  otelCollector:
    enabled: true
    config: |
      receivers:
        otlp:
          protocols:
            grpc:
              endpoint: "localhost:4317"
      exporters:
        otlp:
          endpoint: http://gw-layer-2-otel-agent-gateway:4317
          tls:
            insecure: true
      service:
        pipelines:
          traces:
            receivers: [otlp]
            exporters: [otlp]
          metrics:
            receivers: [otlp]
            exporters: [otlp]
          logs:
            receivers: [otlp]
            exporters: [otlp]

Visualizar pods de puerta de enlace en Fleet Automation

La puerta de enlace del recopilador de DDOT incluye la extensión Datadog por defecto. Esta extensión exporta información de compilación y configuraciones del recopilador a Datadog, lo que te permite monitorizar tu pipeline de telemetría desde Infrastructure Monitoring y Fleet Automation.

Para visualizar tus pods de puerta de enlace:

Ve a Integrations > Fleet Automation (Integraciones > Fleet Automation).

Página de Fleet Automation que muestra pods de puerta de enlace de DDOT

Selecciona un pod de puerta de enlace para ver información detallada sobre la compilación y la configuración del recopilador en ejecución.

Página de Fleet Automation que muestra la configuración del recopilador en un pod de puerta de enlace DDOT

Limitaciones conocidas

Condición de carrera de inicio: Al desplegar el DaemonSet y la puerta de enlace en la misma versión, los pods del DaemonSet pueden iniciarse antes de que el servicio de puerta de enlace esté listo, provocando logs de error de conexión inicial. El exportador OTLP sigue reintentando automáticamente, por lo que estos logs pueden ser ignorados. También puedes desplegar primero la puerta de enlace y esperar a que esté lista antes de desplegar el DaemonSet.