prometheus-grafana

name	prometheus-grafana
description	Monitoring & observabilité — Prometheus pour la collecte de métriques, Alertmanager pour les alertes, Grafana pour les dashboards, Loki pour les logs, bonnes pratiques SRE
version	1.0.0
author	EVA
license	Privée EVA
category	mlops
metadata	{"EVA":{"tags":["prometheus","grafana","monitoring","alerting","metrics","dashboards","loki","alertmanager","observabilité","sre"],"related_skills":["kubernetes-avance","docker-avance","ansible-automation","ci-cd-pipelines"]}}

Prometheus & Grafana — Monitoring & Observabilité

Vue d'ensemble

Prometheus (collecte de métriques) + Grafana (visualisation) + Alertmanager (notifications) forment la stack de monitoring standard dans l'écosystème cloud-native. Cette compétence couvre l'installation, la configuration, l'écriture de règles d'alerte, la création de dashboards, l'intégration Loki pour les logs, et les patterns SRE (Service Level Objectives).

Quand l'utiliser

• Monitorer les métriques d'infrastructure (CPU, RAM, disque, réseau)
• Surveiller des applications custom avec endpoints Prometheus
• Créer des dashboards Grafana pour visualiser les KPIs
• Mettre en place des alertes (Slack, PagerDuty, Telegram, email)
• Centraliser les logs avec Loki et les corréler aux métriques
• Définir des SLO/SLI/SLA et suivre les burn rates

---

1. Architecture Stack

Applications
    │ (métriques HTTP /metrics)
    ▼
Prometheus Server ──► Alertmanager ──► Slack / Telegram / PagerDuty
    │                     ▲
    │ scrape               │
    ▼                     │
TSDB (local)             │
    │                     │
    ▼  (PromQL)           │
Grafana ◄────────────────┘
    │
    ▼
Loki (logs) ← Promtail (agents log)

---

2. Installation (Docker Compose)

# monitoring/docker-compose.yml
version: "3.8"

networks:
  monitoring:
    driver: bridge

volumes:
  prometheus_data:
  grafana_data:
  loki_data:

services:
  prometheus:
    image: prom/prometheus:v2.55
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
      - '--web.enable-lifecycle'
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - ./rules/:/etc/prometheus/rules/
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - monitoring

  alertmanager:
    image: prom/alertmanager:v0.27
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'
    
       
    
       
    
       

  
     
    
       
       
       
    
       
       
       
    
       
    
       
    
       

  
     
    
       
       
     
    
       
    
       

  
     
     
    
       
       
    
       
    
       

  
     
     
    
       
       
       
    
       

---

3. Configuration Prometheus

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    cluster: 'eva'
    env: 'production'

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

rule_files:
  - '/etc/prometheus/rules/*.yml'

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node'
    static_configs:
      - targets:
          - 'node-exporter:9100'
          - '192.168.1.10:9100'  # Serveur distant

  - job_name: 'docker'
    static_configs:
      - targets: ['host.docker.internal:9323']  # Docker Engine metrics

  - job_name: 'cadvisor'
    static_configs:
      - targets: []

    
    
        []  

    
    
        []  

    
     
    
        []

---

4. Règles d'Alerte

# rules/alerts.yml
groups:
  - name: infrastructure
    interval: 30s
    rules:
      - alert: NodeDown
        expr: up{job="node"} == 0
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Nœud {{ $labels.instance }} down"
          description: "Le nœud {{ $labels.instance }} est injoignable depuis 5 minutes."

      - alert: HighCPUUsage
        expr: 100 - (avg by(instance)(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 90
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU > 90% sur {{ $labels.instance }}"
          description: "CPU à {{ $value | humanizePercentage }} depuis 10 min."

        
                 
         
        
           
        
           

        
               
         
        
           
        
           
           

        
           
         
        
           
        
           
           

    
     
    
        
            
         
        
           
        
           
           

        
                
         
        
           
        
           
           

        
           
         
        
           
        
           

    
     
    
        
                  
        
           
        
           

---

5. Alertmanager

# alertmanager.yml
global:
  resolve_timeout: 5m
  slack_api_url: 'https://hooks.slack.com/services/T00/B00/xxx'
  telegram_api_url: 'https://api.telegram.org'

route:
  receiver: 'default'
  group_by: [alertname, cluster, severity]
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h

  routes:
    - match:
        severity: critical
      receiver: 'critical'
      repeat_interval: 1h

    - match:
        severity: page
      receiver: 'pagerduty'

receivers:
  - name: 'default'
    telegram_configs:
      - bot_token: ${TELEGRAM_BOT_TOKEN}
        chat_id: ${TELEGRAM_CHAT_ID}
        parse_mode: HTML
        message: |
          <b>{{ .GroupLabels.alertname }}</b>
          Sévérité : {{ .CommonLabels.severity }}
          {{ range .Alerts }}
          • {{ .Annotations.summary }}
          {{ end }}

  -  
    
        
         
         
         

    
    
        
         

---

6. Dashboards Grafana (Datasources provisionnées)

# grafana/datasources/datasource.yml
apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    jsonData:
      timeInterval: "15s"

  - name: Loki
    type: loki
    access: proxy
    url: http://loki:3100

  - name: PostgreSQL
    type: postgres
    url: db:5432
    database: eva
    user: grafana
    secureJsonData:
      password: ${DB_PASSWORD}
    jsonData:
      sslmode: disable

Exemple de dashboard JSON (Node Exporter Full)

{
  "title": "Infrastructure - Nœud {{instance}}",
  "tags": ["infrastructure", "node-exporter"],
  "panels": [
    {
      "title": "CPU Usage",
      "type": "timeseries",
      "datasource": "Prometheus",
      "targets": [{
        "expr": "100 - (avg by(cpu)(rate(node_cpu_seconds_total{mode=\"idle\", instance=~\"$instance\"}[5m])) * 100)",
        "legendFormat": "CPU {{cpu}}"
      }]
    },
    {
      "title": "Memory",
      "type": "gauge",
      "targets": [
         
      
       
         
         
         
             
             
             
        
      
    
    
       
       
       
         
         
      
    
  

---

7. Loki & Promtail (Logs)

# loki-config.yaml
auth_enabled: false
server:
  http_listen_port: 3100
  grpc_listen_port: 9095

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

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

storage_config:
  tsdb_shipper:
    active_index_directory: /loki/index
    cache_location: /loki/cache
  filesystem:
    directory: /loki/chunks

compactor:
  working_directory: /loki/compactor
  retention_enabled: true
  retention_delete_delay: 2h

limits_config:
  retention_period: 90d
  ingestion_rate_mb: 10

# promtail-config.yaml
server:
  http_listen_port: 9080
  grpc_listen_port: 9095

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

  - job_name: docker
    pipeline_stages:
      - docker: {}
    static_configs:
      - targets: [localhost]
        labels:
          job: docker
          __path__: /var/lib/docker/containers/*/*-json.log

---

8. Pièges Courants

1. Rétention trop courte : 7 jours par défaut. En production, 30 jours minimum (--storage.tsdb.retention.time=30d).
2. Trop de métriques cardinales : Des labels comme request_id ou user_email explosent la cardinalité. Éviter les labels uniques.
3. Sondes Alertmanager sans groupement : 100 alertes par seconde pour un même incident submerge tout le monde. Grouper par alertname, cluster.
4. Dashboard sans variables : Un dashboard codé en dur pour un serveur ne sert à rien pour 50 serveurs. Ajouter des variables $instance, $job.
5. Promtail lit tout Docker : Sans filtrage, promtail ingère les logs de TOUS les conteneurs, même ceux non monitorés. Filtrer par label.
6. Absence de scrape targets : promtool check config prometheus.yml ne vérifie pas la résolution DNS. Tester avec curl http://target:9090/metrics.

---

9. SLO / SLI / SLA — Patterns SRE

# Exemple : SLO 99.9% de disponibilité API sur 30 jours
groups:
  - name: slo
    rules:
      - record: job:slo_errors_total:ratio_rate1h
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[1h]))
          /
          sum(rate(http_requests_total[1h]))

      - record: job:slo_burn_rate
        expr: |
          job:slo_errors_total:ratio_rate1h / (1 - 0.999)

      - alert: SLOWarning
        expr: job:slo_burn_rate > 1
        for: 1h
        labels:
          severity: warning
        annotations:
          summary: "Burn rate SLO > 1x (atteindra le budget en 30j)"

---

10. Checklist Production

• Rétention Prometheus configurée (≥30 jours)
• Règles d'alerte testées avec promtool test rules rules/alerts.yml
• Alertmanager avec groupement et répétition raisonnable
• Notifications configurées (Slack/Telegram/PagerDuty)
• Dashboards Grafana avec variables réutilisables ($instance, $job)
• Datasources provisionnées automatiquement
• Loki configuré avec rétention (≥90 jours)
• Promtail ne suit que les logs pertinents
• SLO définis et alertés (burn rate alerts)
• promtool check config intégré au CI