Skip to content
Learni
Voir tous les tutoriels
Observabilité

Comment installer Grafana Mimir en local en 2026

12 minBEGINNER
DockerGrafanaMimirPrometheusMonitoring
Read in English

Introduction

Grafana Mimir est une base de données de séries temporelles open-source, conçue pour stocker et interroger des métriques à long terme de manière hautement scalable, tout en restant 100% compatible avec Prometheus. Contrairement à Prometheus qui est limité en rétention (typiquement 2-15 jours), Mimir gère des pétaoctets de données sur des clusters distribués, avec sharding horizontal et réplication.

Pourquoi l'utiliser en 2026 ? Avec l'explosion des métriques cloud-native (Kubernetes, microservices), Mimir résout le goulot d'étranglement du stockage : imaginez Prometheus comme un vélo (rapide mais limité), Mimir comme un camion (capable de transporter des volumes massifs). Ce tutoriel beginner vous déploie une stack locale complète : Mimir en mode monolithique (pour simplicité), Prometheus pour ingestion, Node Exporter pour données réelles, et Grafana pour visualisation. À la fin, vous queryez des métriques avec 7 jours de rétention, scalables à l'infini. Temps estimé : 15 min. (128 mots)

Prérequis

  • Docker version 27+ et Docker Compose v2.29+ installés (vérifiez avec docker --version et docker compose version).
  • 4 Go RAM libres et 10 Go disque (pour données de test).
  • Connaissances basiques de Prometheus (concepts scrape/remote_write) et YAML.
  • Port 3000 (Grafana), 8080 (Mimir), 9090 (Prometheus), 9100 (Node Exporter) libres.
  • Terminal Unix-like (WSL sur Windows recommandé).

Étape 1 : Créer la structure de dossiers

Créez un dossier projet pour organiser les fichiers. Ouvrez un terminal et exécutez :

``bash
mkdir mimir-local && cd mimir-local
mkdir -p mimir grafana/provisioning/datasources prometheus
`

Cette arborescence sépare les configs : mimir/mimir.yaml pour Mimir, prometheus/prometheus.yml pour l'ingestion, grafana/provisioning/datasources/mimir.yml` pour Grafana auto-config. Cela évite les conflits de volumes Docker et facilite les backups.

Configurer Mimir (mode monolithique)

mimir/mimir.yaml
server:
  http_listen_port: 8080
  log_level: info

multitenancy_enabled: false

blocks_storage:
  backend: filesystem
  filesystem:
    dir: /data/blocks
  tsdb:
    dir: /data/tsdb

limits:
  ingestion_rate_mb: 4
  ingestion_burst_size_mb: 6
  retention_period: 168h  # 7 jours pour tests

api:
  enable_admin_endpoints: true

ruler_storage:
  backend: local
  local:
    directory: /data/ruler

alertmanager_storage:
  backend: filesystem
  filesystem:
    dir: /data/alertmanager

Cette config lance Mimir en mode monolithique (tout-en-un) avec stockage filesystem pour simplicité beginner. Les blocks sont conservés dans /data/blocks (compatible remote_write Prometheus), rétention 7 jours. Activez les endpoints admin pour /ready et métrics. Piège : Sans multitenancy=false, l'auth multi-tenant bloque les tests locaux.

Étape 2 : Vérifier la config Mimir

Placez ce fichier dans mimir/mimir.yaml. Mimir utilise un backend 'filesystem' pour les blocks (séries alignées TSDB), idéal pour dev. Analogie : Les 'blocks' sont comme des ZIP de métriques compactées, uploadées périodiquement par Prometheus. Cela permet une scalabilité future vers S3/MinIO sans changer de code.

Configurer Prometheus pour remote_write

prometheus/prometheus.yml
global:
  scrape_interval: 15s

remote_write:
  - url: http://mimir:8080/api/v1/push

scrape_configs:
  - job_name: mimir
    honor_labels: true
    static_configs:
      - targets: ['mimir:8080']
  - job_name: node
    honor_labels: true
    static_configs:
      - targets: ['node_exporter:9100']

rule_files: []

Prometheus scrape Mimir (ses propres métriques) et Node Exporter (CPU/RAM host), puis push vers Mimir via /api/v1/push. 'honor_labels: true' préserve les labels Prometheus. Piège : Sans remote_write, les données restent locales à Prometheus (volatiles). Vérifiez avec curl http://localhost:9090/api/v1/status/config après démarrage.

Étape 3 : Provisionner Grafana automatiquement

Grafana se configure seule au boot via provisioning. Cela évite les clics manuels : datasource 'Mimir' pointe sur http://mimir:8080/prometheus (endpoint compatible Prometheus). Login : admin/admin.

Datasource Grafana pour Mimir

grafana/provisioning/datasources/mimir.yml
apiVersion: 1

providers:
  - name: 'mimir-local'
    orgId: 1
    folder: ''
    type: file
    disableDeletion: false
    updateIntervalSeconds: 60
    allowUiUpdates: true

 datasources:
  - name: Mimir
    type: prometheus
    access: proxy
    orgId: 1
    url: http://mimir:8080/prometheus
    basicAuth: false
    isDefault: true
    version: 1
    editable: true

Ce YAML provisionne un datasource Prometheus pointant l'API Mimir. 'access: proxy' permet les queries depuis Grafana UI sans CORS issues. Piège : URL interne 'mimir:8080' (Docker network) ; exposez 8080 pour accès externe. Testez query up dans Grafana Explore.

Docker Compose : Stack complète

docker-compose.yml
version: '3.8'

services:
  mimir:
    image: grafana/mimir:2.14.1
    command:
      - '-config.file=/etc/mimir/mimir.yaml'
    ports:
      - '8080:8080'
    volumes:
      - ./mimir/mimir.yaml:/etc/mimir/mimir.yaml
      - mimir-data:/data
    networks:
      - mimir
    healthcheck:
      test: ['CMD', 'wget', '--no-verbose', '--tries=1', '--spider', 'http://localhost:8080/ready']
      interval: 10s
      timeout: 5s
      retries: 3

  prometheus:
    image: prom/prometheus:v2.53.1
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - '9090:9090'
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.enable-lifecycle'
    networks:
      - mimir
    depends_on:
      mimir:
        condition: service_healthy

  grafana:
    image: grafana/grafana:11.3.0
    ports:
      - '3000:3000'
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_USERS_ALLOW_SIGN_UP=false
    networks:
      - mimir
    depends_on:
      - prometheus

  node_exporter:
    image: prom/node-exporter:v1.8.2
    ports:
      - '9100:9100'
    networks:
      - mimir

volumes:
  mimir-data:
  grafana-data:

networks:
  mimir:
    driver: bridge

Ce Compose orchestre la stack : Mimir healthycheck sur /ready, Prometheus dépend de Mimir, Grafana provisionnée. Volumes persistants pour données (ne pas perdre blocks). Piège : Versions pinned pour stabilité ; mettez à jour image tags ensemble. depends_on assure l'ordre de boot.

Étape 4 : Lancer et vérifier la stack

Exécutez docker compose up -d (démon). Vérifiez logs : docker compose logs mimir. Accédez :

Vérifier avec curl (Mimir metrics)

terminal
#!/bin/bash

# Vérifier Mimir prêt
echo "Mimir ready:"
curl -s http://localhost:8080/ready | jq

# Query exemple : up jobs
curl -G -s http://localhost:8080/prometheus/api/v1/query \
  -d 'query=up' \
  --data-urlencode 'time=now' | jq '.data.result'

# Compter séries stockées (admin endpoint)
curl -s http://localhost:8080/admin/tsdb/series-count | jq

Ce script bash teste l'API Mimir : /ready confirme le boot, /prometheus/api/v1/query simule Grafana Explore, /admin/tsdb compte séries (ex: 100+ après 5 min). Installez jq pour pretty-print. Piège : Sans -G --data-urlencode, les params query échouent.

Bonnes pratiques

  • Persistance : Toujours volume /data pour blocks ; docker compose down sans --volumes garde les données.
  • Sécurité : En prod, activez multitenancy + auth (OAuth/JWT) ; limitez ports exposés.
  • Monitoring : Ajoutez Loki/Promtail pour logs ; scalez via Helm sur K8s.
  • Rétention : Testez blocks_storage.tsdb.retention à 90d+ ; monitorez 'mimir_tsdb_blocks_compactions_failed_total'.
  • Backup : Rsync /data/blocks vers S3 ; utilisez mimirtool pour snapshots.

Erreurs courantes à éviter

  • Mimir not ready : Logs montrent 'tsdb dir locked' → supprimez volumes orphelins (docker volume prune).
  • No data in Grafana : Vérifiez remote_write queue (prometheus_remote_storage_samples_pending) ; attendez 2min post-boot.
  • CORS/Proxy errors : Dans Grafana, 'access: proxy' + exposez 8080 ; testez curl depuis container (docker exec).
  • OOS après restart : Filesystem n'est pas distribué ; migrez vers S3/MinIO pour prod.

Pour aller plus loin