Grafana Loki : Centralisation des logs sans indexation

Vous cherchez vos logs sur 10 serveurs différents à chaque incident ? Loki centralise tous vos logs en un seul endroit et vous les rend accessibles via Grafana. Contrairement à Elasticsearch, Loki n’indexe pas le contenu des logs — il indexe uniquement les labels. Résultat : déploiement rapide, stockage réduit, coût maîtrisé.

En 15 minutes, vous aurez Loki qui collecte les logs de votre infrastructure, accessibles depuis Grafana avec le langage de requête LogQL.

Formation pratique disponible

Déployez Loki sur Kubernetes avec le TP05 — Loki et LogQL de notre formation observabilité.

Quickstart en 2 minutes

Docker

# Télécharger la config minimale
wget https://raw.githubusercontent.com/grafana/loki/main/cmd/loki/loki-local-config.yaml -O loki-config.yaml

# Lancer Loki
docker run -d --name loki \
  -p 3100:3100 \
  -v $(pwd)/loki-config.yaml:/etc/loki/config.yaml \
  grafana/loki:3.4.2 \
  -config.file=/etc/loki/config.yaml

# Vérifier
curl http://localhost:3100/ready

Kubernetes (Helm)

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

# Installation simple (mode monolithique)
helm install loki grafana/loki --namespace monitoring --create-namespace \
  --set loki.auth_enabled=false \
  --set singleBinary.replicas=1

Pour la production, utilisez plutôt loki-distributed ou le mode microservices.

Vérification : curl http://<loki-host>:3100/ready doit retourner ready.

Ce que Loki résout

Problème	Solution Loki
Logs éparpillés sur N serveurs	Centralisation avec Promtail/Alloy
Coût de stockage Elasticsearch	Pas d’indexation full-text = stockage réduit
Corrélation logs/métriques difficile	Mêmes labels que Prometheus
Apprentissage d’un nouveau langage	LogQL proche de PromQL

Glissez pour voir

Quand ne PAS utiliser Loki

Si vous avez besoin de recherche full-text avancée (analystes sécurité, audit réglementaire), Elasticsearch ou OpenSearch restent plus adaptés. Loki excelle pour le debugging opérationnel.

Architecture en 3 minutes

Loki fonctionne avec trois composants :

Composant	Rôle
Promtail / Alloy	Agent qui collecte les logs et les envoie à Loki
Loki	Stocke les logs, organise par labels, répond aux requêtes
Grafana	Interface de requête et visualisation

Glissez pour voir

Labels : la clé de Loki

Loki n’indexe pas le contenu des logs. Il les organise par labels (comme Prometheus).

{namespace="production", app="frontend", pod="frontend-abc123"}

Les labels permettent de :

• Filtrer rapidement (tous les logs de app=“frontend”)
• Corréler avec les métriques Prometheus (mêmes labels)
• Réduire les coûts (pas d’index massif)

LogQL : requêter vos logs

LogQL s’inspire de PromQL. Vous commencez par sélectionner les streams (via labels), puis vous filtrez le contenu.

Syntaxe de base

{label="valeur"}                    # Sélection par labels
{app="nginx"} |= "error"            # Contient "error"
{app="nginx"} |~ "5[0-9]{2}"        # Regex (codes 5xx)
{app="nginx"} != "healthcheck"      # Ne contient pas

Exemples concrets

# Toutes les erreurs du frontend en production
{namespace="production", app="frontend"} |= "error"

# Logs des 5 dernières minutes avec un code 500
{app="api"} |= "500" | json | status_code = 500

# Parser un log JSON et extraire des champs
{app="nginx"} | json | request_time > 1.0

# Compter les erreurs par minute
count_over_time({app="api"} |= "error" [1m])

Opérateurs LogQL

Opérateur	Description	Exemple
|=	Contient (exact)	|= “error”
!=	Ne contient pas	!= “healthcheck”
|~	Match regex	|~ “5[0-9]2”
~/go/bin/kroki convert /tmp/rclone-sync-diagram.excalidraw -f svg -o /home/bob/Projets/test-astro-5/src/assets/images/cloud/rclone-sync-vs-bisync.svg	Ne match pas regex	~/go/bin/kroki convert /tmp/rclone-sync-diagram.excalidraw -f svg -o /home/bob/Projets/test-astro-5/src/assets/images/cloud/rclone-sync-vs-bisync.svg “debug”
| json	Parse JSON	| json | level=“error”
| logfmt	Parse logfmt	| logfmt | duration > 100

Glissez pour voir

LogQL dans Grafana

Dans Grafana, utilisez l’éditeur de requêtes LogQL avec autocomplétion. Cliquez sur “Explore” → sélectionnez votre datasource Loki.

Installation de Promtail (agent de collecte)

Promtail collecte les logs de vos machines/conteneurs et les envoie à Loki.

Docker

# Créer la config Promtail
cat > promtail-config.yaml << 'EOF'
server:
  http_listen_port: 9080

positions:
  filename: /tmp/positions.yaml

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

scrape_configs:
  - job_name: containers
    docker_sd_configs:
      - host: unix:///var/run/docker.sock
        refresh_interval: 5s
    relabel_configs:
      - source_labels: ['__meta_docker_container_name']
        target_label: 'container'
EOF

# Lancer Promtail
docker run -d --name promtail \
  -v $(pwd)/promtail-config.yaml:/etc/promtail/config.yaml \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /var/log:/var/log \
  grafana/promtail:3.4.2 \
  -config.file=/etc/promtail/config.yaml

Kubernetes

# Promtail DaemonSet (collecte automatique des pods)
helm install promtail grafana/promtail \
  --namespace monitoring \
  --set config.clients[0].url=http://loki:3100/loki/api/v1/push

Promtail s’exécute sur chaque nœud et collecte automatiquement les logs stdout/stderr des pods.

Vérification :

# Vérifier que Promtail est actif
curl http://localhost:9080/ready

# Vérifier la réception dans Loki
curl http://localhost:3100/loki/api/v1/labels

Ajouter Loki dans Grafana

1. Accéder à Grafana : http://localhost:3000 (admin/admin)

2. Ajouter une datasource : Configuration → Data Sources → Add → Loki

3. Configurer l’URL : http://loki:3100 (ou l’IP de votre Loki)

4. Tester : Cliquez “Save & Test” — doit afficher “Data source connected”

5. Explorer : Allez dans Explore → sélectionnez Loki → tapez {job=~".+"} pour voir tous vos logs

Configuration avancée

Configuration Loki minimale (développement)

auth_enabled: false

server:
  http_listen_port: 3100

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

schema_config:
  configs:
    - from: 2024-01-01
      store: tsdb
      object_store: filesystem
      schema: v13
      index:
        prefix: index_
        period: 24h

storage_config:
  filesystem:
    directory: /loki/chunks

limits_config:
  retention_period: 168h  # 7 jours

Configuration production (S3)

schema_config:
  configs:
    - from: 2024-01-01
      store: tsdb
      object_store: s3
      schema: v13
      index:
        prefix: loki_index_
        period: 24h

storage_config:
  aws:
    s3: s3://eu-west-1/my-loki-bucket
    s3forcepathstyle: true
  tsdb_shipper:
    active_index_directory: /loki/tsdb-index
    cache_location: /loki/tsdb-cache

Dépannage

Symptôme	Cause probable	Solution
connection refused sur :3100	Loki non démarré	Vérifier docker logs loki
Pas de logs dans Grafana	Promtail ne push pas	Vérifier URL client dans promtail-config.yaml
rate limited dans Promtail	Trop de logs/labels	Augmenter limits_config.ingestion_rate_mb
Requêtes lentes	Trop de streams	Réduire la cardinalité des labels

Glissez pour voir

Piège cardinalité

N’utilisez jamais d’identifiants uniques (request_id, user_id) comme labels. Cela crée des millions de streams et dégrade les performances. Mettez ces données dans le contenu du log.

Bonnes pratiques

1. Labels statiques — namespace, app, pod, container. Pas d’IDs uniques.
2. Rétention adaptée — 7-14 jours pour le debug, archivez ailleurs si besoin légal.
3. Stockage objet en production — S3, GCS ou MinIO. Pas de filesystem pour la production.
4. Grafana Alloy — Le successeur de Promtail, unifie la collecte (métriques + logs + traces).

À retenir

• Loki centralise les logs sans les indexer complètement (économie de stockage)
• Labels = clé d’organisation (même philosophie que Prometheus)
• LogQL = proche de PromQL, facile si vous connaissez déjà Prometheus
• Promtail / Alloy = agents de collecte (DaemonSet sur Kubernetes)
• Cardinalité = ennemi n°1 (éviter les labels dynamiques)

Prochaines étapes

TP Loki sur Kubernetes Déployez Loki avec la loki-stack et explorez LogQL

Grafana Visualisez vos logs dans des dashboards

Corrélation logs/traces Liez vos logs aux traces distribuées

Prometheus Collectez les métriques avec la même philosophie de labels

Ressources

• Documentation officielle Loki
• Référence LogQL
• GitHub Loki
• Grafana Alloy (successeur de Promtail)

×

📖 Voir la documentation →