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

De Fluent Bit para Fluentd — um pipeline de registos de dois níveis, dois destinos

Este exemplo compila um pipeline de registos real — um forwarder Fluent Bit que envia registos para um agregador Fluentd através do protocolo forward — a partir de um único Aggregate escrito pelo programador em 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 transferem nada em tempo de compilação; helm/fluent-bit-chart e helm/fluentd-chart renderizam, em vez disso, os charts do próprio projeto Fluent, para uma compilação que consiga chegar a um repositório de charts.

O mesmo aggregate.yaml conduz ambas. Só muda, de realização para 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) recolhe registos de log e envia-os numa saída forward. É tipificado como servidor sem estado.
  • aggregator (core/observability/fluentd) escuta no protocolo de entrada forward, recebe os registos e encaminha-os para a sua saída. É tipificado como servidor com estado; a Recipe helm sintetizada mantém o buffer em memória por predefinição, pelo que é 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 encaminhados 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.

Ficheiros

FicheiroPapel
aggregate.yamlIntenção do programador: 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 como por uma helm sintetizada, os Manifests referenciam-nas com âmbito de fornecedor (compose/… e helm/…).

O que demonstra

  • Uma única superfície de autoria, muitos destinos. Um único Aggregate é a fonte de 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 encaminhados para o forwarder e renderizados em Host e Port de uma saída forward. O compilador encaminha as strings sem as interpretar — assim, a compilação para Compose liga um nome de serviço do compose e a compilação para 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 é tipificado como servidor com estado e liga-se ao socket sem problemas — o socket seleciona pelo papel operacional de servidor, e não pelo facto de o sink guardar estado. O que o sink fala é verificado à parte: a saída forward fala o protocolo forward do Fluentd, pelo que a compilação é interrompida 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 fornecedor 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, pelo que as cargas de trabalho renderizadas referenciam imagens fixas e as Recipes sintetizadas não renderizam nenhuma tag flutuante.

Gerar o exemplo

É possível compilar este exemplo com os comandos abaixo, ou pedir ao assistente de IA que o compile.

Escreva o exemplo numa nova pasta com o nome dele:

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

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta:

Terminal window
cd fluent-bit-to-fluentd

Compilação

Este workspace não contém nenhum .aggrega-config.yaml, pelo que as entidades da biblioteca standard são resolvidas a partir do registo do hub, hub.aggrega.ai, e não é necessária nenhuma flag de catálogo; --auto-pull escreve durante a compilação o lockfile que falta a um clone acabado de criar:

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 artefactos renderizados ficam em dist/.

Com um assistente de IA

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

Utilize apenas as ferramentas do Aggrega e não crie nenhuma pasta por si. Se a pasta da área de trabalho ainda não contiver uma pasta `fluent-bit-to-fluentd`, chame uma vez a ferramenta `scaffold` com `example` definido como `fluent-bit-to-fluentd` e sem `dir`: esta escreve o exemplo numa nova pasta `fluent-bit-to-fluentd`. Em seguida, chame a ferramenta `build` uma vez para cada Release, por esta ordem — `release-compose.yaml`, `release-helm-synth.yaml` — de cada vez com `workspace_root` definido como `fluent-bit-to-fluentd`, `release` definido como esse ficheiro, `auto_pull` definido como true e `write` definido como true. Indique-me que ficheiros cada build escreveu; encontram-se em `fluent-bit-to-fluentd/dist/`.

Como é 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 viajam pelo uso forward_target, e cada destino renderiza-os no seu próprio idioma. A porta 24224 é o endpoint forward do agregador, exportado através dos seus provides e encaminhado 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 monitorização do forwarder é publicado apenas no endereço de loopback do host, em http://localhost:2020 — o seu endpoint /api/v1/metrics indica os registos processados e encaminhados. O endpoint não verifica nenhum chamador, pelo que não é publicado nas outras interfaces do host, a menos que a Release defina infra.publish_on_all_interfaces: true no forwarder. Para desmontar, execute docker compose -f dist/app/compose/docker-compose.yaml down.