Loki – Log-Sammlung unter Verwendung des Prometheus-Ansatzes

Hallo, Habr-Bewohner! Im Vorfeld des Starts eines neuen Kurses „DevOps-Praktiken und -Werkzeuge“ haben wir für euch eine Übersetzung eines interessanten Materials vorbereitet.

Dieser Artikel ist eine kurze Einführung in Loki. Das Loki-Projekt wird von Grafana unterstützt und zielt darauf ab, Logs zentral zu sammeln (von Servern oder Containern).

Die Hauptquelle der Inspiration für Loki war Prometheus die Idee, seine Ansätze für das Log-Management anzuwenden:

• die Verwendung von Labels zur Speicherung von Daten
• der geringe Ressourcenverbrauch

Wir werden noch auf die Funktionsweise von Prometheus zurückkommen und einige Beispiele für seine Verwendung im Kontext von Kubernetes anführen.

Ein paar Worte zu Prometheus

Um zu verstehen, wie Loki funktioniert, ist es wichtig, einen Schritt zurückzutreten und sich ein wenig an Prometheus zu erinnern.

Eine der charakteristischen Eigenschaften von Prometheus ist das Sammeln von Metriken aus den Sammelpunkten (über Exporteure) und deren Speicherung in einer TSDB (Time Series Data Base) unter Hinzufügung von Metadaten in Form von Labels.

Wozu das Ganze?

In letzter Zeit ist Prometheus zum De-facto-Standard in der Welt der Container und Kubernetes geworden: Seine Installation ist sehr einfach, und im Kubernetes-Cluster gibt es von Anfang an einen Endpunkt für Prometheus. Prometheus kann auch Metriken aus in Containern bereitgestellten Anwendungen extrahieren, wobei bestimmte Labels beibehalten werden. Daher ist das Monitoring von Anwendungen sehr einfach umzusetzen.

Leider gibt es bisher keine schlüsselfertige Lösung für das Log-Management, und ihr müsst eine Lösung für euch finden:

• einen verwalteten Cloud-Service zur Zentralisierung von Logs (AWS, Azure oder Google)
• einen Überwachungsdienst "Monitoring as a Service" (zum Beispiel Datadog)
• oder die Erstellung eines eigenen Log-Sammeldienstes.

Für die dritte Option habe ich traditionell Elasticsearch verwendet, obwohl ich nicht immer damit zufrieden war (insbesondere wegen seiner Komplexität und der schwierigen Konfiguration).

Loki wurde mit dem Ziel entworfen, die Implementierung gemäß den folgenden Prinzipien zu erleichtern:

• einfach zu starten sein
• wenig Ressourcen verbrauchen
• eigenständig ohne spezielle Wartung funktionieren
• als Ergänzung zu Prometheus dienen, um bei der Fehlersuche zu helfen.

Diese Einfachheit wird jedoch durch einige Kompromisse erreicht. Einer davon ist, dass der Inhalt nicht indiziert wird. Daher ist die Textsuche nicht sehr effektiv oder umfassend und ermöglicht keine Statistiken über den Textinhalt. Aber da Loki das Äquivalent zu grep und eine Ergänzung zu Prometheus sein möchte, ist das kein Nachteil.

Vorfalluntersuchung

Um besser zu verstehen, warum Loki keine Indizierung benötigt, wollen wir auf die Methode der Vorfalluntersuchung zurückblicken, die die Entwickler von Loki verwendet haben:

1 Alarm → 2 Dashboard → 3 Ad-hoc-Abfrage → 4 Protokollaggregation → 5 Verteiltes Tracing → 6 Beheben!
(1 Alarm → 2 Dashboard → 3 Ad-hoc-Abfrage → 4 Protokollaggregation → 5 Verteiltes Tracing → 6 Beheben!)

Die Idee ist, dass wir einen Alarm erhalten (Slack-Benachrichtigung, SMS usw.) und dann:

• die Grafana-Dashboards ansehen
• die Metriken der Dienste ansehen (z. B. in Prometheus)
• die Protokolle anzeigen (z. B. in Elasticsearch)
• vielleicht einen Blick auf die verteilten Traces werfen (Jaeger, Zipkin usw.)
• und schließlich das ursprüngliche Problem beheben.

Hier, im Fall von Grafana + Prometheus + Elasticsearch + Zipkin, müssen vier verschiedene Werkzeuge verwendet werden. Um die Zeit zu verkürzen, wäre es gut, all diese Schritte mit einem Tool auszuführen: Grafana. Es ist erwähnenswert, dass dieser Ansatz zur Ermittlung in Grafana seit Version 6 implementiert ist. Somit ist es möglich, direkt aus Grafana auf die Daten von Prometheus zuzugreifen.

Der Explorer-Bildschirm ist zwischen Prometheus und Loki aufgeteilt

Auf diesem Bildschirm können Logs in Loki, die mit den Metriken von Prometheus verknüpft sind, unter Verwendung des Konzeptes der Bildschirmteilung angesehen werden. Seit Version 6.5 ermöglicht Grafana die Verarbeitung der Trace-ID in den Protokollaufzeichnungen von Loki, um zu Ihren bevorzugten verteilten Tracing-Tools (Jaeger) zu navigieren.

Lokaler Loki-Test

Der einfachste Weg, Loki lokal zu testen, ist die Verwendung von docker-compose. Die docker-compose-Datei befindet sich im Loki-Repository. Das Repository kann mit folgendem Befehl abgerufen werden: git:

$ git clone https://github.com/grafana/loki.git

Dann müssen Sie in das Verzeichnis production wechseln:

$ cd production

Danach können die neuesten Docker-Images abgerufen werden:

$ docker-compose pull

Schließlich wird der Loki-Stack mit folgendem Befehl gestartet:

$ docker-compose up

Architektur von Loki

Hier ist ein kleines Diagramm zur Architektur von Loki:

Prinzipien der Architektur von Loki

Der Web-Client startet Anwendungen auf dem Server, Promtail sammelt die Protokolle und sendet sie an Loki. Der Web-Client sendet auch Metadaten an Loki. Loki aggregiert alles und überträgt es an Grafana.
Loki ist gestartet. Um die vorhandenen Komponenten anzuzeigen, führen Sie den folgenden Befehl aus:

$ docker ps

Im Falle einer frisch installierten Docker-Umgebung sollte der Befehl das folgende Ergebnis zurückgeben:

IMAGE               PORTS                  NAMES
grafana/promtail:                          production_promtail_1
grafana/grafana: m  0.0.0.0:3000->3000/tcp production_grafana_1
grafana/loki: late  80/tcp,0.0.0.0:3100... production_loki_1

Wir sehen die folgenden Komponenten:

• Promtail: ein Agent, der für die Zentralisierung der Protokolle verantwortlich ist
• Grafana: ein bekanntes Tool für Dashboards
• Loki: ein Datenzentralisierungsdaemon

Im Rahmen einer klassischen Infrastruktur (z. B. auf virtuellen Maschinen) sollte auf jeder Maschine ein Promtail-Agent bereitgestellt werden. Grafana und Loki können auf einer Maschine installiert werden.

Bereitstellung in Kubernetes

Die Installation der Loki-Komponenten in Kubernetes besteht aus Folgendem:

• DaemonSet zur Bereitstellung des Promtail-Agents auf jeder Maschine im Server-Cluster
• Bereitstellung (Deployment) von Loki
• und zuletzt – Bereitstellung von Grafana.

Glücklicherweise ist Loki als Helm-Paket verfügbar, was die Bereitstellung erleichtert.

Installation über Helm

Helm sollte bereits auf Ihrem System installiert sein. Es kann aus dem GitHub-Repository des Projekts heruntergeladen werden. Es wird installiert, indem das Archiv entpackt wird, das Ihrer Architektur entspricht, und helm hinzugefügt wird zu $PATH.

Hinweis: Die Version 3.0.0 von Helm wurde kürzlich veröffentlicht. Da viele Änderungen darin enthalten sind, wird dem Leser empfohlen, etwas zu warten, bevor er sie verwendet..

Hinzufügen einer Quelle für Helm

Der erste Schritt besteht darin, das Repository "loki" mit dem folgenden Befehl hinzuzufügen:

$ helm add loki https://grafana.github.io/loki/charts

Danach können Sie nach Paketen mit dem Namen "loki" suchen:

$ helm search loki

Ergebnis:

loki/loki       0.17.2 v0.4.0 Loki: wie Prometheus, aber für Protokolle.
loki/loki-stack 0.19.1 v0.4.0 Loki: wie Prometheus, aber für Protokolle.
loki/fluent-bit 0.0.2  v0.0.1 Verwendet das fluent-bit Loki Go-Plugin für...
loki/promtail   0.13.1 v0.4.0 Verantwortlich für das Sammeln von Protokollen und...

Diese Pakete bieten folgende Funktionen:

• das Paket loki/loki entspricht nur dem Loki-Server
• das Paket loki/fluent-bit ermöglicht es Ihnen, einen DaemonSet bereitzustellen, der fluent-bit zur Protokollsammlung anstelle von Promtail verwendet
• das Paket loki/promtail enthält einen Agenten zur Protokolldatensammlung
• das Paket loki/loki-stack, ermöglicht die gleichzeitige Bereitstellung von Loki zusammen mit Promtail.

Installation von Loki

Um Loki in Kubernetes bereitzustellen, führen Sie den folgenden Befehl im Namespace "monitoring" aus:

$ helm upgrade --install loki loki/loki-stack --namespace monitoring

Um auf der Festplatte zu speichern, fügen Sie den Parameter hinzu --set loki.persistence.enabled = true:

$ helm upgrade --install loki loki/loki-stack 
              --namespace monitoring 
              --set loki.persistence.enabled=true

Hinweis: Wenn Sie Grafana gleichzeitig bereitstellen möchten, fügen Sie den Parameter hinzu --set grafana.enabled = true

Beim Ausführen dieses Befehls sollten Sie die folgende Ausgabe erhalten:

LETZTER DEPLOYMENT: Di, 19. Nov 2019 15:56:54
NAMESPACE: monitoring
STATUS: DEPLOYED
RESSOURCEN:
==> v1/ClusterRole
NAME ALTER
loki-promtail-clusterrole 189d
…
HINWEISE:
Der Loki-Stack wurde in Ihrem Cluster bereitgestellt. Loki kann nun als Datenquelle in Grafana hinzugefügt werden.
Siehe <a href="http://docs.grafana.org/features/datasources/loki/">http://docs.grafana.org/features/datasources/loki/</a> für weitere Details.

Wenn wir den Zustand der Pods im Namespace „monitoring“ betrachten, sehen wir, dass alles bereitgestellt wurde:

$ kubectl -n monitoring get pods -l release=loki

Ergebnis:

NAME                 READY  STATUS   RESTARTS  AGE
loki-0               1/1    Running  0         147m
loki-promtail-9zjvc  1/1    Running  0         3h25m
loki-promtail-f6brf  1/1    Running  0         11h
loki-promtail-hdcj7  1/1    Running  0         3h23m
loki-promtail-jbqhc  1/1    Running  0         11h
loki-promtail-mj642  1/1    Running  0         62m
loki-promtail-nm64g  1/1    Running  0         24m

Alle Pods sind gestartet. Jetzt ist es Zeit, einige Tests durchzuführen!

Verbindung zu Grafana

Um sich über Kubernetes mit Grafana zu verbinden, müssen Sie einen Tunnel zu seinem Pod öffnen. Unten finden Sie den Befehl, um Port 3000 für den Grafana-Pod zu öffnen:

$ kubectl -n port-forward monitoring svc/loki-grafana 3000:80

Ein weiterer wichtiger Punkt ist die Wiederherstellung des Administratorpassworts von Grafana. Das Passwort wird im Geheimnis loki-grafana im Feld .data.admin-user im Base64-Format gespeichert.

Um es wiederherzustellen, müssen Sie den folgenden Befehl ausführen:

$ kubectl -n monitoring get secret loki-grafana 
 --template '{{index .data "admin-password" | base64decode}}'; echo

Verwenden Sie dieses Passwort zusammen mit dem Standard-Administrator-Konto (admin).

Festlegen der Datenquelle Loki in Grafana

Stellen Sie zunächst sicher, dass die Datenquelle Loki (Konfiguration / Datenquelle) erstellt wurde.
Hier ist ein Beispiel:

Beispiel für die Konfiguration einer Datenquelle für Loki

Durch Klicken auf „Test“ können Sie die Verbindung zu Loki überprüfen.

Anfragen an Loki stellen

Gehen Sie jetzt in Grafana zum Abschnitt „Explore“. Beim Empfang von Logs von Containern fügt Loki Metadaten von Kubernetes hinzu. Somit wird es möglich, die Logs eines bestimmten Containers anzuzeigen.

Um beispielsweise die Logs des Containers promtail auszuwählen, können Sie die folgende Anfrage verwenden: {container_name = "promtail"}.
Vergessen Sie auch nicht, die Datenquelle Loki auszuwählen.

Diese Anfrage gibt die Aktivität der Container in folgender Form zurück:

Ergebnis der Anfrage in Grafana

Hinzufügen zum Dashboard

Seit Grafana 6.4 ist es möglich, Loginformationen direkt auf dem Dashboard anzuzeigen. Danach kann der Benutzer schnell zwischen der Anzahl der Anfragen auf seiner Website und den Anwendungstraces wechseln.

Nachfolgend ein Beispiel eines Dashboards, das diese Interaktion implementiert:

Beispiel eines Dashboards mit Prometheus-Metriken und Loki-Protokollen

Die Zukunft von Loki

Ich begann im Mai/Juni mit der Verwendung von Loki in Version 0.1. Heute wurde bereits Version 1 sowie 1.1 und 1.2 veröffentlicht.

Man muss zugeben, dass Version 0.1 nicht besonders stabil war. Aber 0.3 zeigte bereits echte Anzeichen von Reife, und die folgenden Versionen (0.4, dann 1.0) verstärkten diesen Eindruck nur.

Nach 1.0.0 gibt es keine Ausreden mehr, dieses wunderbare Werkzeug nicht zu benutzen.

Zukünftige Verbesserungen sollten sich weniger auf Loki konzentrieren, sondern vielmehr auf seine Integration mit dem hervorragenden Grafana. Tatsächlich gibt es in Grafana 6.4 bereits eine gute Integration mit Dashboards.

Grafana 6.5, das kürzlich veröffentlicht wurde, verbessert diese Integration weiter, indem es den Inhalt von Protokollen im JSON-Format automatisch erkennt.

Unten im Video finden Sie ein kleines Beispiel für diesen Mechanismus:

Verwendung von Loki-Zeilen, die in Grafana angezeigt werden

Es wird möglich, eines der JSON-Felder zu verwenden, zum Beispiel für:

• Links zu externen Werkzeugen
• Filtern von Protokollinhalten

Zum Beispiel können Sie auf traceId klicken, um zu Zipkin oder Jaeger zu gelangen.

Traditionell erwarten wir Ihre Kommentare und laden Sie ein zu einem offenen Webinar, in dem wir über die Entwicklungen in der DevOps-Branche im Jahr 2019 sprechen und mögliche Entwicklungsmöglichkeiten für 2020 diskutieren.

Quelle: habr.com