Grafana Loki konfigurieren

Dieser Leitfaden enthält Anweisungen zur Konfiguration von Loki zum Sammeln von Protokollen und Grafana zum Abfragen und Anzeigen von Protokollen für einen Milvus-Cluster.

In diesem Leitfaden erfahren Sie, wie Sie:

• Loki und Alloy auf einem Milvus-Cluster mit Helm bereitstellen.
• Konfigurieren Sie den Objektspeicher für Loki.
• Abfragen von Protokollen mit Grafana.

Als Referenz wird Promtail veraltet sein, weshalb wir Alloy einführen, das offiziell von Grafana Labs als neuer Agent zum Sammeln von Kubernetes-Protokollen und Weiterleiten an Loki vorgeschlagen wurde.

Voraussetzungen

• Sie haben einen Milvus-Cluster auf K8s installiert.
• Sie haben die notwendigen Tools installiert, einschließlich Helm und Kubectl.

Loki bereitstellen

Loki ist ein von Prometheus inspiriertes System zur Protokollaggregation. Setzen Sie Loki mit Helm ein, um Protokolle von Ihrem Milvus-Cluster zu sammeln.

1. Hinzufügen des Grafana Helm Chart Repository

Fügen Sie das Chart-Repository von Grafana zu Helm hinzu und aktualisieren Sie es:

helm repo add grafana https://grafana.github.io/helm-charts
helm repo update

2. Konfigurieren Sie den Objektspeicher für Loki

Wählen Sie eine der folgenden Speicheroptionen und erstellen Sie eine loki.yaml Konfigurationsdatei:

• Option 1: Verwendung von MinIO für die Speicherung

  loki:
    commonConfig:
      replication_factor: 1
    auth_enabled: false
  
  minio:
    enabled: true
  

• Option 2: Verwendung von AWS S3 für die Speicherung

  Im folgenden Beispiel ersetzen Sie <accessKey> und <keyId> durch Ihren eigenen S3-Zugangsschlüssel und Ihre ID, s3.endpoint durch den S3-Endpunkt und s3.region durch die S3-Region.

  loki:
    commonConfig:
      replication_factor: 1
    auth_enabled: false
    storage:
      bucketNames:
        chunks: loki-chunks
        ruler: loki-ruler
        admin: loki-admin
      type: 's3'
      s3:
        endpoint: s3.us-west-2.amazonaws.com
        region: us-west-2
        secretAccessKey: <accessKey>
        accessKeyId: <keyId>
  

3. Loki installieren

Führen Sie die folgenden Befehle aus, um Loki zu installieren:

kubectl create ns loki
helm install --values loki.yaml loki grafana/loki -n loki

Alloy bereitstellen

Wir werden Ihnen die Alloy-Konfiguration zeigen.

1. Alloy-Konfiguration erstellen

Wir werden die folgende alloy.yaml verwenden, um Logs aller Kubernetes-Pods zu sammeln und sie über loki-gateway an Loki zu senden:

alloy:
  enableReporting: false
  resources: {}
  configMap:
    create: true
    content: |-
      loki.write "default" {
        endpoint {
          url = "http://loki-gateway/loki/api/v1/push"
        }
      }

      discovery.kubernetes "pod" {
        role = "pod"
      }

      loki.source.kubernetes "pod_logs" {
        targets    = discovery.relabel.pod_logs.output
        forward_to = [loki.write.default.receiver]
      }

      // Rewrite the label set to make log query easier
      discovery.relabel "pod_logs" {
        targets = discovery.kubernetes.pod.targets
        rule {
          source_labels = ["__meta_kubernetes_namespace"]
          action = "replace"
          target_label = "namespace"
        }

        // "pod" <- "__meta_kubernetes_pod_name"
        rule {
          source_labels = ["__meta_kubernetes_pod_name"]
          action = "replace"
          target_label = "pod"
        }

        // "container" <- "__meta_kubernetes_pod_container_name"
        rule {
          source_labels = ["__meta_kubernetes_pod_container_name"]
          action = "replace"
          target_label = "container"
        }

        // "app" <- "__meta_kubernetes_pod_label_app_kubernetes_io_name"
        rule {
          source_labels = ["__meta_kubernetes_pod_label_app_kubernetes_io_name"]
          action = "replace"
          target_label = "app"
        }

        // "job" <- "__meta_kubernetes_namespace", "__meta_kubernetes_pod_container_name"
        rule {
          source_labels = ["__meta_kubernetes_namespace", "__meta_kubernetes_pod_container_name"]
          action = "replace"
          target_label = "job"
          separator = "/"
          replacement = "$1"
        }

        // L"__path__" <- "__meta_kubernetes_pod_uid", "__meta_kubernetes_pod_container_name"
        rule {
          source_labels = ["__meta_kubernetes_pod_uid", "__meta_kubernetes_pod_container_name"]
          action = "replace"
          target_label = "__path__"
          separator = "/"
          replacement = "/var/log/pods/*$1/*.log"
        }

        // "container_runtime" <- "__meta_kubernetes_pod_container_id"
        rule {
          source_labels = ["__meta_kubernetes_pod_container_id"]
          action = "replace"
          target_label = "container_runtime"
          regex = "^(\\S+):\\/\\/.+$"
          replacement = "$1"
        }
      }

2. Alloy installieren

helm install --values alloy.yaml alloy grafana/alloy -n loki

Logs mit Grafana abfragen

Setzen Sie Grafana ein und konfigurieren Sie es so, dass es sich mit Loki verbindet, um Logs abzufragen.

1. Grafana bereitstellen

Installieren Sie Grafana mit den folgenden Befehlen:

kubectl create ns monitoring
helm install my-grafana grafana/grafana --namespace monitoring

Bevor Sie auf Grafana zugreifen können, müssen Sie das Passwort admin abrufen:

kubectl get secret --namespace monitoring my-grafana -o jsonpath="{.data.admin-password}" | base64 --decode ; echo

Leiten Sie dann den Grafana-Port an Ihren lokalen Rechner weiter:

export POD_NAME=$(kubectl get pods --namespace monitoring -l "app.kubernetes.io/name=grafana,app.kubernetes.io/instance=my-grafana" -o jsonpath="{.items[0].metadata.name}")
kubectl --namespace monitoring port-forward $POD_NAME 3000

2. Loki als Datenquelle in Grafana hinzufügen

Sobald Grafana läuft, müssen Sie Loki als Datenquelle hinzufügen, um Logs abzufragen.

1. Öffnen Sie einen Webbrowser und navigieren Sie zu 127.0.0.1:3000. Melden Sie sich mit dem Benutzernamen admin und dem zuvor erhaltenen Passwort an.
2. Wählen Sie im Menü auf der linken Seite Verbindungen > Neue Verbindung hinzufügen.
3. Wählen Sie auf der nun erscheinenden Seite Loki als Datenquellentyp. Sie können loki in die Suchleiste eingeben, um die Datenquelle zu finden.
4. Geben Sie in den Einstellungen für die Loki-Datenquelle den Namen und die URL an, und klicken Sie dann auf Speichern und testen.

Datenquelle

3. Milvus Logs abfragen

Nachdem Sie Loki als Datenquelle hinzugefügt haben, fragen Sie Milvus Logs in Grafana ab:

1. Klicken Sie im Menü auf der linken Seite auf Explore.
2. Wählen Sie in der oberen linken Ecke der Seite die Datenquelle loki.
3. Verwenden Sie den Label-Browser, um Labels auszuwählen und Logs abzufragen.

Abfrage