DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesSurveiller ses applications avec Prometheus et Grafana

Module

Surveillez vos applications avec Prometheus, Grafana, logs centralisés et alerting.

  • 1h30
  • Intermédiaire
  • 6 exercices
Voir les exercices

Formation 100 % Linux

Tous les modules nécessitent un environnement Linux. Si vous êtes sur Windows, installez d'abord WSL (Windows Subsystem for Linux) avant de continuer.

Surveiller ses applications avec Prometheus et Grafana

🎯 Objectifs

  • Comprendre les 3 piliers de l'observabilité
  • Collecter des métriques avec Prometheus
  • Visualiser avec Grafana
  • Configurer des alertes
  • Centraliser les logs

📖 Prérequis

  • Docker niveau intermédiaire
  • Kubernetes niveau débutant (recommandé)
  • Notions de réseau (HTTP, ports)

🤔 Pourquoi le Monitoring ?

💡 *"If you can't measure it, you can't improve it."* - Peter Drucker

Sans monitoring, vous êtes aveugle en production :

  • Détecter les problèmes avant vos utilisateurs
  • Comprendre les performances de vos applications
  • Planifier la capacité (scaling)
  • Diagnostiquer rapidement les incidents

📊 Les 3 Piliers de l'Observabilité

Métriques

Valeurs numériques mesurées dans le temps : CPU, RAM, latence, taux d'erreurs.

Logs

Événements textuels horodatés. Préférez les logs structurés (JSON).

Traces

Suivi d'une requête à travers plusieurs services (distributed tracing).

PilierExempleOutil typique
MétriquesCPU à 85%Prometheus
Logs{"level":"error","msg":"timeout"}Loki, ELK
TracesRequête → API → DB → CacheJaeger, Zipkin

🔥 Prometheus

Qu'est-ce que c'est ?

Système open-source de collecte de métriques et d'alerting. Prometheus tire (pull/scrape) les métriques depuis vos applications.

Architecture

Applications → /metrics endpoint
Prometheus  → scrape toutes les X secondes
             → stocke en time-series DB
AlertManager → envoie des notifications

Types de métriques

TypeUsageExemple
CounterValeur croissanteNombre total de requêtes
GaugeValeur variableTempérature CPU
HistogramDistributionLatence des requêtes
SummaryPercentilesTemps de réponse p95

PromQL - Requêtes essentielles

promql
# Taux de requêtes par seconde (5 min)
rate(http_requests_total[5m])

# Latence moyenne
avg(http_request_duration_seconds)

# Taux d'erreurs (%)
sum(rate(http_requests_total{status=~"5.."}[5m]))
/ sum(rate(http_requests_total[5m])) * 100

# Percentile 95 de latence
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))

Démarrage rapide (Docker Compose)

yaml
# docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
yaml
# prometheus.yml
scrape_configs:
  - job_name: "mon-app"
    static_configs:
      - targets: ["app:8080"]

📈 Grafana

Qu'est-ce que c'est ?

Plateforme de visualisation qui se connecte à Prometheus (et d'autres sources).

Fonctionnalités clés

  • Panels : graphes, jauges, tableaux, heatmaps
  • Variables : dashboards dynamiques (filtrer par environnement, service)
  • Alertes : notifications directement depuis Grafana
  • Import : dashboards communautaires prêts à l'emploi

Dashboards essentiels

DashboardID GrafanaUsage
Node Exporter Full1860Métriques système (CPU, RAM, disque)
Docker Monitoring893Conteneurs Docker
Kubernetes Cluster6417Cluster K8s

💡 Importez un dashboard : Grafana → + → Import → entrez l'ID.


🚨 Alerting

AlertManager

Composant Prometheus qui gère les alertes : groupement, silencing, routage.

Exemple de règle d'alerte

yaml
groups:
  - name: app-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Taux d'erreurs élevé (> 10%)"

Canaux de notification

CanalUsage
SlackAlertes équipe
EmailNotifications formelles
PagerDutyAstreintes (on-call)
WebhookIntégrations custom

⚠️ Évitez le alert fatigue : alertez uniquement sur ce qui nécessite une action humaine.


📝 Logs Centralisés

Pourquoi centraliser ?

Les conteneurs sont éphémères - quand un pod redémarre, les logs disparaissent.

Solutions

SolutionComposantsComplexité
ELK StackElasticsearch + Logstash + KibanaÉlevée
Loki + GrafanaLoki + Promtail + GrafanaFaible

💡 Loki est le choix recommandé pour débuter : léger, intégré à Grafana, syntaxe similaire à PromQL.

Bonnes pratiques de logging

json
{
  "timestamp": "2026-04-15T10:30:00Z",
  "level": "error",
  "service": "api-users",
  "message": "Connection DB timeout",
  "duration_ms": 5000,
  "trace_id": "abc123"
}
  • ✅ Logs structurés (JSON)
  • ✅ Inclure un trace_id pour corréler
  • ✅ Niveaux cohérents : DEBUG, INFO, WARN, ERROR
  • ❌ Ne loggez jamais de données sensibles (mots de passe, tokens)

✅ Bonnes Pratiques

Méthodes de monitoring

MéthodeCibleMétriques
USEInfrastructureUtilization, Saturation, Errors
REDServicesRate, Errors, Duration
4 Golden SignalsToutLatence, Trafic, Erreurs, Saturation

SLI / SLO / SLA

  • SLI (Indicator) : métrique mesurée (ex: latence p99 = 200ms)
  • SLO (Objective) : cible interne (ex: 99.9% de requêtes < 200ms)
  • SLA (Agreement) : engagement contractuel avec pénalités

💡 Définissez vos SLOs avant de configurer vos alertes.


🔑 Points Clés

ConceptÀ retenir
3 PiliersMétriques + Logs + Traces
PrometheusCollecte de métriques (pull model)
GrafanaVisualisation et dashboards
AlertManagerGestion et routage des alertes
LokiCentralisation de logs légère
USE/REDMéthodes de monitoring structurées

📚 Ressources

  • Prometheus Documentation
  • Grafana Documentation
  • Loki Getting Started
  • Google SRE Book - Monitoring

🚀 Prochaines étapes

Vos applications sont surveillées. Gérez maintenant votre infrastructure as code :

  1. Infrastructure as Code : premiers pas avec Terraform - Découvrez l'Infrastructure as Code et créez vos premières ressources

Exercices Pratiques

6 exercices pour mettre en pratique

01

01 - Découvrir Prometheus et les métriques

20 minutesDébutant
02

02 - Interroger les métriques avec PromQL

20 minutesDébutant
03

03 - Créer des dashboards avec Grafana

25 minutesIntermédiaire
04

04 - Configurer des alertes avec Alertmanager

30 minutesIntermédiaire
05

05 - Centraliser les logs avec Loki et Promtail

30 minutesIntermédiaire
06

06 - Projet Capstone : Mettre en place un stack de monitoring complet avec Prometheus et Grafana

1hAvancé
Retour aux modules

Sur cette page

  • 🎯 Objectifs
  • 📖 Prérequis
  • 🤔 Pourquoi le Monitoring ?
  • 📊 Les 3 Piliers de l'Observabilité
  • Métriques
  • Logs
  • Traces
  • 🔥 Prometheus
  • Qu'est-ce que c'est ?
  • Architecture
  • Types de métriques
  • PromQL - Requêtes essentielles
  • Démarrage rapide (Docker Compose)
  • 📈 Grafana
  • Qu'est-ce que c'est ?
  • Fonctionnalités clés
  • Dashboards essentiels
  • 🚨 Alerting
  • AlertManager
  • Exemple de règle d'alerte
  • Canaux de notification
  • 📝 Logs Centralisés
  • Pourquoi centraliser ?
  • Solutions
  • Bonnes pratiques de logging
  • ✅ Bonnes Pratiques
  • Méthodes de monitoring
  • SLI / SLO / SLA
  • 🔑 Points Clés
  • 📚 Ressources
  • 🚀 Prochaines étapes