Tutorial sobre observabilidad de Kubernetes: Recopilación y análisis de métricas

Este blog es el segundo de la serie de tutoriales sobre observabilidad de Kubernetes; exploraremos cómo puedes monitorear todos los aspectos de tus aplicaciones que se ejecutan en Kubernetes, incluidos los siguientes:

• Ingesta y análisis de logs
• Métricas de estado y rendimiento de recopilación
• Monitoreo de rendimiento de aplicaciones con Elastic APM

Veremos cómo usar Elastic Observability para ingestar y analizar métricas de contenedores en Kibana usando la app Metrics y dashboards listos para usar.

Recopilación de métricas de Kubernetes

Similar al blanco móvil de los logs de Kubernetes, recopilar métricas de Kubernetes puede resultar un desafío por varios motivos:

1. Kubernetes ejecuta componentes en distintos hosts que necesitan monitorearse recopilando métricas como uso de CPU, memoria y disco, y E/S de disco y red.
2. Los contenedores de Kubernetes, que son una especie de mini-VM, también producen su propio conjunto de métricas.
3. Si bien tanto los servidores de aplicaciones como las bases de datos pueden ejecutarse como pods de Kubernetes, cada tecnología tiene su propia manera de reportar las métricas relevantes.

Las organizaciones suelen usar varias tecnologías para manejar la recopilación de métricas en Kubernetes, lo cual complica aún más la tarea de monitorear sus despliegues de Kubernetes. Es aquí donde Elastic Observability entra en juego combinando tus logs, métricas y datos de APM para una visibilidad y análisis unificados usando una herramienta.

Recopilación de métricas de K8 con Metricbeat

Como Filebeat, Metricbeat es el único componente que usaremos para recopilar varias métricas de los pods que se ejecutan en nuestro cluster de Kubernetes, al igual que las métricas del cluster propio de Kubernetes. Los módulos de Metricbeat proporcionan una forma fácil y rápida de tomar métricas de varias fuentes y enviarlas a Elasticsearch como eventos compatibles con ECS, listos para correlacionarse con logs, tiempo de actividad y datos de APM. Metricbeat se despliega simultáneamente en Kubernetes de dos maneras:

• Un solo pod que recopila métricas de Kubernetes. Este pod usa kube-state-metrics para recopilar métricas a nivel del cluster.
• Un DaemonSet que despliega Metricbeat como una sola instancia por host de Kubernetes para recopilar métricas de los pods desplegados en ese host. Metricbeat interactúa con las API de kubelet para que los componentes se ejecuten en ese host y usa diferentes métodos, como la autodetección, para interrogar aún más los componentes con el objetivo de recopilar métricas específicas de la tecnología.

Recopilación de métricas de host, Docker y Kubernetes

Cada instancia DaemonSet recopilará métricas de host, Docker y Kubernetes, según se define en la configuración YAML $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

Configuración de métricas del sistema (host)

system.yml: |-
  - module: system
    period: 10s
    metricsets:
      - cpu
      - load
      - memory
      - network
      - process
      - process_summary
      - core
      - diskio
      # - socket
    processes: ['.*']
    process.include_top_n:
      by_cpu: 5      # include top 5 processes by CPU
      by_memory: 5   # include top 5 processes by memory
  - module: system
    period: 1m
    metricsets:
      - filesystem
      - fsstat
    processors:
    - drop_event.when.regexp:
        system.filesystem.mount_point: '^/(sys|cgroup|proc|dev|etc|host|lib)($|/)'

Configuración de métricas de Docker

docker.yml: |-
  - module: docker
    metricsets:
      - "container"
      - "cpu"
      - "diskio"
      - "event"
      - "healthcheck"
      - "info"
      # - "image"
      - "memory"
      - "network"
    hosts: ["unix:///var/run/docker.sock"]
    period: 10s
    enabled: true

Configuración de métricas de Kubernetes

Se incluye la recopilación de métricas de pods desplegados en el host a través de la comunicación con la API de kubelet:

kubernetes.yml: |-
  - module: kubernetes
    metricsets:
      - node
      - system
      - pod
      - container
      - volume
    period: 10s
    host: ${NODE_NAME}
    hosts: ["localhost:10255"]
  - module: kubernetes
    metricsets:
      - proxy
    period: 10s
    host: ${NODE_NAME}
    hosts: ["localhost:10249"]

Para obtener más información sobre los módulos de Metricbeat y los datos detrás de los conjuntos de métricas, consulta la documentación de Metricbeat.

Recopilación de eventos y métricas de estado de Kubernetes

Se despliega una sola instancia para recopilar métricas de Kubernetes. Se integra con la API de kube-state-metrics para monitorear los cambios de estado de objetos gestionados por Kubernetes. Esta es la sección en la configuración que define la recopilación de state_metrics, $HOME/k8s-o11y-workshop/Metricbeat/Metricbeat.yml:

kubernetes.yml: |-
  - module: kubernetes
    metricsets:
      - state_node
      - state_deployment
      - state_replicaset
      - state_pod
      - state_container
      # Uncomment this to get k8s events:
      - event
    period: 10s
    host: ${NODE_NAME}
    hosts: ["kube-state-metrics:8080"]

Autodescubrimiento de Metricbeat usando anotaciones de pods

El despliegue de Metricbeat como DaemonSet tiene la capacidad de autodetectar el componente que se ejecuta en el pod y aplicar un módulo de Metricbeat específico para recopilar las métricas específicas de la tecnología. Una de las formas de habilitar el autodescubrimiento es usar las anotaciones del pod para indicar cuál módulo aplicar junto con otra configuración específica del módulo. En esta sección de la configuración de Metricbeat se habilita el autodescubrimiento basado en Kubernetes, $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

metricbeat.autodiscover:
  providers:
   - type: kubernetes
     host: ${NODE_NAME}
     hints.enabled: true

Hay dos componentes en este tutorial que usan el autodescubrimiento basado en sugerencias:

• Definición de NGINX, $HOME/k8s-o11y-workshop/nginx/nginx.yml

  template:
    metadata:
      labels:
        app: nginx
      annotations:
        co.elastic.metrics/module: nginx
        co.elastic.metrics/hosts: '${data.host}:${data.port}'
  	

• Definición de MySQL, $HOME/k8s-o11y-workshop/mysql/mysql.yml

  template:
    metadata:
      labels:
        app: mysql
      annotations:
        co.elastic.metrics/module: mysql
        co.elastic.metrics/hosts: 'root:petclinic@tcp(${data.host}:${data.port})/'
  	

Consulta la documentación de Metricbeat para obtener más información sobre el autodescubrimiento basado en sugerencias.

Recopilación de métricas de aplicaciones, al estilo Prometheus

Nuestra aplicación Spring Boot petclinic expone todo el rango de métricas específicas de la aplicación expuestas de forma que puedan ser extraídas con Prometheus. Puedes navegar al endpoint http de la aplicación a http://:30080/metrics/Prometheus para ver cómo se reportan las métricas en formato sin procesar. Sin embargo, en nuestro tutorial, usaremos Metricbeat para recopilar estas métricas y mantener el espíritu de solo usar componentes de Elastic para todas nuestras necesidades de observabilidad.

Este es un ejemplo de lo que reporta nuestra aplicación:

Y esta es la configuración de las sugerencias en la configuración del despliegue YAML de petclinic para recopilar estas métricas usando el módulo de Prometheus, $HOME/k8s-o11y-workshop/petclinic/petclinic.yml:

template:
  metadata:
    labels:
      app: petclinic
    annotations:
      co.elastic.metrics/module: prometheus
      co.elastic.metrics/hosts: '${data.host}:${data.port}'
      co.elastic.metrics/metrics_path: '/metrics/prometheus'
      co.elastic.metrics/period: 1m

En general, Metricbeat puede incrementar o reemplazar por completo el servidor de Prometheus. Si ya desplegaste y usas un servidor Prometheus, Metricbeat puede exportar las métricas del servidor usando la API de federación de Prometheus, proporcionando así visibilidad de varios servidores Prometheus, clusters y espacios de nombres de Kubernetes, habilitando la correlación de métricas de Prometheus con Logs, APM y eventos de tiempo de actividad. Si elijes simplificar tu arquitectura de monitoreo, usa Metricbeat para recopilar las métricas de Prometheus y enviarlas directamente a Elasticsearch.

Enriquecimiento de metadatos

Todos los eventos recopilados por Metricbeat se enriquecen con los procesadores siguientes, $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

processors:
  - add_cloud_metadata:
  - add_host_metadata:
  - add_kubernetes_metadata:
  - add_docker_metadata:

Esto permite la correlación de las métricas con los hosts, pods de Kubernetes, contenedores Docker y metadatos de infraestructura de Proveedor Cloud, y con otras piezas del rompecabezas de observabilidad, como los logs y datos de monitoreo de rendimiento de aplicaciones.

Metrics en Kibana

La configuración de Metricbeat en nuestro tutorial impulsa las vistas siguientes en la app Metrics. No dudes en hacer clic en las opciones para revisarlas. Observa la barra de búsqueda, en cada lugar al que vas en Kibana, que te permite precisamente hacer búsquedas. Es una forma excelente de filtrar las vistas y hacer zoom cuando estás buscando una aguja en un pajar. En nuestro tutorial, solo tenemos un host, que aquí está:

Métricas de infraestructura del host

Infraestructura y métricas de Docker (vista de tabla)

Infraestructura y métricas de Kubernetes

Metrics Explorer

Dashboards de Kibana listos para usar

Metricbeat envía con una variedad de dashboards de Kibana prediseñados que se pueden agregar con facilidad a tu cluster con un solo comando. Después puedes usar estos dashboards como están o como punto de partida para dashboards customizados personalizados según tus necesidades. Estos dashboards ayudarán a mostrar de forma clara los datos de tu entorno del tutorial.

Host

Sistema

Docker

Kubernetes

NGINX

MySQL

Resumen

En esta parte, vimos cómo recopilar métricas de Kubernetes y aplicaciones con Metricbeat. Puedes comenzar a monitorear tus sistemas e infraestructura hoy. Regístrate para una prueba gratuita de Elasticsearch Service en Elastic Cloud o descarga el Elastic Stack y hospédalo tú mismo. 

Una vez en marcha, monitorea la disponibilidad de tus hosts con monitoreo de tiempo de actividad e instrumenta las aplicaciones que se ejecutan en tus hosts con Elastic APM. Estarás camino a un sistema completamente observable, integrado por completo con tu cluster de métricas nuevas. Si encuentras algún obstáculo o tienes preguntas, visita nuestros foros de debate; estamos aquí para ayudarte.

A continuación: Monitoreo de rendimiento de aplicaciones con Elastic APM