Composição
Esta página explica uma ideia, construir uma aplicação a partir de partes maiores do que um componente, e não é um espaço de trabalho executável. Encaminhamento de módulos para fronteiras — colocar submódulos inteiros em fronteiras mostra-a num espaço de trabalho que se constrói; pode escrevê-lo numa pasta própria com:
aggrega scaffold --example module-boundary-routingDepois, imprime os próximos comandos a executar:
cd module-boundary-routingaggrega build --release release.yaml --auto-pullMódulos: um Aggregate importado por outro
Um Aggregate pode importar outro Aggregate como módulo em aggregates:. O módulo compõe os seus próprios componentes e liga as suas próprias arestas, pelo que nada do seu interior aparece no Aggregate que o importa. O exemplo importa dois módulos do catálogo da biblioteca padrão, a partir de aggregate.yaml:
spec: aggregates: metrics: type: core/thanos documents: type: core/ferretdbO bloco exportedComponents de um módulo é a sua interface pública: os componentes aos quais algo exterior ao módulo se pode ligar, cada um sob o nome com que é exportado. core/ferretdb exporta o seu componente proxy como mongo, pelo que um componente do Aggregate importador o alcança com o caminho pontuado documents.mongo:
uses: database: main: target: documents.mongoUm módulo pode declarar parâmetros próprios, que o Aggregate importador preenche no parameters: da importação.
Colocar um módulo
A Release coloca um módulo inteiro numa fronteira com uma entrada aggregates: cuja chave é o nome do módulo, e cada componente que o módulo contém acompanha-o. Pode também configurar os componentes do módulo, cada um pelo nome que tem dentro do módulo. De release.yaml, sem os comentários:
spec: boundaries: observability: directory: observability annotations: aggrega.ai/namespace: observability aggregates: metrics: components: query: infra: compute: cpu: 500m memory: 1Gi data: directory: data annotations: aggrega.ai/namespace: data aggregates: documents: {}As anotações próprias de um módulo chegam aos seus próprios componentes exatamente como as de um Aggregate chegam aos seus, pelo que um módulo pode colocar os seus componentes num namespace que declara. O Aggregate importador não declara nada que chegue ao interior do módulo; a Release sim, e o seu valor prevalece na mesma chave.
Um serviço que a compilação não aprovisiona
Um servidor que já existe continua a ser um nó do grafo: participa nas ligações, na política e no que os seus consumidores recebem, e nada é aprovisionado para ele. O seu Manifest associa uma Recipe que não aprovisiona nada, e a Release indica o endereço. Em Um contrato, três realizações, o Manifest manifest-external.yaml associa core/datastore/postgres a helm/postgres-external, que emite apenas um Service ExternalName, e a Release fornece o endereço, a partir de release-external.yaml:
db: infra: overrides: host: postgres.data.example.netO endereço é uma string de ponteiro: a compilação passa-o sem o resolver, e aquilo que responder nesse nome quando a aplicação estiver em execução é o que a aplicação alcança. O Aggregate é o mesmo ficheiro para as três Releases do exemplo.
Subsistemas: agrupar dentro de um Aggregate
Um subsistema agrupa componentes dentro de um Aggregate. As anotações declaradas nele chegam a todos os componentes que contém, e uma Feature acoplada a ele é acoplada a cada um deles:
spec: subsystems: billing: annotations: team.aggrega.ai/owner: billing-squad aggrega.ai/namespace: billing features: metrics: type: core/prometheus-exporter components: invoice-api: type: core/compute/server payment-worker: type: core/compute/workerA compilação achata a árvore de subsistemas: invoice-api e payment-worker transportam cada um o acoplamento metrics e ambas as anotações, que uma Recipe lê como {{ index .context.annotations.aggregate "team.aggrega.ai/owner" }}. aggrega.ai/namespace é uma anotação do fornecedor, pelo que também coloca ambos os componentes no namespace billing. A Release configura o infra do acoplamento na entrada de cada componente, pelo nome que o subsistema lhe deu, e um namespace que a Release define substitui o do subsistema para os componentes que abrange.
Um acoplamento que se liga a algo próprio
Um acoplamento pode transportar o seu próprio bloco uses:, traçando uma aresta a partir do acoplamento em vez de a partir do componente em que assenta. Em Um datastore com cópia de segurança em todos os destinos, o operador acopla core/backup à base de dados e liga o acoplamento ao bucket para onde vão as cópias de segurança, a partir de release-helm-velero.yaml:
spec: components: db: features: backup: type: core/backup infra: schedule: "30 2 * * *" retention_days: 14 uses: store: bucket: target: backupsAs ligações próprias da base de dados não se alteram: a aresta para backups pertence ao acoplamento, é registada como traçada por ele e é verificada pela política como qualquer outra aresta. Uma Feature operacional e uma Feature de credenciais acoplam-se da mesma forma, e qualquer uma delas pode transportar um bloco uses:.