Aller au contenu
medium

Formation Observabilité Kubernetes

11 min de lecture

Vous voulez surveiller vos applications Kubernetes mais vous ne savez pas par où commencer ? Cette formation vous guide pas à pas pour construire une plateforme d’observabilité complète — de l’installation de Minikube jusqu’à une stack production-ready avec métriques, logs, traces et alertes.

En 9 modules pratiques, vous déployez une application microservices, puis vous ajoutez brique par brique : Prometheus pour les métriques, Grafana pour la visualisation, Alertmanager pour les notifications, Loki pour les logs centralisés, et Tempo pour les traces distribuées.

Cette formation est conçue pour les développeurs, ops et SRE qui veulent :

  • Comprendre les fondamentaux de l’observabilité (métriques, logs, traces)
  • Savoir déployer et configurer les outils standards de l’industrie
  • Créer des dashboards et des alertes pertinentes - Diagnostiquer des problèmes en production grâce à la corrélation des signaux
PrérequisNiveau requisNotes
Linux / TerminalBasiqueSavoir naviguer, éditer des fichiers, lire des logs
DockerBasiqueComprendre ce qu’est un conteneur
KubernetesNotionsSavoir ce qu’est un pod, un service, un namespace
YAMLBasiqueSavoir lire et modifier des fichiers YAML
RessourceMinimumRecommandé
RAM8 Go16 Go
CPU4 cœurs6+ cœurs
Disque20 Go libres40 Go libres
OSLinux, macOS, Windows (WSL2)Linux

À la fin de cette formation, vous saurez :

  1. Déployer une application microservices instrumentée avec OpenTelemetry
  2. Installer et configurer Prometheus pour collecter les métriques
  3. Écrire des requêtes PromQL pour extraire des insights
  4. Créer des dashboards Grafana avec variables et provisioning as code
  5. Configurer Alertmanager pour envoyer des notifications (Slack, email, webhook)
  6. Centraliser les logs avec Loki et interroger avec LogQL
  7. Collecter les traces distribuées avec OpenTelemetry et Tempo
  8. Corréler les 3 signaux pour un diagnostic efficace
  9. Appliquer les bonnes pratiques production (HA, rétention, RBAC)

Vous allez construire cette architecture complète :

Architecture de la stack d'observabilité Kubernetes

SignalCollecteStockageRequêtageVisualisation
MétriquesOTel CollectorPrometheus TSDBPromQLGrafana
LogsPromtailLokiLogQLGrafana
TracesOTel CollectorTempoTraceQLGrafana
AlertesPrometheus RulesAlertmanagerGrafana

La formation est organisée en 9 modules progressifs. Chaque module s’appuie sur les précédents.

ModuleDuréeDifficultéCe que vous construisez
00 — Setup30 minMinikube + Helm + kubectl
01 — Application démo30 minOpenTelemetry Demo (23 pods) + Collector
02 — Prometheus90 min⭐⭐Prometheus + PromQL
03 — Grafana60 min⭐⭐Dashboards + Variables + Provisioning
04 — Alerting45 min⭐⭐Alertmanager + Règles + Routing
05 — Loki60 min⭐⭐Loki + Promtail + LogQL
06 — Tempo60 min⭐⭐⭐Tempo + Traces distribuées
07 — Corrélation45 min⭐⭐⭐Exemplars + Liens Logs↔Traces
08 — Production60 min⭐⭐⭐HA + Rétention + RBAC + GitOps

Durée totale : ~7h30 (pauses incluses)

Les modules suivants sont en cours de finalisation :

ModuleContenu prévuStatut
06 — TempoTraces distribuées, spans, instrumentation🚧 En cours
07 — CorrélationExemplars, liens logs↔traces, Explore🚧 En cours
08 — ProductionHA, rétention longue durée, RBAC multi-tenant, GitOps🚧 En cours

Vous travaillerez avec OpenTelemetry Demo, l’application de référence de la CNCF pour l’observabilité. C’est une application e-commerce complète avec 23 microservices.

CritèreAvantage
Multi-langageGo, Java, .NET, Python, Node.js, Rust — représentatif du monde réel
Instrumentation nativeMétriques et traces OpenTelemetry intégrées
Générateur de chargeTrafic réaliste automatique avec Locust
Scénarios d’erreurFeature flags pour simuler des pannes
Open sourceMaintenu par la CNCF, bien documenté

Architecture de l'application OpenTelemetry Demo

Tous les fichiers de configuration Helm sont disponibles dans ce dépôt :

Fenêtre de terminal
git clone https://github.com/stephrobert/lab-observability.git
cd lab-observability
lab-observability/
├── 00-setup/ # Scripts de vérification
├── 01-demo-app/
│ ├── values.yaml # Helm values pour OTel Demo
│ └── otel-collector-values.yaml # Config du Collector
├── 02-prometheus/
│ └── helm-values/
│ └── prometheus-minimal.yaml
├── 03-grafana/
│ └── helm-values/
│ └── grafana.yaml
├── 04-alerting/
│ ├── helm-values/
│ │ └── alertmanager.yaml
│ └── rules/ # Règles d'alerte
├── 05-loki/
│ └── helm-values/
│ └── loki-stack.yaml
├── 06-tempo/ # (à venir)
├── 07-correlation/ # (à venir)
├── 08-production/ # (à venir)
└── README.md

Une fois la formation terminée, vous accéderez aux interfaces via NodePort :

ServiceURLCredentials
OTel Demohttp://<MINIKUBE_IP>:30080
Prometheushttp://<MINIKUBE_IP>:30090
Grafanahttp://<MINIKUBE_IP>:30030admin / admin
Alertmanagerhttp://<MINIKUBE_IP>:30093

Pour obtenir l’IP de Minikube :

Fenêtre de terminal
minikube ip
  • Installer Minikube avec les bonnes ressources
  • Configurer kubectl et Helm
  • Ajouter les repos Helm nécessaires
  • Déployer une application microservices avec Helm
  • Comprendre le protocole OTLP (OpenTelemetry Protocol)
  • Configurer un OpenTelemetry Collector
  • Expliquer le modèle pull de Prometheus
  • Configurer le scraping automatique
  • Écrire des requêtes PromQL (rate, sum, histogram_quantile)
  • Créer des recording rules
  • Créer des dashboards avec différents types de panels
  • Utiliser les variables pour des dashboards dynamiques
  • Provisionner dashboards et datasources as code
  • Importer des dashboards communautaires
  • Écrire des règles d’alerte efficaces
  • Configurer le routing dans Alertmanager
  • Gérer les silences et les inhibitions
  • Intégrer Slack, email ou webhook
  • Déployer Loki en mode single binary
  • Configurer Promtail pour collecter les logs Kubernetes
  • Écrire des requêtes LogQL
  • Parser les logs JSON et extraire des labels
  1. Suivez l’ordre des modules

    Chaque module installe des composants utilisés par les suivants. Sauter un module causera des erreurs.

  2. Exécutez chaque commande

    Ne vous contentez pas de lire. Tapez chaque commande et observez le résultat.

  3. Validez avant de passer au module suivant

    Chaque module se termine par une section “Validation”. Assurez-vous que tout fonctionne avant de continuer.

  4. En cas de problème, consultez le dépannage

    Chaque module contient une section “Dépannage” avec les erreurs courantes.

  5. Prenez des notes

    Notez les commandes utiles et les concepts que vous voulez approfondir.

  • L’observabilité repose sur 3 piliers : métriques, logs, traces
  • Prometheus collecte les métriques en mode pull et stocke dans une TSDB
  • PromQL est le langage de requête pour extraire des insights des métriques
  • Grafana centralise la visualisation de tous les signaux
  • Alertmanager gère le routing et la déduplication des alertes
  • Loki stocke les logs de façon économique en indexant uniquement les labels
  • OpenTelemetry est le standard pour l’instrumentation des applications
  • La corrélation entre signaux est la clé du diagnostic efficace

Prêt à construire votre plateforme d’observabilité ? Commencez par le setup de l’environnement :

Chaque dossier (00-setup/, 01-demo-app/, etc.) correspond à un module.

ModuleDurée
00 — Setup20 min
01 — Application démo30 min
02 — Prometheus90 min
03 — Grafana60 min
04 — Alerting45 min
05 — Loki60 min
06 — Tempo45 min
07 — Corrélation30 min
08 — Production60 min
Total~7h30

Ce site vous est utile ?

Sachez que moins de 1% des lecteurs soutiennent ce site.

Je maintiens +700 guides gratuits, sans pub ni tracing. Aujourd'hui, ce site ne couvre même pas mes frais d'hébergement, d'électricité, de matériel, de logiciels, mais surtout de cafés.

Un soutien régulier, même symbolique, m'aide à garder ces ressources gratuites et à continuer de produire des guides de qualité. Merci pour votre appui.