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

De Fluent Bit à Fluentd — un pipeline de logs à deux niveaux, deux cibles

Cet exemple compile un véritable pipeline de logs — un forwarder Fluent Bit qui envoie des enregistrements à un agrégateur Fluentd via le protocole forward — à partir d’un seul Aggregate écrit par le développeur en deux réalisations :

  • Docker Compose pour le développement local, et
  • les Recipes helm synthétisées qui exécutent les images upstream officielles fluent/fluent-bit et fluent/fluentd directement sur Kubernetes (aucun chart externe).

Les Recipes helm synthétisées ne récupèrent rien au moment du build ; helm/fluent-bit-chart et helm/fluentd-chart rendent plutôt les propres charts du projet Fluent, pour un build qui peut atteindre un dépôt de charts.

Le même aggregate.yaml pilote les deux. Seule la couche de Recipe sélectionnée par le Manifest change d’une réalisation à l’autre.

Le pipeline

Deux composants forment un pipeline du forwarder vers l’agrégateur :

  • forwarder (core/observability/fluent-bit) collecte les enregistrements de logs et les envoie sur une sortie forward. Il est typé comme serveur sans état.
  • aggregator (core/observability/fluentd) écoute sur le protocole d’entrée forward, reçoit les enregistrements et les achemine vers sa sortie. Il est typé comme serveur avec état ; la Recipe helm synthétisée met en tampon en mémoire par défaut, si bien qu’il est rendu sous forme d’un Deployment à réplique unique.

Le forwarder déclare une utilisation forward_target de l’agrégateur. Les provides.host et provides.port de l’agrégateur — l’hôte et le port de son endpoint forward (le port forward conventionnel de Fluentd, 24224) — sont acheminés dans le forwarder et rendus dans Host et Port de sa sortie forward. Ainsi, le forwarder envoie vers l’endpoint forward de l’agrégateur, câblé à l’avance à partir d’une seule arête.

Fichiers

FichierRôle
aggregate.yamlIntention du développeur : un puits aggregator (core/observability/fluentd) et un forwarder (core/observability/fluent-bit) qui déclare une utilisation forward_target de l’agrégateur.
manifest-compose.yamlAssocie le type Fluent Bit à la Recipe Compose (compose/fluent-bit) et le type Fluentd à la Recipe Compose (compose/fluentd).
manifest-helm-synth.yamlAssocie le type Fluent Bit à la Recipe helm synthétisée (helm/fluent-bit) et le type Fluentd à la Recipe helm synthétisée (helm/fluentd).
release-compose.yaml / release-helm-synth.yamlEnregistrements de l’opérateur pour les deux réalisations.

Comme les noms fluent-bit et fluentd sont portés à la fois par une Recipe Compose et par une helm synthétisée, les Manifests les référencent avec une portée de fournisseur (compose/… et helm/…).

Ce qu’il démontre

  • Une seule surface de rédaction, plusieurs cibles. Un seul Aggregate est la source de vérité sur ce qu’est le pipeline. Chaque Manifest dit comment le réaliser.
  • Câblage forward via le String Pipe. Le forwarder déclare une utilisation forward_target de l’agrégateur ; les provides.host et provides.port de la Recipe de l’agrégateur sont acheminés dans le forwarder et rendus dans Host et Port d’une sortie forward. Le compilateur achemine les chaînes sans les interpréter — ainsi le build Compose câble un nom de service compose et le build Kubernetes câble un nom de Service, à partir de la même arête.
  • Un puits avec état sur le socket d’un forwarder sans état. Le socket forward_target du forwarder sélectionne un server ou un stateful-server. Fluentd est typé comme serveur avec état, et il se lie proprement au socket — le socket sélectionne selon le rôle opérationnel de serveur, et non selon que le puits conserve ou non un état. Ce que parle le puits est vérifié à part : la sortie forward parle le protocole forward de Fluentd, si bien que le build s’arrête à moins que le puits ne publie protocol: forward, comme le fait Fluentd.
  • Synthèse de Workload (Kubernetes). Chaque Recipe helm synthétisée déclare un Workload — un Deployment plus un Service ClusterIP exécutant l’image officielle — que le fournisseur helm traduit en manifestes Kubernetes sans aucun chart externe. L’ensemble de ressources rendu est exactement ce que déclarent les Workloads.
  • Images reproductibles. infra.engine_version épingle chaque tag d’image, si bien que les charges de travail rendues référencent des images fixes et que les Recipes synthétisées ne rendent aucun tag flottant.

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 fluent-bit-to-fluentd

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

Terminal window
cd fluent-bit-to-fluentd

Build

Ce workspace ne contient aucun .aggrega-config.yaml, si bien que les entités de la bibliothèque standard sont résolues depuis le registre du hub, hub.aggrega.ai, et aucune option de catalogue n’est nécessaire ; --auto-pull écrit pendant le build le lockfile qui manque à un clone récent :

Terminal window
# Local development (Docker Compose)
aggrega build --release release-compose.yaml --auto-pull
# Kubernetes (synthesized helm Recipes, official images)
aggrega build --release release-helm-synth.yaml --auto-pull

Les artefacts rendus atterrissent sous dist/.

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 `fluent-bit-to-fluentd`, appelez une fois l’outil `scaffold` avec `example` défini sur `fluent-bit-to-fluentd` et sans `dir` : il écrit l’exemple dans un nouveau dossier `fluent-bit-to-fluentd`. Appelez ensuite l’outil `build` une fois pour chaque Release, dans cet ordre — `release-compose.yaml`, `release-helm-synth.yaml` — en définissant à chaque fois `workspace_root` sur `fluent-bit-to-fluentd`, `release` sur ce fichier, `auto_pull` sur true et `write` sur true. Indiquez-moi les fichiers écrits par chaque build ; ils se trouvent sous `fluent-bit-to-fluentd/dist/`.

À quoi ressemble la cible forward injectée

Sur Compose, le forwarder écrit un fluent-bit.conf dont la sortie forward cible le nom de service compose et le port forward de l’agrégateur :

[OUTPUT]
Name forward
Match *
Host aggregator
Port 24224

Sur Kubernetes, la même sortie cible le nom du Service interne au cluster de l’agrégateur :

[OUTPUT]
Name forward
Match *
Host aggregator-default
Port 24224

Les deux découlent de la même arête de l’Aggregate — l’hôte et le port de l’agrégateur transitent par l’utilisation forward_target, et chaque cible les rend dans son propre idiome. Le port 24224 est l’endpoint forward de l’agrégateur, exporté via ses provides et acheminé à l’avance dans le forwarder.

L’exécuter (Compose)

Terminal window
aggrega build --release release-compose.yaml --auto-pull
docker compose -f dist/app/compose/docker-compose.yaml up -d

L’endpoint de supervision du forwarder est publié uniquement sur l’adresse de bouclage de l’hôte, à http://localhost:2020 — son endpoint /api/v1/metrics indique les enregistrements traités et transférés. L’endpoint ne vérifie aucun appelant, si bien qu’il n’est pas publié sur les autres interfaces de l’hôte, sauf si la Release définit infra.publish_on_all_interfaces: true sur le forwarder. Pour tout arrêter, utilisez docker compose -f dist/app/compose/docker-compose.yaml down.