Visión general

Esta sección tiene como objetivo documentar especificidades y proporcionar buenas configuraciones base para monitorear el Plano de Control de Kubernetes. Luego puedes personalizar estas configuraciones para agregar cualquier característica de Datadog.

Con las integraciones de Datadog para el servidor API, Etcd, Administrador de Controladores y Programador, puedes recopilar métricas clave de los cuatro componentes del Plano de Control de Kubernetes.

Kubernetes con Kubeadm

Las siguientes configuraciones se prueban en Kubernetes v1.18+.

Servidor API

La integración del servidor API se configura automáticamente. El Agente de Datadog lo descubre automáticamente.

Etcd

Al proporcionar acceso de lectura a los certificados de Etcd ubicados en el servidor, la verificación del Agente de Datadog puede comunicarse con Etcd y comenzar a recopilar métricas de Etcd.

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiKey: <DATADOG_API_KEY>
      appKey: <DATADOG_APP_KEY>
    clusterName: <CLUSTER_NAME>
    kubelet:
      tlsVerify: false
  override:
    clusterAgent:
      image:
        name: registry.datadoghq.com/cluster-agent:latest
    nodeAgent:
      image:
        name: registry.datadoghq.com/agent:latest
      extraConfd:
        configMap:
          name: datadog-checks
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /host/etc/kubernetes/pki/etcd
            - name: disable-etcd-autoconf
              mountPath: /etc/datadog-agent/conf.d/etcd.d
      volumes:
        - name: etcd-certs
          hostPath:
            path: /etc/kubernetes/pki/etcd
        - name: disable-etcd-autoconf
          emptyDir: {}
      tolerations:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: datadog-checks
data:
  etcd.yaml: |-
    ad_identifiers:
      - etcd
    init_config:
    instances:
      - prometheus_url: https://%%host%%:2379/metrics
        tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
        tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
        tls_private_key: /host/etc/kubernetes/pki/etcd/server.key

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
  ignoreAutoConfig:
  - etcd
  confd:
    etcd.yaml: |-
      ad_identifiers:
        - etcd
      instances:
        - prometheus_url: https://%%host%%:2379/metrics
          tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
          tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
          tls_private_key: /host/etc/kubernetes/pki/etcd/server.key
agents:
  volumes:
    - hostPath:
        path: /etc/kubernetes/pki/etcd
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/kubernetes/pki/etcd
      readOnly: true
  tolerations:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
    operator: Exists

Administrador de Controladores y Programador

Puertos inseguros

Si los puertos inseguros de sus instancias de Administrador de Controladores y Programador están habilitados, el Agente de Datadog descubre las integraciones y comienza a recopilar métricas sin ninguna configuración adicional.

Puertos seguros

Los puertos seguros permiten la autenticación y autorización para proteger los componentes de su Plano de Control. El Agente de Datadog puede recopilar métricas del Administrador de Controladores y del Programador dirigiéndose a sus puertos seguros.

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  global:
    credentials:
      apiKey: <DATADOG_API_KEY>
      appKey: <DATADOG_APP_KEY>
    clusterName: <CLUSTER_NAME>
    kubelet:
      tlsVerify: false
  override:
    clusterAgent:
      image:
        name: registry.datadoghq.com/cluster-agent:latest
    nodeAgent:
      image:
        name: registry.datadoghq.com/agent:latest
      extraConfd:
        configMap:
          name: datadog-checks
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /host/etc/kubernetes/pki/etcd
            - name: disable-etcd-autoconf
              mountPath: /etc/datadog-agent/conf.d/etcd.d
            - name: disable-scheduler-autoconf
              mountPath: /etc/datadog-agent/conf.d/kube_scheduler.d
            - name: disable-controller-manager-autoconf
              mountPath: /etc/datadog-agent/conf.d/kube_controller_manager.d
      volumes:
        - name: etcd-certs
          hostPath:
            path: /etc/kubernetes/pki/etcd
        - name: disable-etcd-autoconf
          emptyDir: {}
        - name: disable-scheduler-autoconf
          emptyDir: {}
        - name: disable-controller-manager-autoconf
          emptyDir: {}
      tolerations:
        - key: node-role.kubernetes.io/master
          operator: Exists
          effect: NoSchedule
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: datadog-checks
data:
  etcd.yaml: |-
    ad_identifiers:
      - etcd
    init_config:
    instances:
      - prometheus_url: https://%%host%%:2379/metrics
        tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
        tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
        tls_private_key: /host/etc/kubernetes/pki/etcd/server.key
  kube_scheduler.yaml: |-
    ad_identifiers:
      - kube-scheduler
    instances:
      - prometheus_url: https://%%host%%:10259/metrics
        ssl_verify: false
        bearer_token_auth: true
  kube_controller_manager.yaml: |-
    ad_identifiers:
      - kube-controller-manager
    instances:
      - prometheus_url: https://%%host%%:10257/metrics
        ssl_verify: false
        bearer_token_auth: true

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
  ignoreAutoConfig:
    - etcd
    - kube_scheduler
    - kube_controller_manager
  confd:
    etcd.yaml: |-
      ad_identifiers:
        - etcd
      instances:
        - prometheus_url: https://%%host%%:2379/metrics
          tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
          tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
          tls_private_key: /host/etc/kubernetes/pki/etcd/server.key
    kube_scheduler.yaml: |-
      ad_identifiers:
        - kube-scheduler
      instances:
        - prometheus_url: https://%%host%%:10259/metrics
          ssl_verify: false
          bearer_token_auth: true
    kube_controller_manager.yaml: |-
      ad_identifiers:
        - kube-controller-manager
      instances:
        - prometheus_url: https://%%host%%:10257/metrics
          ssl_verify: false
          bearer_token_auth: true
agents:
  volumes:
    - hostPath:
        path: /etc/kubernetes/pki/etcd
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/kubernetes/pki/etcd
      readOnly: true
  tolerations:
  - effect: NoSchedule
    key: node-role.kubernetes.io/master
    operator: Exists

Notas:

  • El campo ssl_verify en la configuración de kube_controller_manager y kube_scheduler necesita ser establecido en false al usar certificados autofirmados.
  • Al apuntar a puertos seguros, la opción bind-address en la configuración de su Administrador de Controladores y Programador debe ser accesible por el Agente de Datadog. Ejemplo:
apiVersion: kubeadm.k8s.io/v1beta2
kind: ClusterConfiguration
controllerManager:
  extraArgs:
    bind-address: 0.0.0.0
scheduler:
  extraArgs:
    bind-address: 0.0.0.0

Kubernetes en Amazon EKS

Método recomendado

Esta función está en vista previa.

Datadog admite el monitoreo de los componentes del plano de control de Kubernetes, incluidos el servidor API, el Administrador de Controladores y el Programador.

Requisitos previos

  1. Datadog Operator >= v1.18.0
  2. Agente de Datadog >= v7.69

Configuración general

El monitoreo del plano de control está habilitado por defecto, pero requiere que la introspección esté habilitada.

Puedes habilitar la introspección usando el chart de Helm datadog-operator:

datadog-agent.yaml

introspection:
  enabled: true

Usando la línea de comandos:

helm install datadog-operator datadog/datadog-operator --set introspection.enabled=true

Dado que esta función está habilitada por defecto, puedes implementar una spec mínima de DatadogAgent.

Requisitos previos

  1. Versión del chart de Helm >= 3.152.0
  2. Agente de Datadog >= v7.69

Configuración general

Habilita el monitoreo del plano de control usando la opción providers.eks.controlPlaneMonitoring:

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
providers:
  eks:
    controlPlaneMonitoring: true

Validación

Verifica que las verificaciones estén en ejecución:

kubectl exec <cluster-agent-pod> -- agent clusterchecks

Busca:

  • kube_apiserver_metrics
  • kube_controller_manager
  • kube_scheduler

Deberías ver métricas del plano de control en Datadog, incluyendo:

  • kube_apiserver.*
  • kube_controller_manager.*
  • kube_scheduler.*

Configuración heredada

Amazon Elastic Kubernetes Service (EKS) admite el monitoreo de todos los componentes del plano de control utilizando verificaciones de clúster.

Requisitos previos

  • Un clúster de EKS ejecutándose en la versión de Kubernetes >= 1.28
  • Despliega el Datadog Agent utilizando uno de:
    • Versión del chart de Helm >= 3.90.1
    • Datadog Operator >= v1.13.0
  • Habilita el Datadog Cluster Agent

Agrega las siguientes anotaciones al servicio default/kubernetes:

annotations:
  ad.datadoghq.com/endpoints.checks: |-
    {
      "kube_apiserver_metrics": {
        "init_config": {},
        "instances": [
          {
            "prometheus_url": "https://%%host%%:%%port%%/metrics",
            "bearer_token_auth": "true"
          }
        ]
      }
    }
  ad.datadoghq.com/service.checks: |-
    {
      "kube_controller_manager": {
        "init_config": {},
        "instances": [
          {
            "prometheus_url": "https://%%host%%:%%port%%/apis/metrics.eks.amazonaws.com/v1/kcm/container/metrics",
            "extra_headers": {"accept":"*/*"},
            "bearer_token_auth": "true",
            "tls_ca_cert": "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
          }
        ]
      },
      "kube_scheduler": {
        "init_config": {},
        "instances": [
          {
            "prometheus_url": "https://%%host%%:%%port%%/apis/metrics.eks.amazonaws.com/v1/ksh/container/metrics",
            "extra_headers": {"accept":"*/*"},
            "bearer_token_auth": "true",
            "tls_ca_cert": "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
          }
        ]
      }
    }

Notas:

  • Amazon expone métricas kube_controller_manager y kube_scheduler bajo el grupo de API metrics.eks.amazonaws.com.
  • La adición de "extra_headers":{"accept":"*/*"} previene errores HTTP 406 al consultar la API de métricas de EKS.

Kubernetes en OpenShift 4

Esta función está en vista previa.

Datadog admite el monitoreo de los componentes del plano de control de Kubernetes, incluidos el servidor API, Etcd, el Administrador de Controladores y el Programador.

Requisitos previos

  1. Datadog Operator >= v1.18.0
  2. Agente de Datadog >= v7.69

Nota: etcd no es compatible con las versiones 4.0-4.13.

Configuración general

El monitoreo del plano de control está habilitado por defecto, pero requiere que la introspección esté habilitada.

Puede habilitar la introspección utilizando el chart de Helm datadog-operator:

datadog-agent.yaml

introspection:
  enabled: true

Usando la línea de comandos:

helm install datadog-operator datadog/datadog-operator --set introspection.enabled=true

O, para usuarios de OpenShift que instalaron el Datadog Operator a través de OperatorHub/Marketplace (el método recomendado), parcheando la versión del servicio del clúster del operador:

oc patch csv <datadog-operator.VERSION> -n <datadog-operator-namespace> \
  --type='json' \
  -p='[{"op": "add", "path": "/spec/install/spec/deployments/0/spec/template/spec/containers/0/args/-", "value": "--introspectionEnabled=true"}]'

Dado que esta función está habilitada por defecto, puedes implementar una especificación mínima de DatadogAgent.

Habilite features.clusterChecks.useClusterChecksRunners para programar verificaciones allí; de lo contrario, las verificaciones del plano de control se ejecutan en el Agente de Nodo.

Para OpenShift 4.14 y versiones posteriores, la supervisión de etcd requiere que copie los certificados de etcd. Revisa los registros del operador para obtener el comando exacto. Revisa el siguiente ejemplo (ajusta el espacio de nombres según sea necesario):

oc get secret etcd-metric-client -n openshift-etcd-operator -o yaml | \
  sed 's/namespace: openshift-etcd-operator/namespace: datadog/' | \
  oc apply -f -

Requisitos previos

  1. Versión del chart de Helm >= 3.150.0
  2. Agente de Datadog >= v7.69

Nota: etcd no es compatible con las versiones 4.0-4.13.

Configuración general

Habilita el monitoreo del plano de control utilizando la opción providers.openshift.controlPlaneMonitoring:

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
providers:
  openshift:
    controlPlaneMonitoring: true

Para OpenShift 4.14 y versiones posteriores, el monitoreo de Etcd requiere que copies los certificados de Etcd. Para copiarlos en el mismo espacio de nombres que el Agente de Datadog:

oc get secret etcd-metric-client -n openshift-etcd-operator -o yaml | sed 's/namespace: openshift-etcd-operator/namespace: <datadog agent namespace>/'  | oc create -f -

Validación

Verifica que las verificaciones estén en ejecución:

kubectl exec <cluster-agent-pod> -- agent clusterchecks

Busca:

  • kube_apiserver_metrics
  • kube_controller_manager
  • kube_scheduler
  • etcd

Deberías ver métricas del plano de control en Datadog, incluyendo:

  • kube_apiserver.*
  • kube_controller_manager.*
  • kube_scheduler.*
  • etcd.*

Configuración heredada

En OpenShift 4, todos los componentes del plano de control se pueden monitorear utilizando verificaciones de punto final.

Requisitos previos

  1. Habilita el Datadog Cluster Agent
  2. Habilita verificaciones de clúster
  3. Habilita verificaciones de punto final
  4. Asegúrate de haber iniciado sesión con permisos suficientes para editar servicios y crear secretos.

Servidor API

El servidor API se ejecuta detrás del servicio kubernetes en el espacio de nombres default. Anota este servicio con la configuración kube_apiserver_metrics:

oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.check_names=["kube_apiserver_metrics"]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "bearer_token_auth": "true"}]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.resolve=ip'

La última anotación ad.datadoghq.com/endpoints.resolve es necesaria porque el servicio está frente a los pods estáticos. El Datadog Cluster Agent programa las verificaciones como verificaciones de punto final y las despacha a los Cluster Check Runners. Los nodos en los que se están ejecutando pueden ser identificados con:

oc exec -it <datadog cluster agent pod> -n <datadog ns> -- agent clusterchecks

Etcd

Se necesitan certificados para comunicarse con el servicio Etcd, que se pueden encontrar en el secreto kube-etcd-client-certs en el espacio de nombres openshift-monitoring. Para dar acceso al Datadog Agent a estos certificados, primero cópielos en el mismo espacio de nombres en el que se está ejecutando el Datadog Agent:

oc get secret kube-etcd-client-certs -n openshift-monitoring -o yaml | sed 's/namespace: openshift-monitoring/namespace: <datadog agent namespace>/'  | oc create -f -

Estos certificados deben montarse en los pods Cluster Check Runner agregando los volumes y volumeMounts como se indica a continuación.

Nota: También se incluyen montajes para deshabilitar el archivo de autoconfiguración de verificación de Etcd empaquetado con el agente.

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  override:
    clusterChecksRunner:
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /etc/etcd-certs
            - name: disable-etcd-autoconf
              mountPath: /etc/datadog-agent/conf.d/etcd.d
      volumes:
        - name: etcd-certs
          secret:
            secretName: kube-etcd-client-certs
        - name: disable-etcd-autoconf
          emptyDir: {}

datadog-values.yaml

...
clusterChecksRunner:
  volumes:
    - name: etcd-certs
      secret:
        secretName: kube-etcd-client-certs
    - name: disable-etcd-autoconf
      emptyDir: {}
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/etcd
      readOnly: true
    - name: disable-etcd-autoconf
      mountPath: /etc/datadog-agent/conf.d/etcd.d

Luego, anote el servicio que se está ejecutando frente a Etcd:

oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.check_names=["etcd"]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "tls_ca_cert": "/etc/etcd-certs/etcd-client-ca.crt", "tls_cert": "/etc/etcd-certs/etcd-client.crt",
      "tls_private_key": "/etc/etcd-certs/etcd-client.key"}]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Se necesitan certificados para comunicarse con el servicio Etcd, que se pueden encontrar en el secreto etcd-metric-client en el espacio de nombres openshift-etcd-operator. Para dar acceso al Datadog Agent a estos certificados, cópielos en el mismo espacio de nombres que el Datadog Agent:

oc get secret etcd-metric-client -n openshift-etcd-operator -o yaml | sed 's/namespace: openshift-etcd-operator/namespace: <datadog agent namespace>/'  | oc create -f -

Estos certificados deben montarse en los pods Cluster Check Runner agregando los volumes y volumeMounts como se indica a continuación.

Nota: También se incluyen montajes para deshabilitar el archivo de autoconfiguración de verificación de Etcd empaquetado con el agente.

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  override:
    clusterChecksRunner:
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /etc/etcd-certs
            - name: disable-etcd-autoconf
              mountPath: /etc/datadog-agent/conf.d/etcd.d
      volumes:
        - name: etcd-certs
          secret:
            secretName: etcd-metric-client
        - name: disable-etcd-autoconf
          emptyDir: {}

datadog-values.yaml

...
clusterChecksRunner:
  volumes:
    - name: etcd-certs
      secret:
        secretName: etcd-metric-client
    - name: disable-etcd-autoconf
      emptyDir: {}
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/etcd
      readOnly: true
    - name: disable-etcd-autoconf
      mountPath: /etc/datadog-agent/conf.d/etcd.d

Luego, anote el servicio que se está ejecutando frente a Etcd:

oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.check_names=["etcd"]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "tls_ca_cert": "/etc/etcd-certs/etcd-client-ca.crt", "tls_cert": "/etc/etcd-certs/etcd-client.crt",
      "tls_private_key": "/etc/etcd-certs/etcd-client.key"}]'
oc annotate service etcd -n openshift-etcd 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Controller Manager

El Controller Manager se ejecuta detrás del servicio kube-controller-manager en el espacio de nombres openshift-kube-controller-manager. Anote el servicio con la configuración de verificación:

oc annotate service kube-controller-manager -n openshift-kube-controller-manager 'ad.datadoghq.com/endpoints.check_names=["kube_controller_manager"]'
oc annotate service kube-controller-manager -n openshift-kube-controller-manager 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service kube-controller-manager -n openshift-kube-controller-manager 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "ssl_verify": "false", "bearer_token_auth": "true"}]'
oc annotate service kube-controller-manager -n openshift-kube-controller-manager 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Scheduler

El Scheduler se ejecuta detrás del servicio scheduler en el espacio de nombres openshift-kube-scheduler. Anote el servicio con la configuración de verificación:

oc annotate service scheduler -n openshift-kube-scheduler 'ad.datadoghq.com/endpoints.check_names=["kube_scheduler"]'
oc annotate service scheduler -n openshift-kube-scheduler 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service scheduler -n openshift-kube-scheduler 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "ssl_verify": "false", "bearer_token_auth": "true"}]'
oc annotate service scheduler -n openshift-kube-scheduler 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Kubernetes en OpenShift 3

En OpenShift 3, todos los componentes del plano de control pueden ser monitoreados utilizando verificaciones de punto de conexión.

Requisitos previos

  1. Habilite el Datadog Cluster Agent
  2. Habilite verificaciones de clúster
  3. Habilite Verificaciones de punto de conexión
  4. Asegúrese de haber iniciado sesión con permisos suficientes para crear y editar servicios.

Servidor API

El servidor API se ejecuta detrás del servicio kubernetes en el espacio de nombres default. Anote este servicio con la configuración kube_apiserver_metrics:

oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.check_names=["kube_apiserver_metrics"]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "bearer_token_auth": "true"}]'
oc annotate service kubernetes -n default 'ad.datadoghq.com/endpoints.resolve=ip'

La última anotación ad.datadoghq.com/endpoints.resolve es necesaria porque el servicio está frente a los pods estáticos. El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners. Los nodos en los que se están ejecutando pueden ser identificados con:

oc exec -it <datadog cluster agent pod> -n <datadog ns> -- agent clusterchecks

Etcd

Se necesitan certificados para comunicarse con el servicio Etcd, que se encuentran en el host. Estos certificados deben montarse en los pods Cluster Check Runner agregando los volumes y volumeMounts como se indica a continuación.

Nota: También se incluyen montajes para deshabilitar el archivo de autoconfiguración de verificación de Etcd empaquetado con el agente.

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  override:
    clusterChecksRunner:
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /host/etc/etcd
            - name: disable-etcd-autoconf
              mountPath: /etc/datadog-agent/conf.d/etcd.d
      volumes:
        - name: etcd-certs
          hostPath:
            path: /etc/etcd
        - name: disable-etcd-autoconf
          emptyDir: {}

datadog-values.yaml

...
clusterChecksRunner:
  volumes:
    - hostPath:
        path: /etc/etcd
      name: etcd-certs
    - name: disable-etcd-autoconf
      emptyDir: {}
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/etcd
      readOnly: true
    - name: disable-etcd-autoconf
      mountPath: /etc/datadog-agent/conf.d/etcd.d

Las ediciones directas de este servicio no se persisten, así que haga una copia del servicio Etcd:

oc get service etcd -n kube-system -o yaml | sed 's/name: etcd/name: etcd-copy/'  | oc create -f -

Anote el servicio copiado con la configuración de verificación:

oc annotate service etcd-copy -n openshift-etcd 'ad.datadoghq.com/endpoints.check_names=["etcd"]'
oc annotate service etcd-copy -n openshift-etcd 'ad.datadoghq.com/endpoints.init_configs=[{}]'
oc annotate service etcd-copy -n openshift-etcd 'ad.datadoghq.com/endpoints.instances=[{"prometheus_url": "https://%%host%%:%%port%%/metrics", "tls_ca_cert": "/host/etc/etcd/ca/ca.crt", "tls_cert": "/host/etc/etcd/server.crt",
      "tls_private_key": "/host/etc/etcd/server.key"}]'
oc annotate service etcd-copy -n openshift-etcd 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Controller Manager y Scheduler

El Controller Manager y el Scheduler se ejecutan detrás del mismo servicio, kube-controllers en el espacio de nombres kube-system. Las ediciones directas del servicio no se persisten, así que haga una copia del servicio:

oc get service kube-controllers -n kube-system -o yaml | sed 's/name: kube-controllers/name: kube-controllers-copy/'  | oc create -f -

Anote el servicio copiado con las configuraciones de verificación:

oc annotate service kube-controllers-copy -n kube-system 'ad.datadoghq.com/endpoints.check_names=["kube_controller_manager", "kube_scheduler"]'
oc annotate service kube-controllers-copy -n kube-system 'ad.datadoghq.com/endpoints.init_configs=[{}, {}]'
oc annotate service kube-controllers-copy -n kube-system 'ad.datadoghq.com/endpoints.instances=[{ "prometheus_url": "https://%%host%%:%%port%%/metrics",
      "ssl_verify": "false", "bearer_token_auth": "true" }, { "prometheus_url": "https://%%host%%:%%port%%/metrics",
      "ssl_verify": "false", "bearer_token_auth": "true" }]'
oc annotate service kube-controllers-copy -n kube-system 'ad.datadoghq.com/endpoints.resolve=ip'

El Datadog Cluster Agent programa las verificaciones como verificaciones de punto de conexión y las despacha a los Cluster Check Runners.

Kubernetes en Talos Linux

Helm es el método de instalación recomendado para Talos Linux. Utilice Helm configurando la bandera providers.talos.enabled a true.

Servidor API

La integración del servidor API se configura automáticamente. El Datadog Agent lo descubre automáticamente.

Etcd

Al proporcionar acceso de lectura a los certificados etcd ubicados en el host, la verificación del Datadog Agent puede comunicarse con etcd y comenzar a recopilar métricas de etcd.

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
  ignoreAutoConfig:
  - etcd
  confd:
    etcd.yaml: |-
      # You can configure the Agent to only run this check on the host where etcd is running
      # by using `ad_identifiers` for a pod that would only be running on a control-plane node.
      # This is to avoid errors when the Agent is running on worker nodes.
      # Another approach is to run a minimal pod on the control-plane node and use it for `ad_identifiers`.
      ad_identifiers:
        - kube-scheduler
      instances:
          # This is the node IP where metrics are exposed because kube-scheduler runs in host network mode.
          # Otherwise, the IP could be hardcoded to the master node IP (also in the environment variable `DD_KUBERNETES_KUBELET_HOST`).
        - prometheus_url: https://%%host%%:2379/metrics
          tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
          tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
          tls_private_key: /host/etc/kubernetes/pki/etcd/server.key
agents:
  # Tolerations are needed to be scheduled on control-plane nodes running etcd
  tolerations:
  - key: node-role.kubernetes.io/control-plane
    operator: Exists
    effect: NoSchedule
  volumes:
    # On Talos, etcd certificates are stored in /system/secrets/etcd
    - hostPath:
        path: /system/secrets/etcd
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/kubernetes/pki/etcd
      readOnly: true
providers:
  talos:
    enabled: true

Controller Manager y Scheduler

Puertos seguros

Los puertos seguros permiten la autenticación y autorización para proteger los componentes de su Plano de Control. El Datadog Agent puede recopilar métricas del Controller Manager y del Scheduler dirigiéndose a sus puertos seguros.

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
  ignoreAutoConfig:
    - etcd
    - kube_scheduler
    - kube_controller_manager
  confd:
    etcd.yaml: |-
      ad_identifiers:
        - kube-scheduler
      instances:
        - prometheus_url: https://%%host%%:2379/metrics
          tls_ca_cert: /host/etc/kubernetes/pki/etcd/ca.crt
          tls_cert: /host/etc/kubernetes/pki/etcd/server.crt
          tls_private_key: /host/etc/kubernetes/pki/etcd/server.key
    kube_scheduler.yaml: |-
      ad_identifiers:
        - kube-scheduler
      instances:
        - prometheus_url: https://%%host%%:10259/metrics
          ssl_verify: false
          bearer_token_auth: true
    kube_controller_manager.yaml: |-
      ad_identifiers:
        - kube-controller-manager
      instances:
        - prometheus_url: https://%%host%%:10257/metrics
          ssl_verify: false
          bearer_token_auth: true
agents:
  tolerations:
  - key: node-role.kubernetes.io/control-plane
    operator: Exists
    effect: NoSchedule
  volumes:
    - hostPath:
        path: /system/secrets/etcd
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/etc/kubernetes/pki/etcd
      readOnly: true
providers:
  talos:
    enabled: true

Notas:

  • El campo ssl_verify en la configuración de kube_controller_manager y kube_scheduler necesita ser establecido en false al usar certificados autofirmados.
  • Al apuntar a puertos seguros, la opción bind-address en la configuración de tu Controller Manager y Scheduler debe ser accesible por el Datadog Agent. Aplique el parche a continuación a los nodos del plano de control en la generación del clúster; o, para nodos Talos en ejecución, ejecute talosctl patch mc -n <control-plane-node1,control-plane-node2> --patch @controlplane-datadog-monitoring-patch.yaml.

controlplane-datadog-monitoring-patch.yaml

cluster:
  controllerManager:
    extraArgs:
      bind-address: 0.0.0.0
  scheduler:
    extraArgs:
      bind-address: 0.0.0.0

Kubernetes en Rancher Kubernetes Engine (v2.5+)

Rancher v2.5 se basa en PushProx para exponer los puntos finales de métricas del plano de control, lo que permite que el Datadog Agent ejecute verificaciones del plano de control y recopile métricas.

Requisitos previos

  1. Instale el Datadog Agent con el rancher-monitoring chart.
  2. Los pushprox daemonsets se implementan con rancher-monitoring y están en ejecución en el espacio de nombres cattle-monitoring-system.

Servidor API

Para configurar la verificación kube_apiserver_metrics, agregue las siguientes anotaciones al servicio default/kubernetes:

annotations:
  ad.datadoghq.com/endpoints.check_names: '["kube_apiserver_metrics"]'
  ad.datadoghq.com/endpoints.init_configs: '[{}]'
  ad.datadoghq.com/endpoints.instances: '[{ "prometheus_url": "https://%%host%%:%%port%%/metrics", "bearer_token_auth": "true" }]'

Agregue servicios de Kubernetes para configurar verificaciones de Autodiscovery

Al agregar servicios de Kubernetes sin cabeza para definir configuraciones de verificación, el Datadog Agent puede dirigirse a los pods pushprox y recolectar métricas.

Aplique rancher-control-plane-services.yaml:

apiVersion: v1
kind: Service
metadata:
  name: pushprox-kube-scheduler-datadog
  namespace: cattle-monitoring-system
  labels:
    component: kube-scheduler
    k8s-app: pushprox-kube-scheduler-client
  annotations:
    ad.datadoghq.com/endpoints.check_names: '["kube_scheduler"]'
    ad.datadoghq.com/endpoints.init_configs: '[{}]'
    ad.datadoghq.com/endpoints.instances: |
      [
        {
          "prometheus_url": "http://%%host%%:10251/metrics"
        }
      ]
spec:
  clusterIP: None
  selector:
    k8s-app: pushprox-kube-scheduler-client
---
apiVersion: v1
kind: Service
metadata:
  name: pushprox-kube-controller-manager-datadog
  namespace: cattle-monitoring-system
  labels:
    component: kube-controller-manager
    k8s-app: pushprox-kube-controller-manager-client
  annotations:
    ad.datadoghq.com/endpoints.check_names: '["kube_controller_manager"]'
    ad.datadoghq.com/endpoints.init_configs: '[{}]'
    ad.datadoghq.com/endpoints.instances: |
      [
        {
          "prometheus_url": "http://%%host%%:10252/metrics"
        }
      ]
spec:
  clusterIP: None
  selector:
    k8s-app: pushprox-kube-controller-manager-client
---
apiVersion: v1
kind: Service
metadata:
  name: pushprox-kube-etcd-datadog
  namespace: cattle-monitoring-system
  labels:
    component: kube-etcd
    k8s-app: pushprox-kube-etcd-client
  annotations:
    ad.datadoghq.com/endpoints.check_names: '["etcd"]'
    ad.datadoghq.com/endpoints.init_configs: '[{}]'
    ad.datadoghq.com/endpoints.instances: |
      [
        {
          "prometheus_url": "https://%%host%%:2379/metrics",
          "tls_ca_cert": "/host/opt/rke/etc/kubernetes/ssl/kube-ca.pem",
          "tls_cert": "/host/opt/rke/etc/kubernetes/ssl/kube-etcd-<node-ip>.pem",
          "tls_private_key": "/host/opt/rke/etc/kubernetes/ssl/kube-etcd-<node-ip>.pem"
        }
      ]
spec:
  clusterIP: None
  selector:
    k8s-app: pushprox-kube-etcd-client

Despliegue el Datadog Agent con manifiestos basados en las siguientes configuraciones:

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  features:
    clusterChecks:
      enabled: true
  global:
    credentials:
      apiKey: <DATADOG_API_KEY>
      appKey: <DATADOG_APP_KEY>
    clusterName: <CLUSTER_NAME>
    kubelet:
      tlsVerify: false
  override:
    nodeAgent:
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /host/opt/rke/etc/kubernetes/ssl
      volumes:
        - name: etcd-certs
          hostPath:
            path: /opt/rke/etc/kubernetes/ssl
      tolerations:
        - key: node-role.kubernetes.io/controlplane
          operator: Exists
          effect: NoSchedule
        - key: node-role.kubernetes.io/etcd
          operator: Exists
          effect: NoExecute

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
agents:
  volumes:
    - hostPath:
        path: /opt/rke/etc/kubernetes/ssl
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/opt/rke/etc/kubernetes/ssl
      readOnly: true
  tolerations:
    - effect: NoSchedule
      key: node-role.kubernetes.io/controlplane
      operator: Exists
    - effect: NoExecute
      key: node-role.kubernetes.io/etcd
      operator: Exists

Kubernetes en Rancher Kubernetes Engine (antes de v2.5)

API Server, Controller Manager y Scheduler

Instale el Datadog Agent con el rancher-monitoring chart.

Los componentes del plano de control se ejecutan en Docker fuera de Kubernetes. Dentro de Kubernetes, el servicio kubernetes en el espacio de nombres default apunta a la(s) IP(s) del nodo del plano de control. Puede confirmar esto ejecutando $ kubectl describe endpoints kubernetes.

Puede anotar este servicio con verificaciones de punto de conexión (gestionadas por el Datadog Cluster Agent) para monitorear el API Server, el Controller Manager y el Scheduler:

kubectl edit service kubernetes
metadata:
  annotations:
    ad.datadoghq.com/endpoints.check_names: '["kube_apiserver_metrics", "kube_controller_manager", "kube_scheduler"]'
    ad.datadoghq.com/endpoints.init_configs: '[{},{},{}]'
    ad.datadoghq.com/endpoints.instances: '[{ "prometheus_url": "https://%%host%%:%%port%%/metrics", "bearer_token_auth": "true" },
      {"prometheus_url": "http://%%host%%:10252/metrics"},
      {"prometheus_url": "http://%%host%%:10251/metrics"}]'

Etcd

Etcd se ejecuta en Docker fuera de Kubernetes, y se requieren certificados para comunicarse con el servicio Etcd. Los pasos sugeridos para configurar la supervisión de Etcd requieren acceso SSH a un nodo del plano de control que ejecute Etcd.

  1. Acceda por SSH al nodo del plano de control siguiendo la documentación de Rancher. Confirme que Etcd se está ejecutando en un contenedor Docker con $ docker ps, y luego use $ docker inspect etcd para encontrar la ubicación de los certificados utilizados en el comando de ejecución ("Cmd"), así como la ruta del host de los montajes.

Las tres banderas en el comando a buscar son:

--trusted-ca-file
--cert-file
--key-file
  1. Usando la información de montaje disponible en la salida $ docker inspect etcd, configure volumes y volumeMounts en la configuración de Datadog Agent. También incluya tolerancias para que Datadog Agent pueda ejecutarse en los nodos del plano de control.

Los siguientes son ejemplos de cómo configurar el Datadog Agent con Helm y el Datadog Operator:

datadog-agent.yaml

kind: DatadogAgent
apiVersion: datadoghq.com/v2alpha1
metadata:
  name: datadog
spec:
  features:
    clusterChecks:
      enabled: true
  global:
    credentials:
      apiKey: <DATADOG_API_KEY>
      appKey: <DATADOG_APP_KEY>
    clusterName: <CLUSTER_NAME>
    kubelet:
      tlsVerify: false
  override:
    nodeAgent:
      containers:
        agent:
          volumeMounts:
            - name: etcd-certs
              readOnly: true
              mountPath: /host/opt/rke/etc/kubernetes/ssl
      volumes:
        - name: etcd-certs
          hostPath:
            path: /opt/rke/etc/kubernetes/ssl
      tolerations:
        - key: node-role.kubernetes.io/controlplane
          operator: Exists
          effect: NoSchedule
        - key: node-role.kubernetes.io/etcd
          operator: Exists
          effect: NoExecute

datadog-values.yaml

datadog:
  apiKey: <DATADOG_API_KEY>
  appKey: <DATADOG_APP_KEY>
  clusterName: <CLUSTER_NAME>
  kubelet:
    tlsVerify: false
agents:
  volumes:
    - hostPath:
        path: /opt/rke/etc/kubernetes/ssl
      name: etcd-certs
  volumeMounts:
    - name: etcd-certs
      mountPath: /host/opt/rke/etc/kubernetes/ssl
      readOnly: true
  tolerations:
    - effect: NoSchedule
      key: node-role.kubernetes.io/controlplane
      operator: Exists
    - effect: NoExecute
      key: node-role.kubernetes.io/etcd
      operator: Exists
  1. Configure un DaemonSet con un contenedor de pausa para ejecutar la verificación de Etcd en los nodos que ejecutan Etcd. Este DaemonSet se ejecuta en la red del servidor para que pueda acceder al servicio de Etcd. También tiene la configuración de verificación y las tolerancias necesarias para ejecutarse en el(los) nodo(s) del plano de control. Asegúrese de que las rutas de los archivos de certificado montados coincidan con lo que configuró en su instancia y reemplace la parte <...> en consecuencia.
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: etcd-pause
spec:
  selector:
    matchLabels:
      app: etcd-pause
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      annotations:
        ad.datadoghq.com/pause.check_names: '["etcd"]'
        ad.datadoghq.com/pause.init_configs: '[{}]'
        ad.datadoghq.com/pause.instances: |
          [{
            "prometheus_url": "https://%%host%%:2379/metrics",
            "tls_ca_cert": "/host/etc/kubernetes/ssl/kube-ca.pem",
            "tls_cert": "/host/etc/kubernetes/ssl/kube-etcd-<...>.pem",
            "tls_private_key": "/host/etc/kubernetes/ssl/kube-etcd-<...>-key.pem"
          }]
      labels:
        app: etcd-pause
      name: etcd-pause
    spec:
      hostNetwork: true
      containers:
      - name: pause
        image: k8s.gcr.io/pause:3.0
      tolerations:
      - effect: NoExecute
        key: node-role.kubernetes.io/etcd
        operator: Exists
      - effect: NoSchedule
        key: node-role.kubernetes.io/controlplane
        operator: Exists

Para desplegar el DaemonSet y la configuración de verificación, ejecute

kubectl apply -f <filename>

Kubernetes en servicios administrados (AKS, GKE)

En otros servicios administrados, como Azure Kubernetes Service (AKS) y Google Kubernetes Engine (GKE), el usuario no puede acceder a los componentes del plano de control. Como resultado, no es posible ejecutar las verificaciones kube_apiserver, kube_controller_manager, kube_scheduler o etcd en estos entornos.