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

Fluentd — un agrégateur de logs, deux cibles

Cet exemple compile un agrégateur de logs Fluentd — l’extrémité réceptrice d’un pipeline de logs — à partir d’un seul Aggregate écrit par le développeur en deux réalisations :

  • Docker Compose pour le développement local, et
  • la Recipe helm synthétisée qui exécute l’image upstream officielle fluent/fluentd directement sur Kubernetes (aucun chart externe).

La Recipe helm synthétisée ne récupère rien au moment du build ; helm/fluentd-chart rend le propre chart du projet Fluent sous la forme du même agrégateur, 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 rôle d’agrégateur

Un pipeline de logs a deux extrémités. Un forwarder (comme Fluent Bit) collecte les enregistrements de logs et les envoie en aval. Un agrégateur est le puits à l’autre extrémité : il écoute sur le protocole d’entrée forward, reçoit les enregistrements que lui envoient les forwarders en amont et les achemine vers sa sortie. Fluentd joue ici le rôle d’agrégateur.

Comme l’agrégateur reçoit au lieu de transférer, il ne déclare aucun socket uses en aval. Il exporte plutôt l’hôte et le port de son endpoint forward via provides, si bien qu’un forwarder peut le lier sur un socket forward et lui envoyer des enregistrements. L’endpoint forward écoute sur le port 24224 — le port forward conventionnel de Fluentd.

Fichiers

FichierRôle
aggregate.yamlIntention du développeur : un composant aggregator (core/observability/fluentd) à l’écoute sur l’entrée forward.
manifest-compose.yamlAssocie le type Fluentd à la Recipe Compose (compose/fluentd).
manifest-helm-synth.yamlAssocie 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.
release-helm-synth-buffer.yamlLa réalisation helm synthétisée avec la mise en tampon durable activée (infra.storage.size défini).

Comme le nom fluentd est porté à 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 sous les noms compose/fluentd et helm/fluentd.

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 la stack. Chaque Manifest dit comment la réaliser.
  • L’extrémité réceptrice du String Pipe. L’agrégateur exporte son endpoint forward via provides — host (le service de l’agrégateur) et port (24224) sur le protocole forward. Un forwarder qui se lie à ce composant achemine ces chaînes dans sa propre sortie forward ; le compilateur les achemine sans les interpréter.
  • Synthèse de Workload (Kubernetes). La Recipe helm synthétisée déclare un Workload — un Deployment plus un Service ClusterIP exécutant l’image officielle fluent/fluentd — que le fournisseur helm traduit en manifestes Kubernetes sans aucun chart externe. L’ensemble de ressources rendu est exactement ce que déclare le Workload.
  • Routage contrôlé par le développeur. Le match de sortie du développeur sélectionne les enregistrements reçus qui sont acheminés vers la sortie de l’agrégateur. Sa valeur par défaut est **, qui achemine chaque enregistrement reçu.
  • Tampon éphémère par défaut, durable sur demande. L’agrégateur met en tampon en mémoire, si bien que le rendu par défaut ne comporte aucun volume persistant. Définir infra.storage.size (voir release-helm-synth-buffer.yaml) adosse le tampon à un volume durable monté sur /fluentd/log ; la charge de travail reste un Deployment à réplique unique.
  • Images reproductibles. infra.engine_version épingle le tag de l’image Fluentd, si bien que la charge de travail rendue référence une image fixe et que la Recipe synthétisée ne rend 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 fluentd-aggregator

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

Terminal window
cd fluentd-aggregator

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

À quoi ressemble l’endpoint forward

Sur Compose, l’agrégateur écrit un fluent.conf avec une source d’entrée forward liée au port forward, et achemine les enregistrements correspondants vers la sortie standard :

<source>
@type forward
bind 0.0.0.0
port 24224
</source>
<match **>
@type stdout
</match>

Sur Kubernetes, la Recipe helm synthétisée écrit le même fluent.conf au démarrage, et le Service ClusterIP expose le port forward :

spec:
type: ClusterIP
[… omitted: the selector matching the aggregator's Pods]
ports:
- name: forward
port: 24224
targetPort: forward

Le Deployment référence l’image épinglée et expose le port forward sur le conteneur :

image: fluent/fluentd:v1.19.3-debian-2.1
[… omitted: the start-up command that writes the fluent.conf shown above]
ports:
- name: forward
containerPort: 24224

Lorsque infra.storage.size est défini, la Recipe rend en outre un PersistentVolumeClaim et le monte sur /fluentd/log, servant de support à un tampon sur fichier afin que les enregistrements en tampon survivent aux redémarrages.

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’agrégateur écoute les enregistrements transférés sur localhost:24224. Envoyez-lui un enregistrement de test avec n’importe quel forwarder Fluentd ou Fluent Bit pointé vers ce port, et les enregistrements reçus apparaissent sur la sortie standard de l’agrégateur. Pour tout arrêter, utilisez docker compose -f dist/app/compose/docker-compose.yaml down.