Composição
Esta página explica uma ideia, construir uma aplicação a partir de partes maiores que um componente, e não é um espaço de trabalho executável. Roteamento de módulos para fronteiras — colocando submódulos inteiros em fronteiras a mostra em um espaço de trabalho que você constrói; escreva-o em uma pasta sua com:
aggrega scaffold --example module-boundary-routingEm seguida ele 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 seus próprios componentes e conecta suas próprias arestas, então nada do seu interior aparece no Aggregate que o importa. O exemplo importa dois módulos do catálogo da biblioteca padrão, 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 de fora do módulo pode se conectar, cada um sob o nome com que é exportado. core/ferretdb exporta o seu componente proxy como mongo, então 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.
Posicionando um módulo
A Release coloca um módulo inteiro em uma fronteira com uma entrada aggregates: cuja chave é o nome do módulo, e cada componente que o módulo contém vai junto com ele. Ela também pode 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 alcançam os seus próprios componentes exatamente como as de um Aggregate alcançam os seus, então um módulo pode colocar os seus componentes em um namespace que ele declara. O Aggregate importador não declara nada que alcance o interior do módulo; a Release sim, e o seu valor prevalece na mesma chave.
Um serviço que o build não provisiona
Um servidor que já existe continua sendo um nó do grafo: ele participa das conexões, da política e do que os seus consumidores recebem, e nada é provisionado para ele. O seu Manifest vincula uma Recipe que não provisiona nada, e a Release fornece o endereço. Em Um contrato, três realizações, o Manifest manifest-external.yaml vincula core/datastore/postgres a helm/postgres-external, que emite apenas um Service ExternalName, e a Release fornece o endereço, de release-external.yaml:
db: infra: overrides: host: postgres.data.example.netO endereço é uma string de ponteiro: o build a repassa sem resolvê-la, e o que quer que responda nesse nome quando a aplicação é executada é o que a aplicação alcança. O Aggregate é o mesmo arquivo para as três Releases do exemplo.
Subsistemas: agrupando dentro de um Aggregate
Um subsistema agrupa componentes dentro de um Aggregate. As anotações declaradas nele alcançam cada componente que ele 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/workerO build achata a árvore de subsistemas: invoice-api e payment-worker carregam 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 provedor, então ela 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 ela cobre.
Um acoplamento que se conecta a algo próprio
Um acoplamento pode carregar o seu próprio bloco uses:, traçando uma aresta a partir do acoplamento em vez de a partir do componente em que está. Em Um datastore com backup em todos os destinos, o operador acopla core/backup ao banco de dados e conecta o acoplamento ao bucket para onde vão os backups, 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 conexões próprias do banco de dados não mudam: a aresta para backups pertence ao acoplamento, é registrada como traçada por ele e é verificada pela política como qualquer outra aresta. Uma Feature operacional e uma Feature de credenciais são acopladas da mesma forma, e qualquer uma delas pode carregar um bloco uses:.