Docker : Installer et Exécuter Grafana Loki

Introduction

Grafana Loki est un système d'agrégation de logs hautement disponible, multi-tenant et scalable horizontalement, inspiré par Prometheus. Il est conçu pour être très rentable et facile à opérer. Contrairement à d'autres systèmes de journalisation, Loki n'indexe pas le contenu des logs, mais plutôt un ensemble d'étiquettes (labels) pour chaque flux de logs.

Dans ce laboratoire, vous effectuerez une installation de base de Grafana Loki en utilisant son image Docker officielle. Vous apprendrez à créer un fichier de configuration minimal et à lancer le service Loki en tant que conteneur. C'est la première étape fondamentale pour construire une pile de journalisation complète avec Loki.

Tirer l'Image Docker de Loki

Dans cette étape, vous allez télécharger l'image Docker officielle de Grafana Loki depuis Docker Hub. La commande docker pull récupère une image ou un dépôt depuis un registre. Votre environnement de laboratoire a déjà Docker installé et configuré.

Exécutez la commande suivante dans le terminal pour tirer l'image Loki la plus récente :

docker pull grafana/loki

Vous verrez une sortie indiquant la progression du téléchargement. Docker tirera l'image avec le tag latest par défaut.

Sortie attendue (les numéros de version peuvent varier) :

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

Créer le Fichier loki-config.yaml de Base

Dans cette étape, vous allez créer un fichier de configuration minimal pour Loki. Ce fichier, loki-config.yaml, indique à Loki comment s'exécuter, où stocker les données et quel schéma utiliser. Pour ce laboratoire, nous allons configurer Loki pour utiliser le système de fichiers local pour le stockage.

Nous utiliserons l'éditeur de texte nano pour créer le fichier. Exécutez la commande suivante pour ouvrir un nouveau fichier nommé loki-config.yaml :

nano loki-config.yaml

Maintenant, copiez et collez le contenu YAML suivant dans l'éditeur nano :

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

Cette configuration maintient tout ce dont Loki a besoin sous /tmp/loki à l'intérieur du conteneur, ce qui évite les problèmes de permissions et rend la configuration facile à comprendre. Elle désactive l'authentification, active un anneau en mémoire (inmemory ring) pour une utilisation sur un seul nœud, et stocke les blocs et les index sur le système de fichiers local.

Voici ce que fait chaque section du fichier :

auth_enabled: false: Désactive l'authentification afin que vous puissiez communiquer avec Loki sans identifiants supplémentaires. Cela simplifie les tests locaux ; vous activeriez l'authentification en production.
server.http_listen_port: 3100: Indique à Loki d'écouter les requêtes HTTP sur le port 3100. Lorsque vous utilisez curl localhost:3100, vous atteignez ce port.
common.path_prefix: Définit le dossier de base où Loki stocke les données temporaires à l'intérieur du conteneur. Chaque autre chemin dans ce fichier est construit à partir de /tmp/loki pour que tout reste au même endroit.
common.storage.filesystem: Indique à Loki deux dossiers pour stocker les morceaux (chunks) de données de logs et les fichiers de règles. Comme nous ne montons rien de spécial dans le conteneur, l'utilisation de /tmp/loki évite les problèmes de permissions.
common.ring.kvstore.store: inmemory: Conserve les informations d'appartenance en mémoire. Pour un laboratoire sur un seul nœud, c'est parfait ; un vrai cluster utiliserait un magasin partagé comme Consul ou etcd.
schema_config: Définit comment Loki doit organiser l'index pour les données de logs. Nous fixons une date de début, choisissons le magasin boltdb-shipper, et gardons l'index sur le système de fichiers. Le prefix et la period contrôlent comment les fichiers sont nommés et à quelle fréquence un nouveau fichier d'index est créé (toutes les 24 heures).
storage_config: Fournit les dossiers exacts pour l'index boltdb-shipper (active_index_directory et cache_location) et pour le stockage des blocs bruts. Tous les chemins résident à nouveau sous /tmp/loki pour garder les choses ordonnées.
ruler.alertmanager_url: Prépare le composant ruler de Loki à envoyer des alertes à un Alertmanager à http://localhost:9093. Rien ne cassera si Alertmanager n'est pas en cours d'exécution ; Loki enregistrera simplement un avertissement lorsqu'il tentera d'envoyer une alerte.
limits_config.allow_structured_metadata: false: Désactive une fonctionnalité avancée afin que Loki s'en tienne aux métadonnées de logs en texte brut plus simples auxquelles les débutants s'attendent.

Appuyez sur Ctrl+X pour quitter, puis Y pour confirmer l'enregistrement, et enfin Enter pour sauvegarder le fichier sous le nom loki-config.yaml.

Exécuter le Conteneur Loki sur le Port 3100 avec Configuration

Maintenant que vous avez l'image Loki et un fichier de configuration, vous allez exécuter Loki en tant que conteneur Docker. Vous utiliserez la commande docker run pour démarrer le conteneur, monter votre fichier de configuration et exposer le port nécessaire.

Exécutez la commande suivante :

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

Décortiquons cette commande :

-d: Exécute le conteneur en mode détaché (en arrière-plan).
--name loki: Attribue le nom loki au conteneur pour une référence facile.
-v $(pwd)/loki-config.yaml:/etc/loki/config.yml: Monte votre fichier local loki-config.yaml dans le conteneur à l'emplacement /etc/loki/config.yml. Loki lira sa configuration à partir de ce fichier.
-p 3100:3100: Mappe le port 3100 de la machine hôte au port 3100 à l'intérieur du conteneur, vous permettant d'accéder à l'API Loki.
grafana/loki: L'image à utiliser pour le conteneur.
-config.file=/etc/loki/config.yml: Un argument de ligne de commande passé au processus Loki, lui indiquant où trouver le fichier de configuration.

Après avoir exécuté la commande, Docker affichera l'identifiant unique du conteneur nouvellement créé.

e8a9f2b1c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0

Vérifier le Point de Terminaison 'Ready' de Loki à localhost:3100/ready

Dans cette étape, vous allez effectuer une vérification d'état (health check) pour confirmer que le serveur Loki est démarré et fonctionne correctement. Loki expose un point de terminaison HTTP /ready qui peut être utilisé à cette fin. Une réponse réussie indique que le serveur est prêt à recevoir des requêtes.

Utilisez la commande curl pour envoyer une requête à ce point de terminaison. Puisque nous avons mappé le port 3100 à l'étape précédente, vous pouvez y accéder via localhost:3100.

curl http://localhost:3100/ready

Si Loki a démarré avec succès, il répondra par le texte ready et un code d'état HTTP 200 OK.

Sortie attendue :

ready

Vérifier les Journaux de Loki pour Confirmation de Démarrage

Une autre façon de vérifier que Loki a démarré avec succès est d'inspecter les journaux (logs) de son conteneur. Ceci est utile pour déboguer des problèmes de configuration ou d'autres problèmes de démarrage. La commande docker logs récupère les journaux d'un conteneur.

Utilisez la commande suivante pour visualiser les journaux de votre conteneur loki :

docker logs loki

Vous devriez voir une sortie détaillant le processus de démarrage. Recherchez une ligne confirmant que le serveur écoute les connexions. Cela confirme que le service s'est initialisé sans erreurs critiques.

Extrait de sortie attendu (les détails des journaux peuvent varier) :

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"

Résumé

Félicitations ! Vous avez terminé avec succès ce laboratoire (lab).

Dans ce laboratoire, vous avez appris les étapes fondamentales pour démarrer une instance de Grafana Loki. Vous avez :

Tiré (pulled) l'image Docker officielle de Loki depuis Docker Hub.
Créé un fichier loki-config.yaml de base pour définir les paramètres du serveur et du stockage (storage).
Lancé Loki dans un conteneur Docker, en montant le fichier de configuration et en exposant le port de l'API.
Vérifié que l'instance Loki est en cours d'exécution et saine en utilisant son point de terminaison /ready et en consultant ses journaux de conteneur.

Cette configuration de base est le fondement pour construire une architecture de journalisation (logging) plus complexe et robuste. À partir de là, vous pourriez passer à la configuration d'un agent d'envoi de journaux comme Promtail pour envoyer des journaux à Loki et utiliser Grafana pour les interroger et les visualiser.

Installation de Loki