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

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:

Terminal window
aggrega scaffold --example module-boundary-routing

Em seguida ele imprime os próximos comandos a executar:

Terminal window
cd module-boundary-routing
aggrega build --release release.yaml --auto-pull

Mó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/ferretdb

O 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.mongo

Um 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.net

O 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/worker

O 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: backups

As 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:.