01 — Application démo : OpenTelemetry Demo

Ce module déploie une application e-commerce microservices complète. Elle génère nativement des métriques Prometheus, des logs structurés et des traces OpenTelemetry — exactement ce qu’il faut pour apprendre l’observabilité sur des données réalistes.

Durée estimée

30 minutes (téléchargement des images inclus)

Pourquoi OpenTelemetry Demo ?

L’OpenTelemetry Demo est l’application de référence de la CNCF pour tester l’observabilité. Elle simule un site e-commerce avec 10+ microservices communicants.

Caractéristique	Détail
Architecture	Microservices (Go, Java, .NET, Python, Node.js, Rust)
Métriques	Envoyées via OTLP (OpenTelemetry Protocol)
Logs	JSON structurés sur stdout
Traces	Instrumentation OpenTelemetry native (OTLP)
Charge	Générateur de trafic intégré

Glissez pour voir

Architecture de l’application

L’application simule un e-commerce complet :

Chaque flèche génère des traces distribuées que vous pourrez visualiser.

Prérequis

Vérifiez que votre environnement est prêt (module 00) :

kubectl get nodes
helm repo list | grep open-telemetry

Déployer l’application

1. Cloner le dépôt du lab (si ce n’est pas fait)

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

2. Installer le chart Helm

   On désactive les composants d’observabilité intégrés (Jaeger, Prometheus, Grafana) car on les installera nous-mêmes dans les modules suivants :

   helm upgrade --install otel-demo open-telemetry/opentelemetry-demo \
     -n otel-demo --create-namespace \
     -f 01-demo-app/values.yaml \
     --wait --timeout 10m

   Patience...

   Le premier déploiement télécharge ~2 Go d’images. Comptez 5-10 minutes.

   Upgrade entre versions

   Le chart OpenTelemetry Demo ne supporte pas l’upgrade entre versions. upgrade --install fonctionne pour rejouer le TP à version identique. Pour changer de version : helm uninstall otel-demo -n otel-demo puis réinstallez.

3. Vérifier le déploiement

   kubectl get pods -n otel-demo

   Attendez que tous les pods soient Running :

   NAME                                    READY   STATUS    RESTARTS   AGE
    accounting-54d7898d59-ctg5p        1/1     Running   0               7m18s
    ad-64b9c46676-nkjz8                1/1     Running   0               7m17s
    cart-74b78c4f77-wth4t              1/1     Running   0               7m18s
    checkout-7cbbb79889-kzk88          1/1     Running   0               7m17s
    currency-7d8d9c987f-vdrp7          1/1     Running   0               7m18s
    email-996d5d78-kl2gl               1/1     Running   0               7m19s
    flagd-79955b8b64-6w66j             2/2     Running   0               7m16s
    fraud-detection-8646ff7565-h557r   1/1     Running   0               7m17s
    frontend-75d6c5bb89-8jdrb          1/1     Running   0               7m18s
    frontend-proxy-64bb7b6c74-zdgw4    1/1     Running   0               7m16s
    image-provider-567588f685-7ddvh    1/1     Running   0               7m19s
    kafka-76f785c87d-vdscf             1/1     Running   0               7m19s
    llm-d7c896f6-nbbbp                 1/1     Running   0               7m19s
    load-generator-d6c6d8cbf-kjssh     1/1     Running   0               7m17s
    opensearch-0                       1/1     Running   0               7m19s
    payment-588f77555c-c8bs6           1/1     Running   0               7m19s
    postgresql-67cff7567d-crcdt        1/1     Running   0               7m17s
    product-catalog-96c86b4d-5gncr     1/1     Running   6 (3m55s ago)   7m19s
    product-reviews-74cdd974dc-fcbn4   1/1     Running   0               7m19s
    quote-789b99df4b-p97pk             1/1     Running   0               7m19s
    recommendation-5dbb786688-hlnnl    1/1     Running   0               7m19s
    shipping-7b644f59cc-p6swn          1/1     Running   0               7m19s
    valkey-cart-7b8b45bf46-rb8gz       1/1     Running   0               7m18s

4. Accéder à l’interface

   minikube service frontend-proxy -n otel-demo

   Ou avec port-forward :

   kubectl port-forward svc/frontend-proxy 8080:8080 -n otel-demo

   Ouvrez http://localhost:8080 — vous verrez le site e-commerce. Vous devrez voir des produits, pouvoir les ajouter au panier et passer commande.

   

Explorer les signaux générés

L’application OpenTelemetry Demo utilise le protocole OTLP (OpenTelemetry Protocol) pour envoyer ses métriques et traces vers un collecteur. Les logs sont émis sur stdout.

Métriques

Les services envoient leurs métriques via OTLP vers un collecteur OpenTelemetry. Dans notre configuration, nous avons désactivé le collecteur intégré — nous installerons Prometheus dans le module suivant pour les recevoir.

Pas d'endpoint /metrics

Contrairement à une application instrumentée avec le client Prometheus natif, les services OTel Demo n’exposent pas d’endpoint /metrics. Les métriques transitent par OTLP.

Logs

Les logs sont émis sur stdout. Consultez-les avec kubectl :

kubectl logs -n otel-demo -l app.kubernetes.io/component=product-catalog --tail=5

Vous verrez probablement des messages comme :

2026/02/08 13:17:15 traces export: exporter export timeout: rpc error: code = Unavailable desc = name resolver error
2026/02/08 13:17:25 failed to upload metrics: exporter export timeout: rpc error: code = Unavailable desc = ...

Erreurs attendues

Ces erreurs exporter export timeout sont normales. Les services tentent d’envoyer leurs métriques et traces via OTLP, mais le collecteur n’est pas encore installé. Ces erreurs disparaîtront après l’installation de Prometheus et Tempo.

Traces

Les services envoient leurs traces en OTLP. Pour l’instant, elles ne sont pas collectées (pas de backend). Vous les configurerez dans le module 06 (Tempo).

Pour voir les tentatives d’envoi :

kubectl logs -n otel-demo -l app.kubernetes.io/component=product-catalog --tail=20 | grep -i trace

Services déployés

Service	Port	Description
frontend-proxy	8080 (NodePort 30080)	Point d’entrée web
frontend	8080	Interface React
cart	8080	Gestion du panier
checkout	8080	Passage de commande
product-catalog	8080	Catalogue produits
recommendation	8080	Recommandations
payment	8080	Paiement
shipping	8080	Expédition
ad	8080	Publicités
load-generator	8089	Génère du trafic automatique

Glissez pour voir

Générateur de charge

Le load-generator simule des utilisateurs qui naviguent, ajoutent au panier et passent commande. Il génère un flux constant de métriques et traces.

Il utilise Locust et expose une interface web sur le port 8089. Vérifiez qu’il fonctionne :

kubectl port-forward svc/load-generator 8089:8089 -n otel-demo &
curl -s http://localhost:8089 | grep -o "<title>.*</title>"

Ce que vous devez voir :

<title>Locust</title>

Interface Locust

Ouvrez http://localhost:8089 dans votre navigateur pour voir l’interface Locust avec les statistiques de charge en temps réel.

Dépannage

Pods en CrashLoopBackOff

Vérifiez les logs du pod en erreur :

kubectl logs -n otel-demo <pod-name>
kubectl describe pod -n otel-demo <pod-name>

Cause fréquente : mémoire insuffisante. Augmentez les ressources Minikube :

minikube stop
minikube start --memory=10240 --cpus=4

Pods en Pending

Ressources insuffisantes sur le cluster :

kubectl describe pod -n otel-demo <pod-name> | grep -A5 Events

Si vous voyez “Insufficient memory”, augmentez Minikube.

Images qui ne téléchargent pas

Vérifiez la connexion réseau et les limites Docker :

docker system df
docker image prune -a  # Libérer de l'espace si nécessaire

Déployer l’OpenTelemetry Collector

L’application OTel Demo envoie ses métriques via le protocole OTLP (OpenTelemetry Protocol). Pour que Prometheus puisse les collecter, nous devons installer un OpenTelemetry Collector qui :

1. Reçoit les métriques OTLP des microservices
2. Convertit et expose ces métriques au format Prometheus

Pourquoi dans le même namespace ?

On installe le Collector dans otel-demo (même namespace que l’application) pour simplifier la configuration : les services peuvent atteindre le Collector via otel-collector:4317 sans FQDN cross-namespace.

1. Examinez la configuration du Collector

   cat 01-demo-app/otel-collector-values.yaml

   Points clés :

   mode: deployment   # Obligatoire : définit le type de workload
   
   config:
     receivers:
       otlp:
         protocols:
           grpc:
             endpoint: 0.0.0.0:4317   # Reçoit OTLP gRPC
           http:
             endpoint: 0.0.0.0:4318   # Reçoit OTLP HTTP
   
     exporters:
       prometheus:
         endpoint: 0.0.0.0:8889       # Expose pour Prometheus
         namespace: otel              # Préfixe des métriques

   Le Collector reçoit les métriques OTLP sur les ports 4317/4318 et les expose au format Prometheus sur le port 8889 avec le préfixe otel_.

2. Installez le Collector dans le namespace otel-demo

   helm upgrade --install otel-collector open-telemetry/opentelemetry-collector \
     -n otel-demo \
     -f 01-demo-app/otel-collector-values.yaml \
     --wait

   Ce que vous devez voir :

   Release "otel-collector" does not exist. Installing it now.
   NAME: otel-collector
   NAMESPACE: otel-demo
   STATUS: deployed

3. Vérifiez le déploiement

   kubectl get pods -n otel-demo -l app.kubernetes.io/name=opentelemetry-collector

   Ce que vous devez voir :

   NAME                              READY   STATUS    RESTARTS   AGE
   otel-collector-xxxxxxxxxx-xxxxx   1/1     Running   0          1m

4. Vérifiez que les métriques sont collectées

   kubectl port-forward svc/otel-collector 8889:8889 -n otel-demo &
   sleep 2
   curl -s http://localhost:8889/metrics | head -20
   kill %1

   Ce que vous devez voir : des métriques préfixées par otel_ provenant des microservices.

Les erreurs disparaissent

Après l’installation du Collector, les erreurs exporter export timeout dans les logs des pods OTel Demo disparaîtront progressivement car les services ont maintenant un collecteur vers lequel envoyer leurs données.

Validation

Avant de passer au module suivant, vérifiez :

# Tous les pods OTel Demo running (y compris le Collector)
kubectl get pods -n otel-demo | grep -v Running | grep -v NAME

# Récupérer l'IP Minikube
minikube ip

# Frontend accessible (remplacez <IP> par le résultat ci-dessus)
curl -s http://<IP>:30080 | grep -o "Otel Demo"

Ce que vous devez voir :

• Première commande : aucune sortie (tous les pods sont Running, y compris le Collector)
• Deuxième commande : l’IP de Minikube (ex: 192.168.49.2)
• Troisième commande : Otel Demo

Ce qu’on a appris

• L’OpenTelemetry Demo est une application microservices complète (~25 pods)
• Les métriques et traces sont envoyées via OTLP vers un collecteur
• L’OpenTelemetry Collector (installé dans le même namespace) convertit les métriques OTLP en format Prometheus (port 8889)
• Le chart Collector nécessite mode: deployment (ou daemonset/statefulset)
• Les métriques sont préfixées par otel_ (ex: otel_http_server_duration_seconds_count)
• Le load-generator utilise Locust pour créer du trafic réaliste

Prochaine étape

02 — Prometheus → Installer Prometheus pour collecter et requêter les métriques.

×

📖 Voir la documentation →