Engineering

Kubernetes-Observability-Tutorial: Erfassen und Analysieren von Metriken

Dies ist der zweite Teil unserer Tutorial-Reihe zur Observability in Kubernetes, in der es um die Überwachung aller Aspekte der in Kubernetes laufenden Anwendungen geht:

Wir zeigen Ihnen, wie Sie mithilfe der App Metrics und den integrierten Dashboards in Elastic Observability Container-Metriken in Kibana ingestieren und analysieren können.

Erfassen von Metriken aus Kubernetes

Das Erfassen von Metriken aus Kubernetes kann – wie schon das Erfassen von Kubernetes-Logdaten, die wir als sich bewegendes Ziel beschrieben haben, – aus mehreren Gründen eine Herausforderung darstellen:

  1. Bei Kubernetes werden Komponenten auf unterschiedlichen Hosts ausgeführt, die überwacht werden müssen, indem Metriken wie CPU-, Arbeitsspeicher- und Massenspeicherauslastung sowie Disk- und Netzwerk-I/O erfasst werden.
  2. Die Kubernetes-Container, die man sich als eine Art Mini-VMs vorstellen kann, produzieren ebenfalls eigene Metriken.
  3. Zwar können sowohl Anwendungsserver als auch Datenbanken als Kubernetes-Pods ausgeführt werden, aber jede Technologie meldet die relevanten Metriken anders.

Verkompliziert wird die Überwachung von Kubernetes-Deployments auch dadurch, dass in vielen Organisationen mehrere Technologien zur Erfassung von Kubernetes-Metriken verwendet werden. In all den beschriebenen Fällen hilft Elastic Observability, indem es Ihre Logdaten, Metriken und APM-Daten mit nur einem Tool so kombiniert, dass sie für das Aufrufen und Analysieren an einem zentralen Ort bereitstehen.

Erfassen von K8s-Metriken mit Metricbeat

Ähnlich wie das auch schon bei Filebeat der Fall war, reicht uns zum Erfassen der verschiedenen Metriken aus Pods in unserem Kubernetes-Cluster sowie der Kubernetes-eigenen Cluster-Metriken eine einzige Komponente: Metricbeat. Metricbeat-Module dienen dazu, schnell und einfach Metriken aus verschiedenen Quellen zu erfassen und als ECS-kompatible Ereignisse an Elasticsearch zu übermitteln, wo sie mit Log-, Uptime- und APM-Daten korreliert werden können. Metricbeat wird auf zweierlei Art gleichzeitig auf Kubernetes bereitgestellt:

  • Zum einen als einzelner Pod zur Erfassung von Kubernetes-Metriken, der zur Erfassung von Metriken auf Cluster-Ebene auf „kube-state-metrics“ zurückgreift.
  • Zum anderen als DaemonSet, der Metricbeat als Einzelinstanz pro Kubernetes-Host bereitstellt und so das Erfassen von Metriken aus den Pods ermöglicht, die auf dem Host bereitgestellt werden. Metricbeat interagiert mit Kubelet-APIs, um die Komponenten auf diesem Host zum Laufen zu bringen, und nutzt unterschiedliche Methoden, wie z. B. die automatische Erkennung, um technologiespezifische Metriken von den Komponenten abzurufen.
Bevor es losgeht: Das folgende Tutorial setzt das Vorhandensein einer bestimmten Kubernetes-Umgebung voraus. Lesen Sie dazu unseren ergänzenden Blogpost, in dem wir die Schritte zur Einrichtung einer Einzelknoten-Minikube-Umgebung mit einer Demo-Anwendung beschreiben. Diese Umgebung benötigen Sie, um die weiteren Aktivitäten nachvollziehen zu können.

Erfassen von Host-, Docker- und Kubernetes-Metriken

Jede der DaemonSet-Instanzen erfasst Host-, Docker- und Kubernetes-Metriken gemäß der YAML-Konfigurationsdatei ($HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml):

Konfiguration für die Erfassung von System(Host)-Metriken

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      # Zur Berücksichtigung der Top-5-Prozesse nach CPU
      by_memory: 5   # Zur Berücksichtigung der Top-5-Prozesse nach Arbeitsspeicher
  - module: system
    period: 1m
    metricsets:
      - filesystem
      - fsstat
    processors:
    - drop_event.when.regexp:
        system.filesystem.mount_point: '^/(sys|cgroup|proc|dev|etc|host|lib)($|/)'

Konfiguration für die Erfassung von Docker-Metriken

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

Konfiguration für die Erfassung von Kubernetes-Metriken

Hierbei werden Metriken aus Pods berücksichtigt, die durch Kommunikation mit der Kubelet-API auf dem Host bereitgestellt werden:

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"]

Weitere Informationen zu den Metricbeat-Modulen und Daten hinter den Metricsets finden Sie in der Metricbeat-Dokumentation.

Erfassen von Kubernetes-Zustandsmetriken und ‑ereignissen

Es wird eine einzelne Instanz zum Erfassen von Kubernetes-Metriken bereitgestellt. Diese ist in die Kube-state-metrics-API integriert, damit Änderungen des Zustands von Objekten überwacht werden können, die von Kubernetes verwaltet werden. In der Konfigurationsdatei, die die Erfassung von Zustandsmetriken definiert ($HOME/k8s-o11y-workshop/Metricbeat/Metricbeat.yml), sieht der entsprechende Abschnitt wie folgt aus:

kubernetes.yml: |-
  - module: kubernetes
    metricsets:
      - state_node
      - state_deployment
      - state_replicaset
      - state_pod
      - state_container
      # Durch Entkommentieren erhalten Sie k8s-Ereignisse:
      - event
    period: 10s
    host: ${NODE_NAME}
    hosts: ["kube-state-metrics:8080"]

Metricbeat-Autodiscovery mit Pod-Annotationen

Das Metricbeat-DaemonSet-Deployment ist in der Lage, automatisch zu erkennen, welche Komponente im Pod läuft, und das entsprechende Metricbeat-Modul anzuwenden, um technologiespezifische Metriken zu erfassen. Eine der Methoden zur Aktivierung der Autodiscovery sind Pod-Annotationen, mit denen, neben anderen modulspezifischen Konfigurationsinformationen, angegeben wird, welches Modul anzuwenden ist. Der Abschnitt der Metricbeat-Konfigurationsdatei ($HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml), der die Kubernetes-basierte Autodiscovery aktiviert, sieht wie folgt aus:

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

In diesem Tutorial gibt es zwei Komponenten, die von der Hint-gestützten Autodiscovery Gebrauch machen:

  • die NGINX-Definition $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}'
    	
  • die MySQL-Definition $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})/'
    	

Mehr über die Hint-basierte Autodiscovery erfahren Sie in der Metricbeat-Dokumentation.

Erfassen von Anwendungsmetriken in Prometheus-Manier

Unsere Spring Boot-Anwendung Petclinic zeigt die gesamte Palette von anwendungsspezifischen Metriken in einer Prometheus-Scrape-kompatiblen Form. Wenn Sie sehen möchten, wie die Metriken in ihrer Rohform gemeldet werden, gehen Sie zum HTTP-Endpoint der Anwendung unter http://

Hier ein Beispiel für die Ausgabe von Metriken durch unsere Anwendung:

Prometheus-Metriken

Und so sieht die Konfiguration der Hints in der Petclinic-Konfigurationsdatei ($HOME/k8s-o11y-workshop/petclinic/petclinic.yml) aus, mit denen Metricbeat angewiesen wird, diese Metriken mithilfe des Prometheus-Moduls zu erfassen:

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

Generell lässt sich sagen: Metricbeat kann den Prometheus-Server ergänzen oder ihn sogar ganz ersetzen. Wenn Sie schon einen Prometheus-Server bereitgestellt haben und nutzen, kann Metricbeat die Metriken mithilfe der Prometheus-Federation-API aus dem Server exportieren und so dafür sorgen, dass Daten auf mehreren Prometheus-Servern, in verschiedenen Kubernetes-Namespaces und auf mehreren Clustern erfasst werden. Das ermöglicht es, die Prometheus-Metriken mit Log-, APM- und Uptime-Ereignissen zu korrelieren. Wenn es Ihr Ziel ist, Ihre Monitoring-Architektur zu vereinfachen, nutzen Sie Metricbeat, um Prometheus-Metriken zu erfassen und direkt an Elasticsearch zu senden.

Anreicherung mit Metadaten

Alle von Metricbeat verarbeiteten Ereignisse werden von den folgenden Prozessoren angereichert (aus $HOME/k8s-o11y-workshop/metricbeat/metricbeat.yml):

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

So können Metriken mit den Host-, Kubernetes-Pod-, Docker-Container- und Cloudanbieter-Infrastruktur-Metadaten sowie mit anderen Teilen des Observability-Puzzles, wie APM- und Logdaten, korreliert werden.

Metriken in Kibana

Die folgenden Ansichten in der App Metrics basieren auf der Metricbeat-Konfiguration in unserem Tutorial. Klicken Sie sich ruhig einmal durch, um sich ein genaueres Bild zu verschaffen. Sie werden bemerken, dass es überall in Kibana eine Suchfunktion gibt, mit der Sie, nun ja, suchen können. So lässt sich die Ansicht filtern und zoomen, was die Suche nach der sprichwörtlichen Nadel im Heuhaufen deutlich vereinfacht. In unserem Tutorial gibt es nur einen Host – und hier ist er:

Metriken zur Host-Infrastruktur

Host-Metriken in Kibana

Docker-Infrastruktur und -Metriken (Tabellenansicht)

Host-Metriken in der Datentabellenansicht

Kubernetes-Infrastruktur und -Metriken

Kubernetes-Infrastruktur und -Metriken

Metrics Explorer

Metrics Explorer in Kibana

Integrierte Kibana-Dashboards

Metricbeat wird mit einer Reihe vordefinierter Kibana-Dashboards ausgeliefert, die Sie mit nur einem Befehl Ihrem Cluster hinzufügen können. Sie können diese Dashboards dann so einsetzen, wie sie sind, oder als Ausgangspunkt für die Anpassung an Ihre eigenen Anforderungen verwenden. Die folgenden Dashboards helfen Ihnen, die Daten aus Ihrer Tutorial-Umgebung zu visualisieren.

Host

Host-Metriken-Dashboard in Kibana

System

Systemmetriken-Dashboard in Kibana

Docker

Docker-Metriken-Dashboard in Kibana

Kubernetes

Kubernetes-Metriken-Dashboard in Kibana

NGINX

NGINX-Metriken-Dashboard in Kibana

MySQL

MySQL-Metriken-Dashboard in Kibana

Zusammenfassung

In diesem Teil haben wir uns mit der Erfassung von Anwendungs- und Kubernetes-Metriken mit Metricbeat beschäftigt. Für einen schnellen Einstieg in die Überwachung Ihrer Systeme und Infrastruktur haben Sie zwei Möglichkeiten: Entweder Sie melden sich an, um den Elasticsearch Service auf Elastic Cloud kostenlos auszuprobieren, oder Sie laden den Elastic Stack herunter und hosten ihn lokal. 

Nachdem alles eingerichtet ist, können Sie mit Elastic Uptime die Verfügbarkeit Ihrer Hosts überwachen und mit Elastic APM die Anwendungen instrumentieren, die auf Ihren Hosts ausgeführt werden. Auf diese Weise sorgen Sie für komplette Observability in Ihrem System, vollständig in Ihren neuen Metriken-Cluster integriert. Wenn Sie auf Probleme stoßen oder Fragen haben, wird Ihnen in unseren Discuss-Foren sicher schnell weitergeholfen.

Als Nächstes behandeln wir das Thema „Monitoring der Anwendungsperformance mit Elastic APM“.

ElasticON Global 2021

Join us at ElasticON Global for free!

Our biggest event of the year is back Oct 5-7. Take your organization's search, observability, or security capabilities to a whole new level.