Engineering

Tutorial de observabilidade do Kubernetes: coleta e análise de métricas

Este post é o segundo da nossa série de tutoriais de observabilidade do Kubernetes, onde exploramos como você pode monitorar todos os aspectos das suas aplicações em execução no Kubernetes, incluindo:

Abordaremos o uso do Elastic Observability para ingerir e analisar métricas de containers no Kibana usando o app do Metrics e dashboards prontos para uso.

Coleta de métricas do Kubernetes

De maneira semelhante ao alvo móvel dos logs do Kubernetes, a coleta de métricas do Kubernetes pode representar um desafio por alguns motivos:

  1. O Kubernetes executa componentes em diferentes hosts que precisam ser monitorados por meio da coleta de métricas como CPU, memória, utilização de disco e E/S de disco e rede.
  2. Os containers do Kubernetes, que são uma espécie de mini-VMs, também produzem seu próprio conjunto de métricas.
  3. Embora servidores de aplicações e bancos de dados possam ser executados como pods do Kubernetes, cada tecnologia tem sua própria maneira de relatar as métricas relevantes.

As organizações costumam usar uma série de tecnologias para lidar com a coleta de métricas no Kubernetes, o que complica ainda mais a tarefa de monitorar as implantações do Kubernetes. É aqui que o Elastic Observability muda a narrativa, combinando seus logs, métricas e dados de APM para proporcionar visibilidade e análise unificadas usando uma única ferramenta.

Coleta de métricas do Kubernetes com o Metricbeat

De maneira semelhante ao Filebeat, o Metricbeat é o único componente que usaremos para coletar várias métricas de pods em execução no nosso cluster do Kubernetes, bem como as próprias métricas de cluster do Kubernetes. Os módulos do Metricbeat oferecem uma maneira rápida e fácil de coletar métricas de várias fontes e enviá-las ao Elasticsearch como eventos compatíveis com o ECS, prontos para serem correlacionados com dados de logs, tempo de funcionamento e APM. O Metricbeat é implantado simultaneamente no Kubernetes de duas maneiras:

  • Um único pod para coletar métricas do Kubernetes. Esse pod usa kube-state-metrics para coletar métricas no nível do cluster.
  • Um DaemonSet que implanta o Metricbeat como uma única instância por host do Kubernetes para coletar métricas de pods implantados nesse host. O Metricbeat interage com APIs do kubelet para acessar os componentes executados nesse host e usa métodos diferentes, como detecção automática, para interrogar ainda mais os componentes e coletar métricas específicas da tecnologia.
Antes de começar: para o tutorial a seguir, é necessário ter um ambiente do Kubernetes configurado. Criamos um post suplementar que mostra o processo de configuração de um ambiente do Minikube de nó único com uma aplicação de demonstração para executar o restante das atividades.

Coletar métricas do host, do Docker e do Kubernetes

Cada instância do DaemonSet coletará métricas do host, do Docker e do Kubernetes, conforme definido na configuração de YAML $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

Configuração da métrica do 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)($|/)'

Configuração da métrica do 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

Configuração das métricas do Kubernetes

Inclui a coleta de métricas de pods implantados no host por meio da comunicação com a API do 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 obter mais informações sobre os módulos do Metricbeat e os dados por trás dos conjuntos de métricas, consulte a documentação do Metricbeat.

Coleta de métricas e eventos de estado do Kubernetes

Uma única instância é implantada para coletar métricas do Kubernetes. Ela é integrada com a API de kube-state-metrics para monitorar as alterações de estado dos objetos gerenciados pelo Kubernetes. Esta é a seção da configuração que define a coleção 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"]

Descoberta automática do Metricbeat usando anotações do pod

A implantação do DaemonSet do Metricbeat tem a capacidade de detectar automaticamente o componente em execução no pod e aplicar um módulo do Metricbeat específico para coletar métricas específicas da tecnologia. Uma das maneiras de habilitar a descoberta automática é usar anotações do pod para indicar qual módulo aplicar junto com outra configuração específica do módulo. Esta seção da configuração do Metricbeat habilita a descoberta automática com base no Kubernetes. $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

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

Existem dois componentes neste tutorial que fazem uso da descoberta automática com base em dicas:

  • Definição do 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}'
    	
  • Definição do 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})/'
    	

Consulte a documentação do Metricbeat para obter mais informações sobre a descoberta automática com base em dicas.

Coleta de métricas da aplicação no estilo Prometheus

Nossa aplicação petclinic do Spring Boot expõe toda a gama de métricas específicas da aplicação de uma forma que possa ser extraída pelo Prometheus. Você pode navegar até o endpoint http da aplicação em http://:30080/metrics/Prometheus para ver como as métricas são relatadas em sua forma bruta. No entanto, em nosso tutorial, usaremos o Metricbeat para coletar essas métricas, mantendo o espírito de usar apenas componentes da Elastic para todas as nossas necessidades de observabilidade.

Aqui está um exemplo do que a nossa aplicação relata:

Métricas do Prometheus

E aqui está a configuração das dicas na implantação de YAML do petclinic para dizer ao Metricbeat para coletar essas métricas usando o módulo do 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

Em geral, o Metricbeat pode ampliar ou substituir o servidor Prometheus completamente. Se você já implantou e usa o servidor Prometheus, o Metricbeat pode exportar as métricas para fora do servidor usando a API de Federação do Prometheus, proporcionando visibilidade de vários servidores Prometheus e espaços de nome e clusters do Kubernetes e, assim, permitindo a correlação de métricas do Prometheus com eventos de logs, APM e tempo de funcionamento. Se você escolheu simplificar sua arquitetura de monitoramento, use o Metricbeat para coletar métricas do Prometheus e enviá-las diretamente ao Elasticsearch.

Enriquecimento de metadados

Todos os eventos coletados pelo Metricbeat são enriquecidos pelos processadores a seguir. $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml:

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

Isso permite a correlação de métricas com os hosts, pods do Kubernetes, containers do Docker e metadados de infraestrutura do provedor de serviços em nuvem, bem como a correlação com outras peças do quebra-cabeça da observabilidade, como logs e dados de monitoramento de performance de aplicação.

Métricas no Kibana

A configuração do Metricbeat em nosso tutorial leva às visualizações exibidas a seguir no app do Metrics. Fique à vontade para clicar e examiná-las. Observe como, em todos os lugares aonde você vai no Kibana, há uma barra de busca. É uma ótima maneira de filtrar as visualizações e examinar algumas coisas mais de perto quando você está procurando uma agulha em um palheiro. Em nosso tutorial, temos apenas um host, então aqui está:

Métricas de infraestrutura do host

Métricas do host no Kibana

Métricas e infraestrutura do Docker (visualização de tabela)

Métricas do host na visualização de tabela dos dados

Métricas e infraestrutura do Kubernetes

Métricas e infraestrutura do Kubernetes

Explorador de métricas

Metrics Explorer (Explorador de Métricas) no Kibana

Dashboards do Kibana prontos para uso

O Metricbeat vem com uma variedade de dashboards do Kibana pré-criados que podem ser facilmente adicionados ao seu cluster com um único comando. Você pode usar esses dashboards como estão ou como um ponto de partida e customizá-los de acordo com as suas necessidades. Aqui estão os dashboards que ajudarão a exibir claramente os dados do seu ambiente de tutorial.

Host

Dashboard de métricas do host no Kibana

Sistema

Dashboard de métricas do sistema no Kibana

Docker

Dashboard de métricas do Docker no Kibana

Kubernetes

Dashboard de métricas do Kubernetes no Kibana

NGINX

Dashboard de métricas do NGINX no Kibana

MySQL

Dashboard de métricas do MySQL no Kibana

Resumo

Nesta parte, vimos como coletar métricas do Kubernetes e da aplicação com o Metricbeat. Você pode começar a monitorar seus sistemas e infraestrutura hoje mesmo. Inscreva-se para fazer uma avaliação gratuita do Elasticsearch Service no Elastic Cloud ou baixe o Elastic Stack e hospede-o você mesmo(a). 

Quando ele estiver em funcionamento, monitore a disponibilidade dos seus hosts com o monitoramento de tempo de funcionamento e instrumente as aplicações em execução nos seus hosts com o Elastic APM. Você estará no caminho certo para ter um sistema totalmente observável, completamente integrado com seu novo cluster de métricas. Se encontrar obstáculos ou tiver dúvidas, vá para os nossos fóruns de discussão — estamos aqui para ajudar.

A seguir: Monitoramento de performance de aplicação com o Elastic APM