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

Kafka — broker de streaming d’événements à nœud unique pour Kubernetes

Cet exemple compile une petite stack réelle — un broker de streaming d’événements Apache Kafka dans sa structure KRaft à nœud unique — à partir d’un seul Aggregate écrit par le développeur vers Kubernetes, synthétisée directement à partir de l’image officielle d’Apache Kafka sans chart upstream.

Kafka est un broker de streaming d’événements : les producteurs ajoutent des enregistrements à des topics et les consommateurs les relisent dans l’ordre. Dans la structure KRaft à nœud unique, les rôles de broker et de contrôleur s’exécutent dans un seul processus — pas de ZooKeeper ni de second service fourni avec — si bien que tout le serveur est une seule charge de travail avec état. Le journal de commit est persisté sur un volume de données local. Un producteur ou un consommateur se connecte à l’endpoint de bootstrap des clients et y échange des enregistrements.

Fichiers

FichierRôle
aggregate.yamlIntention du développeur : un seul composant broker (core/messaging/kafka).
manifest.yamlMappe le type de composant vers la Recipe de synthèse de Kafka (kafka).
release.yamlDocument de l’opérateur pour la cible Kubernetes : les ressources de calcul du serveur et la taille du volume du journal de commit.

Ce qu’il démontre

  • Une seule surface de rédaction. Un seul Aggregate est la source de vérité sur ce qu’est Kafka ; le Manifest dit comment le réaliser.
  • Un broker KRaft à nœud unique. La Recipe de synthèse rend Kafka sous forme d’un seul StatefulSet avec un volume de données et de deux objets Service — un ClusterIP exposant le port de bootstrap des clients, et un Service headless de gouvernance pour le StatefulSet.
  • KRaft, sans ZooKeeper. Le nœud exécute à la fois les rôles de broker et de contrôleur dans un seul processus, configuré entièrement par des variables d’environnement.
  • Une identité de cluster épinglée. L’identité du cluster est une valeur fixe du développeur transmise telle quelle à l’image, qui la lit sans modification ni génération aléatoire, si bien que le manifeste rendu est identique octet par octet d’un build à l’autre.
  • Une adresse annoncée stable. Le broker annonce le nom du Service interne au cluster, si bien que les clients se reconnectent via l’adresse stable plutôt que via le nom d’hôte propre du pod.
  • Un journal persistant. Le journal de commit écrit sur le volume persistant à /var/lib/kafka/data, si bien que les données des enregistrements survivent aux redémarrages.
  • Un contrat de bootstrap exporté. Le composant exporte son hôte de bootstrap et son port client via la topologie uses, si bien qu’un producteur ou un consommateur se câble à lui et s’y connecte.
  • Images reproductibles. La Recipe épingle l’image du serveur Kafka 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 kafka-broker

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

Terminal window
cd kafka-broker

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 `kafka-broker`, appelez une fois l’outil `scaffold` avec `example` défini sur `kafka-broker` et sans `dir` : il écrit l’exemple dans un nouveau dossier `kafka-broker`. Appelez ensuite l’outil `build` avec `workspace_root` défini sur `kafka-broker`, `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 `kafka-broker/dist/`.

Ce qui est rendu

Le build émet le serveur Kafka sous forme de trois objets Kubernetes :

  • un StatefulSet — le processus Kafka à nœud unique, avec son journal de commit sur un volume persistant monté sur /var/lib/kafka/data et toute la configuration KRaft fournie par des variables d’environnement,
  • un Service ClusterIP — exposant le port de bootstrap des clients sur 9092,
  • un Service headless — le Service de gouvernance dont le StatefulSet a besoin pour une identité stable par réplica.

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