Kubernetes mit Terraform - Monitoring mit Grafana und Loki

Grafana deployen

Wie bei Prometheus und dem Ingress Controller zuvor müssen für das Deployment die Kommentare für das Grafana Modul entfernt werden:

module "grafana" {
source = "./modules/grafana"
kubeconfig_path = var.kubeconfig_path
cluster_name = var.cluster_name
}

Der Aufruf von

terraform plan -out=k8s_svc.plan

mit anschließendem

terraform apply k8s_svc.plan

erzeugt dann die Ressourcen im Cluster.

Um auf Grafana zuzugreifen, gibt es zwei Möglichkeiten. Entweder können wir Portforwarding analog zum Zugriff auf Prometheus verwenden oder wir wählen den Weg über den Loadbalancer. Beim Zugriff auf den Loadbalancer muss beachtet werden, dass für den DNS-Namen des Grafanas (grafana.kube.home) kein DNS-Eintrag besteht. Am einfachsten lässt sich dies lösen, indem man die /etc/hosts Datei um einen speziellen Eintrag erweitert, der auf die öffentliche IP des Loadbalancers zeigt: 162.55.154.61 grafana.kube.home

Verbinden von Grafana und Prometheus

Nun können wir Grafana im Browser unter der oben angegebenen Adresse erreichen. Nach dem Login (Credentials: admin/admin) muss als erstes eine Datenquelle hinzugefügt werden. Dies geschieht im Menüpunkt Configuration.

Hinzufügen einer Datenquelle in Grafana.

Als mögliche Datenquelle wird Prometheus ausgewählt:

Auswahl von Prometheus als Datenquelle.

Im nachfolgenden Menü müssen keine großen Anpassungen vorgenommen werden. Es genügt, den Service zu adressieren. Dies erfolgt über das Namensschema <Servicename>.<Namespace>.svc.cluster.local, in diesem Fall prometheus.prometheus metrics.svc.cluster.local.

Hinzufügen des Kubernetes Dashboards

Das Grafana hat Zugriff auf den Datenbestand des Prometheus und jetzt lassen sich mit diesen Daten Dashboards erzeugen. Ein Beispiel-Dashboard befindet sich im Pfad modules/grafana/templates/dashboard.json. Das Dashboard kann über die Zwischenablage in Grafana importiert werden, indem man im linken Seitenmenü unterhalb des ‚+‘ Buttons das Import-Menü öffnet:

Import in Grafana.

Anschließend wählt man dort die zuvor konfigurierte Datenquelle aus und kann dann auf das das Dashboard zugreifen:

Log-Aggregation mit Loki

Loki ist ein von Grafana entwickeltes Log-Aggregations Tool, welches es ermöglicht, im Kubernetes-Cluster Logs einzusammeln. Loki greift dabei einige Ideen von Prometheus auf, worauf die Entwickler:innen auch hinweisen. Im Wesentlichen stellt Loki nach außen eine API bereit, über die Daten gelesen und geschrieben werden können.

Um Logfiles auf einem Cluster-Knoten einzusammeln, benötigt Loki einen lokal laufenden Daemon, der die Daten liest und an Loki sendet. Dies ist im vorliegenden Fall Promtail. Promtail verwendet die Annotation analog zu Prometheus und erlaubt auch im Cluster Service-Discovery.

Um die Service Discovery zu nutzen, müssen wir Promtail lediglich die notwendigen Informationen in der Konfiguration mitgeben. Sollen die Logs in laufenden Containern überwacht werden, genügt es, dies in Promtail einzustellen. Eine weitere wichtige Konfigurationsoption ist unter Clients zu finden. Hier findet sich die Adresse des Service, der den Zugriff auf Loki ermöglicht.

server:
log_level: info
http_listen_port: 3101
clients:
- url: http://simple-loki.loki.svc.cluster.local:3100/loki/api/v1/push
positions:
filename: /run/promtail/positions.yaml
scrape_configs:
# See also
https://github.com/grafana/loki/blob/master/production/ksonnet/promtail/scrap e_config.libsonnet for reference
- job_name: kubernetes-pods
pipeline_stages:
- cri: {}
kubernetes_sd_configs:
- role: pod

Deployment von Loki/Promtail

Um Loki und Promtail zu installieren werden zunächst die Kommentare für das Terraform Modul entfernt:

module "loki" {
source = "./modules/loki"
kubeconfig_path = var.kubeconfig_path
cluster_name = var.cluster_name
}

Danach können beide einfach über ein

terraform plan -out=k8s_svc.plan

mit anschließendem

terraform apply k8s_svc.plan

installiert werden.

Ist Loki installiert, kann man sich die installierten Pods genauer ansehen und sie zu einem Port auf einem der Promtail Daemons verbinden:

$ kubectl get pods --namespace=loki
NAME READY STATUS RESTARTS AGE
simple-loki-0 1/1 Running 0 24h
simple-promtail-jl292 1/1 Running 0 23h
simple-promtail-rqjln 1/1 Running 0 8m36s
simple-promtail-wtqm9 1/1 Running 0 23h

$ kubectl describe pod simple-promtail-rqjln --namespace=loki | grep port prometheus.io/port: http-metrics

$ kubectl port-forward simple-promtail-rqjln 3222:http-metrics -- namespace=loki
Forwarding from 127.0.0.1:3222 -> 3101
Forwarding from [::1]:3222 -> 3101

Danach erhält man über localhost:3222 Zugriff auf die Oberfläche von Promtail:

Anzeige der Pods im Prometheus UI.

Integration in Grafana

Wie man sieht, hat Promtail alle Container entdeckt und sammelt für jeden der Container Logdaten ein. Promtail selbst aggregiert die Daten nur und eignet sich nicht für die Analyse der Logfiles. Es ist aber sehr einfach, die Daten zur Analyse in Grafana zu importieren.
Dies geschieht genau wie bei Prometheus über das Einbinden einer Datenquelle, wo wieder die Adresse des Loki-Service angegeben wird:

Einbinden einer Datenquelle in Grafana.

NGINX Dashboard mit Anzeige von Log-Daten

Im Pfad ./modules/grafana/templates liegt ein weiteres nginx-Dashboard, welches zusätzliche Log-Daten, die über Loki gesammelt werden, darstellt. Wird das Dashboard analog zum vorherigen Dashboard importiert, kann nun eine zusätzliche Datenquelle angegeben werden:

Angeben einer zusätzlichen Datenquelle.

Als Resultat werden nun die Logdaten des Ingress Controllers im Dashboard angezeigt:

Übersichtliche Anzeige der Logdaten.

Loki sammelt noch viele zusätzliche Daten aus den von Promtail erkannten Datenquellen. Die Komplexität der damit abbildbaren Log-Architektur lässt sich im Rahmen dieses Blogs nur schwer abbilden. Da die Grundlagen jetzt aber gesetzt sind, empfiehlt es sich, hier noch viele Versuche mit dem Log-Browser in Grafana anzustellen.

Zusammenfassung

Im nunmehr letzten Kapitel der Blogreihe haben wir folgende Dinge erreicht:

Es wurde dem Cluster ein Ingress Container hinzugefügt, mit dessen Hilfe Services innerhalb des Clusters nach außen verfügbar gemacht worden sind. Es wurde gezeigt, wie ein Ingress für einen Dienst konfiguriert wird.
Prometheus sammelt Metriken über den Zustand des Clusters und speichert sie in einer Datenbank. Zusätzlich können Metriken aus Pods automatisch ausgelesen werden, indem man dem Pod Annotations hinzufügt.
Grafana kann die Prometheus Metriken in Dashboards darstellen und so den Zustand des Clusters visualisieren.
Loki sammelt Logs aus dem Ingress Controller ein und zeigt sie im Grafana Dashboard an.

Über die gesamte Blogreihe haben wir nun also mittels Terraform einen vollständigen Kubernetes Cluster aus Cloud Ressourcen aufgebaut, der sowohl Dienste im Netz anbieten kann, als auch den Zugriff auf Metriken und Logdaten seiner Services erlaubt.

Weitere Quellen:

Repos

• https://github.com/michaelgroening/terraform-hcloud-kubernetes – Das Repo, welches das Setup für den Cluster enthält
• https://github.com/michaelgroening/tf_k8s_svc – Die Services für das Deployment des zweiten Teiles des Tutorials

Literatur

Begleitend zu diesem Tutorial sind folgende Quellen zu empfehlen, da sie viele Themen noch umfassender beleuchten können als in einem kurzen Tutorial möglich ist:

Kubernetes:

▪ Kubernetes Up and Running – Sehr gutes Buch, welches das grundlegende Setup von Kubernetes erklärt
▪ https://kubernetes.io/de/docs/home/ – Die Offizielle Dokumentation für Kubernetes

Kubernetes mit Terraform – Monitoring mit Grafana und Loki