Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Fluentd — un aggregatore di log, due target

Questo esempio compila un aggregatore di log Fluentd — l’estremità ricevente di una pipeline di log — a partire da un unico Aggregate scritto dallo sviluppatore in due realizzazioni:

  • Docker Compose per lo sviluppo locale, e
  • la Recipe helm sintetizzata che esegue l’immagine upstream ufficiale fluent/fluentd direttamente su Kubernetes (nessun chart esterno).

La Recipe helm sintetizzata non scarica nulla in fase di build; helm/fluentd-chart renderizza il chart del progetto Fluent stesso come il medesimo aggregatore, per un build che può raggiungere un repository di chart.

Lo stesso aggregate.yaml guida entrambe. Per ogni realizzazione cambia solo il livello di Recipe selezionato dal Manifest.

Il ruolo di aggregatore

Una pipeline di log ha due estremità. Un forwarder (come Fluent Bit) raccoglie i record di log e li invia a valle. Un aggregatore è il sink all’altra estremità: è in ascolto sul protocollo di input forward, riceve i record che gli inviano i forwarder a monte e li instrada verso il proprio output. Qui Fluentd svolge il ruolo di aggregatore.

Poiché l’aggregatore riceve anziché inoltrare, non dichiara alcun socket uses a valle. Esporta invece host e porta del suo endpoint forward tramite provides, così un forwarder può legarlo su un socket forward e inviargli record. L’endpoint forward è in ascolto sulla porta 24224 — la porta forward convenzionale di Fluentd.

File

FileRuolo
aggregate.yamlIntento dello sviluppatore: un componente aggregator (core/observability/fluentd) in ascolto sull’input forward.
manifest-compose.yamlMappa il tipo Fluentd sulla Recipe Compose (compose/fluentd).
manifest-helm-synth.yamlMappa il tipo Fluentd sulla Recipe helm sintetizzata (helm/fluentd).
release-compose.yaml / release-helm-synth.yamlDocumenti dell’operatore per le due realizzazioni.
release-helm-synth-buffer.yamlLa realizzazione helm sintetizzata con il buffering durevole abilitato (infra.storage.size impostato).

Poiché il nome fluentd è portato sia da una Recipe Compose sia da una helm sintetizzata, i Manifests vi fanno riferimento con ambito di provider come compose/fluentd e helm/fluentd.

Che cosa dimostra

  • Un’unica superficie di authoring, molti target. Un unico Aggregate è la fonte di verità su che cosa è lo stack. Ogni Manifest dice come realizzarlo.
  • L’estremità ricevente dello String Pipe. L’aggregatore esporta il suo endpoint forward tramite provides — host (il servizio dell’aggregatore) e port (24224) sul protocollo forward. Un forwarder che si lega a questo componente convoglia quelle stringhe nel proprio output forward; il compilatore le instrada senza interpretarle.
  • Sintesi del Workload (Kubernetes). La Recipe helm sintetizzata dichiara un Workload — un Deployment più un Service ClusterIP che esegue l’immagine ufficiale fluent/fluentd — che il provider helm traduce in manifest Kubernetes senza alcun chart esterno. L’insieme di risorse renderizzato è esattamente ciò che dichiara il Workload.
  • Instradamento controllato dallo sviluppatore. Il match di output dello sviluppatore seleziona quali record ricevuti vengono instradati verso l’output dell’aggregatore. Il valore predefinito è **, che instrada ogni record ricevuto.
  • Buffer effimero per impostazione predefinita, durevole su richiesta. L’aggregatore mantiene il buffer in memoria, quindi il rendering predefinito non contiene alcun volume persistente. Impostare infra.storage.size (vedi release-helm-synth-buffer.yaml) appoggia il buffer su un volume durevole montato in /fluentd/log; il carico di lavoro resta un Deployment a replica singola.
  • Immagini riproducibili. infra.engine_version fissa il tag dell’immagine di Fluentd, quindi il carico di lavoro renderizzato fa riferimento a un’immagine fissa e la Recipe sintetizzata non renderizza alcun tag flottante.

Generare l’esempio

Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

Terminal window
aggrega scaffold --example fluentd-aggregator

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:

Terminal window
cd fluentd-aggregator

Build

Questo workspace non contiene alcun .aggrega-config.yaml, quindi le entità della libreria standard vengono risolte dal registry dell’hub, hub.aggrega.ai, e non serve alcun flag di catalogo; --auto-pull scrive durante il build il lockfile che manca a un clone appena creato:

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

Gli artefatti renderizzati finiscono sotto dist/.

Con un assistente AI

Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella dell’area di lavoro non contiene ancora una cartella `fluentd-aggregator`, chiama una volta lo strumento `scaffold` con `example` impostato a `fluentd-aggregator` e senza `dir`: scrive l’esempio in una nuova cartella `fluentd-aggregator`. Poi chiama lo strumento `build` una volta per ogni Release, in quest’ordine — `release-compose.yaml`, `release-helm-synth.yaml`, `release-helm-synth-buffer.yaml` — ogni volta con `workspace_root` impostato a `fluentd-aggregator`, `release` impostato a quel file, `auto_pull` impostato a true e `write` impostato a true. Dimmi quali file ha scritto ciascuna build; si trovano in `fluentd-aggregator/dist/`.

Come appare l’endpoint forward

Su Compose, l’aggregatore scrive un fluent.conf con una sorgente di input forward legata alla porta forward, e instrada i record corrispondenti verso lo standard output:

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

Su Kubernetes, la Recipe helm sintetizzata scrive lo stesso fluent.conf all’avvio, e il Service ClusterIP espone la porta forward:

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

Il Deployment fa riferimento all’immagine fissata ed espone la porta forward sul container:

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

Quando infra.storage.size è impostato, la Recipe renderizza inoltre un PersistentVolumeClaim e lo monta in /fluentd/log, appoggiandovi un buffer su file così che i record nel buffer sopravvivano ai riavvii.

Eseguirlo (Compose)

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

L’aggregatore è in ascolto dei record inoltrati su localhost:24224. Inviagli un record di prova con un qualsiasi forwarder Fluentd o Fluent Bit puntato su quella porta, e i record ricevuti compaiono sullo standard output dell’aggregatore. Per smontarlo, usa docker compose -f dist/app/compose/docker-compose.yaml down.