Autodiscovery con JMX

Docs > Monitorización de contenedores > Guías de contenedores > Autodiscovery con JMX

En los entornos contenedorizados, existen algunas diferencias en la forma en que el Agent se conecta al servidor JMX. Las funciones de Autodiscovery permiten configurar dinámicamente estas integraciones. Utiliza integraciones basadas en JMX de Datadog para recopilar métricas de aplicaciones JMX de tus pods en Kubernetes.

Si utilizas el trazador de Java para tus aplicaciones, puedes aprovechar la función métricas de ejecución de Java para enviar estas métricas al Agent.

Instalación

Utilizar un Agent habilitado por JMX

Las utilidades JMX no están instaladas por defecto en el Agent. Para configurar una integración JMX, añade -jmx to your Agent’s image tag. For example, gcr.io/datadoghq/agent:latest-jmx.

Si utilizas Datadog Operator o Helm, las siguientes configuraciones añaden -jmx a la etiqueta de imagen de Agent:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      image:
        jmxEnabled: true

agents:
  image:
    tagSuffix: jmx

Configuración

Utiliza uno de los siguientes métodos:

Anotaciones de Autodiscovery (recomendado)
Archivos de configuración de Autodiscovery: para una amplia personalización de los parámetros de configuración

Anotaciones de Autodiscovery

En este método, se aplica una configuración de check de JMX utilizando anotaciones en tus pods basados en Java. Esto permite al Agent configurar automáticamente el check de JMX cuando se inicia un nuevo contenedor. Asegúrate de que estas anotaciones están en el pod creado, y no en el objeto (Deployment, DaemonSet, etc.) que crea el pod.

Utiliza la siguiente plantilla para las anotaciones de Autodiscovery:

apiVersion: v1
kind: Pod
metadata:
  name: <POD_NAME>
  annotations:
    ad.datadoghq.com/<CONTAINER_IDENTIFIER>.checks: |
      {
        "<INTEGRATION_NAME>": {
          "init_config": {
            "is_jmx": true,
            "collect_default_metrics": true
          },
          "instances": [{
            "host": "%%host%%",
            "port": "<JMX_PORT>"
          }]
        }
      }      
    # (...)
spec:
  containers:
    - name: '<CONTAINER_IDENTIFIER>'
      # (...)
      env:
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: JAVA_OPTS
          value: >-
            -Dcom.sun.management.jmxremote
            -Dcom.sun.management.jmxremote.authenticate=false
            -Dcom.sun.management.jmxremote.ssl=false
            -Dcom.sun.management.jmxremote.local.only=false
            -Dcom.sun.management.jmxremote.port=<JMX_PORT>
            -Dcom.sun.management.jmxremote.rmi.port=<JMX_PORT>
            -Djava.rmi.server.hostname=$(POD_IP)

En este ejemplo:

<POD_NAME> es el nombre de tu pod.
<CONTAINER_IDENTIFIER> coincide con el contenedor deseado dentro de tu pod.
<INTEGRATION_NAME> es el nombre de la integración de JMX deseada. Consulta la lista de integraciones de JMX disponibles.
Configura <JMX_PORT> como desees, siempre que coincida entre las anotaciones y JAVA_OPTS.

Con esta configuración, el Datadog Agent descubre este pod y hace una solicitud al servidor JMX sobre la variable de plantilla de Autodiscovery %%host%%; esta solicitud resuelve a la dirección IP del pod descubierto. Esta es la razón por la que java.rmi.server.hostname se establece en la dirección POD_IP previamente rellenada con la API descendente de Kubernetes.

Nota: La variable de entorno JAVA_OPTS se utiliza habitualmente en las imágenes de contenedor basadas en Java como parámetro de inicio (por ejemplo, java $Java_OPTS -jar app.jar). Si utilizas una aplicación personalizada, o si tu aplicación no sigue este patrón, establece estas propiedades del sistema manualmente.

Ejemplo de anotación: Tomcat

La siguiente configuración ejecuta la integración de JMX de Tomcat contra el puerto 9012:

apiVersion: v1
kind: Pod
metadata:
  name: tomcat-test
  annotations:
    ad.datadoghq.com/tomcat.checks: |
      {
        "tomcat": {
          "init_config": {
            "is_jmx": true,
            "collect_default_metrics": true
          },
          "instances": [{
            "host": "%%host%%",
            "port": "9012"
          }]
        }
      }      
spec:
  containers:
    - name: tomcat
      image: tomcat:8.0
      imagePullPolicy: Always
      ports:
        - name: jmx-metrics
          containerPort: 9012
      env:
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: JAVA_OPTS
          value: >-
            -Dcom.sun.management.jmxremote
            -Dcom.sun.management.jmxremote.authenticate=false
            -Dcom.sun.management.jmxremote.ssl=false
            -Dcom.sun.management.jmxremote.local.only=false
            -Dcom.sun.management.jmxremote.port=9012
            -Dcom.sun.management.jmxremote.rmi.port=9012
            -Djava.rmi.server.hostname=$(POD_IP)

Plantilla de anotación de métrica personalizada

Si necesitas recopilar métricas adicionales de estas integraciones, añádelos a la sección init_config:

ad.datadoghq.com/<CONTAINER_IDENTIFIER>.checks: |
  {
    "<INTEGRATION_NAME>": {
      "init_config": {
        "is_jmx": true,
        "collect_default_metrics": true,
        "conf": [{
          "include": {
            "domain": "java.lang",
            "type": "OperatingSystem",
            "attribute": {
               "FreePhysicalMemorySize": {
                 "metric_type": "gauge",
                 "alias": "jvm.free_physical_memory"
               } 
            }
          }
        }]
      },
      "instances": [{
        "host": "%%host%%",
        "port": "<JMX_PORT>"
      }]
    }
  }

Consulta la documentación de la integración de JMX para obtener más información sobre el formato de estas métricas.

Archivos de configuración de Autodiscovery

Si necesitas pasar una configuración personalizada más compleja para tu integración de Datadog y JMX, puedes utilizar Identificadores de contenedor de Autodiscovery para pasar archivos de configuración de integración personalizada, así como un archivo metrics.yaml personalizado.

1. Componer el archivo de configuración

Cuando se utiliza este método, el Agent necesita un archivo de configuración y un archivo opcional metrics.yaml para que las métricas los recopile. Estos archivos pueden montarse en el pod del Agent o incorporarse a la imagen del contenedor.

La convención de nomenclatura de archivos de configuración consiste en identificar primero el nombre de la integración deseada a partir de los pasos previos de las integraciones disponibles. Una vez determinado esto, el Agent necesita un archivo de configuración con un nombre relativo a esa integración; o dentro del directorio de configuración de la integración.

Por ejemplo, para la integración de Tomcat, cree alguna de las siguientes opciones:

/etc/datadog-agent/conf.d/tomcat.yamlo
/etc/datadog-agent/conf.d/tomcat.d/conf.yaml

Si utilizas un archivo metrics.yaml personalizado, inclúyelo en el directorio de configuración de la integración. (Por ejemplo: /etc/datadog-agent/conf.d/tomcat.d/metrics.yaml).

Este archivo de configuración debe incluir ad_identifiers:

ad_identifiers:
  - "<SHORT_IMAGE>"

init_config:
  is_jmx: true
  conf:
    <METRICS_TO_COLLECT>

instances:
  - host: "%%host%%"
    port: "<JMX_PORT>"

Sustituye <SHORT_IMAGE> por el nombre corto de imagen de tu contenedor deseado. Por ejemplo, la imagen de contenedor gcr.io/CompanyName/my-app:latest tiene un nombre de imagen corto my-app. Como el Datadog Agent descubre ese contenedor, establece la configuración de JMX como se describe en este archivo.

También puedes hacer referencia y especificar identificadores personalizados para tus contenedores si no deseas basarte en el nombre corto de la imagen.

Al igual que las anotaciones de Kubernetes, los archivos de configuración pueden utilizar Variables de plantilla de Autodiscovery. En este caso, la configuración del host utiliza %%host%% para resolver a la dirección IP del contenedor descubierto.

Consulta la documentación de la integración de JMX (así como las configuraciones de ejemplo para las integraciones recibidas previamente) para obtener más información sobre cómo estructurar tu configuración init_config y instances para <METRICS_TO_COLLECT>.

2. Montar el archivo de configuración

Si utilizas Datadog Operator, añade una anulación:

apiVersion: datadoghq.com/v2alpha1
kind: DatadogAgent
metadata:
  name: datadog
spec:
  #(...)
  override:
    nodeAgent:
      image:
        jmxEnabled: true
      extraConfd:
        configDataMap:
          <INTEGRATION_NAME>.yaml: |-
            ad_identifiers:
              - "<SHORT_IMAGE>"

            init_config:
              is_jmx: true

            instances:
              - host: "%%host%%"
                port: "<JMX_PORT>"

En Helm, utiliza la opción datadog.confd:

datadog:
  confd:
    <INTEGRATION_NAME>.yaml: |
      ad_identifiers:
        - "<SHORT_IMAGE>"

      init_config:
        is_jmx: true

      instances:
        - host: "%%host%%"
          port: "<JMX_PORT>"

Si no puedes montar estos archivos en el contenedor del Agent (por ejemplo, en Amazon ECS) puedes crear una imagen de Docker del Agent que contenga los archivos de configuración deseados.

Por ejemplo:

FROM gcr.io/datadoghq/agent:latest-jmx
COPY <PATH_JMX_CONF_FILE> conf.d/tomcat.d/
COPY <PATH_JMX_METRICS_FILE> conf.d/tomcat.d/

A continuación, utiliza esta nueva imagen personalizada como tu Agent normal contenedorizado.

3. Exponer servidor de JMX

Configura el servidor de JMX de forma que el Agent pueda acceder a él:

spec:
  containers:
    - # (...)
      env:
      - name: POD_IP
        valueFrom:
          fieldRef:
            fieldPath: status.podIP
      - name: JAVA_OPTS
        value: >-
          -Dcom.sun.management.jmxremote
          -Dcom.sun.management.jmxremote.authenticate=false
          -Dcom.sun.management.jmxremote.ssl=false
          -Dcom.sun.management.jmxremote.local.only=false
          -Dcom.sun.management.jmxremote.port=<JMX_PORT>
          -Dcom.sun.management.jmxremote.rmi.port=<JMX_PORT>
          -Djava.rmi.server.hostname=$(POD_IP)

Integraciones de JMX disponibles

El Datadog Agent viene con varias integraciones de JMX preconfiguradas.

Nombre de la integración	Archivo de métricas	Archivo de configuración
activemq	metrics.yaml	conf.yaml.example
cassandra	metrics.yaml	conf.yaml.example
confluent_platform	metrics.yaml	conf.yaml.example
hazelcast	metrics.yaml	conf.yaml.example
hive	métricas.yaml	conf.yaml.example
hivemq	metrics.yaml	conf.yaml.example
hudi	metrics.yaml	conf.yaml.example
ignite	metrics.yaml	conf.yaml.example
jboss_wildfly	metrics.yaml	conf.yaml.example
kafka	metrics.yaml	conf.yaml.example
presto	metrics.yaml	conf.yaml.example
solr	metrics.yaml	conf.yaml.example
sonarqube	metrics.yaml	conf.yaml.example
tomcat	metrics.yaml	conf.yaml.example
weblogic	metrics.yaml	conf.yaml.example

Cada integración de la tabla anterior tiene un archivo metrics.yaml predefinido para coincidir con el patrón esperado de las métricas de JMX devueltas por aplicación. Utiliza los nombres de integración de la lista como <INTEGRATION_NAME> en tus anotaciones de Autodiscovery o archivos de configuración.

También puedes utilizar jmx como tu <INTEGRATION_NAME> para configurar una integración de JMX básica y recopilar solo las métricas jvm.* predeterminadas.