Loki Installation

DockerBeginner
Jetzt üben

Einführung

Grafana Loki ist ein horizontal skalierbares, hochverfügbares, mandantenfähiges Log-Aggregationssystem, das von Prometheus inspiriert wurde. Es ist darauf ausgelegt, sehr kosteneffizient und einfach zu betreiben zu sein. Im Gegensatz zu anderen Logging-Systemen indiziert Loki nicht den Inhalt der Logs, sondern eine Reihe von Labels für jeden Log-Stream.

In diesem Lab führen Sie eine Basisinstallation von Grafana Loki mithilfe seines offiziellen Docker-Images durch. Sie lernen, wie Sie eine minimale Konfigurationsdatei erstellen und den Loki-Dienst als Container starten. Dies ist der erste grundlegende Schritt beim Aufbau eines vollständigen Logging-Stacks mit Loki.

Loki Docker Image ziehen

In diesem Schritt laden Sie das offizielle Grafana Loki Docker Image von Docker Hub herunter. Der Befehl docker pull holt ein Image oder ein Repository von einer Registry. Ihre Laborumgebung verfügt bereits über eine installierte und konfigurierte Docker-Installation.

Führen Sie den folgenden Befehl im Terminal aus, um das neueste Loki-Image zu ziehen:

docker pull grafana/loki

Sie sehen eine Ausgabe, die den Download-Fortschritt anzeigt. Docker zieht standardmäßig das Image mit dem Tag latest.

Erwartete Ausgabe (Versionsnummern können variieren):

latest: Pulling from grafana/loki
a48641c1b8a9: Pull complete
...
Digest: sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Status: Downloaded newer image for grafana/loki
docker.io/grafana/loki

Basis-Datei loki-config.yaml erstellen

In diesem Schritt erstellen Sie eine minimale Konfigurationsdatei für Loki. Diese Datei, loki-config.yaml, teilt Loki mit, wie es ausgeführt werden soll, wo Daten gespeichert werden sollen und welches Schema verwendet werden soll. Für dieses Lab konfigurieren wir Loki so, dass es das lokale Dateisystem zur Speicherung verwendet.

Wir verwenden den Texteditor nano, um die Datei zu erstellen. Führen Sie den folgenden Befehl aus, um eine neue Datei namens loki-config.yaml zu öffnen:

nano loki-config.yaml

Kopieren Sie nun den folgenden YAML-Inhalt und fügen Sie ihn in den nano-Editor ein:

auth_enabled: false

server:
  http_listen_port: 3100

common:
  path_prefix: /tmp/loki
  storage:
    filesystem:
      chunks_directory: /tmp/loki/chunks
      rules_directory: /tmp/loki/rules
  ring:
    kvstore:
      store: inmemory

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb-shipper
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb_shipper:
    active_index_directory: /tmp/loki/index
    cache_location: /tmp/loki/cache
  filesystem:
    directory: /tmp/loki/chunks

ruler:
  alertmanager_url: http://localhost:9093

limits_config:
  allow_structured_metadata: false

Diese Konfiguration speichert alles, was Loki benötigt, unter /tmp/loki innerhalb des Containers, was Berechtigungsprobleme vermeidet und die Einrichtung leicht verständlich hält. Sie deaktiviert die Authentifizierung, aktiviert einen In-Memory-Ring für die Verwendung auf einem einzelnen Knoten und speichert Blöcke und Indizes auf dem lokalen Dateisystem.

Hier ist, was jeder Abschnitt in der Datei bewirkt:

  • auth_enabled: false: Schaltet die Authentifizierung aus, sodass Sie ohne zusätzliche Anmeldeinformationen mit Loki kommunizieren können. Dies vereinfacht lokale Tests; in einer Produktionsumgebung würden Sie die Authentifizierung aktivieren.
  • server.http_listen_port: 3100: Weist Loki an, HTTP-Anfragen auf Port 3100 entgegenzunehmen. Wenn Sie curl localhost:3100 verwenden, treffen Sie auf diesen Port.
  • common.path_prefix: Legt den Basisordner fest, in dem Loki temporäre Daten innerhalb des Containers speichert. Jeder andere Pfad in dieser Datei wird von /tmp/loki abgeleitet, sodass alles an einem Ort bleibt.
  • common.storage.filesystem: Verweist Loki auf zwei Ordner zur Speicherung von Log-Daten-Chunks und Regeldateien. Da wir nichts Spezielles in den Container einbinden, vermeidet die Verwendung von /tmp/loki Probleme mit Berechtigungen.
  • common.ring.kvstore.store: inmemory: Speichert Mitgliedsinformationen im Speicher. Für ein Einzelknoten-Lab ist dies perfekt; ein echter Cluster würde einen gemeinsam genutzten Speicher wie Consul oder etcd verwenden.
  • schema_config: Definiert, wie Loki den Index für Log-Daten anlegen soll. Wir legen ein Startdatum fest, wählen den boltdb-shipper-Speicher und behalten den Index auf dem Dateisystem. Das prefix und period steuern, wie Dateien benannt werden und wie oft eine neue Indexdatei erstellt wird (alle 24 Stunden).
  • storage_config: Gibt die genauen Ordner für den boltdb-shipper-Index (active_index_directory und cache_location) und für die Speicherung der Roh-Chunks an. Alle Pfade befinden sich wieder unter /tmp/loki, um Ordnung zu halten.
  • ruler.alertmanager_url: Bereitet die Ruler-Komponente von Loki darauf vor, Alerts an einen Alertmanager unter http://localhost:9093 zu senden. Es wird nichts fehlschlagen, wenn Alertmanager nicht läuft; Loki protokolliert lediglich eine Warnung, wenn es versucht, einen Alert zu senden.
  • limits_config.allow_structured_metadata: false: Deaktiviert eine erweiterte Funktion, sodass Loki sich an die einfacheren, reinen Text-Log-Metadaten hält, die Anfänger erwarten.

Drücken Sie Ctrl+X, um zu beenden, dann Y, um das Speichern zu bestätigen, und schließlich Enter, um die Datei unter dem Namen loki-config.yaml zu speichern.

Loki Container mit Konfiguration auf Port 3100 ausführen

Nachdem Sie das Loki-Image und eine Konfigurationsdatei erstellt haben, starten Sie Loki nun als Docker-Container. Sie verwenden den Befehl docker run, um den Container zu starten, Ihre Konfigurationsdatei einzubinden (mounten) und den notwendigen Port freizugeben.

Führen Sie den folgenden Befehl aus:

docker run -d --name loki -v $(pwd)/loki-config.yaml:/etc/loki/config.yml -p 3100:3100 grafana/loki -config.file=/etc/loki/config.yml

Schlüsseln wir diesen Befehl auf:

  • -d: Führt den Container im Detached-Modus (im Hintergrund) aus.
  • --name loki: Weist dem Container den Namen loki zur einfachen Referenzierung zu.
  • -v $(pwd)/loki-config.yaml:/etc/loki/config.yml: Bindet Ihre lokale Datei loki-config.yaml in den Container unter /etc/loki/config.yml ein. Loki liest seine Konfiguration aus dieser Datei.
  • -p 3100:3100: Ordnet Port 3100 der Host-Maschine dem Port 3100 innerhalb des Containers zu, wodurch Sie auf die Loki API zugreifen können.
  • grafana/loki: Das zu verwendende Image für den Container.
  • -config.file=/etc/loki/config.yml: Ein Kommandozeilenargument, das an den Loki-Prozess übergeben wird und ihm mitteilt, wo sich die Konfigurationsdatei befindet.

Nach Ausführung des Befehls gibt Docker die eindeutige ID des neu erstellten Containers aus.

e8a9f2b1c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0

Loki Ready Endpoint unter localhost:3100/ready überprüfen

In diesem Schritt führen Sie einen Health Check durch, um zu bestätigen, dass der Loki-Server gestartet ist und korrekt läuft. Loki stellt einen HTTP-Endpunkt /ready bereit, der für diesen Zweck verwendet werden kann. Eine erfolgreiche Antwort signalisiert, dass der Server bereit ist, Anfragen entgegenzunehmen.

Verwenden Sie den curl-Befehl, um eine Anfrage an diesen Endpunkt zu senden. Da wir in dem vorherigen Schritt Port 3100 zugeordnet haben, können Sie über localhost:3100 darauf zugreifen.

curl http://localhost:3100/ready

Wenn Loki erfolgreich gestartet wurde, antwortet es mit dem Text ready und einem HTTP 200 OK Statuscode.

Erwartete Ausgabe:

ready

Loki-Protokolle auf Startbestätigung prüfen

Eine weitere Möglichkeit, die erfolgreiche Inbetriebnahme von Loki zu überprüfen, besteht darin, die Container-Logs (Protokolle) zu inspizieren. Dies ist nützlich zur Fehlerbehebung bei Konfigurationsproblemen oder anderen Startschwierigkeiten. Der Befehl docker logs ruft die Protokolle eines Containers ab.

Verwenden Sie den folgenden Befehl, um die Logs für Ihren loki-Container anzuzeigen:

docker logs loki

Sie sollten eine Ausgabe sehen, die den Startvorgang detailliert beschreibt. Achten Sie auf eine Zeile, die bestätigt, dass der Server auf Verbindungen wartet. Dies bestätigt, dass der Dienst ohne kritische Fehler initialisiert wurde.

Erwarteter Ausgabe-Ausschnitt (Log-Details können variieren):

level=info ts=... caller=server.go:299 http=[::]:3100 grpc=[::]:9096 msg="server listening on addresses"
level=info ts=... caller=loki.go:372 msg="Loki started"

Zusammenfassung

Herzlichen Glückwunsch! Sie haben dieses Lab erfolgreich abgeschlossen.

In diesem Lab haben Sie die grundlegenden Schritte erlernt, um eine Grafana Loki-Instanz zu starten und betriebsbereit zu machen. Sie haben:

  • Das offizielle Loki Docker Image von Docker Hub gezogen.
  • Eine grundlegende Datei loki-config.yaml erstellt, um Server- und Speichereinstellungen zu definieren.
  • Loki in einem Docker Container gestartet, wobei die Konfiguration eingebunden und der API-Port freigegeben wurde.
  • Überprüft, ob die Loki-Instanz läuft und gesund ist, indem Sie den /ready-Endpunkt verwendet und die Container-Logs kontrolliert haben.

Dieses Basis-Setup bildet die Grundlage für den Aufbau einer komplexeren und robusteren Logging-Architektur. Von hier aus könnten Sie fortfahren, einen Log-Shipping-Agenten wie Promtail zu konfigurieren, um Logs an Loki zu senden, und Grafana zur Abfrage und Visualisierung dieser Logs zu nutzen.