Aller au contenu principal

Grafana Loki

Overview​

Loki, c'est le système de logging développé par Grafana qui pense "comme Prometheus, mais pour les logs". Contrairement aux solutions traditionnelles qui indexent tout le contenu des logs, Loki n'indexe que les métadonnées (labels), ce qui le rend incroyablement efficace en termes de stockage et de performance. Si tu veux du logging moderne, scalable et peu gourmand, c'est parfait.

Loki s'intègre nativement avec l'écosystème Grafana (Grafana, Prometheus, Alertmanager) et utilise le même langage de requête LogQL que PromQL. Architecture multi-tenant, compression avancée, stockage object (S3, GCS, Azure), ça scale horizontalement sans problème.

Loki se distingue par son approche "labels-first" (pas d'indexation full-text, juste les métadonnées), sa scalabilité horizontale native (architecture micro-services), et son intégration parfaite avec Grafana (tu vois tes logs dans le même dashboard que tes métriques).

Informations essentielles​

PropriétéValeur
Site officielhttps://grafana.com/oss/loki/
Repositoryhttps://github.com/grafana/loki
LicenceApache 2.0
DéveloppeurGrafana Labs
LangageGo
StockageLocal, S3, GCS, Azure Blob Storage

Fonctionnalités principales​

Architecture moderne​

  • Composants découplés (distributors, ingesters, queriers)
  • Scalabilité horizontale native
  • Multi-tenant avec isolation des données
  • Haute disponibilité avec réplication
  • Support clustering et load balancing

Efficacité du stockage​

  • Indexation uniquement des labels (pas du contenu)
  • Compression avancée des logs
  • Stockage par chunks avec retention flexible
  • Déduplication automatique
  • Support object storage (S3, GCS, Azure)

Langage de requête LogQL​

  • Syntaxe similaire à PromQL
  • Filtrage par labels et expressions régulières
  • Fonctions d'agrégation et calculs de métriques
  • Requêtes temporelles et historiques
  • Alerting basé sur les logs

Intégrations natives​

  • Grafana Dashboard intégré
  • Promtail pour la collecte de logs
  • Support Kubernetes avec annotations automatiques
  • Intégration avec Prometheus et Alertmanager
  • APIs REST pour intégration custom

Cas d'usage​

  • Observabilité moderne : Logging scalable pour infrastructures cloud-native
  • Corrélation metrics/logs : Voir logs et métriques dans le même dashboard
  • Debugging distribué : Tracer les problèmes dans des architectures microservices
  • Compliance : Centraliser et archiver les logs pour audit
  • Monitoring application : Alerting basé sur les patterns de logs

Installation​

Via Docker Compose​

version: '3'
services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml
    volumes:
      - ./loki-config.yml:/etc/loki/local-config.yaml

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log:ro
      - ./promtail-config.yml:/etc/promtail/config.yml
    command: -config.file=/etc/promtail/config.yml

Via Helm (Kubernetes)​

helm repo add grafana https://grafana.github.io/helm-charts
helm install loki grafana/loki-stack \
  --set grafana.enabled=true \
  --set prometheus.enabled=true

Via binaire​

# Télécharger et démarrer Loki
curl -O -L "https://github.com/grafana/loki/releases/latest/download/loki-linux-amd64.zip"
unzip loki-linux-amd64.zip
./loki-linux-amd64 -config.file=loki-local-config.yaml

Utilisation basique​

Configuration Promtail pour collecte​

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

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

scrape_configs:
  - job_name: system
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*log

Requêtes LogQL dans Grafana​

# Logs d'une application spécifique
{job="myapp"} |= "error"

# Agrégation - taux d'erreurs par minute  
rate({job="myapp"} |= "error" [1m])

# Filtrage avec regex
{job="myapp"} |~ "user [0-9]+ login"

# Métriques extraites des logs
sum(rate({job="nginx"} | json | status_code="500" [5m])) by (server)

API REST​

# Envoyer des logs via API
curl -H "Content-Type: application/json" -XPOST -s "http://localhost:3100/loki/api/v1/push" \
  --data-raw '{"streams": [{"stream": {"job": "test"}, "values": [["'$(date +%s%N)'", "test log message"]]}]}'

# Requête via API
curl -G -s "http://localhost:3100/loki/api/v1/query" \
  --data-urlencode 'query={job="test"}' | jq

Avantages​

  • ✅ Efficacité du stockage : indexation labels uniquement, stockage optimisé, ça prend moins de place
  • ✅ Scalabilité native : architecture horizontale, ça scale sans limite
  • ✅ Intégration Grafana : logs et métriques dans le même dashboard, tout est corrélé
  • ✅ LogQL puissant : langage de requête expressif, si tu connais PromQL c'est pareil
  • ✅ Multi-tenant : isolation des données, parfait pour les environnements partagés

Limitations​

  • Courbe d'apprentissage pour LogQL si tu viens d'ELK : mais c'est similaire à PromQL
  • Pas de recherche full-text traditionnelle : mais les labels couvrent la plupart des besoins
  • Configuration plus complexe que des solutions monolithiques : mais plus flexible

Alternatives​

  • Elasticsearch + Kibana : Solution traditionnelle avec indexation full-text
  • Fluentd + Elasticsearch : Stack de logging classique
  • Splunk : Solution enterprise propriétaire
  • Vector : Alternative moderne axée performance

Ressources​