Configurare Grafana Loki

Questa guida fornisce istruzioni su come configurare Loki per raccogliere i log e Grafana per interrogare e visualizzare i log per un cluster Milvus.

In questa guida si apprende come:

• Distribuire Loki e Alloy su un cluster Milvus utilizzando Helm.
• Configurare lo storage a oggetti per Loki.
• Interrogare i registri utilizzando Grafana.

Come riferimento, Promtail sarà deprecato. Introduciamo quindi Alloy, che è stato ufficialmente suggerito dai Grafana Labs come nuovo agente per raccogliere i log di Kubernetes e inoltrarli a Loki.

Prerequisiti

• È stato installato un cluster Milvus su K8s.
• Avete installato gli strumenti necessari, tra cui Helm e Kubectl.

Distribuire Loki

Loki è un sistema di aggregazione dei log ispirato a Prometheus. Distribuite Loki usando Helm per raccogliere i log dal vostro cluster Milvus.

1. Aggiungere il repository dei grafici Helm di Grafana

Aggiungete il repository dei grafici di Grafana a Helm e aggiornatelo:

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

2. Configurare l'archiviazione a oggetti per Loki

Scegliere una delle seguenti opzioni di archiviazione e creare un file di configurazione loki.yaml:

• Opzione 1: Utilizzo di MinIO per lo storage

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

• Opzione 2: Utilizzo di AWS S3 per lo storage

  Nell'esempio seguente, sostituire <accessKey> e <keyId> con la propria chiave di accesso e ID S3, s3.endpoint con l'endpoint S3 e s3.region con la regione S3.

  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. Installare Loki

Eseguire i seguenti comandi per installare Loki:

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

Distribuire Alloy

Verrà mostrata la configurazione di Alloy.

1. Creare la configurazione di Alloy

Utilizzeremo il seguente alloy.yaml per raccogliere i log di tutti i pod Kubernetes e inviarli a Loki tramite loki-gateway:

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. Installare Alloy

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

Interrogare i log con Grafana

Distribuire Grafana e configurarlo per connettersi a Loki per interrogare i log.

1. Installazione di Grafana

Installare Grafana utilizzando i seguenti comandi:

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

Prima di poter accedere a Grafana, è necessario recuperare la password admin:

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

Quindi, inoltrare la porta di Grafana al computer locale:

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. Aggiungere Loki come origine dati in Grafana

Una volta che Grafana è in funzione, è necessario aggiungere Loki come origine dati per interrogare i registri.

1. Aprire un browser web e navigare all'indirizzo 127.0.0.1:3000. Accedere utilizzando il nome utente admin e la password ottenuta in precedenza.
2. Nel menu di sinistra, scegliere Connessioni > Aggiungi nuova connessione.
3. Nella pagina visualizzata, scegliere Loki come tipo di origine dati. È possibile inserire loki nella barra di ricerca per trovare l'origine dati.
4. Nelle impostazioni dell'origine dati Loki, specificare il nome e l'URL, quindi fare clic su Salva e prova.

Origine dati

3. Interrogare i registri Milvus

Dopo aver aggiunto Loki come fonte di dati, è possibile interrogare i registri Milvus in Grafana:

1. Nel menu di sinistra, fare clic su Esplora.
2. Nell'angolo superiore sinistro della pagina, scegliere l'origine dati Loki.
3. Utilizzare il browser delle etichette per selezionare le etichette e interrogare i registri.

Interrogazione