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:

• Ingestieren und Analysieren von Logdaten
• Erfassen von Performance- und Zustandsmetriken
• Monitoring der Anwendungsperformance mit Elastic APM

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.

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:

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

Docker-Infrastruktur und -Metriken (Tabellenansicht)

Kubernetes-Infrastruktur und -Metriken

Metrics Explorer

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

System

Docker

Kubernetes

NGINX

MySQL

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“.