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

Anotações bem conhecidas

Os Providers leem anotações específicas para configurar um contexto específico da plataforma — definidas na fronteira de uma Release ou na entrada de um componente em uma Release, ou declaradas no Aggregate em um subsistema ou em uma instância de componente. O próprio compilador é agnóstico em relação aos valores dessas anotações — ele os repassa como strings opacas. Cada provedor declara quais anotações lê, em qual escopo e qual padrão se aplica quando a anotação está ausente. Essa declaração fica em spec.provider.wellKnownAnnotations de um Plugin de renderização de provedor, e é deliberadamente estreita: um provedor lista uma chave apenas onde a lê. Um provedor que não lê nenhuma delas declara, em vez disso, spec.provider.readsNoWellKnownAnnotations: true.

A matriz de suporte deste capítulo é gerada a partir dessas declarações, na granularidade que a declaração carrega — por provedor por tipo de entrada, porque um provedor pode ler uma chave quando sintetiza uma unidade de implantação e não ter como lê-la quando renderiza um artefato copiado localmente. Escreva com base na matriz daqui: uma célula diz o que aquele provedor lê naquele caminho, porque uma célula não pode dizer nada que o provedor não tenha declarado. Uma declaração que nomeia um tipo de entrada que o próprio contrato de comportamento de renderização do provedor não renderiza é recusada quando a entidade Plugin é lida, então as duas afirmações não podem divergir.

O vocabulário reservado é o conjunto mais amplo, e fica em dois lugares — este capítulo, que nomeia cada chave reservada, inclusive as que nenhum provedor lê, e o conjunto de prefixos reservados que o lint de publicação verifica.

Os invariantes

  1. O compilador nunca interpreta nem valida o valor de uma anotação bem conhecida de provedor: ele carrega a chave e seu valor pela cascata e emite um aviso onde um destino não age sobre a chave.
  2. Cada provedor documenta quais anotações lê e quais padrões aplica.
  3. As anotações se aplicam de maneira uniforme dentro de uma fronteira. Se um valor varia por componente, ele pertence às anotações no nível do componente (que substituem as anotações da fronteira) ou a infra do componente.
  4. As anotações bem conhecidas dos Provider nunca duplicam os rótulos dos componentes. Os rótulos de Component descrevem o que um componente é. As anotações de fronteira descrevem onde um componente é implantado.
  5. As Recipes não tratam as anotações bem conhecidas do provedor. O provedor aplica automaticamente o contexto de posicionamento (namespace, prefixo de registro, service account) depois que a Recipe produz seu conteúdo.
  6. O prefixo aggrega.ai/ é reservado para a biblioteca padrão. Anotações corporativas personalizadas usam o próprio prefixo.
  7. As anotações no nível de Component na Release substituem as anotações no nível de fronteira (mesclagem profunda, o componente prevalece). Onde um provedor monta a saída de várias fronteiras em um único artefato, ele pode exigir que uma anotação seja resolvida de maneira uniforme entre elas — o provedor helm-chart obtém o nome do chart guarda-chuva de aggrega.ai/chart-name e, quando mais de uma fronteira contribui para o mesmo chart e elas resolvem essa anotação para valores diferentes, o build é interrompido nomeando as fronteiras em desacordo, porque um chart não pode ter dois nomes.
  8. As anotações que o Aggregate declara alcançam as mesmas chaves abaixo das da Release. Uma chave declarada em um subsistema ou em uma instância de componente — no próprio Aggregate, ou em um módulo que ele importa, onde alcança os componentes próprios do módulo — se aplica ao componente sempre que a Release não define nenhum valor para essa chave; onde a Release define um, na fronteira ou na entrada do componente, o valor aplicado é o da Release. As anotações próprias de uma entidade do catálogo nunca definem nenhum. aggrega.ai/chart-name é a exceção ao alcance do Aggregate: ela nomeia uma montagem em vez de um componente, e é lida das fronteiras da Release que contribuem para ela.

A matriz completa de anotações

Como ler esta matriz

As seis tabelas por categoria abaixo nomeiam cada anotação do vocabulário reservado aggrega.ai/, o que ela controla e o que o provedor faz quando ela está ausente. Se um determinado provedor aplica uma determinada chave é uma questão mais fina, porque um provedor renderiza mais de um tipo de entrada — um artefato copiado localmente (sourced), um Workload que o próprio provedor sintetiza (synthesized) ou os artifacts: de uma Recipe como a saída inteira de um nó (artifacts-only) — e uma chave pode ser lida em um desses caminhos enquanto é inalcançável em outro. Qual provedor renderiza qual tipo de entrada está em ../../architecture/16-recipe-input-composition.md; o que cada um aplica é Suporte por provedor e tipo de entrada abaixo, que é a declaração oficial desta página.

Cada célula dessa grade carrega um de três níveis:

  • Aplicada — o provedor aplica a chave neste tipo de entrada, e a saída renderizada muda de forma determinística como resultado.
  • Aplicada condicionalmente — o compilador emite uma substituição aditiva ao lado do artefato de destino em vez de editar o artefato, então o valor ter efeito depende de esse artefato expor uma chave correspondente própria. Eficaz na prática, nunca uma garantia. Nenhum provedor implementa uma célula condicional, e a superfície de declaração não oferece como expressar uma, então a grade gerada abaixo emite apenas os outros dois níveis. O nível é nomeado porque a via existe de fato para um artefato copiado localmente, e um vocabulário de dois níveis forçaria a matriz a reivindicar uma garantia que não pode dar ou a negar que a via sequer exista.
  • Não aplicada — nenhum provedor aplica a chave neste caminho: o destino não tem ali nenhum slot de renderização para ela, então o mecanismo de posicionamento não contribui em nada para o que é renderizado, e a coluna Padrão da tabela da categoria diz o que você obtém em vez disso. O valor ainda passa pelo build como uma string opaca, intacto. O nível recebe o nome do mecanismo, e não do que acontece com o valor, porque são perguntas diferentes e só a primeira é uma que uma célula consegue responder: o que um provedor aplica é uma propriedade dos slots de renderização desse destino, que é exatamente o que a declaração por trás de cada célula afirma.

Dois escopos, e só um deles faz do tipo de entrada um eixo significativo:

  • Com escopo de nó — aggrega.ai/namespace, aggrega.ai/image-registry, aggrega.ai/image-pull-secret, aggrega.ai/service-account e aggrega.ai/kubernetes-version moldam a saída renderizada própria de um componente, que é produzida pelo caminho que o seu tipo de entrada seleciona. Estas são as colunas da grade.
  • Com escopo de montagem e de referência — aggrega.ai/chart-name é resolvida uma única vez quando um chart guarda-chuva é montado, e as três chaves aggrega.ai/aws-* são resolvidas quando uma referência cruza uma fronteira. O tipo de entrada não é um eixo para nenhuma das duas: o valor é lido na montagem ou na referência, independentemente de como cada nó contribuinte foi renderizado. Elas têm uma tabela própria em Chaves resolvidas por montagem e por referência.

Categoria 1 — Posicionamento

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/namespacehelm (com fonte, sintetizado); compose (com fonte, sintetizado)Namespace do Kubernetes (helm); nome da rede do Docker (compose)Não é injetado se ausente (helm); uma rede nomeada a partir do caminho do arquivo compose, compartilhada por todos os nós desse arquivo sem a anotação (compose)
aggrega.ai/project-namereservada; nenhum provedor a lêReservada para um nome de projeto do Docker Compose—
aggrega.ai/regionreservada; nenhum provedor a lêReservada para uma região de nuvem no escopo de posicionamento—
aggrega.ai/account-idreservada; nenhum provedor a lêReservada para um identificador de conta de nuvem no escopo de posicionamento—
aggrega.ai/kubernetes-versionhelm (com fonte)Versão do Kubernetes do cluster em que o componente é implantado, que um chart renderizado a partir da fonte lê como .Capabilities.KubeVersionA versão para a qual renderiza o helm template padrão da mesma release do helm: a da biblioteca cliente do Kubernetes com a qual o provedor é construído

aggrega.ai/namespace tem duplo propósito por design. Expressa a mesma intenção de isolamento lógico — “os recursos desta fronteira vivem em seu próprio escopo endereçável” — na forma nativa de cada destino: um metadata.namespace do Kubernetes para o helm, um nome de rede do Docker para o compose. Os autores de Recipe definem uma única anotação; cada provedor a materializa de forma apropriada para o destino. No caso do compose, o nome da rede é resolvido por nó a partir da anotação desse nó, recorrendo ao caminho do arquivo compose onde o nó não carrega nenhuma anotação — de modo que fronteiras sem anotação que compartilham um arquivo compose compartilham uma rede, e é aggrega.ai/namespace que as separa. Seja qual for dos dois que fornece a identidade, ela é então escrita nos caracteres que um nome de rede do compose aceita — qualquer outro caractere é escrito como sequência de escape em vez de ser substituído, de modo que duas identidades que difiram em qualquer coisa permanecem em duas redes, e as maiúsculas e minúsculas da identidade são mantidas como foram escritas. A referência do provedor compose documenta a derivação por completo, incluindo como ler um nome codificado e quanto custa uma renomeação.

aggrega.ai/kubernetes-version declara uma propriedade do cluster em que um componente é implantado, e não onde dentro dele o componente vai parar: os templates de chart escolhem uma versão de API, um campo ou um mecanismo inteiro pela versão para a qual são renderizados, e o build não tem nenhum cluster a quem perguntar. O provedor helm lê o valor da mesma forma que helm template --kube-version lê sua flag e interrompe o build diante de um valor que não é uma versão; onde nenhuma é nomeada, um chart é renderizado para a versão para a qual renderiza helm template da mesma release do helm. A referência do provedor helm documenta as formas aceitas e o padrão.

Categoria 2 — Registro

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/image-registryhelm, compose — somente sintetizadoPrefixo de registro para imagens de contêiner, aplicado a toda referência a imagem de contêiner sintetizadaNenhum prefixo
aggrega.ai/image-pull-secrethelm — somente sintetizadoNome de imagePullSecrets do Kubernetes, unido às entradas existentes do pod sintetizadoNenhum

Categoria 3 — Rede

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/cluster-domainreservada; nenhum provedor a lêReservada para um sufixo DNS para descoberta de serviços entre namespaces—
aggrega.ai/ingress-classreservada; nenhum provedor a lêReservada para uma IngressClass do Kubernetes em recursos Ingress—
aggrega.ai/service-meshreservada; nenhum provedor a lêReservada para anotações de injeção de sidecar da malha—

Categoria 4 — Segurança

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/service-accounthelm — somente sintetizadoServiceAccount do Kubernetes para Pods sintetizados; substitui o workload.serviceAccount da Recipe quando ambos estão definidosO workload.serviceAccount da Recipe, ou não definido quando a Recipe não declara nenhum
aggrega.ai/pod-security-standardreservada; nenhum provedor a lêReservada para um nível dos Pod Security Standards—
aggrega.ai/iam-rolereservada; nenhum provedor a lêReservada para um papel de identidade de nuvem vinculado a uma carga de trabalho—

Categoria 5 — Empacotamento

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/chart-namehelm-chart — por montagemNome do chart guarda-chuvaNome do Aggregate e caminho de montagem do guarda-chuva, unidos — veja Resolução do nome do chart
aggrega.ai/chart-versionreservada; nenhum provedor a lêReservada para uma versão de chart do Helm—
aggrega.ai/stack-namereservada; nenhum provedor a lêReservada para uma stack nomeada explicitamente—
aggrega.ai/tf-backendreservada; nenhum provedor a lêReservada para um identificador de backend de estado do Terraform—

Categoria 6 — Destino de nuvem

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/aws-accountcloudformation — por referência entre fronteirasConta da AWS em que a stack (fronteira) é implantadaMesma conta — uma referência entre stacks é resolvida por meio da importação de uma exportação de stack da mesma conta
aggrega.ai/aws-regioncloudformation — por referência entre fronteirasRegião da AWS em que a stack (fronteira) é implantadaMesma região — uma referência entre stacks é resolvida por meio da importação de uma exportação de stack da mesma região
aggrega.ai/aws-assume-role-arncloudformation — por referência entre fronteirasARN do papel do IAM que uma leitura de stack entre contas assume para alcançar os valores exportados de uma stack homólogaNenhum papel é fornecido em uma referência entre contas

Cada fronteira do CloudFormation é renderizada em uma única stack. Quando uma aresta uses cruza de uma fronteira para outra, o provedor cloudformation precisa saber onde fica a stack homóloga para moldar a referência: duas stacks na mesma conta e região trocam valores por meio de uma exportação e importação de stack; uma homóloga em uma conta ou região diferente precisa de uma leitura de saídas de stack entre contas, opcionalmente sob um papel assumido. Essas anotações carregam esse contexto de posicionamento. Cada uma é lida no momento em que o provedor molda tal referência, e resolvida nesse momento pela cascata comum de anotações — um valor definido no componente prevalece sobre um valor definido na fronteira, e um valor que a Release define prevalece sobre um que o Aggregate declara. Um valor no nível da fronteira é, portanto, a forma comum de expressá-las, não a única. São strings de ponteiro escalares opacas — o provedor as repassa para a referência que constrói e nunca as resolve contra o estado real da AWS; a conta, a região e o papel são fornecidos pela Release ou declarados no Aggregate, e o ambiente de execução resolve a leitura física final. Quando todas as anotações estão ausentes, o provedor trata a homóloga como da mesma conta e da mesma região e não fornece nenhum papel.

Suporte por provedor e tipo de entrada

As chaves com escopo de nó, por provedor e por tipo de entrada. Os cabeçalhos das colunas omitem o prefixo aggrega.ai/ que toda chave carrega. applied e — carregam os níveis definidos acima, sendo — não aplicada; n/a significa que o provedor não renderiza esse tipo de entrada de forma alguma, então não existe ali nenhum caminho em que a chave possa ser aplicada ou deixar de ser aplicada.

ProviderTipo de entradanamespaceimage-registryimage-pull-secretservice-accountkubernetes-version
helmsourcedapplied———applied
helmsynthesizedappliedappliedappliedapplied—
helmartifacts-only—————
composesourcedapplied————
composesynthesizedappliedapplied———
composeartifacts-only—————
helm-chartsourced—————
helm-chartsynthesizedn/an/an/an/an/a
helm-chartartifacts-onlyn/an/an/an/an/a
terraformsourced—————
terraformsynthesizedn/an/an/an/an/a
terraformartifacts-only—————
cloudformationsourced—————
cloudformationsynthesizedn/an/an/an/an/a
cloudformationartifacts-only—————

Todo provedor distribuído com o compilador tem linhas aqui, inclusive um que não lê nenhuma anotação de posicionamento — um conjunto de linhas vazio seria indistinguível de um provedor que ninguém descreveu ainda. Um provedor fornecido separadamente declara o que lê da mesma forma e não é listado aqui, porque uma página publicada não pode enumerar provedores que nunca viu.

Uma Recipe pode declarar mais de um tipo de entrada ao mesmo tempo — um workload: com artifacts: ao lado, por exemplo. Leia a grade por tipo: a saída sintetizada de um nó assim é a linha synthesized, e os arquivos de artefatos dele são o caso dos artefatos. A linha artifacts-only é o tipo de entrada em que uma Recipe declara artifacts: e nada mais.

Você não precisa consultar a grade para descobrir. Definir uma chave que o destino de uma das suas renderizações não lê em nenhum dos tipos de entrada dessa renderização produz um aviso que nomeia a chave, o destino e cada tipo de entrada que essa renderização declara, de modo que uma célula em que você caiu por acidente se anuncia no momento em que você faz o build, em vez de esperar que você pense em olhar aqui:

warning: node "frontend" (provider "helm-chart"): target "helm-chart" does not support annotation aggrega.ai/namespace on sourced input and ignored it

Em uma renderização que declara mais de um tipo de entrada, o aviso diz respeito a essa renderização como um todo, não a uma de suas metades. Como os tipos se compõem por adição, um destino que lê a chave em qualquer um deles de fato a aplica, e a saída dessa renderização carrega o resultado — por isso nenhum aviso é emitido. Um aviso só aparece quando nenhum dos tipos que essa renderização declara aplica a chave, e ele nomeia todos eles:

warning: node "backend" (provider "helm"): target "helm" does not support annotation aggrega.ai/cluster-domain on sourced or synthesized input and ignored it

Assim, um workload: ao lado de um source: basta para fazer aggrega.ai/service-account ter efeito nesse nó, e o build fica em silêncio a respeito — que é o relato honesto, porque o valor alcança a metade sintetizada e aparece nos manifestos emitidos.

Leia a grade por renderização, não por componente. Uma funcionalidade vinculada a um nó gera seus recursos por meio do destino que a sua própria FeatureRecipe nomeia, nos tipos de entrada que essa FeatureRecipe declara — então ela vai parar na sua própria linha desta grade, que não precisa ser a linha em que o seu componente hospedeiro vai parar. Um componente que sintetiza o seu Workload enquanto uma funcionalidade vinculada contribui com artifacts: ao lado dele lê a linha synthesized para os manifestos próprios do componente e a linha artifacts-only para os arquivos da vinculação, e uma chave aplicada na primeira pode deixar de ser aplicada na segunda. O aviso segue a mesma divisão e informa você sobre cada uma separadamente, porque são arquivos diferentes. Uma funcionalidade vinculada a uma fronteira em vez de a um componente nomeado lê a grade da mesma forma.

O valor ainda passa intacto — o build não é interrompido, porque uma fronteira que abrange componentes em destinos heterogêneos sempre terá alguma renderização que não consegue agir sobre uma determinada chave, e isso é uma Release comum e não um erro. Uma anotação de fronteira se propaga em cascata, então uma linha escrita gera um aviso por renderização que não consegue agir sobre ela, e é assim que você vê quais partes da sua saída são afetadas. Ele pertence à classe unsupported-field e é silenciado com a flag dessa classe; Avisos traz os detalhes. Dois limites que vale a pena conhecer: apenas as chaves com o prefixo aggrega.ai/ simples são verificadas, já que uma chave com subprefixo é o seu próprio vocabulário, e um provedor que não declara nenhuma afirmação de suporte não produz nenhum aviso, porque não há nada com que comparar o que você escreveu. Um provedor que declara não ler nenhuma dessas chaves não fica em silêncio dessa forma: readsNoWellKnownAnnotations: true na sua entidade Plugin é uma afirmação que não cobre nenhuma chave, então cada chave com prefixo simples que alcança uma de suas renderizações gera o aviso. O provedor terraform o declara.

Por que um artefato copiado localmente aplica menos chaves. Uma anotação com escopo de nó é aplicada onde o provedor tem um slot de renderização para ela. Quando o provedor sintetiza ele mesmo a unidade de implantação, ele é dono de cada campo do resultado, então um prefixo de registro, um pull secret e uma service account têm todos onde ficar. Um artefato copiado localmente — um chart do Helm, um arquivo compose, um módulo do Terraform — carrega em vez disso a sua própria interface de configuração, e o compilador não lê essa interface, então não pode saber a qual das chaves próprias do artefato um prefixo de registro ou uma service account corresponderia. O posicionamento que a chamada de renderização ao redor controla continua sendo aplicado, e é por isso que aggrega.ai/namespace é aplicado a um chart renderizado a partir da fonte. O posicionamento que significaria decidir onde, dentro do artefato de outra pessoa, um valor pertence não é aplicado, e um autor o fornece por meio dos valores próprios desse artefato. É por isso que as linhas com fonte são esparsas onde as linhas sintetizadas são completas, e essa é a forma esperada de qualquer chave adicionada depois.

Chaves resolvidas por montagem e por referência

Quatro das chaves incluídas não têm escopo de nó, por isso ficam fora da grade acima em vez de serem incorporadas a ela: o tipo de entrada não é um eixo significativo para elas, e dar a cada uma uma linha por tipo de entrada repetiria uma única célula três vezes e sugeriria uma distinção que não existe. Cada uma declara o escopo de fronteira, e a tabela abaixo é gerada a partir dessas declarações.

AnotaçãoAplicada porFinalidadePadrão
aggrega.ai/chart-namehelm-chartNome do chart guarda-chuva do Helm montado.O nome do Aggregate e o caminho de montagem do guarda-chuva — o seu diretório de saída sob dist/, como boundaries/data/helm-chart — são usados, cada um codificado, e unidos.
aggrega.ai/aws-accountcloudformationA conta da AWS em que a stack (fronteira) é implantada. Uma referência entre fronteiras a lê para decidir se uma stack homóloga está na mesma conta.A homóloga é tratada como da mesma conta, e uma referência entre stacks é resolvida por meio da importação de uma exportação de stack da mesma conta em vez de uma leitura de saídas de stack entre contas.
aggrega.ai/aws-regioncloudformationA região da AWS em que a stack (fronteira) é implantada. Uma referência entre fronteiras a lê para decidir se uma stack homóloga está na mesma região.A homóloga é tratada como da mesma região, e uma referência entre stacks é resolvida por meio da importação de uma exportação de stack da mesma região.
aggrega.ai/aws-assume-role-arncloudformationO ARN do papel do IAM que uma leitura de stack entre contas assume para alcançar os valores exportados de uma stack homóloga.Nenhum papel é fornecido, e uma referência entre contas não carrega nenhum assume-role.

Quando cada uma é resolvida, algo que a própria declaração não carrega. aggrega.ai/chart-name é resolvida uma única vez por montagem de chart guarda-chuva, a partir da cascata de anotações da fronteira; cada contribuinte de uma mesma montagem deve resolvê-la para o mesmo valor, e uma divergência interrompe o build nomeando as fronteiras. As três chaves aggrega.ai/aws-* são resolvidas por referência entre fronteiras com precedência do componente sobre a fronteira, então um valor do componente prevalece sobre um valor da fronteira; a Categoria 6 acima descreve a referência que cada uma molda.

Nomes reservados que nenhum provedor lê

Onze chaves da matriz acima estão marcadas como reservada; nenhum provedor a lê: aggrega.ai/project-name, aggrega.ai/region, aggrega.ai/account-id, aggrega.ai/cluster-domain, aggrega.ai/ingress-class, aggrega.ai/service-mesh, aggrega.ai/pod-security-standard, aggrega.ai/iam-role, aggrega.ai/chart-version, aggrega.ai/stack-name e aggrega.ai/tf-backend.

Definir uma delas em uma Release ou em um Aggregate não tem nenhum efeito na saída renderizada. Nenhum provedor as lê, e nenhum padrão é aplicado no lugar delas — em particular, nenhum sufixo DNS é aplicado para aggrega.ai/cluster-domain, então uma Recipe que precisa de um domínio de cluster deve fornecê-lo como um valor comum em vez de depender desta anotação. Um autor de Recipe que precisa de um desses comportamentos o expressa como um valor da Recipe ou um campo infra do componente.

Nenhum provedor declara estas onze. O wellKnownAnnotations de um provedor lista apenas o que ele lê, então nenhuma das onze aparece ali — quem abre o Plugin helm, helm-chart, compose ou cloudformation vê as chaves que funcionam e nada mais. Esse é o objetivo da declaração estreita: uma chave declarada é uma chave que funciona, e o escopo ao lado dela diz em qual caminho.

Dois dos nomes reservados ficam próximos de chaves ativas e não são intercambiáveis com elas. aggrega.ai/region e aggrega.ai/account-id nomeiam uma região e uma conta no escopo de posicionamento e não chegam a nenhum provedor; as chaves que o provedor cloudformation lê são aggrega.ai/aws-region e aggrega.ai/aws-account, no namespace da nuvem, na Categoria 6. Quando você quiser dizer o contexto de posicionamento entre stacks do CloudFormation, escreva a forma aws- — o par sem prefixo é reservado contra colisões, não está ligado a nada. Outros dois nomes reservados são cobertos por outras superfícies em vez de por uma anotação: aggrega.ai/stack-name é reservado, enquanto o nome da stack em que uma fronteira cloudformation é renderizada é derivado de forma determinística da identidade da release e da fronteira; e o papel de identidade de nuvem de uma carga de trabalho é fornecido como um campo comum definido pelo operador na Feature que emite a associação, não por meio de aggrega.ai/iam-role.

Os nomes continuam reservados, e continuam listados aqui, porque o prefixo aggrega.ai/ é reservado: um catálogo corporativo não deve reutilizar uma dessas chaves com um significado próprio, porque a plataforma mantém a chave para um significado seu. Esta matriz e o conjunto de prefixos reservados que o lint de publicação verifica são juntos o registro de reservas, e os dois são mantidos no mesmo conjunto de nomes por uma verificação que lê ambos e falha quando divergem. Escrever uma das onze, portanto, não faz a validação falhar nem dispara a regra “não use o prefixo aggrega.ai/ simples” — ela simplesmente não tem efeito.

A versão do chart guarda-chuva que uma fronteira helm-chart emite é sempre 0.1.0; é um valor fixo e não um padrão de aggrega.ai/chart-version.

Observação: associações features.annotations do Manifest que usam o prefixo aggrega.ai/ são rejeitadas no carregamento; o prefixo é reservado exclusivamente para as anotações bem conhecidas de provedor documentadas neste capítulo. Autores de associações de Feature orientadas por anotações usam feature.aggrega.ai/ para atalhos da biblioteca padrão ou um domínio personalizado para atalhos corporativos.

Observação: um null explícito em uma anotação da Release remove a associação herdada da fronteira ou do componente que faz a substituição (desativação de Feature orientada por anotações). Componentes irmãos na mesma fronteira que não fizeram a desativação mantêm a associação herdada; chaves ausentes continuam herdando da cascata pai normalmente.

Anotações escritas no catálogo que o compilador lê

Tudo acima é uma anotação de provedor: escrita na Release ou declarada no Aggregate, repassada pelo compilador como uma string opaca, lida por um provedor. Um segundo vocabulário, muito menor, funciona no sentido contrário — escrito pelo Arquiteto nos metadata.annotations próprios de uma entidade do catálogo, lido pelo compilador e nunca visto por um provedor. O invariante 1 acima trata do vocabulário de provedor e não se estende a estas; o compilador lê exatamente as chaves listadas aqui e nenhuma outra.

Essas chaves ficam sob um subprefixo <scope>.aggrega.ai/, não sob o prefixo aggrega.ai/ simples, então estão fora do registro de reservas que a matriz acima carrega e fora da regra de prefixos reservados que o lint de publicação aplica às chaves de prefixo simples.

AnotaçãoEscrita emLida porFinalidade
features.aggrega.ai/requiredType.<label>metadata.annotations do Componento compilador, sobre o grafo finalizadoDeclara um mandato de presença: toda instância deste Component deve carregar pelo menos uma vinculação cujo tipo seja igual ao valor da anotação. <label> é um sufixo escolhido pelo autor que nomeia o requisito no diagnóstico; não é um nome de slot e nada o desreferencia. Repita a chave com rótulos diferentes para declarar vários mandatos.

O mandato é satisfeito por uma vinculação em qualquer escopo — um bloco features: no nível do componente ou do subsistema, um bloco da Release no nível da fronteira ou do componente, ou uma expansão orientada por anotações — porque ele testa o conjunto final de vinculações da instância em vez de onde cada vinculação se originou. Um mandato não satisfeito interrompe o build nomeando o rótulo e o tipo exigido; um valor que não seja um URI de tipo de Feature, ou uma chave sem rótulo depois do prefixo, é interrompido com um diagnóstico distinto de declaração malformada. O tratamento completo da escrita, e como um mandato difere de um slot featuresSchema, está em entities/component.md “Obrigações de presença”.

Rótulos de proveniência emitidos pelos provedores

As anotações acima fluem para dentro do build — a Release ou o Aggregate as escreve, os provedores as consomem. Os Providers também emitem um conjunto paralelo de rótulos para fora do build, anexando-os à saída renderizada para que as ferramentas a jusante possam atribuir os recursos em tempo de execução ao conteúdo do catálogo que os produziu. Esses rótulos de proveniência não são escritos na Release; eles são derivados do próprio estado do build (identidade da Recipe, caminho da fronteira, nome do agregado, ambiente, sync wave, versão do compilador) e emitidos pelo provedor no momento da renderização.

O conjunto que os provedores emitem, anexado a cada manifesto do Kubernetes que o provedor helm renderiza, a cada artefato carregado via $import: que o provedor helm-chart adiciona a um subchart e a cada serviço emitido pelo compose — os templates próprios de um subchart do helm-chart são copiados como seu autor os escreveu, então carregam o que quer que esse autor tenha escrito:

RótuloOrigemEmissão
app.kubernetes.io/nameID do nó (ou, para um recurso que uma FeatureRecipe emite, o identificador derivado para essa vinculação — veja abaixo)Somente helm e helm-chart — rótulo padrão do Kubernetes, não emitido nos serviços do compose
aggrega.ai/component-idID do nó (ou, para um recurso que uma FeatureRecipe emite, o identificador derivado para essa vinculação — veja abaixo)Os três provedores
aggrega.ai/recipe-uri<recipe-name>:<recipe-version> da Recipe produtora (ou da FeatureRecipe produtora para recursos emitidos por uma FR)Os três provedores, quando a entidade produtora tem tanto o nome quanto a versão definidos; uma anotação no helm e no helm-chart
aggrega.ai/boundary-pathCaminho da fronteira para o qual o componente foi roteadoOs três provedores, quando o caminho da fronteira não está vazio; uma anotação no helm e no helm-chart
aggrega.ai/aggregate-namemetadata.name do AggregateOs três provedores, quando definido
aggrega.ai/compiler-versionVersão do compilador carimbada no momento do buildOs três provedores, quando definido
aggrega.ai/providerO provedor que renderizou o recursoOs três provedores
aggrega.ai/provider-versionA versão desse provedorOs três provedores
aggrega.ai/environmentmetadata.environment da ReleaseOs três provedores — toda Release o declara
aggrega.ai/sync-waveInteiro syncWave por fronteiraOs três provedores, quando diferente de zero; uma anotação no helm e no helm-chart

Os valores de aggrega.ai/aggregate-name, aggrega.ai/environment, aggrega.ai/compiler-version, aggrega.ai/provider e aggrega.ai/provider-version vêm de strings que o build não submete às regras do Kubernetes para valores de rótulo — um Aggregate chamado imported/flow, um ambiente chamado eu/prod, a versão (devel) de um build de desenvolvimento. No helm e no helm-chart, cada um desses rótulos carrega seu valor como escrito quando o valor já é um valor de rótulo válido: letras, dígitos, -, _ e ., uma letra ou um dígito nas duas extremidades, no máximo 63 caracteres. Caso contrário, o rótulo carrega o valor reescrito nessa forma — qualquer outro caractere vira -, sequências de - se reduzem a um só, as extremidades são aparadas até uma letra ou um dígito e o resultado é cortado para no máximo 63 caracteres — e o valor literal é adicionado como anotação sob a mesma chave. Um Aggregate chamado imported/flow recebe, portanto, o rótulo aggrega.ai/aggregate-name: imported-flow e a anotação aggrega.ai/aggregate-name: imported/flow; um valor sem nenhum caractere que um rótulo mantém é carregado apenas pela anotação. Um seletor compara o valor do rótulo como ele aparece na saída renderizada, e as ferramentas que precisam do nome exato leem a anotação quando há uma. O Compose, cujos valores de rótulo não têm restrições, carrega o valor literal como rótulo.

Notas de emissão por provedor

  • helm — os rótulos vão para metadata.labels em cada recurso do Kubernetes renderizado (Deployment, Service, PVC etc.), e as chaves que o valor de um rótulo não pode carregar — aggrega.ai/recipe-uri, aggrega.ai/boundary-path, aggrega.ai/sync-wave e o valor literal de qualquer rótulo reescrito como descrito acima — para metadata.annotations. Os caminhos do modo com fonte (renderização via SDK do Helm com injeção de rótulos pós-renderização), do modo sintetizado (síntese da carga de trabalho) e de artifacts: produzem o mesmo conjunto.
  • helm-chart — os mesmos rótulos e anotações vão para cada artefato carregado via $import: que o provedor adiciona aos templates/ de um subchart. Os templates próprios do chart de origem, e um artefato de conteúdo inline colocado na raiz do subchart, não carregam nenhum deles — veja helm-chart.md.
  • compose — os rótulos vão para services.<name>.labels em cada serviço do compose emitido. O modo com fonte (injeção de rótulos pós-mesclagem no documento mesclado de base + valuesMapping) e o modo sintetizado (síntese da carga de trabalho que define diretamente o bloco de rótulos do serviço) produzem ambos o mesmo conjunto. O rótulo app.kubernetes.io/name, específico do Kubernetes, é omitido da saída do compose.

Para recursos que uma FeatureRecipe emite, o valor de aggrega.ai/component-id é construído a partir da vinculação, e não do nome do componente hospedeiro — para cada forma pela qual uma FeatureRecipe pode entregar esses recursos, de modo que os recursos de uma vinculação nunca sejam indistinguíveis por rótulo dos recursos do próprio componente hospedeiro. Se essa identidade é também aquilo de que esses recursos recebem o nome depende da entrega: uma carga de trabalho que o Aggrega sintetiza recebe o nome da identidade, enquanto um chart ou fragmento fornecido pelo autor da vinculação mantém o nome da release do Helm e o prefixo do arquivo de saída do componente hospedeiro, porque os templates próprios do autor são renderizados com esse nome. Como o valor é composto — os dois inícios possíveis, as partes e sua junção com --, como um caractere que um rótulo não pode carregar é escrito por extenso, como um valor longo demais para o seu destino é encurtado, e de quais nomes ele é e não é a base — não depende do provedor, por isso é descrito uma única vez em vocabulary/labels-and-annotations.md “Labels de proveniência emitidos na saída renderizada” em vez de repetido aqui. Esta página cuida da outra metade: onde os rótulos vão parar na saída renderizada de cada provedor.

A chave aggrega.ai/recipe-uri é resolvida para o name:version próprio da FeatureRecipe, e não para a identidade da Recipe consumidora — as ferramentas a jusante que leem o rótulo para identificar a entidade produtora obtêm a proveniência correta tanto para a saída emitida por componentes quanto para a emitida por FR.

Anotações sync-wave

A chave aggrega.ai/sync-wave acima é pareada com uma anotação sync-wave que as ferramentas a jusante leem para ordenar o que aplicam. No compose, a chave é um rótulo, que expõe o valor da onda para consultas por seletor; no helm e no helm-chart, ela é uma anotação, e a anotação pareada expõe o valor onde cada ferramenta o lê por convenção.

AnotaçãoEmissãoConsumida por
argocd.argoproj.io/sync-wavehelm, em cada recurso do Kubernetes que renderiza, e helm-chart, em cada artefato carregado via $import: — onde syncWave é diferente de zero na fronteira contribuinteOrdenação sync-wave do ArgoCD
helm.sh/hook-weightSomente helm, em manifestos gerados pelos templates do chart que já carregam uma anotação helm.sh/hook quando syncWave é diferente de zeroOrdenação por hook-weight do Helm dentro de uma fase de hook

A emissão de helm.sh/hook-weight depende do caminho

Uma sutileza que vale a pena destacar para os autores de charts: helm.sh/hook-weight só é emitida em manifestos renderizados pelo caminho de templating do chart — o diretório templates/ do chart renderizado via SDK do Helm. Os Manifests produzidos pelo caminho de artefatos — no provedor helm, cada entrada do bloco artifacts: da Recipe, de conteúdo inline ou carregada via $import:, e no helm-chart uma entrada carregada via $import: — carregam a anotação argocd.argoproj.io/sync-wave e o conjunto completo de rótulos de proveniência, mas não recebem helm.sh/hook-weight — mesmo quando o artefato carrega uma anotação helm.sh/hook.

A distinção é estrutural: helm.sh/hook e helm.sh/hook-weight são primitivas de ordenação do runtime do Helm que se aplicam aos recursos de hook gerados pelos templates do chart. Os artefatos do autor da Recipe são recursos extras declarados na camada da Recipe; por padrão, eles não participam do ciclo de vida dos hooks do Helm.

Se você precisar da ordenação por hook-weight do Helm em um recurso de hook, escreva o recurso como template de chart sob o diretório source: de uma Recipe que o provedor helm renderiza, em vez de como entrada de artifacts:; os templates de um subchart do helm-chart são copiados como foram escritos e não recebem nenhuma das duas anotações. O template do chart receberá tanto argocd.argoproj.io/sync-wave quanto helm.sh/hook-weight, correspondentes ao valor syncWave da fronteira contribuinte.

Exemplos de autoria

Posicionamento e configuração do registro no nível da fronteira:

release.yaml
spec:
boundaries:
production:
annotations:
aggrega.ai/namespace: prod-east
aggrega.ai/image-registry: registry.corp.com
aggrega.ai/image-pull-secret: corp-registry-creds
components:
api: {}
worker: {}

Substituição por componente (o componente prevalece sobre a fronteira na mesma chave de anotação):

release.yaml
spec:
boundaries:
production:
annotations:
aggrega.ai/namespace: prod-east
components:
api: {}
legacy-thing:
annotations:
aggrega.ai/namespace: legacy-east # override — this component deploys elsewhere

Cascata de anotações do lado do Aggregate

As anotações também ficam na superfície de autoria do Aggregate — no escopo do subsistema (spec.subsystems.<name>.annotations) e no escopo da instância de componente (spec.subsystems.<name>.components.<name>.annotations ou spec.components.<name>.annotations para componentes de nível superior). A cascata do lado do Aggregate leva as anotações escritas pelo desenvolvedor para baixo pela árvore de subsistemas até os componentes contidos.

A regra da cascata

Uma anotação no nível do subsistema se propaga para cada subsistema aninhado e para cada componente contido na subárvore do subsistema. As anotações de um nível mais próximo substituem as de um nível mais externo com granularidade por chave: uma anotação no nível do componente substitui qualquer anotação herdada no nível do subsistema para a mesma chave, sem afetar as chaves irmãs nem os componentes irmãos.

Uma chave de anotação em um escopo está em um de três estados:

  • Chave ausente — o escopo não declara nenhum valor para esta anotação. Subsistemas aninhados e componentes contidos herdam qualquer binding de um escopo ancestral.
  • Um valor de string — o escopo declara um valor. Os subsistemas aninhados e os componentes contidos herdam esse valor, a menos que declarem um valor próprio ou abram mão dele.
  • null YAML explícito — o escopo remove da sua subárvore qualquer associação herdada para essa chave. Os componentes irmãos e os subsistemas irmãos mantêm a sua herança independente; só a subárvore do escopo que abre mão perde a associação.
spec:
subsystems:
data:
annotations:
feature.myco/db-pool: "shared-pool" # propagates to api and worker
components:
api:
# inherits feature.myco/db-pool: "shared-pool"
worker:
annotations:
feature.myco/db-pool: null # opts out for this component only
special:
annotations:
feature.myco/db-pool: "vip-pool" # closer-level override

Anotações dos Provider declaradas no Aggregate

As chaves da matriz acima também descem em cascata pelo Aggregate, e um provedor aplica o que a cascata deixa em cada componente. O aggrega.ai/namespace de um subsistema posiciona cada componente abaixo dele; o valor próprio de uma instância de componente posiciona, em vez disso, esse componente. Um módulo que o Aggregate importa carrega a sua própria cascata: os seus subsistemas e instâncias de componente alcançam os componentes próprios do módulo, e nada do que o Aggregate importador declara alcança o interior de um módulo.

A Release fica acima do Aggregate em toda chave. Onde a Release define uma chave para um componente — na sua fronteira ou na entrada própria do componente —, o valor da Release é aplicado; onde ela não define nenhum, o do Aggregate. Os dois lados se sobrepõem chave por chave, de modo que uma Release que define apenas aggrega.ai/namespace deixa em vigor um aggrega.ai/image-registry que o Aggregate declarou.

Um null explícito na Release retira apenas o valor próprio da Release. Uma entrada de componente que escreve aggrega.ai/namespace: null remove o namespace que a fronteira da sua Release teria lhe atribuído, e o componente passa então a ter o valor que o seu Aggregate declara — ou nenhum, onde o Aggregate também não declara nenhum. Uma Release não pode remover um valor que o Aggregate declara; ela só pode definir um próprio por cima dele.

# Aggregate
spec:
subsystems:
billing:
annotations:
aggrega.ai/namespace: billing # api and worker render into billing
components:
api:
type: core/server:1.0.0
worker:
type: core/server:1.0.0
annotations:
aggrega.ai/namespace: billing-batch # worker renders into billing-batch
# Release
spec:
boundaries:
production:
components:
api:
annotations:
aggrega.ai/namespace: prod-billing # the Release's value wins: api renders into prod-billing
worker: {}

aggrega.ai/chart-name é a única chave fora desse alcance: ela nomeia um chart guarda-chuva montado a partir de vários componentes, por isso é lida das fronteiras da Release que contribuem para esse chart, nunca das anotações de um componente.

Um template de Recipe ou de FeatureRecipe lê os compartimentos de anotações pelo nome — .context.annotations.aggregate, .context.annotations.release e .context.annotations.catalog contêm cada um o que aquele lado escreveu —, de modo que um template que lê uma chave de posicionamento de um compartimento vê apenas o valor daquele lado.

A partição entre lado e pilar

A invariante do Aggregate como superfície de autoria restringe as anotações do lado do Aggregate ao pilar de valores. Uma associação de anotação de um Manifest declara caminhos de roteamento sob maps.infra (roteamento do lado da Release) ou sob maps.values (roteamento do lado do Aggregate); uma anotação do lado do Aggregate cuja associação declara apenas caminhos sob maps.infra interrompe o build com um diagnóstico claro que nomeia a chave da anotação, o pilar roteado e o lado de autoria. A regra simétrica se aplica ao lado da Release: as anotações do lado da Release só podem rotear por maps.infra; uma anotação do lado da Release contra uma associação somente de valores dispara o erro paralelo. Cada diagnóstico é classificado no domínio do documento em que o valor da anotação foi escrito — [DEVELOPER_ERROR] a partir de um Aggregate, [OPS_ERROR] a partir de uma Release —, de modo que o cabeçalho nomeia a superfície a abrir.

As associações que declaram caminhos nos dois pilares roteiam, a cada passagem, o subconjunto compatível com o lado: uma anotação do lado do Aggregate aciona apenas os caminhos do pilar de valores, e uma anotação do lado da Release aciona apenas os caminhos do pilar infra. A composição entre lados — values a partir do Aggregate, infra a partir da Release — produz uma vinculação de Feature por par (Component, Feature) com os dois pilares preenchidos e uma proveniência por folha que registra qual lado contribuiu com cada folha.

Exemplo de autoria — uma anotação de subsistema é roteada para values

# Manifest binding
spec:
mappings:
features:
type:
core/db-pool: db-pool-helm:1.0.0
annotations:
feature.myco/db-pool:
feature: core/db-pool:1.0.0
maps:
values:
- pool # routes to values.pool
# Aggregate
spec:
subsystems:
data:
annotations:
feature.myco/db-pool: "shared-pool"
components:
api:
type: core/server:1.0.0
worker:
type: core/server:1.0.0

Após a expansão de anotações, tanto api quanto worker carregam uma vinculação sintética da Feature feature.myco/db-pool cujo campo values.pool tem o valor "shared-pool". O grafo do build (aggrega validate --release <release> --ir-graph) registra cada folha com origin: annotation, side: aggregate e annotation_source: aggregate.yaml:subsystems.data.annotations.feature.myco/db-pool.

Valores de anotação estruturados

Uma Feature com vários campos configuráveis convida a usar uma única chave de anotação que carregue valores para vários deles de uma só vez. A forma de anotação estruturada permite que uma chave seja roteada para vários caminhos da associação em uma única declaração:

# Aggregate Subsystem — Developer's intent for db-pool (values-pillar subkeys)
subsystems:
data:
annotations:
feature.myco/db-pool:
db_name: "prod-db"
read_replicas: 5
# Release Boundary — Operator's sizing for db-pool (infra-pillar subkeys)
boundaries:
prod:
annotations:
feature.myco/db-pool:
pool_size: 20
max_connections: 100

A associação do Manifest declara o roteamento das quatro subchaves em listas maps: agrupadas por pilar:

# Manifest
spec:
mappings:
features:
annotations:
feature.myco/db-pool:
feature: core/db-pool:1.0.0
maps:
values:
- db_name
- read_replicas
infra:
- pool_size
- max_connections

A forma do valor da anotação é uma de três:

  • String escalar — um único valor. A associação deve declarar exatamente um caminho no total; o escalar é roteado para esse caminho.
  • Objeto estruturado — um mapa de subchave para subvalor. O caminho de cada subchave deve aparecer na lista maps.infra ou maps.values da associação; o subvalor é roteado para o campo do esquema da Feature nomeado, no pilar declarado.
  • null YAML explícito — abre mão por completo da associação herdada para esse escopo da cascata.

Cada subchave dentro de um valor estruturado é resolvida de forma independente em relação à lista maps da associação. Uma subchave ausente tanto de maps.infra quanto de maps.values interrompe o build com um erro claro que nomeia a subchave problemática e os caminhos declarados.

Mesclagem em cascata para valores estruturados

As anotações estruturadas descem em cascata com mesclagem profunda por subchave. A anotação de um escopo filho da cascata é mesclada com a anotação do pai subchave por subchave; o nível mais próximo substitui o pai com granularidade de subchave:

subsystems:
data:
annotations:
feature.myco/db-pool:
db_name: "data-default"
read_replicas: 3
components:
api:
annotations:
feature.myco/db-pool:
db_name: "api-override" # overrides parent at this subkey only
# read_replicas not listed → inherits 3 from parent
analytics:
annotations:
feature.myco/db-pool:
read_replicas: null # per-subkey opt-out: removes inherited subkey
# db_name not listed → inherits "data-default" from parent

Anotações efetivas após a cascata:

  • Component api: { db_name: "api-override", read_replicas: 3 }
  • Component analytics: { db_name: "data-default" } — read_replicas excluída por renúncia nesse escopo

Um nível filho da cascata cujo valor é um escalar (frente a um pai estruturado) substitui por completo em vez de mesclar. As divergências de forma entre níveis da cascata são resolvidas a favor do valor do nível mais próximo; o compilador não emite aviso em caso de divergência de forma.

null no valor inteiro versus null por subchave

A cascata oferece dois mecanismos de renúncia com granularidades diferentes:

# Whole-value null — opts out wholesale at this scope
components:
api:
annotations:
feature.myco/db-pool: null

Toda a associação da anotação é suprimida nesse componente; nenhuma vinculação sintética de Feature é sintetizada a partir dessa chave de anotação nesse escopo. Os componentes irmãos mantêm a sua associação herdada.

# Per-subkey null — opts out just one subkey
components:
api:
annotations:
feature.myco/db-pool:
db_name: "api-db"
read_replicas: null

A anotação continua contribuindo nesse escopo, mas a subchave read_replicas é suprimida. As outras subchaves (declaradas nesse escopo ou herdadas dos níveis pai da cascata) permanecem.

Orientação de autoria: use null no valor inteiro para desativar em um escopo uma vinculação de Feature orientada por anotação. Use null por subchave quando quiser manter a maior parte da contribuição de uma anotação, mas suprimir um ou mais campos específicos.

Partição entre lado e pilar por subchave

A invariante do Aggregate como superfície de autoria se aplica por subchave quando o valor de uma anotação é estruturado. O pilar de cada subchave (segundo a declaração maps da associação) deve ser compatível com o lado de autoria:

  • Uma anotação do lado do Aggregate só pode carregar subchaves roteadas para maps.values.
  • Uma anotação do lado da Release só pode carregar subchaves roteadas para maps.infra.

Uma subchave roteada para um pilar incompatível interrompe o build com um erro claro que cita a subchave e o pilar específicos. A cadeia de erros reúne todas as subchaves incompatíveis por anotação antes de interromper — os operadores veem todos os problemas em um único ciclo de build em vez de corrigir e recompilar repetidamente.

Validação de tipo por subchave

O valor em tempo de execução de cada subchave é validado em relação ao tipo declarado no spec.schema da Feature de destino, no pilar roteado. Os tipos declarados suportados são string, integer, number, boolean, object, array, null. Um subvalor cujo tipo YAML não corresponde ao tipo declarado do esquema interrompe o build com um erro claro que nomeia a subchave, o tipo real e o tipo declarado.

A correspondência de tipos é estrita — sem coerção. Uma string "20" frente a um campo do esquema de tipo inteiro interrompe o build; os autores declaram os tipos corretamente no esquema da Feature ou usam anotações escalares que passam como strings.

Alavanca de autoria para validação estrita. Propriedades sem um type declarado no spec.schema da Feature aceitam qualquer forma de valor em tempo de execução, incluindo mapas aninhados. Quando o esquema não declara uma restrição, o build não inventa nenhuma. Os autores que querem validação estrita de tipo por subchave declaram type em cada propriedade de spec.schema. A camada de renderização da FeatureRecipe, mais adiante, trata qualquer forma que a contribuição da anotação carregue.

Composição entre lados

Quando tanto uma anotação do lado do Aggregate (subchaves values) quanto uma anotação do lado da Release (subchaves infra) têm como alvo a mesma vinculação de Feature no mesmo Component, o build mescla as contribuições em uma única vinculação de Feature com os dois pilares preenchidos. A proveniência por folha registra a origem de cada subchave — a vinculação sintetizada carrega values.db_name atribuído ao ponto de autoria do Aggregate e infra.pool_size atribuído ao ponto de autoria da Release.

O padrão de composição entre lados é a forma de autoria canônica para Features com campos mistos de intenção do desenvolvedor e de dimensionamento pelo operador: o Aggregate declara as escolhas cognitivas (qual banco de dados, quantas réplicas no nível da aplicação); a Release declara o dimensionamento físico (qual o tamanho do pool, quantas conexões no nível da infraestrutura). Uma única associação do Manifest os une com um só conjunto de declarações maps.