Esta página cubre cómo instalar y configurar integraciones para tu infraestructura de Kubernetes utilizando una función de Datadog conocida como Autodiscovery. Esto te permite usar variables como %%host%% para poblar dinámicamente la configuración. Para una explicación detallada de cómo funciona Autodiscovery, consulta Introducción a los Containers: Autodiscovery. Para opciones avanzadas de Autodiscovery, como excluir ciertos contenedores de Autodiscovery o tolerar pods no listos, consulta Gestión del Descubrimiento de Containers.

Si estás utilizando Docker o Amazon ECS, consulta Docker and Integrations.

Configura tu integración

Algunas integraciones requieren pasos de configuración, como crear un token de acceso o otorgar permiso de lectura al Datadog Agent. Sigue las instrucciones en la sección Setup de la documentación de tu integración.

Integraciones comunitarias

Para usar una integración que no está empaquetada con el Datadog Agent, debes construir una imagen personalizada que contenga la integración deseada. Consulta Usar Integraciones Comunitarias para obtener instrucciones.

Configuration

Algunas integraciones de uso común vienen con una configuración predeterminada para Autodiscovery. Consulta Autodiscovery auto-configuration para más detalles, incluyendo una lista de integraciones configuradas automáticamente y sus correspondientes archivos de configuración predeterminados. Si tu integración está en esta lista y la configuración predeterminada es suficiente para tu caso de uso, no se requiere ninguna acción adicional.

De lo contrario:

1. Elige un método de configuración (anotaciones de pod de Kubernetes, un archivo local, un ConfigMap, un almacén de clave-valor, un manifiesto de Datadog Operator o un Helm chart) que se adapte a tu caso de uso.
2. Consulta el formato de plantilla para el método que elegiste. Cada formato contiene marcadores de posición, como <CONTAINER_NAME>.
3. Proporciona valores para estos marcadores de posición.

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/<CONTAINER_NAME>.checks: |
      {
        "<INTEGRATION_NAME>": {
          "init_config": <INIT_CONFIG>,
          "instances": [<INSTANCES_CONFIG>]
        }
      }
    ad.datadoghq.com/<CONTAINER_NAME>.logs: '[<LOGS_CONFIG>]'
    # (...)
spec:
  containers:
    - name: '<CONTAINER_NAME>'
# (...)

apiVersion: v1
kind: Pod
# (...)
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/<CONTAINER_NAME>.check_names: '[<INTEGRATION_NAME>]'
    ad.datadoghq.com/<CONTAINER_NAME>.init_configs: '[<INIT_CONFIG>]'
    ad.datadoghq.com/<CONTAINER_NAME>.instances: '[<INSTANCES_CONFIG>]'
    ad.datadoghq.com/<CONTAINER_NAME>.logs: '[<LOGS_CONFIG>]'
    # (...)
spec:
  containers:
    - name: '<CONTAINER_NAME>'
# (...)

kind: ConfigMap
apiVersion: v1
metadata:
  name: "<NAME>-config-map"
  namespace: default
data:
  <INTEGRATION_NAME>-config: |-
    ad_identifiers:
      <CONTAINER_IMAGE>
    init_config:
      <INIT_CONFIG>
    instances:
      <INSTANCES_CONFIG>
    logs:
      <LOGS_CONFIG>

config_providers:
  - name: etcd
    polling: true
    template_dir: /datadog/check_configs
    template_url: '<KV_STORE_IP>:<KV_STORE_PORT>'
    username:
    password:

  - name: consul
    polling: true
    template_dir: datadog/check_configs
    template_url: '<KV_STORE_IP>:<KV_STORE_PORT>'
    ca_file:
    ca_path:
    cert_file:
    key_file:
    username:
    password:
    token:

  - name: zookeeper
    polling: true
    template_dir: /datadog/check_configs
    template_url: '<KV_STORE_IP>:<KV_STORE_PORT>'
    username:
    password:

/datadog/
  check_configs/
    <CONTAINER_IMAGE>/
      - check_names: ["<INTEGRATION_NAME>"]
      - init_configs: ["<INIT_CONFIG>"]
      - instances: ["<INSTANCES_CONFIG>"]
      - logs: ["<LOGS_CONFIG>"]
    ...

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    [...]
  features:
    [...]
  override:
    nodeAgent:
      extraConfd:
        configDataMap:
          <INTEGRATION_NAME>.yaml: |-
            ad_identifiers:
              - <CONTAINER_IMAGE>
            init_config:
              <INIT_CONFIG>
            instances:
              <INSTANCES_CONFIG>
            logs:
              <LOGS_CONFIG>

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    [...]
  features:
    clusterChecks:
      enabled: true
    [...]
  override:
    nodeAgent:
      [...]
    clusterAgent:
      extraConfd:
        configDataMap:
          <INTEGRATION_NAME>.yaml: |-
            ad_identifiers:
              - <CONTAINER_IMAGE>
            cluster_check: true
            init_config:
              <INIT_CONFIG>
            instances:
              <INSTANCES_CONFIG>
            logs:
              <LOGS_CONFIG>

datadog:
  confd:
    <INTEGRATION_NAME>.yaml: |-
      ad_identifiers:
        - <CONTAINER_IMAGE>
      init_config:
        <INIT_CONFIG>
      instances:
        <INSTANCES_CONFIG>
      logs:
        <LOGS_CONFIG>

datadog:
  clusterChecks:
    enabled: true
clusterAgent:
  enabled: true
  confd:
    <INTEGRATION_NAME>.yaml: |-
      ad_identifiers:
        - <CONTAINER_IMAGE>
      cluster_check: true
      init_config:
        <INIT_CONFIG>
      instances:
        <INSTANCES_CONFIG>
      logs:
        <LOGS_CONFIG>

Valores de marcador de posición

Proporcione valores de marcador de posición de la siguiente manera:

<INTEGRATION_NAME>

El nombre de su integración de Datadog, como etcd o redisdb.

<CONTAINER_NAME>

Un identificador para hacer coincidir con los nombres (spec.containers[i].name, no spec.containers[i].image) de los contenedores que corresponden a su integración.

<CONTAINER_IMAGE>

Un identificador para hacer coincidir con la imagen del contenedor (.spec.containers[i].image).

Por ejemplo: si proporcionas redis como un identificador de contenedor, tu plantilla de Autodiscovery se aplica a todos los contenedores con nombres de imagen que coincidan con redis. Si tienes un contenedor ejecutándose foo/redis:latest y bar/redis:v2, tu plantilla de Autodiscovery se aplica a ambos contenedores.

El parámetro ad_identifiers acepta una lista, por lo que puedes proporcionar múltiples identificadores de contenedor. También puedes usar identificadores personalizados. Consulta Identificadores de Autodiscovery Personalizados.

<INIT_CONFIG>

Los parámetros de configuración que se enumeran bajo init_config en el archivo <INTEGRATION_NAME>.d/conf.yaml.example de tu integración. La sección init_config suele estar vacía.

<INSTANCES_CONFIG>

Los parámetros de configuración que se enumeran bajo instances en el archivo <INTEGRATION_NAME>.d/conf.yaml.example de tu integración.

<LOGS_CONFIG>

Los parámetros de configuración que se enumeran bajo logs en el archivo <INTEGRATION_NAME>.d/conf.yaml.example de tu integración.

Parámetros avanzados de anotación

Además de las anotaciones básicas de Autodiscovery para verificaciones, registros e instancias, puedes usar anotaciones adicionales para personalizar el comportamiento de las verificaciones:

Cardinalidad de etiquetas

Establece el nivel de cardinalidad de etiquetas para una verificación específica utilizando la anotación check_tag_cardinality. Esto anula la configuración global de cardinalidad de etiquetas del Agent para las métricas recopiladas por ese check.

apiVersion: v1
kind: Pod
metadata:
  name: '<POD_NAME>'
  annotations:
    ad.datadoghq.com/<CONTAINER_NAME>.checks: |
      {
        "<INTEGRATION_NAME>": {
          "init_config": <INIT_CONFIG>,
          "instances": [<INSTANCES_CONFIG>]
        }
      }
    ad.datadoghq.com/<CONTAINER_NAME>.check_tag_cardinality: "<low|orchestrator|high>"
spec:
  containers:
    - name: '<CONTAINER_NAME>'

Para más información sobre la cardinalidad de etiquetas, consulta Configuración de etiquetas por verificación.

Auto-configuración

El Datadog Agent reconoce automáticamente y proporciona una configuración básica para algunas tecnologías comunes. Para una lista completa, consulta Auto-configuración de Autodiscovery.

Las configuraciones establecidas con anotaciones de Kubernetes tienen prioridad sobre la auto-configuración, pero la auto-configuración tiene prioridad sobre las configuraciones establecidas con Datadog Operator o Helm. Para usar Datadog Operator o Helm para configurar una integración en la lista de Auto-configuración de Autodiscovery, debes deshabilitar la auto-configuración.

Las integraciones a menudo necesitan leer archivos de configuración, certificados u otros recursos del sistema de archivos.

Cuando las rutas de archivos provienen de proveedores de configuración no confiables (por ejemplo, anotaciones de pods o auto-descubrimiento de servicios externos), existe un riesgo de recorrido de ruta o acceso no autorizado a archivos. .

A partir de la versión 7.78.0 del Agente de Datadog, puede establecer los siguientes parámetros en el datadog.yaml del Agente para controlar el acceso al sistema de archivos según el nivel de confianza de un proveedor de configuración.

Estas opciones son compatibles hacia atrás: los valores predeterminados preservan el comportamiento existente. Para optar por esta opción, habilite integration_ignore_untrusted_file_params y ajuste los parámetros restantes para que coincidan con su entorno.

Ejemplo datadog.yaml:

integration_ignore_untrusted_file_params: true
integration_file_paths_allowlist:
  - /etc/datadog-agent/certs
  - /var/run/secrets
integration_trusted_providers:
  - file
  - remote-config
integration_security_excluded_checks:
  - <INTEGRATION_NAME>

Con esta configuración, una integración configurada a través de anotaciones de pod (un proveedor no confiable) no puede hacer referencia a rutas de archivos fuera de /etc/datadog-agent/certs o /var/run/secrets, a menos que el nombre de la integración esté listado en integration_security_excluded_checks.

Ejemplo: integración de Postgres

En este escenario de ejemplo, implementaste Postgres en Kubernetes. Deseas configurar la integración de Datadog-Postgres. Todos tus contenedores de Postgres tienen nombres de contenedor que contienen la cadena postgres.

Primero, consulta la documentación de integración de Postgres para cualquier paso adicional de configuración. La integración de Postgres requiere que crees un usuario de solo lectura llamado datadog y almacenes la contraseña correspondiente como una variable de entorno llamada PG_PASSWORD.

Si configuraras esta integración en un host, podrías consultar postgresql.d/conf.yaml.example para los parámetros y crear un archivo postgresql.d/conf.yaml que contenga lo siguiente:

init_config:
instances:
  - host: localhost
    port: 5432
    username: datadog
    password: <PASSWORD>
logs:
  - type: file
    path: /var/log/postgres.log
    source: postgresql
    service: pg_service

Aquí, <PASSWORD> corresponde a la contraseña para el usuario datadog que creaste.

Para aplicar esta configuración a tus contenedores de Postgres:

apiVersion: v1
kind: Pod
metadata:
  name: postgres
  annotations:
    ad.datadoghq.com/postgres.checks: |
      {
        "postgres": {
          "instances": [
            {
              "host": "%%host%%",
              "port": "5432",
              "username": "datadog",
              "password":"%%env_PG_PASSWORD%%"
            }
          ]
        }
      }
    ad.datadoghq.com/postgres.logs: |
      [
        {
          "type": "file",
          "path": "/var/log/postgres.log",
          "source": "postgresql",
          "service": "pg_service"
        }
      ]
spec:
  containers:
    - name: postgres

apiVersion: v1
kind: Pod
metadata:
  name: postgres
  annotations:
    ad.datadoghq.com/postgres.check_names: '["postgres"]'
    ad.datadoghq.com/postgres.init_configs: '[{}]'
    ad.datadoghq.com/postgres.instances: |
      [
        {
          "host": "%%host%%",
          "port": "5432",
          "username": "datadog",
          "password":"%%env_PG_PASSWORD%%"
        }
      ]
    ad.datadoghq.com/postgres.logs: |
      [
        {
          "type": "file",
          "path": "/var/log/postgres.log",
          "source": "postgresql",
          "service": "pg_service"
        }
      ]
spec:
  containers:
    - name: postgres

kind: ConfigMap
apiVersion: v1
metadata:
  name: postgresql-config-map
  namespace: default
data:
  postgresql-config: |-
    ad_identifiers:
      - postgres
    init_config:
    instances:
      - host: "%%host%%"
        port: "5432"
        username: "datadog"
        password: "%%env_PG_PASSWORD%%"
    logs:
      - type: "file"
        path: "/var/log/postgres.log"
        source: "postgresql"
        service: "pg_service"

# [...]
        volumeMounts:
        # [...]
          - name: postgresql-config-map
            mountPath: /etc/datadog-agent/conf.d/postgresql.d
        # [...]
      volumes:
      # [...]
        - name: postgresql-config-map
          configMap:
            name: postgresql-config-map
            items:
              - key: postgresql-config
                path: conf.yaml
# [...]

etcdctl mkdir /datadog/check_configs/postgres
etcdctl set /datadog/check_configs/postgres/check_names '["postgres"]'
etcdctl set /datadog/check_configs/postgres/init_configs '[{}]'
etcdctl set /datadog/check_configs/postgres/instances '[{"host": "%%host%%","port":"5432","username":"datadog","password":"%%env_PG_PASSWORD%%"}]'

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  global:
    [...]
  features:
    [...]
  override:
    nodeAgent:
      extraConfd:
        configDataMap:
          postgres.yaml: |-
            ad_identifiers:
              - postgres
            init_config:
            instances:
              - host: "%%host%%"
                port: 5432
                username: "datadog"
                password: "%%env_PG_PASSWORD%%"

datadog:
  confd:
    postgres.yaml: |-
      ad_identifiers:
        - postgres
      init_config:
      instances:
        - host: "%%host%%"
          port: 5432
          username: "datadog"
          password: "%%env_PG_PASSWORD%%"

Estas plantillas utilizan variables de plantilla de Autodiscovery:

• %%host%% se llena dinámicamente con la IP del contenedor.
• %%env_PG_PASSWORD%% hace referencia a una variable de entorno llamada PG_PASSWORD tal como la ve el proceso del Datadog Agent.

Para más ejemplos, incluyendo cómo configurar múltiples verificaciones para múltiples conjuntos de contenedores, consulte Autodiscovery: Escenarios y Ejemplos.

Lectura adicional

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

Monitorea Karpenter con DatadogBLOG Recopila los registros de tu aplicaciónDOCUMENTACIÓN Recopila las trazas de tu aplicaciónDOCUMENTACIÓN Recopila tus métricas de PrometheusDOCUMENTACIÓN Limita la recopilación de datos a un subconjunto de contenedores solamenteDOCUMENTACIÓN Asigna etiquetas a todos los datos emitidos por un contenedorDOCUMENTACIÓN Consejos y trucos de Datadog: Cómo escribir anotaciones en Kubernetes con JSON para Datadog AutodiscoveryVIDEO