Formation Observabilité Kubernetes

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.

À qui s'adresse cette formation ?

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érequis

Prérequis	Niveau requis	Notes
Linux / Terminal	Basique	Savoir naviguer, éditer des fichiers, lire des logs
Docker	Basique	Comprendre ce qu'est un conteneur
Kubernetes	Notions	Savoir ce qu'est un pod, un service, un namespace
YAML	Basique	Savoir lire et modifier des fichiers YAML

Configuration matérielle requise

L'application de démonstration déploie à elle seule 23 microservices, auxquels s'ajoutent Prometheus, Grafana, Loki et Tempo. En dessous de 8 Go de RAM, Minikube commence à évincer des pods et les modules suivants deviennent difficiles à valider.

Ressource	Minimum	Recommandé
RAM	8 Go	16 Go
CPU	4 cœurs	6+ cœurs
Disque	20 Go libres	40 Go libres
OS	Linux, macOS, Windows (WSL2)	Linux

Ce que vous allez apprendre

À la fin de cette formation, vous saurez :

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

Architecture de la stack

Chaque module ajoute une brique au schéma ci-dessous, jamais plus d'une à la fois. Le principe reste constant : les applications émettent des signaux, un collecteur les route, une base spécialisée les stocke, et Grafana sert de point d'entrée unique pour les interroger. Repérez dès maintenant où se situe la brique que vous installez, cela évite de confondre un problème de collecte avec un problème de stockage.

Architecture de la stack d'observabilité Kubernetes

Stack technologique

Lisez ce tableau ligne par ligne : chaque signal suit le même trajet, mais avec des outils et surtout un langage de requête différents. C'est la principale source de confusion au début, PromQL, LogQL et TraceQL se ressemblent sans être interchangeables.

Signal	Collecte	Stockage	Requêtage	Visualisation
Métriques	OTel Collector	Prometheus TSDB	PromQL	Grafana
Logs	Promtail	Loki	LogQL	Grafana
Traces	OTel Collector	Tempo	TraceQL	Grafana
Alertes	Prometheus Rules	Alertmanager	PromQL (règles)	Grafana

Parcours de formation

La formation est organisée en 9 modules progressifs. Chaque module s'appuie sur les précédents : il installe des composants que les suivants interrogent, et se termine par une validation à réussir avant d'aller plus loin. Comptez une demi-journée pour arriver à Grafana, la journée complète pour l'ensemble.

Vue d'ensemble

Les étoiles de la colonne Difficulté ne mesurent pas la complexité des commandes, mais celle des concepts à assimiler. Les modules 06 à 08 supposent acquis PromQL et les dashboards.

Module	Durée	Difficulté	Ce que vous construisez
00, Setup	20 min	⭐	Minikube + Helm + kubectl
01, Application démo	30 min	⭐	OpenTelemetry Demo (23 pods) + Collector
02, Prometheus	90 min	⭐⭐	Prometheus + PromQL
03, Grafana	60 min	⭐⭐	Dashboards + Variables + Provisioning
04, Alerting	45 min	⭐⭐	Alertmanager + Règles + Routing
05, Loki	60 min	⭐⭐	Loki + Promtail + LogQL
06, Tempo	45 min	⭐⭐⭐	Tempo + Traces distribuées
07, Corrélation	30 min	⭐⭐⭐	Exemplars + Liens Logs↔Traces
08, Production	60 min	⭐⭐⭐	HA + Rétention + RBAC + GitOps

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

Modules disponibles

Les six modules ci-dessous sont publiés et testés de bout en bout. Ils forment déjà une plateforme exploitable, avec métriques, dashboards, alertes et logs centralisés.

00, Setup de l'environnement Installer Minikube, Helm et kubectl. Valider que tout fonctionne avant de commencer.

01, Application démo OpenTelemetry Déployer une application e-commerce complète qui génère métriques, logs et traces.

02, Prometheus et PromQL Installer Prometheus, comprendre le modèle pull, maîtriser PromQL avec 20+ exemples.

03, Grafana : dashboards et visualisation Créer des dashboards professionnels avec variables, templates et provisioning as code.

04, Alerting avec Alertmanager Configurer des règles d'alerte, le routing, les silences et les notifications.

05, Loki : centralisation des logs Déployer Loki et Promtail, maîtriser LogQL, parser les logs JSON.

Modules à venir

Les modules suivants sont en cours de finalisation :

Module	Contenu prévu	Statut
06, Tempo	Traces distribuées, spans, instrumentation	🚧 En cours
07, Corrélation	Exemplars, liens logs↔traces, Explore	🚧 En cours
08, Production	HA, rétention longue durée, RBAC multi-tenant, GitOps	🚧 En cours

L'application de démonstration

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.

Pourquoi cette application ?

Un « hello world » instrumenté ne produirait qu'une trace à un seul saut et des métriques sans variation, donc rien d'intéressant à observer. OpenTelemetry Demo génère au contraire du trafic continu, des appels entre services écrits dans des langages différents, et des pannes déclenchables à la demande.

Critère	Avantage
Multi-langage	Go, Java, .NET, Python, Node.js, Rust, représentatif du monde réel
Instrumentation native	Métriques et traces OpenTelemetry intégrées
Générateur de charge	Trafic réaliste automatique avec Locust
Scénarios d'erreur	Feature flags pour simuler des pannes
Open source	Maintenu par la CNCF, bien documenté

Architecture de l'application

Inutile de mémoriser ce schéma, mais gardez-le sous la main : quand une trace vous montrera un appel lent, c'est ici que vous identifierez quel service parle à quel autre. Les flèches représentent des appels applicatifs, pas des flux de télémétrie.

Architecture de l'application OpenTelemetry Demo

Dépôt Git du lab

Les fichiers de values Helm utilisés dans la formation sont regroupés dans un dépôt public. Clonez-le avant de commencer : les modules y font référence par leur chemin, et recopier à la main des centaines de lignes de YAML depuis une page web est la meilleure façon d'introduire une erreur d'indentation.

git clone https://github.com/stephrobert/lab-observability.git
cd lab-observability

Structure du dépôt

Un dossier par module, nommé exactement comme lui, ce qui permet de retrouver un fichier de values sans chercher. Les trois derniers dossiers sont marqués « à venir » : ils ne seront alimentés qu'à la publication des modules correspondants.

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

Accès aux interfaces

Les interfaces sont exposées en NodePort, c'est-à-dire sur un port fixe de l'adresse IP de Minikube, et non en port-forward : l'accès survit ainsi à la fermeture du terminal. Aucune de ces interfaces n'est protégée en dehors du mot de passe Grafana ; ce lab reste strictement local et ne doit pas être exposé sur un réseau partagé.

Service	URL	Credentials
OTel Demo	http://<MINIKUBE_IP>:30080	Aucun
Prometheus	http://<MINIKUBE_IP>:30090	Aucun
Grafana	http://<MINIKUBE_IP>:30030	admin / admin
Alertmanager	http://<MINIKUBE_IP>:30093	Aucun

Pour obtenir l'IP de Minikube :

minikube ip

Compétences acquises par module

Le détail ci-dessous sert à deux choses : vérifier que vous avez bien acquis ce qu'un module promettait, et choisir un point d'entrée si vous maîtrisez déjà une partie de la stack. Chaque liste correspond à ce que vous devez savoir refaire sans le guide sous les yeux.

Module 00, Setup

Le module d'installation, à ne pas sauter même avec un cluster existant : le dimensionnement de Minikube conditionne la réussite des modules suivants.

Installer Minikube avec les bonnes ressources
Configurer kubectl et Helm
Ajouter les repos Helm nécessaires

Module 01, Application démo

C'est le module qui fournit la matière à observer : sans lui, les suivants n'auraient que les métriques du cluster à afficher.

Déployer une application microservices avec Helm
Comprendre le protocole OTLP (OpenTelemetry Protocol)
Configurer un OpenTelemetry Collector

Module 02, Prometheus

Le module le plus long, et le plus rentable : PromQL sert ensuite dans les dashboards Grafana comme dans les règles d'alerte.

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

Module 03, Grafana

L'accent est mis sur le provisioning as code : un dashboard construit à la souris disparaît avec le pod qui l'hébergeait.

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

Module 04, Alerting

La difficulté n'est pas de déclencher une alerte, mais d'en déclencher peu : le routage, les silences et les inhibitions décident de ce qui réveille réellement quelqu'un.

É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

Module 05, Loki

Loki n'indexe que les labels, pas le contenu des lignes : c'est ce choix qui rend le stockage économique et qui explique la syntaxe particulière de LogQL.

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

Conseils pour réussir

L'écueil le plus fréquent sur ce type de formation est de lire vite et de ne rien retenir. Les cinq réflexes ci-dessous coûtent quelques minutes par module et évitent de repartir de zéro au troisième. Le premier est le plus important : une erreur non corrigée se propage en cascade dans les modules suivants, où elle se manifestera sous une forme méconnaissable.

Suivez l'ordre des modules

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

Ne vous contentez pas de lire. Tapez chaque commande et observez le résultat.
Validez avant de passer au module suivant

Chaque module se termine par une section "Validation". Assurez-vous que tout fonctionne avant de continuer.
En cas de problème, consultez le dépannage

Chaque module contient une section "Dépannage" avec les erreurs courantes.
Prenez des notes

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

Ressources complémentaires

Documentation officielle

Les quatre références à garder ouvertes pendant la formation, en particulier pour les fonctions PromQL et LogQL qui ne sont pas toutes couvertes ici.

Guides connexes sur ce site

Ces pages traitent les mêmes outils hors du contexte du lab : théorie de l'observabilité d'un côté, guides de référence par outil de l'autre.

Qu'est-ce que l'observabilité ? Comprendre les concepts fondamentaux : métriques, logs, traces.

Introduction à Kubernetes Les bases de Kubernetes si vous débutez.

Prometheus Guide de référence Prometheus.

Grafana Guide de référence Grafana.

À retenir

L'observabilité repose sur plusieurs signaux : métriques, logs, traces (et profiles, baggage)
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

Commencer la formation

Le module 00 vérifie votre poste et installe Minikube, Helm et kubectl en une vingtaine de minutes. Il se termine par un contrôle de bon fonctionnement : ne passez à la suite que s'il est vert, tous les modules suivants supposent ce socle en place.

00, Setup de l'environnement → Installer Minikube, Helm et kubectl pour commencer la formation.

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

Durée estimée

Ces durées correspondent à une première exécution, commandes tapées et sorties observées, sans compter le temps de téléchargement des images. Un lecteur qui connaît déjà Kubernetes ira plus vite sur les modules 00 et 01, mais rarement sur PromQL. Prévoyez de découper la formation en deux ou trois sessions plutôt que de l'enchaîner d'un trait.

Module	Durée
00, Setup	20 min
01, Application démo	30 min
02, Prometheus	90 min
03, Grafana	60 min
04, Alerting	45 min
05, Loki	60 min
06, Tempo	45 min
07, Corrélation	30 min
08, Production	60 min
Total	~7h30