Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Jaeger — backend de traçage à nœud unique pour Kubernetes

Cet exemple compile une petite stack réelle — un backend de traçage distribué Jaeger dans sa structure à nœud unique — à partir d’un seul Aggregate écrit par le développeur vers Kubernetes, synthétisée directement à partir de l’image officielle de Jaeger sans chart upstream.

Jaeger est un backend de traces : il reçoit des spans via le protocole OpenTelemetry, les stocke dans un magasin clé-valeur local embarqué, et répond aux requêtes de consultation et de recherche de traces via son interface de requête. Dans la structure à nœud unique, le récepteur OTLP, l’écrivain de stockage et le service de requête s’exécutent tous dans un seul processus adossé à un magasin local sur disque, si bien que tout le serveur est une seule charge de travail avec état. Une application instrumentée pousse des spans vers le récepteur OTLP de Jaeger ; un opérateur les relit depuis l’interface.

Fichiers

FichierRôle
aggregate.yamlIntention du développeur : un seul composant tracing (core/observability/jaeger).
manifest.yamlMappe le type de composant vers la Recipe de synthèse de Jaeger (jaeger).
release.yamlDocument de l’opérateur pour la cible Kubernetes : les ressources de calcul du serveur et la taille du volume du magasin de traces.

Ce qu’il démontre

  • Une seule surface de rédaction. Un seul Aggregate est la source de vérité sur ce qu’est Jaeger ; le Manifest dit comment le réaliser.
  • Un backend de traces à nœud unique. La Recipe de synthèse rend Jaeger sous forme d’un seul StatefulSet avec un volume de données, d’une ConfigMap portant la configuration de Jaeger v2, et de deux objets Service — un ClusterIP exposant les récepteurs et l’interface, et un Service headless de gouvernance pour le StatefulSet.
  • Une configuration livrée sous forme de fichier. Jaeger v2 est une distribution d’OpenTelemetry Collector configurée par un fichier YAML. La Recipe émet cette configuration sous forme de ConfigMap et la monte dans le conteneur sur /etc/jaeger, et le conteneur la lit avec --config /etc/jaeger/config.yaml.
  • Des traces persistantes. Le magasin clé-valeur embarqué écrit sur le volume persistant à /badger, si bien que les données de traces survivent aux redémarrages.
  • Un contrat d’ingestion exporté. Le composant exporte l’hôte et le port de son récepteur OTLP gRPC via la topologie uses, si bien qu’un producteur de traces se connecte à lui et y pousse des spans.
  • Images reproductibles. La Recipe épingle l’image du serveur Jaeger sur un tag résolvable, si bien que la charge de travail rendue référence une version épinglée.

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example jaeger-tracing

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd jaeger-tracing

Build

Cet espace de travail ne contient aucun .aggrega-config.yaml, si bien que les entités de la bibliothèque standard se résolvent depuis le registre du hub, hub.aggrega.ai, et qu’aucun flag de catalogue n’est nécessaire :

Terminal window
aggrega pull --release release.yaml
aggrega build --release release.yaml

Les artefacts rendus atterrissent sous dist/. La cible Kubernetes rend des manifestes simples hors ligne — aucun pull de chart n’est requis.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `jaeger-tracing`, appelez une fois l’outil `scaffold` avec `example` défini sur `jaeger-tracing` et sans `dir` : il écrit l’exemple dans un nouveau dossier `jaeger-tracing`. Appelez ensuite l’outil `build` avec `workspace_root` défini sur `jaeger-tracing`, `release` défini sur `release.yaml`, `auto_pull` défini sur true et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `jaeger-tracing/dist/`.

Ce qui est rendu

Le build émet le serveur Jaeger sous forme de quatre objets Kubernetes :

  • un StatefulSet — le processus Jaeger à nœud unique, avec son magasin de traces embarqué sur un volume persistant monté sur /badger et la configuration montée sur /etc/jaeger,
  • une ConfigMap — la configuration de Jaeger v2 (les récepteurs OTLP, le processeur batch et le magasin clé-valeur embarqué écrivant dans /badger/key et /badger/data),
  • un Service ClusterIP — exposant le récepteur OTLP gRPC sur 4317, le récepteur OTLP HTTP sur 4318 et l’interface de requête sur 16686,
  • un Service headless — le Service de gouvernance dont le StatefulSet a besoin pour une identité stable par réplica.

L’image de Jaeger est épinglée sur son tag de release, si bien que la charge de travail référence un tag d’image épinglé.