Grafana Loki

Loki est un outil open-source développé par Grafana Labs pour la gestion et l’agrégation des logs. Loki se distingue par son approche innovante qui simplifie le traitement des logs tout en réduisant les coûts et la complexité. Contrairement à d’autres solutions de gestion des logs, Loki n’indexe pas complètement le contenu des logs, ce qui le rend plus léger et plus rapide à déployer.

Ce guide est conçu pour vous aider à comprendre les concepts fondamentaux de Loki, à installer et configurer l’outil et à optimiser son utilisation dans vos environnements. Que vous soyez un administrateur système, un développeur ou un ingénieur DevOps, vous trouverez ici des informations précieuses pour améliorer la gestion des logs dans vos systèmes.

Historique de Loki

Loki a été développé par Grafana Labs et lancé pour la première fois en 2018. À cette époque, le besoin d’un système de gestion des logs léger et bien intégré aux outils de monitoring existants se faisait de plus en plus sentir. De nombreuses organisations utilisaient déjà Prometheus pour la surveillance des métriques, mais il n’existait pas de solution de logs qui soit aussi simple, économique et bien intégrée avec cet écosystème.

Loki a été directement inspiré par Prometheus, un système de monitoring et d’alerting très populaire dans la communauté DevOps. Prometheus a révolutionné la manière dont les métriques sont collectées et analysées grâce à son approche centrée sur les labels. Grafana Labs a donc décidé d’adopter une approche similaire pour la gestion des logs, en se concentrant sur les labels plutôt que sur l’indexation complète des logs.

Depuis son lancement, Loki a connu une adoption rapide grâce à sa simplicité d’utilisation et à ses coûts réduits. Les développeurs et les administrateurs système ont rapidement compris les avantages de Loki par rapport aux solutions traditionnelles de gestion des logs, comme Elasticsearch.

Fonctionnalités de Loki

Loki se distingue par une série de fonctionnalités qui le rendent particulièrement adapté à la gestion des logs dans les environnements DevOps.

Indexation des Logs Limitée

L’une des caractéristiques les plus distinctives de Loki est son approche d’indexation limitée. Contrairement aux systèmes de gestion des logs traditionnels qui indexent chaque champ des logs, Loki n’indexe que certains éléments spécifiques comme les labels. Cette méthode permet de réduire considérablement les besoins en stockage et d’améliorer les performances. Au lieu d’indexer chaque message de log, Loki utilise des labels pour organiser et rechercher les logs. Cela rend le système plus léger et rapide.

Support de Multiples Sources

Loki peut ingérer des logs provenant de multiples sources, ce qui le rend très flexible. Parmi les sources de logs supportées, on trouve :

• Kubernetes : Collecte des logs des pods Kubernetes en utilisant des outils comme Promtail ou Fluentd.
• Docker : Envoi des logs des conteneurs Docker à Loki via des drivers de log Docker.
• Fichiers Journaux Traditionnels : Ingestion des logs provenant de fichiers journaux traditionnels sur des systèmes Linux ou Windows.
• Syslog : Ingestion des messages syslog, facilitant la centralisation des logs système.

Intégration avec Grafana

Loki est parfaitement intégré à Grafana, un outil de visualisation et de surveillance bien connu. Cette intégration permet de créer des tableaux de bord interactifs pour visualiser les logs aux côtés des métriques et des traces. Les utilisateurs peuvent ajouter Loki comme source de données dans Grafana et utiliser le langage de requête LogQL pour rechercher et analyser les logs directement depuis les tableaux de bord Grafana.

Stockage Évolutif

Loki est conçu pour être évolutif et peut gérer de grandes quantités de données de logs. Il utilise des chunks pour stocker les logs, ce qui permet de réduire les coûts de stockage et d’améliorer les performances de requête. Les chunks peuvent être stockés sur différents backend de stockage, comme le système de fichiers local, AWS S3, ou Google Cloud Storage.

Sécurité et Authentification

Loki offre des options de sécurité et d’authentification pour protéger l’accès aux données de logs. Vous pouvez configurer des mécanismes d’authentification et d’autorisation pour restreindre l’accès aux logs sensibles. De plus, Loki peut être configuré pour fonctionner dans des environnements sécurisés, en utilisant des protocoles comme HTTPS pour sécuriser les communications.

Performance et Scalabilité

L’architecture de Loki est conçue pour être performante et évolutive. La séparation des logs en chunks compressés permet de gérer de grandes quantités de données sans compromettre les performances. De plus, la capacité de Loki à s’intégrer avec des systèmes de stockage évolutifs permet de répondre aux besoins croissants des environnements de production.

Concepts de Base

Avant de plonger dans l’utilisation de Loki, il est essentiel de comprendre quelques concepts clés qui forment la base de son fonctionnement. Ces concepts incluent les labels, les streams, les chunks et le processus d’ingestion et de requêtes. Chacun de ces éléments joue un rôle important dans la manière dont Loki gère et organise les logs.

Labels

Les labels sont au cœur de l’organisation des logs dans Loki. Un label est une paire clé-valeur qui est associée à chaque flux de logs (stream). Par exemple, un flux de logs peut avoir des labels tels que {job="app", instance="server1"}. Les labels permettent de regrouper et de filtrer les logs de manière efficace, facilitant ainsi les recherches et l’analyse. Les labels doivent être définis de manière judicieuse pour maximiser l’efficacité des requêtes.

Streams

Un stream dans Loki est une collection de logs qui partagent les mêmes labels. En d’autres termes, un stream est défini par un ensemble unique de labels. Par exemple, tous les logs d’une application spécifique sur un serveur particulier peuvent être regroupés dans un stream avec des labels tels que {job="app", instance="server1"}. Cette organisation permet de gérer et de requêter les logs de manière structurée et ordonnée.

Chunks

Les logs dans Loki sont stockés en chunks. Un chunk est un bloc de données compressé qui contient une série de logs. Cette méthode de stockage permet de réduire la consommation d’espace disque et d’améliorer les performances de lecture et d’écriture. Les chunks sont stockés sur différents backend de stockage, comme le système de fichiers local, AWS S3, ou Google Cloud Storage, en fonction de la configuration.

Ingestion des Logs

L’ingestion des logs dans Loki peut se faire de plusieurs manières. Les logs peuvent provenir de différentes sources comme Promtail, Fluentd, ou Logstash.

Requêtes et LogQL

Loki utilise le langage de requête LogQL pour interroger les logs. LogQL est similaire à PromQL (le langage de requête de Prometheus) et permet de filtrer et d’analyser les logs de manière efficace. Voici un exemple de requête LogQL pour rechercher des logs contenant le mot “error”:

{job="varlogs"} |= "error"

Installation de Loki

Pour commencer à utiliser Loki, vous devez l’installer sur votre infrastructure. Loki offre plusieurs méthodes d’installation adaptées à différents environnements. Que vous utilisiez Docker, Kubernetes, ou que vous préfériez une installation classique, Loki peut s’intégrer facilement dans votre workflow.

Installation avec Docker

L’installation de Loki avec Docker est rapide et simple. Voici les étapes pour lancer Loki en tant que conteneur Docker :

1. Téléchargez et exécutez l’image Docker officielle de Loki :

   docker run -d --name loki -p 3100:3100 grafana/loki:2.9.7

2. Vous pouvez personnaliser la configuration en montant un fichier de configuration dans le conteneur. Créez un fichier loki-config.yaml avec votre configuration souhaitée et lancez le conteneur avec le montage du fichier de configuration :

   docker run -d --name loki -p 3100:3100 -v /path/to/loki-config.yaml:/etc/loki/local-config.yaml grafana/loki:2.9.7 -config.file=/etc/loki/local-config.yaml

Installation avec Kubernetes

Pour déployer Loki sur un cluster Kubernetes, vous pouvez utiliser Helm, un outil de gestion des packages Kubernetes. Voici comment procéder :

1. Ajoutez le dépôt Helm de Grafana :

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

2. Mettez à jour votre dépôt Helm local pour vous assurer d’avoir les dernières versions des charts :

   helm repo update

3. Installez Loki en utilisant le chart loki :

   helm install loki grafana/loki

4. Vous pouvez personnaliser l’installation en fournissant un fichier de valeurs YAML :

   helm install loki grafana/loki -f values.yaml

Installation Classique

Pour ceux qui préfèrent une installation classique, Loki peut être téléchargé et configuré directement sur votre machine. Voici les étapes pour une installation manuelle :

1. Téléchargez le binaire de Loki depuis le site officiel ↗ et extrayez-le dans un répertoire de votre choix.

2. Créez un fichier de configuration loki-config.yaml.

3. Lancez Loki en utilisant le fichier de configuration :

   ./loki-linux-amd64 -config.file=loki-config.yaml

Vérification de l’installation

Après avoir installé Loki, vous pouvez vérifier qu’il fonctionne correctement en accédant à son interface web. Ouvrez votre navigateur et allez à l’adresse http://localhost:3100/metrics. Vous devriez voir une page avec diverses métriques exposées par Loki, confirmant que le service est opérationnel.

Configuration de Loki

Configurer Loki correctement est essentiel pour tirer le meilleur parti de ses capacités de gestion des logs. Voici quelques exemples de configurations basées sur la version 2.9.8, fournies par la documentation officielle.

Voici un exemple de configuration simple permettant d’installer localement loki :

auth_enabled: false

server:
  http_listen_port: 3100

common:
  ring:
    instance_addr: 127.0.0.1
    kvstore:
      store: inmemory
  replication_factor: 1
  path_prefix: /tmp/loki

schema_config:
  configs:
  - from: 2020-05-15
    store: tsdb
    object_store: filesystem
    schema: v13
    index:
      prefix: index_
      period: 24h

storage_config:
  filesystem:
    directory: /tmp/loki/chunks

Section server

• http_listen_port: 3100 : Le port sur lequel Loki écoute les requêtes HTTP. Ceci permet aux utilisateurs d’interagir avec Loki via des requêtes HTTP sur le port 3100.

Section common

Le bloc common contient des configurations partagées par plusieurs composants de Loki :

• ring : Utilisé pour la gestion des anneaux de distribution, indispensable pour le clustering et la répartition des données.
  • instance_addr: 127.0.0.1 : Adresse de l’instance actuelle de Loki. Cela permet à Loki de savoir où il se trouve dans le réseau.
  • kvstore : Type de stockage des informations d’anneau.
    • store: inmemory : Utilise la mémoire pour stocker les informations de l’anneau. Cela est simple et rapide pour les petites configurations, mais ne doit pas être utilisé en production sans une solution de stockage persistante.
• replication_factor: 1 : Nombre de répliques pour chaque donnée, important pour la redondance et la résilience. Un facteur de réplication de 1 signifie qu’il n’y a pas de réplication des données.
• path_prefix: /tmp/loki : Chemin de base pour le stockage des données de Loki. Tous les fichiers de données seront stockés sous ce chemin.

Section schema_config

La configuration des schémas définit comment les logs sont indexés et stockés dans Loki.

• from: 2020-05-15 : Date à partir de laquelle cette configuration de schéma est applicable.
• store: tsdb : Type de stockage utilisé (Time Series Database).
• object_store: filesystem : Type de stockage d’objet utilisé, ici le système de fichiers.
• schema: v13 : Version du schéma utilisé.
• index :
  • prefix: index_ : Préfixe utilisé pour les index.
  • period: 24h : Période d’indexation, ici définie à 24 heures. Cela signifie que les index sont créés pour chaque période de 24 heures.

Section storage_config

La configuration du stockage détermine où et comment les données de logs sont stockées.

• filesystem :
  • directory: /tmp/loki/chunks : Répertoire où les chunks de données de logs sont stockés. En utilisant le système de fichiers local, cela facilite les tests et les petits déploiements, mais pour des environnements de production, il est recommandé d’utiliser des solutions de stockage plus robustes comme des buckets S3.

Pour des configurations supplémentaires et des exemples détaillés, veuillez consulter la documentation officielle de Loki ↗.

Ingestion des Logs

Loki supporte plusieurs méthodes pour ingérer des logs provenant de différentes sources, telles que Promtail, Fluentd et Logstash. Dans ce guide, nous aborderons principalement l’utilisation de Promtail pour l’ingestion des logs.

Promtail est l’agent d’ingestion de logs pour Loki, similaire à ce que Prometheus est pour les métriques. Il est utilisé pour collecter les logs, les étiqueter avec les labels appropriés et les envoyer à Loki.

Installation de Promtail

Promtail peut être installé de différentes manières, y compris via Docker, Kubernetes, ou en téléchargeant le binaire directement. Voici un exemple d’installation avec Docker :

docker run -d --name promtail -v /path/to/promtail-config.yaml:/etc/promtail/promtail-config.yaml -v /var/log:/var/log grafana/promtail:2.9.7

Configuration de Promtail

La configuration de Promtail se fait via un fichier YAML. Voici un exemple de configuration simpliste pour collecter des logs de conteneurs Docker et des fichiers journaux traditionnels :

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://localhost:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/**/*.log
  - job_name: docker
    docker_sd_configs:
      - host: unix:///var/run/docker.sock
    relabel_configs:
      - source_labels: [__meta_docker_container_name]
        target_label: container

• server : Configure le serveur HTTP et gRPC pour Promtail.
  • http_listen_port: 9080 : Le port HTTP sur lequel Promtail écoute.
  • grpc_listen_port: 0 : Le port gRPC, désactivé ici.
• positions : Fichier où Promtail stocke les positions des logs déjà lus.
  • filename: /tmp/positions.yaml : Chemin du fichier de positions.
• clients : Configuration des clients pour envoyer les logs à Loki.
  • url: http://localhost:3100/loki/api/v1/push ↗ : URL de Loki où les logs sont envoyés.
• scrape_configs : Configuration de la collecte des logs.
  • job_name: system : Nom du job de collecte.
    • static_configs : Configuration statique pour les cibles de collecte.
      • targets : Cibles de collecte, ici localhost.
      • labels : Labels appliqués aux logs collectés.
        • job: varlogs : Label indiquant le job de collecte.
        • path: /var/log//*.log** : Chemin des fichiers journaux à collecter.
  • job_name: docker : Nom du job pour la collecte des logs Docker.
    • docker_sd_configs : Configuration de la découverte automatique des conteneurs Docker.
      • host: unix:///var/run/docker.sock : Socket Docker pour la découverte des conteneurs.
    • relabel_configs : Configuration pour réétiqueter les logs.
      • source_labels: [__meta_docker_container_name] : Utilise le nom du conteneur Docker comme label.
      • target_label: container : Applique le label container avec la valeur du nom du conteneur.

Vérification de l’Ingestion

Après avoir configuré et lancé votre agent d’ingestion, vous pouvez vérifier que les logs sont correctement ingérés par Loki en consultant l’interface de Grafana et en utilisant le langage de requête LogQL pour rechercher et analyser les logs.

1. Ajouter Loki comme Source de Données :
   • Dans le panneau de gauche, cliquez sur l’icône Gear (Configuration) puis sur Data Sources.
   • Cliquez sur le bouton Add data source.
   • Recherchez et sélectionnez Loki.
   • Configurez les paramètres de la source de données :
     • URL : http://ip:3100
     • Access : Server
   • Cliquez sur Save & Test pour valider la configuration.

Une fois Loki ajouté comme source de données, vous pouvez créer des tableaux de bord pour visualiser les logs.

1. Créer un Nouveau Tableau de Bord :

   • Cliquez sur l’icône Plus (Add) dans le panneau de gauche puis sur Dashboard.
   • Cliquez sur Add new panel pour ajouter un nouveau panneau de visualisation.

2. Configurer le Panneau :

   • Dans le champ Query, sélectionnez Loki comme source de données.
   • Utilisez le langage de requête LogQL pour interroger les logs. Par exemple, pour afficher tous les logs du job varlogs :

     {job="varlogs"}

   • Vous pouvez affiner la requête en ajoutant des filtres. Par exemple, pour afficher uniquement les logs contenant le mot “error” :

     {job="varlogs"} |= "error"

   • Configurez le panneau de visualisation selon vos besoins (type de graphique, intervalle de temps, etc.).

3. Enregistrer le Tableau de Bord :

   • Une fois le panneau configuré, cliquez sur Apply pour enregistrer le panneau.
   • Cliquez sur Save dashboard pour enregistrer le tableau de bord entier. Donnez-lui un nom et cliquez sur Save.

Langage LogQL

LogQL est le langage de requête de Loki, inspiré par PromQL de Prometheus. Il permet de filtrer, d’analyser et de manipuler les logs de manière flexible et puissante. Voici une explication détaillée de LogQL basée sur la documentation officielle.

LogQL se divise en deux types principaux de requêtes : les requêtes de log et les requêtes de métriques dérivées des logs.

Requêtes de Log

Les requêtes de log récupèrent les entrées de log brutes :

1. Sélection de Labels : Les logs sont filtrés par labels, encapsulés entre accolades {}. Les labels sont des paires clé-valeur.

{app="backend", level="error"}

2. Filtrage par Mot-Clé : Pour filtrer les logs contenant un certain mot ou phrase, utilisez |=.

   {job="api"} |= "error"

3. Exclusion de Mot-Clé : Pour exclure les logs contenant un certain mot ou phrase, utilisez !=.

   {job="api"} != "debug"

4. Expressions Régulières : Utilisez |~ pour filtrer avec des expressions régulières et !~ pour exclure.

   {job="api"} |~ "timeout|timed out"

Requêtes de Métriques

Les requêtes de métriques sont utilisées pour calculer des statistiques à partir des logs :

1. Compter les Occurrences : count_over_time compte les entrées de log sur une période spécifiée.

   count_over_time({job="api"} |= "error"[5m])

2. Taux de Logs : rate calcule le taux de logs par seconde.

   rate({job="api"}[5m])

3. Somme, Moyenne, Min, Max : Vous pouvez utiliser sum_over_time, avg_over_time, min_over_time et max_over_time pour obtenir des statistiques sur les logs.

   avg_over_time({job="api"} |= "error"[5m])

Opérateurs

Les opérateurs permettent de combiner plusieurs expressions LogQL :

1. Addition, Soustraction :

   sum(rate({app="backend"}[5m])) + sum(rate({app="frontend"}[5m]))

2. Division, Multiplication :

   rate({app="backend"}[5m]) / rate({app="frontend"}[5m])

Fonctions Utiles

1. Histogramme : histogram_over_time crée un histogramme des valeurs sur une période.

   histogram_over_time({job="api"} |= "error"[1h])

2. TopK : topk sélectionne les k meilleurs résultats.

   topk(5, sum(rate({job="api"}[5m])) by (instance))

Exemples Combinés

Voici quelques exemples combinant plusieurs concepts :

1. Taux d’Erreurs par Instance :

   rate({job="api", level="error"}[5m]) by (instance)

2. Comptage d’Erreurs par Instance et par Application :

   sum by (instance, app) (count_over_time({level="error"}[5m]))

3. Taux de Logs Multipliés par un Facteur :

   rate({job="api"}[5m]) * 2

Utilisation de logcli

logcli est un outil en ligne de commande pour interagir avec Loki. Il permet d’exécuter des requêtes LogQL et de gérer les logs directement depuis le terminal.

Installation de logcli

Pour installer logcli, vous pouvez télécharger le binaire précompilé depuis le site officiel de Loki ↗. Voici comment l’installer sur un système Unix :

wget https://github.com/grafana/loki/releases/download/v2.9.8/logcli-linux-amd64.zip
unzip logcli-linux-amd64.zip
sudo mv logcli-linux-amd64 /usr/local/bin/logcli
chmod +x /usr/local/bin/logcli

Configuration de logcli

Avant d’utiliser logcli, configurez-le pour pointer vers votre instance Loki. Vous pouvez le faire en utilisant des variables d’environnement ou en fournissant les paramètres de connexion directement dans les commandes.

Exemple de configuration via des variables d’environnement :

export LOKI_ADDR=http://localhost:3100

Utilisation de base de logcli

Voici quelques commandes de base pour utiliser logcli :

Pour exécuter une requête LogQL simple et afficher les résultats dans le terminal :

logcli query '{job="varlogs"} |= "error"'

Vous pouvez spécifier une plage de temps pour la requête en utilisant les options --since et --until :

logcli query '{job="varlogs"} |= "error"' --since=1h

Pour exporter les logs dans un fichier :

logcli query '{job="varlogs"} |= "error"' --since=1h --output=json > logs.json

Pour suivre les logs en temps réel, utilisez l’option --tail :

logcli query '{job="varlogs"}' --tail

logcli supporte différents formats de sortie comme json, raw et logfmt :

logcli query '{job="varlogs"}' --since=1h --output=raw

Pour limiter le nombre de lignes de logs retournées :

logcli query '{job="varlogs"}' --limit=100

Bonnes Pratiques pour Utiliser Loki et LogQL

Pour tirer le meilleur parti de Loki, il est important de suivre certaines bonnes pratiques. Voici des recommandations pour optimiser l’utilisation de Loki et assurer une gestion efficace des logs.

Utilisation des Labels

• Définissez des labels pertinents : Utilisez des labels significatifs pour organiser vos logs. Les labels doivent refléter des attributs importants comme le nom de l’application, l’environnement (prod, dev) et le niveau de journalisation (error, info).
• Évitez les labels à haute cardinalité : Des labels avec trop de valeurs uniques (comme des identifiants de requêtes) peuvent ralentir les performances. Utilisez-les avec parcimonie.

Configuration de Loki

• Optimisez la rétention des logs : Configurez une rétention des logs appropriée pour éviter d’accumuler trop de données inutiles. Utilisez la section limits_config pour définir des politiques de rétention claires.
• Surveillez les ressources : Loki peut consommer beaucoup de ressources, surtout dans des environnements à haute charge. Utilisez des outils de monitoring pour surveiller l’utilisation de la mémoire et du CPU.

Sécurité

• Restreignez l’accès : Utilisez des mécanismes d’authentification et d’autorisation pour protéger l’accès à vos logs. Loki doit être configuré pour n’accepter les requêtes que des sources de confiance.
• Chiffrez les communications : Utilisez HTTPS pour sécuriser les communications entre les clients (comme Promtail) et Loki, ainsi qu’entre Loki et Grafana.

Maintenance

• Planifiez des sauvegardes régulières : Assurez-vous de sauvegarder régulièrement vos configurations et vos données de logs importantes pour prévenir la perte de données.
• Mettez à jour régulièrement : Maintenez Loki et Grafana à jour pour bénéficier des dernières fonctionnalités et corrections de bugs. Suivez les notes de version pour connaître les changements importants.

Conclusion

Loki est donc une solution puissante et flexible pour la gestion des logs, particulièrement bien adaptée aux environnements DevOps modernes. Grâce à son intégration avec Prometheus et Grafana, Loki permet de centraliser, analyser et visualiser les logs de manière efficace. En suivant les bonnes pratiques et en utilisant LogQL pour interroger les logs, vous pouvez extraire des informations précieuses et optimiser la performance de vos systèmes.

Plus d’infos

• Site officiel de Loki ↗
• Documentation de Loki ↗