prometheus-configuration

Par wshobson · agents

Configurez Prometheus pour la collecte, le stockage et la surveillance complète des métriques d'infrastructure et d'applications. À utiliser lors de la mise en place de la collecte de métriques, de l'infrastructure de monitoring ou de la configuration des systèmes d'alerte.

npx skills add https://github.com/wshobson/agents --skill prometheus-configuration

Configuration Prometheus

Guide complet de la configuration de Prometheus, de la collecte de métriques, de la configuration des scrapes et des règles d'enregistrement.

Objectif

Configurer Prometheus pour une collecte complète de métriques, une alerte et une surveillance de l'infrastructure et des applications.

Quand l'utiliser

  • Mettre en place la surveillance Prometheus
  • Configurer le scraping de métriques
  • Créer des règles d'enregistrement
  • Concevoir des règles d'alerte
  • Implémenter la découverte de services

Architecture Prometheus

┌──────────────┐
│ Applications │ ← Instrumentées avec des client libraries
└──────┬───────┘
       │ endpoint /metrics
       ↓
┌──────────────┐
│  Prometheus  │ ← Scrape les métriques périodiquement
│    Server    │
└──────┬───────┘
       │
       ├─→ AlertManager (alertes)
       ├─→ Grafana (visualisation)
       └─→ Stockage long terme (Thanos/Cortex)

Installation

Kubernetes avec Helm

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

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set prometheus.prometheusSpec.retention=30d \
  --set prometheus.prometheusSpec.storageVolumeSize=50Gi

Docker Compose

version: "3.8"
services:
  prometheus:
    image: prom/prometheus:v3.2
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--storage.tsdb.retention.time=30d"

volumes:
  prometheus-data:

Fichier de configuration

prometheus.yml :

global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    cluster: "production"
    region: "us-west-2"

# Configuration AlertManager
alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - alertmanager:9093

# Charger les fichiers de règles
rule_files:
  - /etc/prometheus/rules/*.yml

# Configurations de scrape
scrape_configs:
  # Prometheus lui-même
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  # Node exporters
  - job_name: "node-exporter"
    static_configs:
      - targets:
          - "node1:9100"
          - "node2:9100"
          - "node3:9100"
    relabel_configs:
      - source_labels: [__address__]
        target_label: instance
        regex: "([^:]+)(:[0-9]+)?"
        replacement: "${1}"

  # Pods Kubernetes avec annotations
  - job_name: "kubernetes-pods"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)
      - source_labels:
          [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
        action: replace
        regex: ([^:]+)(?::\d+)?;(\d+)
        replacement: $1:$2
        target_label: __address__
      - source_labels: [__meta_kubernetes_namespace]
        action: replace
        target_label: namespace
      - source_labels: [__meta_kubernetes_pod_name]
        action: replace
        target_label: pod

  # Métriques d'application
  - job_name: "my-app"
    static_configs:
      - targets:
          - "app1.example.com:9090"
          - "app2.example.com:9090"
    metrics_path: "/metrics"
    scheme: "https"
    tls_config:
      ca_file: /etc/prometheus/ca.crt
      cert_file: /etc/prometheus/client.crt
      key_file: /etc/prometheus/client.key

Référence : Voir assets/prometheus.yml.template

Configurations de scrape

Cibles statiques

scrape_configs:
  - job_name: "static-targets"
    static_configs:
      - targets: ["host1:9100", "host2:9100"]
        labels:
          env: "production"
          region: "us-west-2"

Découverte de services basée sur fichier

scrape_configs:
  - job_name: "file-sd"
    file_sd_configs:
      - files:
          - /etc/prometheus/targets/*.json
          - /etc/prometheus/targets/*.yml
        refresh_interval: 5m

targets/production.json :

[
  {
    "targets": ["app1:9090", "app2:9090"],
    "labels": {
      "env": "production",
      "service": "api"
    }
  }
]

Découverte de services Kubernetes

scrape_configs:
  - job_name: "kubernetes-services"
    kubernetes_sd_configs:
      - role: service
    relabel_configs:
      - source_labels:
          [__meta_kubernetes_service_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels:
          [__meta_kubernetes_service_annotation_prometheus_io_scheme]
        action: replace
        target_label: __scheme__
        regex: (https?)
      - source_labels: [__meta_kubernetes_service_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)

Référence : Voir references/scrape-configs.md

Règles d'enregistrement

Créer des métriques pré-calculées pour les expressions fréquemment interrogées :

# /etc/prometheus/rules/recording_rules.yml
groups:
  - name: api_metrics
    interval: 15s
    rules:
      # Taux de requêtes HTTP par service
      - record: job:http_requests:rate5m
        expr: sum by (job) (rate(http_requests_total[5m]))

      # Taux d'erreur
      - record: job:http_requests_errors:rate5m
        expr: sum by (job) (rate(http_requests_total{status=~"5.."}[5m]))

      - record: job:http_requests_error_rate:percentage
        expr: |
          (job:http_requests_errors:rate5m / job:http_requests:rate5m) * 100

      # Latence P95
      - record: job:http_request_duration:p95
        expr: |
          histogram_quantile(0.95,
            sum by (job, le) (rate(http_request_duration_seconds_bucket[5m]))
          )

  - name: resource_metrics
    interval: 30s
    rules:
      # Utilisation CPU en pourcentage
      - record: instance:node_cpu:utilization
        expr: |
          100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

      # Utilisation mémoire en pourcentage
      - record: instance:node_memory:utilization
        expr: |
          100 - ((node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100)

      # Utilisation disque en pourcentage
      - record: instance:node_disk:utilization
        expr: |
          100 - ((node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100)

Référence : Voir references/recording-rules.md

Règles d'alerte

# /etc/prometheus/rules/alert_rules.yml
groups:
  - name: availability
    interval: 30s
    rules:
      - alert: ServiceDown
        expr: up{job="my-app"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Le service {{ $labels.instance }} est indisponible"
          description: "{{ $labels.job }} est indisponible depuis plus d'une minute"

      - alert: HighErrorRate
        expr: job:http_requests_error_rate:percentage > 5
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Taux d'erreur élevé pour {{ $labels.job }}"
          description: "Le taux d'erreur est {{ $value }}% (seuil : 5%)"

      - alert: HighLatency
        expr: job:http_request_duration:p95 > 1
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Latence élevée pour {{ $labels.job }}"
          description: "La latence P95 est {{ $value }}s (seuil : 1s)"

  - name: resources
    interval: 1m
    rules:
      - alert: HighCPUUsage
        expr: instance:node_cpu:utilization > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilisation CPU élevée sur {{ $labels.instance }}"
          description: "L'utilisation CPU est {{ $value }}%"

      - alert: HighMemoryUsage
        expr: instance:node_memory:utilization > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Utilisation mémoire élevée sur {{ $labels.instance }}"
          description: "L'utilisation mémoire est {{ $value }}%"

      - alert: DiskSpaceLow
        expr: instance:node_disk:utilization > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Espace disque faible sur {{ $labels.instance }}"
          description: "L'utilisation disque est {{ $value }}%"

Validation

# Valider la configuration
promtool check config prometheus.yml

# Valider les règles
promtool check rules /etc/prometheus/rules/*.yml

# Tester une requête
promtool query instant http://localhost:9090 'up'

Référence : Voir scripts/validate-prometheus.sh

Bonnes pratiques

  1. Utiliser un nommage cohérent pour les métriques (prefix_nom_unité)
  2. Définir des intervalles de scrape appropriés (généralement 15-60s)
  3. Utiliser des règles d'enregistrement pour les requêtes coûteuses
  4. Implémenter la haute disponibilité (plusieurs instances Prometheus)
  5. Configurer la rétention en fonction de la capacité de stockage
  6. Utiliser le relabeling pour nettoyer les métriques
  7. Surveiller Prometheus lui-même
  8. Implémenter la fédération pour les grands déploiements
  9. Utiliser Thanos/Cortex pour le stockage long terme
  10. Documenter les métriques personnalisées

Dépannage

Vérifier les cibles de scrape :

curl http://localhost:9090/api/v1/targets

Vérifier la configuration :

curl http://localhost:9090/api/v1/status/config

Tester une requête :

curl 'http://localhost:9090/api/v1/query?query=up'

Compétences associées

  • grafana-dashboards - Pour la visualisation
  • slo-implementation - Pour la surveillance des SLO
  • distributed-tracing - Pour le traçage des requêtes

Skills similaires

cosmosdb-datamodeling
github / awesome-copilot

Concevoir un modèle de données Azure Cosmos DB NoSQL adapté aux besoins applicatifs.

32 867
rivetkit
rivet-dev / skills

Construire des processus en mémoire haute performance sur le runtime d'acteurs Rivet.

14
arize-instrumentation
github / awesome-copilot

Instrumenter une application avec le tracing Arize AX via une analyse guidée.

32 867
containerize-aspnet-framework
github / awesome-copilot

Conteneuriser une application ASP.NET Framework dans un conteneur Windows Docker.

32 867
axiom-sre
axiomhq / skills

Diagnostiquer et résoudre des incidents SRE avec rigueur data-driven et sans jamais exposer de secrets.

10