Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Brasil)
Esta página foi traduzida automaticamente. Leia o original em inglês.

De Fluent Bit para Fluentd — um pipeline de logs de duas camadas, dois destinos

Este exemplo compila um pipeline de logs real — um forwarder Fluent Bit que envia registros a um agregador Fluentd pelo protocolo forward — a partir de um único Aggregate escrito pelo desenvolvedor para duas realizações:

  • Docker Compose para o desenvolvimento local, e
  • as Recipes helm sintetizadas que executam as imagens upstream oficiais fluent/fluent-bit e fluent/fluentd diretamente no Kubernetes (sem charts externos).

As Recipes helm sintetizadas não baixam nada em tempo de build; helm/fluent-bit-chart e helm/fluentd-chart renderizam, em vez disso, os charts do próprio projeto Fluent, para um build que consiga alcançar um repositório de charts.

O mesmo aggregate.yaml conduz ambas. Só muda por realização a camada de Recipe selecionada pelo Manifest.

O pipeline

Dois componentes formam um pipeline de forwarder para agregador:

  • forwarder (core/observability/fluent-bit) coleta registros de log e os envia por uma saída forward. Ele é tipado como servidor sem estado.
  • aggregator (core/observability/fluentd) escuta no protocolo de entrada forward, recebe os registros e os roteia para a sua saída. Ele é tipado como servidor com estado; a Recipe helm sintetizada mantém o buffer em memória por padrão, então ele é renderizado como um Deployment de réplica única.

O forwarder declara um uso forward_target do agregador. Os provides.host e provides.port do agregador — o host e a porta do seu endpoint forward (a porta forward convencional do Fluentd, 24224) — são canalizados para o forwarder e renderizados em Host e Port da sua saída forward. Assim, o forwarder envia para o endpoint forward do agregador, ligado antecipadamente a partir de uma única aresta.

Arquivos

ArquivoPapel
aggregate.yamlIntenção do desenvolvedor: um sink aggregator (core/observability/fluentd) e um forwarder (core/observability/fluent-bit) que declara um uso forward_target do agregador.
manifest-compose.yamlMapeia o tipo Fluent Bit para a Recipe do Compose (compose/fluent-bit) e o tipo Fluentd para a Recipe do Compose (compose/fluentd).
manifest-helm-synth.yamlMapeia o tipo Fluent Bit para a Recipe helm sintetizada (helm/fluent-bit) e o tipo Fluentd para a Recipe helm sintetizada (helm/fluentd).
release-compose.yaml / release-helm-synth.yamlDocumentos do operador para as duas realizações.

Como os nomes fluent-bit e fluentd são usados tanto por uma Recipe do Compose quanto por uma helm sintetizada, os Manifests as referenciam com escopo de provedor (compose/… e helm/…).

O que ele demonstra

  • Uma única superfície de autoria, muitos destinos. Um único Aggregate é a fonte da verdade sobre o que o pipeline é. Cada Manifest diz como realizá-lo.
  • Ligação forward através do String Pipe. O forwarder declara um uso forward_target do agregador; os provides.host e provides.port da Recipe do agregador são canalizados para o forwarder e renderizados em Host e Port de uma saída forward. O compilador roteia as strings sem interpretá-las — assim, o build do Compose liga um nome de serviço do compose e o build do Kubernetes liga um nome de Service, a partir da mesma aresta.
  • Um sink com estado no socket de um forwarder sem estado. O socket forward_target do forwarder seleciona um server ou um stateful-server. O Fluentd é tipado como servidor com estado e se vincula ao socket sem problemas — o socket seleciona pelo papel operacional de servidor, não pelo fato de o sink manter estado. O que o sink fala é verificado à parte: a saída forward fala o protocolo forward do Fluentd, então o build é interrompido a menos que o sink publique protocol: forward, como o Fluentd faz.
  • Síntese de Workload (Kubernetes). Cada Recipe helm sintetizada declara um Workload — um Deployment mais um Service ClusterIP que executa a imagem oficial — que o provedor helm traduz em manifestos do Kubernetes sem nenhum chart externo. O conjunto de recursos renderizado é exatamente o que os Workloads declaram.
  • Imagens reproduzíveis. infra.engine_version fixa cada tag de imagem, então as cargas de trabalho renderizadas referenciam imagens fixas e as Recipes sintetizadas não renderizam nenhuma tag flutuante.

Gerar o exemplo

Você pode fazer o build deste exemplo com os comandos abaixo, ou pedir ao seu assistente de IA que faça o build por você.

Escreva o exemplo em uma nova pasta com o nome dele:

Terminal window
aggrega scaffold --example fluent-bit-to-fluentd

Em seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova:

Terminal window
cd fluent-bit-to-fluentd

Build

Este workspace não traz nenhum .aggrega-config.yaml, então as entidades da biblioteca padrão são resolvidas a partir do registro do hub, hub.aggrega.ai, e nenhuma flag de catálogo é necessária; --auto-pull escreve durante o build o lockfile que falta a um clone novo:

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

Os artefatos renderizados ficam em dist/.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole este prompt nele.

Use somente as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta do espaço de trabalho ainda não contém uma pasta `fluent-bit-to-fluentd`, chame uma vez a ferramenta `scaffold` com `example` definido como `fluent-bit-to-fluentd` e sem `dir`: ela grava o exemplo em uma nova pasta `fluent-bit-to-fluentd`. Em seguida, chame a ferramenta `build` uma vez para cada Release, nesta ordem — `release-compose.yaml`, `release-helm-synth.yaml` — cada vez com `workspace_root` definido como `fluent-bit-to-fluentd`, `release` definido como esse arquivo, `auto_pull` definido como true e `write` definido como true. Diga-me quais arquivos cada build gravou; eles ficam em `fluent-bit-to-fluentd/dist/`.

Como fica o destino forward injetado

No Compose, o forwarder escreve um fluent-bit.conf cuja saída forward aponta para o nome de serviço do compose e para a porta forward do agregador:

[OUTPUT]
Name forward
Match *
Host aggregator
Port 24224

No Kubernetes, a mesma saída aponta para o nome do Service interno ao cluster do agregador:

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

Ambos derivam da mesma aresta do Aggregate — o host e a porta do agregador trafegam pelo uso forward_target, e cada destino os renderiza no seu próprio idioma. A porta 24224 é o endpoint forward do agregador, exportado pelos seus provides e canalizado antecipadamente para o forwarder.

Executá-lo (Compose)

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

O endpoint de monitoramento do forwarder é publicado apenas no endereço de loopback do host, em http://localhost:2020 — o seu endpoint /api/v1/metrics informa os registros processados e encaminhados. O endpoint não verifica nenhum chamador, então ele não é publicado nas outras interfaces do host, a menos que a Release defina infra.publish_on_all_interfaces: true no forwarder. Para desmontar, use docker compose -f dist/app/compose/docker-compose.yaml down.