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

Da Fluent Bit a Fluentd — una pipeline di log a due livelli, due target

Questo esempio compila una vera pipeline di log — un forwarder Fluent Bit che invia record a un aggregatore Fluentd tramite il protocollo forward — a partire da un unico Aggregate scritto dallo sviluppatore in due realizzazioni:

  • Docker Compose per lo sviluppo locale, e
  • le Recipes helm sintetizzate che eseguono le immagini upstream ufficiali fluent/fluent-bit e fluent/fluentd direttamente su Kubernetes (nessun chart esterno).

Le Recipes helm sintetizzate non scaricano nulla in fase di build; helm/fluent-bit-chart e helm/fluentd-chart renderizzano invece i chart del progetto Fluent stesso, 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.

La pipeline

Due componenti formano una pipeline da forwarder ad aggregatore:

  • forwarder (core/observability/fluent-bit) raccoglie i record di log e li invia su un output forward. È tipizzato come server stateless.
  • aggregator (core/observability/fluentd) è in ascolto sul protocollo di input forward, riceve i record e li instrada verso il proprio output. È tipizzato come server stateful; la Recipe helm sintetizzata mantiene il buffer in memoria per impostazione predefinita, quindi viene renderizzato come un Deployment a replica singola.

Il forwarder dichiara un uso forward_target dell’aggregatore. I provides.host e provides.port dell’aggregatore — host e porta del suo endpoint forward (la porta forward convenzionale di Fluentd, 24224) — vengono convogliati nel forwarder e renderizzati in Host e Port del suo output forward. Così il forwarder invia all’endpoint forward dell’aggregatore, cablato in anticipo a partire da un singolo arco.

File

FileRuolo
aggregate.yamlIntento dello sviluppatore: un sink aggregator (core/observability/fluentd) e un forwarder (core/observability/fluent-bit) che dichiara un uso forward_target dell’aggregatore.
manifest-compose.yamlMappa il tipo Fluent Bit sulla Recipe Compose (compose/fluent-bit) e il tipo Fluentd sulla Recipe Compose (compose/fluentd).
manifest-helm-synth.yamlMappa il tipo Fluent Bit sulla Recipe helm sintetizzata (helm/fluent-bit) e il tipo Fluentd sulla Recipe helm sintetizzata (helm/fluentd).
release-compose.yaml / release-helm-synth.yamlDocumenti dell’operatore per le due realizzazioni.

Poiché i nomi fluent-bit e fluentd sono portati sia da una Recipe Compose sia da una helm sintetizzata, i Manifests vi fanno riferimento con ambito di provider (compose/… e helm/…).

Che cosa dimostra

  • Un’unica superficie di authoring, molti target. Un unico Aggregate è la fonte di verità su che cosa è la pipeline. Ogni Manifest dice come realizzarla.
  • Cablaggio forward attraverso lo String Pipe. Il forwarder dichiara un uso forward_target dell’aggregatore; i provides.host e provides.port della Recipe dell’aggregatore vengono convogliati nel forwarder e renderizzati in Host e Port di un output forward. Il compilatore instrada le stringhe senza interpretarle — così il build Compose cabla un nome di servizio compose e il build Kubernetes cabla un nome di Service, a partire dallo stesso arco.
  • Un sink stateful sul socket di un forwarder stateless. Il socket forward_target del forwarder seleziona un server o uno stateful-server. Fluentd è tipizzato come server stateful e si lega al socket senza problemi — il socket seleziona in base al ruolo operativo di server, non in base al fatto che il sink mantenga uno stato. Ciò che il sink parla viene verificato separatamente: l’output forward parla il protocollo forward di Fluentd, quindi il build si arresta a meno che il sink non pubblichi protocol: forward, come fa Fluentd.
  • Sintesi del Workload (Kubernetes). Ogni Recipe helm sintetizzata dichiara un Workload — un Deployment più un Service ClusterIP che esegue l’immagine ufficiale — che il provider helm traduce in manifest Kubernetes senza alcun chart esterno. L’insieme di risorse renderizzato è esattamente ciò che dichiarano i Workloads.
  • Immagini riproducibili. infra.engine_version fissa ciascun tag di immagine, quindi i carichi di lavoro renderizzati fanno riferimento a immagini fisse e le Recipes sintetizzate non renderizzano 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 fluent-bit-to-fluentd

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

Terminal window
cd fluent-bit-to-fluentd

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 Recipes, official images)
aggrega build --release release-helm-synth.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 `fluent-bit-to-fluentd`, chiama una volta lo strumento `scaffold` con `example` impostato a `fluent-bit-to-fluentd` e senza `dir`: scrive l’esempio in una nuova cartella `fluent-bit-to-fluentd`. Poi chiama lo strumento `build` una volta per ogni Release, in quest’ordine — `release-compose.yaml`, `release-helm-synth.yaml` — ogni volta con `workspace_root` impostato a `fluent-bit-to-fluentd`, `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 `fluent-bit-to-fluentd/dist/`.

Come appare la destinazione forward iniettata

Su Compose, il forwarder scrive un fluent-bit.conf il cui output forward punta al nome del servizio compose dell’aggregatore e alla porta forward:

[OUTPUT]
Name forward
Match *
Host aggregator
Port 24224

Su Kubernetes, lo stesso output punta al nome del Service interno al cluster dell’aggregatore:

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

Entrambi derivano dallo stesso arco dell’Aggregate — host e porta dell’aggregatore viaggiano attraverso l’uso forward_target, e ciascun target li renderizza nel proprio idioma. La porta 24224 è l’endpoint forward dell’aggregatore, esportato tramite i suoi provides e convogliato in anticipo nel forwarder.

Eseguirlo (Compose)

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

L’endpoint di monitoraggio del forwarder è pubblicato solo sull’indirizzo di loopback dell’host, su http://localhost:2020 — il suo endpoint /api/v1/metrics riporta i record elaborati e inoltrati. L’endpoint non verifica alcun chiamante, quindi non viene pubblicato sulle altre interfacce dell’host a meno che la Release non imposti infra.publish_on_all_interfaces: true sul forwarder. Per smontarlo, usa docker compose -f dist/app/compose/docker-compose.yaml down.