Configurer Grafana Loki

Ce guide fournit des instructions sur la manière de configurer Loki pour collecter des journaux et Grafana pour interroger et afficher des journaux pour un cluster Milvus.

Dans ce guide, vous apprendrez à :

• Déployer Loki et Alloy sur un cluster Milvus à l'aide de Helm.
• Configurer le stockage d'objets pour Loki.
• Interroger les journaux à l'aide de Grafana.

Pour référence, Promtail sera déprécié. Nous présentons donc Alloy, qui a été officiellement suggéré par Grafana Labs comme le nouvel agent pour collecter les journaux Kubernetes et les transmettre à Loki.

Conditions préalables

• Vous avez installé un cluster Milvus sur K8s.
• Vous avez installé les outils nécessaires, y compris Helm et Kubectl.

Déployer Loki

Loki est un système d'agrégation de logs inspiré de Prometheus. Déployez Loki à l'aide de Helm pour collecter les journaux de votre cluster Milvus.

1. Ajouter le dépôt de graphiques Helm de Grafana

Ajoutez le dépôt de graphiques de Grafana à Helm et mettez-le à jour :

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

2. Configurer le stockage d'objets pour Loki

Choisissez l'une des options de stockage suivantes et créez un fichier de configuration loki.yaml:

• Option 1 : Utiliser MinIO pour le stockage

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

• Option 2 : Utiliser AWS S3 pour le stockage

  Dans l'exemple suivant, remplacez <accessKey> et <keyId> par votre propre clé d'accès et ID S3, s3.endpoint par le point de terminaison S3, et s3.region par la région 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. Installer Loki

Exécutez les commandes suivantes pour installer Loki :

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

Déployer Alloy

Nous allons vous montrer la configuration d'Alloy.

1. Créer la configuration de l'alliage

Nous utiliserons le site suivant alloy.yaml pour collecter les logs de tous les pods Kubernetes et les envoyer à Loki via 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. Installer Alloy

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

Interroger les logs avec Grafana

Déployer Grafana et le configurer pour se connecter à Loki pour interroger les journaux.

1. Déployer Grafana

Installez Grafana à l'aide des commandes suivantes :

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

Avant de pouvoir accéder à Grafana, vous devez récupérer le mot de passe admin:

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

Ensuite, transférez le port Grafana vers votre machine 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. Ajouter Loki comme source de données dans Grafana

Une fois Grafana lancé, vous devez ajouter Loki en tant que source de données pour interroger les journaux.

1. Ouvrez un navigateur web et naviguez vers 127.0.0.1:3000. Connectez-vous en utilisant le nom d'utilisateur admin et le mot de passe obtenu précédemment.
2. Dans le menu de gauche, choisissez Connexions > Ajouter une nouvelle connexion.
3. Sur la page qui s'affiche, choisissez Loki comme type de source de données. Vous pouvez saisir loki dans la barre de recherche pour trouver la source de données.
4. Dans les paramètres de la source de données Loki, indiquez le nom et l'URL, puis cliquez sur Enregistrer et tester.

Source de données

3. Interroger les journaux Milvus

Après avoir ajouté Loki comme source de données, interrogez les journaux Milvus dans Grafana :

1. Dans le menu de gauche, cliquez sur Explore.
2. Dans le coin supérieur gauche de la page, choisissez la source de données loki.
3. Utilisez le navigateur d'étiquettes pour sélectionner des étiquettes et interroger les journaux.

Interroger