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

Governança e conformidade

Este capítulo define como as equipes de plataforma impõem a conformidade corporativa em todo build — por meio do socket de governança, das bases e dos schemas do catálogo e das convenções que os autores do catálogo seguem — sem codificar políticas no compilador. Os eventos do ciclo de vida Day-2 são o assunto de Ciclos de vida Day-2.

Padrões de governança e conformidade corporativa

Um desafio central da engenharia de plataforma é impor a governança corporativa (como conformidade com SOC 2, rastreamento de centros de custo de FinOps e mapeamento rigoroso de responsabilidade) sem poluir o catálogo de código aberto.

Se o Aggrega codificasse de forma fixa lógica específica de domínio em seus componentes oficiais, ele deixaria de ser um compilador sem opiniões próprias e degeneraria em um framework com opiniões próprias. Por outro lado, se a conformidade for deixada inteiramente para o desenvolvedor, tags críticas serão digitadas errado, esquecidas ou contornadas.

Para resolver isso, o Aggrega fornece os mecanismos de sockets Wasm para a conformidade, enquanto a empresa dita a política. As empresas alcançam uma governança zero-trust adotando dois contratos sociais distintos em seu ecossistema.

1. “Bring Your Own Baseline” (BYOB) + portão de validação Wasm

Para dados estáticos fornecidos pelo desenvolvedor (como o time responsável ou a classificação de dados), as empresas nunca devem depender diretamente do catálogo de código aberto bruto. Em vez disso, o arquiteto de plataforma escreve uma base corporativa — os campos que todo componente interno deve ter, declarados uma única vez em uma entrada de SchemaLibrary — e usa um papel de veredito de governança para impor seu uso.

O contrato do catálogo: A empresa cria uma base que exige tags específicas, mas não provisiona nenhuma infraestrutura.

apiVersion: aggrega.ai/v1beta1
kind: SchemaLibrary
metadata:
name: CorporateBaseline
version: 1.0.0
spec:
schemas:
Ownership:
type: object
properties:
owner: { type: string }
cost_center: { type: string }
# The developer MUST provide these, or the schema validator halts the build
required: [owner, cost_center]

Cada componente interno (por exemplo, acme/datastore/postgres) referencia a entrada a partir do seu próprio schema: e adiciona os valores que lhe são próprios, de modo que os campos compartilhados e os campos próprios do componente são validados juntos:

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: acme/datastore/postgres
version: 1.0.0
labels:
component.aggrega.ai/type: stateful-server
spec:
schema:
values:
$ref: "CorporateBaseline#/schemas/Ownership"
properties:
database: { type: string }
required: [database]

A base é uma entrada de biblioteca em vez de um Component base porque um Component que escreve extends: recebe o schema: de sua base inteiro e não declara valores próprios (consulte Herança e disciplina de publicação).

A salvaguarda de validação Wasm: Para impedir que um desenvolvedor contorne o catálogo interno e puxe um componente core/postgres puro diretamente do hub público, a empresa registra um plugin de validação topológica. Ele é avaliado durante a análise estática — depois que o grafo é montado e antes que qualquer artefato seja renderizado —, e é por isso que enxerga a topologia inteira em vez de um componente por vez.

# Evaluated by the governance ir-verdict role over the assembled graph
package acme.governance
import rego.v1
deny contains msg if {
some id, _ in input.graph.spec.nodes
not input.graph.spec.values_mapping[id].owner
msg := sprintf("node %v declares no owner; use a component whose schema references 'CorporateBaseline#/schemas/Ownership'.", [id])
}

Uma decisão que a política coleta sob sua chave de negação é uma rejeição, e o build é interrompido por ela.

Proibir conexões livres: Um desenvolvedor pode ligar uma aresta por meio de um socket que o catálogo não declarou — um socket ad hoc (consulte dependency-resolution). Essa abertura é deliberada, e também o é o fato de o compilador não ter nenhuma opinião a respeito: uma organização que quer que toda conexão passe por um socket declarado por seus arquitetos expressa isso como política em vez de depender do compilador. Toda aresta do grafo carrega socket_declaration, cujo valor é declared ou ad-hoc, então a regra cabe em uma linha:

# Evaluated by the governance ir-verdict role over the assembled graph
package acme.governance
import rego.v1
deny contains msg if {
some e in input.graph.spec.edges
e.socket_declaration == "ad-hoc"
msg := sprintf("%v connects to %v through the free-form socket %v; declare the socket in the component type's usesSchema.",
[e.source, e.target, e.socket])
}

O valor está sempre presente em toda aresta, seja qual for a forma como a aresta foi escrita, de modo que uma política nunca precisa ler um campo ausente como “declared”. E ele é um eixo próprio: diz de onde veio o socket, não quem traçou a aresta, então se combina com origin_feature e origin_release em vez de se sobrepor a eles — uma política pode proibir conexões livres e ainda permitir que a Release ligue as declaradas.

Governança corporativa centralizada (avaliando a realidade completa): Mecanismos fora de banda (como CODEOWNERS em um repositório git) revisam os arquivos que mudam, não a arquitetura para a qual eles são compilados. Os papéis de veredito de governança julgam a própria arquitetura. Como o compilador AOT constrói o grafo IR achatando tanto o Aggregate do desenvolvedor quanto a Release do operador de plataforma, uma política no papel ir-verdict avalia a realidade completa antes que os artefatos físicos sejam gerados, e uma no papel render-verdict avalia os próprios artefatos. As políticas podem interromper fatalmente o build se um desenvolvedor solicitar um Component não aprovado ou — lendo a proveniência aggrega.ai/recipe-uri carimbada em cada objeto renderizado — se o Manifest mapear um componente para uma Recipe não aprovada.

2. O portão mutador Wasm (conformidade dinâmica)

Os desenvolvedores não devem ser obrigados a digitar manualmente tags de conformidade do ambiente (por exemplo, environment: production ou soc2_in_scope: true) em seu Aggregate, pois elas mudam conforme o destino do GitOps.

Para metadados dinâmicos, as empresas utilizam o Mutation Gate — o papel label-transform do socket de governança, que é executado durante a construção da topologia. Depois que o grafo é expandido, e antes que a análise estática o avalie, o compilador executa o plugin Wasm que a empresa anexou. Esse plugin lê o ambiente da Release, os rótulos que os nós já declaram e os valores que a instância de cada nó declara, e nomeia os rótulos que os nós do build devem carregar — assim os metadados exigidos chegam ao componente sem que o desenvolvedor os digite (por exemplo, o rótulo compliance.aggrega.ai/data-class: restricted decidido a partir do ambiente da Release, ou datastore.aggrega.ai/engine: vector decidido a partir das extensões declaradas de um banco de dados). Os valores são somente leitura: o plugin decide rótulos e nada mais.

Uma política nesse papel nomeia o rótulo — o nó, a chave e o valor que ele assume — em vez de escrever a instrução de edição que o build aplica. O motivo importa para quem escreve uma: a instrução endereça um rótulo por caminho, e uma chave de rótulo do Aggrega rotineiramente contém uma /, que é o separador de caminho, de modo que um caminho escrito à mão endereçaria uma posição aninhada em vez de um único rótulo. O build endereça o rótulo que a decisão nomeia, e a projeção dos nós que esse papel recebe os coloca um nível menos profundo do que um veredito sobre o grafo inteiro.

# Evaluated by the governance label-transform role, during topology construction
package acme.tagging
import rego.v1
labels contains {"node": id, "key": "acme.com/soc2-scope", "value": "true"} if {
input.compilation_context.environment == "production"
some id, node in input.graph.nodes
node.labels["component.aggrega.ai/type"] == "stateful-server"
}

Como essas tags são injetadas em memória no dicionário de metadados padrão antes do início da renderização, os plugins de renderização Wasm podem lê-las para gerar condicionalmente configurações físicas específicas — recursos AWS ou Kubernetes reforçados, por exemplo — à medida que os artefatos são renderizados.

Declarar uma regra uma única vez: anexos de governança têm escopo de workspace. Os dois padrões acima são escritos por componente e por Feature, mas o anexo de governança que os impõe não. Um plugin de governança é anexado na chave plugins.governance da configuração do workspace, e esse anexo vincula todo build no workspace. Uma regra corporativa é, portanto, declarada em exatamente um lugar: o time de plataforma anexa o plugin uma vez, e nenhum componente, Aggregate ou Release precisa aderir, mencioná-lo ou ser editado para que ele se aplique. É isso que torna a salvaguarda de validação do padrão 1 uma resposta completa em vez de uma convenção por projeto — um desenvolvedor que contorna o catálogo interno e solicita um core/postgres puro é avaliado pela mesma política anexada que todos os demais, porque a política é uma propriedade do workspace e não do componente escolhido.

Uma regra do workspace rejeita; ela não reescreve o contrato do desenvolvedor. O escopo é universal, e o efeito é deliberadamente limitado a um veredito. Uma regra que se aplica em toda parte interrompe um build que a viola, indicando o que corrigir, e não pode, em vez disso, alterar o componente infrator para torná-lo conforme. Esse limite é o que mantém o mecanismo depurável na escala de todo o parque: um build ou corresponde às regras que o workspace declara ou para com uma mensagem que aponta para a linha escrita, e a saída renderizada nunca contém uma restrição ou um recurso que nenhum arquivo escrito tenha pedido. Quando uma empresa quer de fato que o grafo seja alterado em vez de julgado, ela anexa um papel de transformação — o padrão 2 acima — e essa alteração tem o escopo daquilo para o qual o operador o anexou, e é por isso que é um ato explícito do time de plataforma e não uma reescrita invisível.

A consequência prática para um time de plataforma que fecha o ciclo da conformidade: expresse a forma que um payload deve ter como restrições de esquema em uma base corporativa, expresse as regras entre entidades que o parque exige como um papel de veredito anexado, e expresse os metadados derivados que o desenvolvedor nunca deveria digitar como um papel de transformação anexado. Os três são declarados uma vez e se aplicam a todo build, e nenhum exige que o desenvolvedor saiba que eles existem.

3. Preservando a inteligência de domínio (as configurações e a segurança)

Como o compilador do Aggrega é um compilador sem opiniões próprias, ele não possui nenhum conhecimento codificado de frameworks de IA, orçamentos de tokens ou particionamento de memória. Em vez disso, os esquemas genéricos nativos de nuvem funcionam como um recipiente vazio. Em vez de ser codificada no núcleo do compilador, a inteligência de domínio altamente especializada é distribuída por todo o ecossistema extensível do Aggrega. Ela é encapsulada no catálogo da plataforma por meio de components, features e recipes especializados. Os desenvolvedores preservam sua intenção de aplicação específica em seus blocos values e uses — rigorosamente governados pelas declarações schema: do arquiteto (forma compacta ou JSON Schema 2020-12 completo) e pelos sockets usesSchema —, enquanto a tradução física dessa inteligência é executada por plugins WebAssembly específicos de cada destino.

A. Modelando implementações específicas de domínio (validadas por esquemas divididos)

Os arquitetos de plataforma podem aproveitar o pipeline de esquemas divididos para modelar qualquer arquitetura complexa, de forma totalmente independente do núcleo do compilador:

  • Lógica de execução opaca (values): Se uma empresa implanta um AI Gateway, o desenvolvedor configura o comportamento próprio do gateway — no gateway de IA da biblioteca padrão, o mapa models que publica cada alias que um chamador pode solicitar e o upstream para o qual cada um é resolvido. O núcleo do compilador não interpreta esses conceitos. Eles residem com segurança no payload opaco values, rigorosamente validado pela declaração schema: do componente. O compilador simplesmente repassa esse payload ao plugin Wasm para gerar a configuração do gateway. Controles que vários produtos de gateway compartilham, como uma cadeia de fallback, um número de tentativas ou a escolha entre entradas que publicam o mesmo alias, são Features anexadas ao gateway em vez de valores nele, cada uma realizada para um gateway nos termos próprios desse gateway.
  • Mapeamento de dependências topológicas (uses): Onde um framework de IA conecta um agente às suas ferramentas ou a um armazenamento de dados vetorial, essa conexão determina quem fala com quem, então ela é declarada no pilar uses; uma lista de nomes mantida em values, como tools_allowed da biblioteca padrão, é uma convenção que não traça nenhuma aresta. O compilador desenha essas arestas explícitas literalmente no grafo IR. Isso permite que os plugins de renderização Wasm a jusante gerem programaticamente as políticas de rede e as fronteiras físicas necessárias para proteger as conexões, sem que o compilador entenda o framework de IA subjacente.
  • Estruturas de dados complexas (por exemplo, CoALA): Em vez de ficarem limitados a uma única lista plana de destinos, os arquitetos declaram em usesSchema tantos sockets quantos uma estrutura precisar, cada um com seu próprio seletor e seu próprio valueSchema por aresta. Por exemplo, para implementar o framework CoALA, um arquiteto pode declarar semantic_memory, episodic_memory e working_memory como sockets distintos, de modo que cada armazenamento de memória seja um destino topológico distinto. Os motores de políticas genéricos avaliam essas arestas estruturadas para exigir salvaguardas granulares de controle de acesso para cada lobo cognitivo distinto.

B. Mecanismos centrais de segurança e indireção

Embora o payload permaneça sem opiniões próprias, o esquema genérico impõe mecanismos estruturais rigorosos que dão suporte à geração segura de artefatos:

  • O padrão anexo-e-não-valor: a convenção da biblioteca padrão é que uma credencial seja solicitada como anexo, nunca escrita em um bloco values, onde seria um literal inline que o compilador carrega literalmente. Um anexo de credencial nomeia um type de Feature de credencial (uma com o rótulo feature.aggrega.ai/kind: secret) e usa seus próprios values para descrever a consulta a um cofre de segredos. O roteamento de credenciais é então uma vinculação tardia independente de capacidade, e o núcleo do compilador nunca resolve nem expõe o material — ele encaminha o ponteiro que a Recipe de Ops forneceu. Esta é uma convenção que o catálogo e os esquemas incentivam, não uma verificação do compilador: o compilador não interpreta o que uma folha de values significa, então um autor que coloca o material inline o coloca inline. O que o esquema de fato garante é que a superfície de anexos existe e é tipada.
  • Verificação abstrata de confiança: Como o bloco values é amplamente extensível, os arquitetos podem exigir diretivas abstratas como tls_pinning ou required_signatures: 2 (para consenso por quórum). O núcleo do compilador repassa literalmente esses objetos validados pelo esquema para o grafo IR plano. Um plugin de renderização Wasm personalizado pode então ler esses valores para gerar artefatos para portões de aprovação Human-in-the-Loop (HITL) em nível de hardware. Se uma aplicação tentar contornar as regras de consenso, o proxy fisicamente implantado bloqueia a execução até que uma aprovação via webhook seja recebida.

C. Segurança operacional avançada (spec.interoperability)

Para proteger cargas de trabalho frágeis contra mutações de infraestrutura conflitantes, o esquema genérico Feature define um controle de interoperabilidade:

  • spec.interoperability.conflictsWith — uma lista das Features que não podem alcançar o mesmo componente que esta. O compilador interrompe o build antes da renderização quando os anexos com que um componente acaba ficando — reunidos de cada escopo que o alcança: o próprio componente, um subsistema ou fronteira que o contém, sua entrada de componente na Release e a expansão orientada por anotações — contêm esta Feature e uma que ela nomeia. É uma comparação entre os nomes que o autor da Feature declarou e as Features que o componente carrega, sem atribuir significado a nenhum dos dois: a incompatibilidade é o julgamento do autor, e o compilador submete o build a ele. Uma declaração basta, os nomes são comparados independentemente de suas versões, e duas Features anexadas a fronteiras irmãs que não compartilham nenhum componente nunca se encontram.

4. Governança de limites de rede (convenção de negação por padrão)

Os desenvolvedores não escrevem políticas de rede diretamente; os limites de rede necessários são mapeados pelo grafo da representação intermediária (IR) do compilador, que carrega cada aresta topológica entre os componentes declarados no Aggregate.

  • Limites internos. O compilador desenha o grafo IR plano e não restringe nada por conta própria: sem uma política, toda conexão que a rede do cluster permite continua alcançável. A convenção é que uma política escrita para um componente permita uma conexão apenas onde o Aggregate declara uma aresta para ela, além do que a própria vinculação da política nomeia, e negue toda outra conexão na direção que a política governa.
  • A realização da biblioteca padrão. O catálogo da biblioteca padrão realiza a convenção como duas Features que o operador vincula a um componente na Release, uma para cada direção de uma conexão: core/caller-allowlist admite conexões apenas dos componentes cujas arestas uses apontam para ele, e core/egress-allowlist permite que o componente se conecte apenas aos componentes para os quais suas próprias arestas apontam e ao DNS do cluster. No alvo helm, cada uma é realizada por uma FeatureRecipe que escreve uma NetworkPolicy do Kubernetes a partir das arestas que o compilador lhe entrega, identificando os pods de cada componente pelo que a renderização do próprio componente emitiu — os seletores e rótulos que suas cargas de trabalho carregam, o namespace em que são emitidas e as portas que seus contêineres declaram —, de modo que nenhum rótulo ou porta é repetido à mão. Cada uma também admite os pods do próprio componente e o que a Release nomeia na vinculação: origens fora do Aggregate no lado de entrada e, no lado de saída, faixas de endereços para um alvo que o cluster não executa, que não renderiza pods a selecionar e só é admitido por faixa, em qualquer porta. O compilador não pode inspecionar o cluster, então cada uma interrompe o build até que a Release afirme que o plugin de rede do cluster aplica políticas de rede; o compose não tem política de rede, e um build que vincule qualquer uma delas ali é interrompido.
  • Ingress público (controle de perímetro agnóstico). O ingress público é governado pelas regras próprias da empresa em um papel de veredito de governança. Uma equipe de segurança corporativa pode escrever uma política que avalia o tipo de ontologia cloud-native de um nó e rejeita o build se um desenvolvedor tentar vincular uma funcionalidade public-ingress a um nó worker ou task. O compilador não interpreta o que “público” significa; ele aplica a saída booleana do portão de validação Wasm.

5. Carimbo de proveniência em tempo de compilação

O compilador constrói um registro de proveniência durante a compilação, capturando a versão do compilador e as versões do Aggregate, do Manifest e da Release que compilou — e nenhum timestamp, de modo que o registro nunca quebra a saída idêntica byte a byte. O renderizador helm emite a versão do compilador como o rótulo aggrega.ai/compiler-version nos manifestos do Kubernetes gerados, e o renderizador helm-chart nos arquivos de template que uma Recipe adiciona a um chart, já que ele copia sem alterações os templates próprios do chart; as equipes de segurança corporativas usam isso para identificar quais artefatos renderizados foram construídos por qual versão do compilador — algo importante quando uma vulnerabilidade é descoberta em uma versão específica do compilador e os artefatos afetados precisam ser auditados.

O provedor compose carimba as mesmas chaves de proveniência como labels de serviço, o provedor terraform como um arquivo de proveniência em cada módulo que monta, e o provedor cloudformation sob o Metadata de cada recurso; o registro de proveniência em memória existe para toda compilação.

6. Metadados e anotações como superfície de extensão

O compilador Go é agnóstico em relação a conceitos específicos de domínio — frameworks de IA, mecanismos de banco de dados, idiomas do Kubernetes — e trabalha apenas com operações planas em nível de grafo sobre a IR. Para impulsionar o ecossistema sem codificar de forma fixa lógica específica de domínio no binário Go, a plataforma usa rótulos e anotações de metadados padrão como superfície de extensão para a inteligência de domínio.

O compilador não lê nenhuma anotação específica de domínio. Ele agrupa todas as anotações fornecidas pelos desenvolvedores e os rótulos de duck typing no grafo IR plano e repassa esses metadados literalmente aos plugins de governança e de renderização. O ecossistema WebAssembly interpreta os metadados e executa a lógica necessária — avaliando políticas de conformidade, injetando tags em artefatos cloud-native ou disparando a expansão de funcionalidades — independentemente do núcleo do compilador.

Isso mantém ampla a superfície de extensibilidade (qualquer pessoa pode escrever um plugin Wasm que leia um novo prefixo de anotação) enquanto mantém estável o núcleo do compilador: nenhuma nova versão do núcleo é necessária para que o ecossistema adicione uma nova anotação específica de domínio.

O que uma política lê sobre uma vinculação

Um papel de veredito que avalia o grafo IR recebe o grafo inteiro — com cada valor que um autor declarou sensível retido, como descrito abaixo — e isso inclui cada vinculação que cada nó carrega, indexada pelo nome que o autor lhe deu — ou, para uma vinculação escrita em uma das conexões do nó, pelo alias da conexão e pelo slot unidos por um ponto. O motivo de carregar o detalhe das vinculações em vez de um resumo é que o Aggrega não tem opinião a resumir: o compilador roteia as vinculações sem julgar o que contêm, então os fatos de que uma política precisa para julgá-las são os fatos que uma política recebe.

Por vinculação, o grafo carrega:

  • O tipo de Feature que ela solicita e a versão do catálogo resolvida para ele. O tipo é a string que o autor escreveu, literalmente — uma referência com versão fixada e uma sem versão são strings diferentes para um mesmo referente, então uma política que compara tipos deve esperar qualquer uma das grafias.
  • Os rótulos de catálogo da Feature vinculada, literalmente. Sem filtragem, sem normalização, na ordem em que a entidade de catálogo os declara. Uma política lê exatamente o que o autor do catálogo escreveu, incluindo rótulos de invenção do próprio autor dos quais o Aggrega não tem conhecimento.
  • As anotações de catálogo da Feature vinculada, literalmente. Os metadata.annotations da própria entidade Feature, carregados exatamente nos mesmos termos que seus rótulos — sem filtragem, sem normalização, na ordem declarada pela entidade —, de modo que uma chave de anotação no namespace próprio de um autor chega como foi escrita. Este é um assunto diferente da anotação que fez existir, em primeiro lugar, uma vinculação expandida por anotação: o grafo informa essa origem separadamente, e uma vinculação escrita em um bloco features: carrega as anotações da entidade sem informar nenhuma origem de expansão.
  • Qual slot de vinculação declarado ela preenche. Um slot featuresSchema é preenchido vinculando uma Feature sob o nome do slot, então uma vinculação que nomeia um slot que seu Component declara informa o nome desse slot, e uma que não preenche nenhum informa free. Uma vinculação escrita em uma conexão preenche um slot que o socket da conexão declara e informa o nome desse slot; como um socket não admite nenhum outro nome, ela nunca informa free. O valor é o nome do slot em vez de uma flag, porque saber qual ponto de binding foi preenchido costuma ser a metade mais útil da resposta.
  • Em qual conexão ela foi escrita, se em alguma. Uma vinculação escrita em uma das conexões do componente carrega o socket e o alias dessa conexão, que nomeiam a aresta do grafo em que ela é apresentada — e, por meio dessa aresta, o componente ao qual ela é apresentada. Uma vinculação do próprio bloco do componente não carrega nenhum dos dois. A conexão é carregada como dado em vez de ficar para ser deduzida do nome da vinculação, que contém o alias e não o socket.
  • Se ela lida com material que um autor declarou sensível, e quais de suas chaves de entrega carregam esse material. Ambos são derivados de declarações — uma folha sensitive no esquema de uma Feature, um slot sensitive no Component consumidor, seja um que ele declara para suas próprias vinculações ou um no socket pelo qual uma conexão é ligada —, nunca da inspeção de um valor.
  • Seus values, seu infra e seu mapeamento de entrega, além de se a vinculação foi escrita em um bloco features: ou contribuída pela expansão guiada por anotações — com cada valor que um autor declarou sensível retido, como o próximo parágrafo descreve.

Uma política é informada de onde está o material declarado sensível, e nunca recebe o material. Cada folha que o grafo marca como declarada sensível — nos values ou no infra de qualquer vinculação, em qualquer escopo ou conexão em que tenha sido escrita, no infra de uma vinculação de limite, nos values e no infra próprios de um nó e nos values e no infra próprios de uma conexão — chega à política como um marcador de chave única, {"aggrega_withheld": "declared"}, no lugar do valor. A chave permanece, então uma política ainda vê quais folhas um payload carrega; a marcação que nomeia essas folhas permanece, então uma política ainda vê quais delas carregam material declarado; e cada fato listado acima chega como antes, junto com cada valor que nenhuma declaração marca. Nenhum dos fatos sobre os quais uma política raciocina — o que uma vinculação é, o que ela preenche, a quem ela é apresentada, o que sua entidade de catálogo diz sobre ela e por onde seu material secreto trafega — é um valor que um autor possa declarar sensível, e o próprio material é a única coisa de que uma política não precisa para julgar para onde ele vai. É a mesma retenção que a linha de comando aplica quando imprime o grafo e que o daemon aplica quando responde à solicitação de um editor por ele. Essas superfícies devolvem os valores a uma pessoa que os pede explicitamente; a cópia de uma política não oferece tal solicitação. Isso se aplica apenas à cópia da política: o grafo a partir do qual o build renderiza permanece intocado, então nenhum byte renderizado muda.

Os rótulos de uma vinculação obrigam o compilador em exatamente um lugar, e não se trata de uma decisão de política: um slot pode declarar um selector, e um preenchimento cujos rótulos não o satisfazem interrompe o build. Além desse portão, os rótulos não direcionam nada — como um valor é roteado e entregue é igual quaisquer que sejam os rótulos que uma Feature carregue. Assim, uma política que lê um rótulo está lendo metadados que o compilador carregou sem interpretar, e não questionando uma ramificação dentro dele.

As anotações de catálogo de uma Feature não a obrigam em lugar nenhum: nenhum comportamento do compilador se ramifica com base nelas, e um slot não declara nenhuma restrição sobre elas como pode fazer sobre rótulos. Elas são carregadas e nada mais.

Regras que isso torna possíveis de escrever, nenhuma das quais o compilador cria por você:

  • Proibir vinculação livre. Uma organização que exige que toda vinculação preencha um ponto de binding declarado rejeita qualquer vinculação que informe free. Esta é a contrapartida de a superfície de vinculação permanecer aberta: a composição é livre por padrão, e um operador que não a quer livre diz isso.
  • Recusar a entrega por valor de material sensível. O Aggrega emite um aviso quando um dado declarado sensível trafega por uma chave de entrega como literal, e nunca interrompe o build — a família de credenciais por valor é deliberada. Um operador que deseja que esse aviso seja uma recusa expressa isso aqui.
  • Decidir por conta própria o que conta como credencial. A biblioteca padrão marca suas Features de credencial com um rótulo de família, e ler esse rótulo é uma forma de raciocinar sobre elas. Um predicado mais amplo ou mais restrito — um rótulo interno, uma regra de nomenclatura, um conjunto de tipos aprovados — está igualmente disponível, porque chegam os rótulos, e não um veredito sobre eles.
  • Condicionar a qualquer coisa que seu catálogo registre em seus próprios metadados. Uma organização que mantém status de revisão, residência de dados ou responsabilidade como anotações em suas entidades Feature pode exigi-los de toda vinculação. Uma regra baseada em uma anotação da qual o Aggrega nunca ouviu falar funciona exatamente tão bem quanto uma baseada em uma chave que ele distribui, porque as anotações chegam como foram escritas — o que também significa que uma Feature e um Component são julgados em pé de igualdade, cada um pelos metadados de catálogo que sua própria entidade declara.
  • Governar o que um componente apresenta e a quem. Uma credencial escrita em uma conexão nomeia essa conexão, e a aresta da conexão nomeia seu alvo, então uma organização pode recusar uma credencial apresentada a um componente fora de uma zona de confiança que ela marca com um rótulo próprio — um julgamento que precisa das duas pontas da conexão, algo que nenhum fato sobre o componente consumidor sozinho fornece.

Um papel de veredito aceita ou rejeita; ele nunca reescreve. O build ou prossegue inalterado ou é interrompido com a mensagem do veredito, então uma política não pode silenciosamente tornar conforme um grafo não conforme.

O detalhe das vinculações chega a uma política que avalia o grafo IR. Uma política que avalia artefatos renderizados recebe esses artefatos e nenhum grafo, o que é uma propriedade dessa entrada e não uma restrição aplicada a ela: as duas etapas respondem a perguntas diferentes, e a topologia das vinculações não está entre as perguntas que se podem fazer à saída renderizada.

Expressar as regras da organização em uma linguagem de políticas

Os padrões acima descrevem o que uma vinculação de governança faz; esta seção trata do que uma empresa escreve para obtê-la. Uma equipe de plataforma com cinquenta regras a declarar não quer cinquenta plugins. Ela quer suas regras como conteúdo — arquivos que revisa, versiona e distribui como qualquer outro artefato — com um único motor vinculado que as avalia.

É isso que um motor de linguagem de políticas vinculado ao socket oferece, e dois deles vêm dentro do compilador exatamente para esse fim: um motor Rego e um motor CEL. Um operador vincula um deles, declara os arquivos de política que ele deve carregar, e as regras são executadas: nenhuma cadeia de ferramentas externa, nada baixado em tempo de build e nenhuma lógica de política no compilador. A avaliação acontece dentro do convidado WebAssembly, que é onde reside toda a inteligência de domínio.

O mesmo motor atende a cada papel de governança, então uma organização cobre toda a sua superfície com um único plugin vinculado e várias vinculações dele:

  • Julgar a arquitetura. Vinculada sobre o grafo de build, uma política lê cada nó, aresta e vinculação que o compilador mantém, além dos caminhos de roteamento enumerados ao lado deles, e informa o que deve interromper o build. É aqui que vive uma invariante de topologia, uma regra de autorização entre limites ou uma regra de fluxo de credenciais.
  • Julgar a saída. Vinculada sobre os artefatos renderizados, uma política lê os arquivos que o build produziu — como texto e como documentos analisados onde o formato foi analisado antes da política — e informa sobre o resultado concreto.
  • Fornecer metadados derivados. Vinculada para moldar rótulos, uma política decide quais rótulos os nós do build carregam, a partir do ambiente da Release e do que os nós já declaram. Este é o mecanismo que o padrão 2 acima descreve, com a regra expressa como conteúdo de política em vez de como um plugin feito sob medida.
  • Adicionar uma capacidade que o desenvolvedor não digitou. Vinculada para injetar anotações, uma política adiciona anotações aos componentes do build; uma anotação sob uma chave para a qual o Manifest registra um binding se expande em uma vinculação de Feature, então uma regra corporativa pode fornecer o invólucro de que um componente precisa em vez de apenas rejeitar sua ausência. Uma decisão grava qualquer valor que um operador poderia escrever nessa anotação — uma string, ou um objeto de subchaves para um binding que roteia várias — e o build o lê exatamente como lê o mesmo valor escrito na Release. Ela só pode adicionar: um valor que removeria uma anotação ou faria opt-out dela é recusado, e um valor injetado que o build não consegue rotear ou que a Feature vinculada não admite é recusado nomeando o plugin que o injetou.

Uma regra lê o que o payload carrega e informa sua decisão sob uma chave nomeada:

# Evaluated by a governance verdict role over the assembled graph
package acme.security
import rego.v1
deny contains msg if {
some id, node in input.graph.spec.nodes
node.labels["compliance.aggrega.ai/data-class"] == "restricted"
not node.labels["acme.com/owner"]
msg := sprintf("node %v holds restricted data and declares no owner.", [id])
}

Uma regra que segue dados ao longo do grafo lê as rotas que o payload enumera. language-reference/examples/policy-data-class-route/ é uma delas, de ponta a ponta: ela interrompe um build em que um componente que contém dados de uma classe alcança um componente de outra classe por uma rota sem nenhuma Feature de desclassificação vinculada a ela, e o mesmo Aggregate é concluído quando uma Release roteia esse tráfego por um gateway que carrega core/data-masking. O compilador carrega o rótulo de classe como uma string e não classifica nada — as classes, sua ordem e as Features que contam como desclassificadoras são as configurações da vinculação. A regra é escrita uma vez para cada um de três motores — os dois compilados na CLI e o OPA por trás do convidado adaptador de referência —, cada cópia por si só, então um build em que dois motores discordam mostra a discordância.

O vocabulário próprio de uma política é preservado. As severidades sobre as quais o socket age são um conjunto fechado, mas os nomes sob os quais uma política agrupa suas decisões pertencem à política. Os nomes padrão são os convencionais que um corpus Rego já usa, e um operador cujas políticas nomeiam suas decisões de outra forma declara o mapeamento nas configurações da vinculação — de modo que uma organização que já mantém uma biblioteca de políticas adota o socket sem reescrevê-la. O mapeamento é tipado pelo esquema que o plugin declara para suas configurações, então um mapeamento malformado interrompe o build antes que qualquer política seja executada, em vez de rotear um veredito de forma errada.

Uma biblioteca de políticas inteira viaja como uma única vinculação. Um conjunto de políticas pode ser vinculado arquivo por arquivo, ou como um único pacote que contém juntos seus arquivos de política e seus documentos de dados, que o convidado abre. Um pacote que não pode ser lido é informado como tal, nomeando o arquivo — nunca como um conjunto de políticas que não chegou a nenhuma decisão, porque “a biblioteca estava ilegível” nunca deve ser indistinguível de “a biblioteca permitiu o build”.

Uma política não avaliável interrompe o build. Quando uma política não pode ser avaliada, a vinculação falha e o build é interrompido com uma falha que nomeia o plugin, deliberadamente distinta de um veredito que interrompe o build. Os dois casos não devem ser confundidos, e nenhum deles é uma permissão.

A superfície completa de criação — o payload que cada papel expõe, as chaves de decisão, o mapeamento para severidades e como um pacote é vinculado — está em language-reference/plugins/policy-socket.md.

Herança e disciplina de publicação

A herança via extends: é o mecanismo de catálogo que permite aos arquitetos de plataforma construir entidades filhas especializadas sobre baselines compartilhadas. Os dois tipos de catálogo se separam em seus pilares de dados. Os esquemas pai e filho de uma Feature se compõem no carregamento do workspace, produzindo um esquema unificado com proveniência por folha. Um Component que estende não escreve conteúdo de pilar: ele escreve o marcador literal schema: inherited e recebe o bloco schema: de sua base exatamente como a base o escreveu, em qualquer profundidade de uma cadeia.

É isso que resolve a questão de governança que uma baseline compartilhada levanta — quais restrições um filho pode declarar em relação à sua base. Para um Component, a resposta é estrutural e não fiscalizada: o contrato declarado do filho simplesmente é o da base, então uma restrição da base não pode ser afrouxada, removida ou ter seu tipo alterado por um filho, e nenhuma verificação em tempo de publicação é necessária para manter a baseline intacta. Um filho que legitimamente precisa de uma regra mais rígida do que a que sua base declara expressa isso como uma entrada adicionada em seu bloco assertions:, que se compõe ao lado das regras da base em vez de substituí-las.

O que um Component filho de fato compõe é a estrutura: seus slots de vinculação (featuresSchema), sockets de topologia (usesSchema), allowlist de autoinjeção (inject) e assertions nomeadas se mesclam ao longo da cadeia, com uma entrada redeclarada substituindo integralmente a da base.

Posicionamento de regras: quais regras ficam no plugin de política e quais no esquema por Component

O plugin de disciplina de publicação é o lugar das regras transversais que se aplicam a todo o catálogo: regras de cadeia de suprimentos (por exemplo, “toda Recipe deve fazer implements: de um Component que exista no catálogo”), regras de conformidade corporativas (por exemplo, “todo Component com compliance.aggrega.ai/scope: pci-dss deve fazer extends: da baseline pci corporativa”). Essas regras atravessam várias entidades, avaliam o workspace como uma unidade ou aplicam convenções em tempo de publicação em vez de em tempo de build.

A declaração schema: por Component / por Feature é o lugar das restrições por entidade: tipos, intervalos, padrões e enums por campo; regras entre campos expressas no bloco assertions: dedicado. Essas restrições são locais a uma entidade e viajam com ela pelo catálogo.

A divisão não é arbitrária. Uma regra como “todo campo obrigatório deve estar presente” é uma restrição por entidade que pertence aos arrays required:. Uma regra como “toda entidade filha que estende um pai pci-dss deve declarar um rótulo de governança em nível de workspace” é uma regra entre entidades que o plugin de política aplica. As duas classes de regras nunca se sobrepõem porque respondem a perguntas diferentes: o esquema valida “esta instância corresponde ao seu contrato”; o plugin de política valida “este catálogo satisfaz as regras transversais que o workspace exige”.

Ao escrever uma nova regra de governança, a questão do posicionamento é: a regra depende apenas do conteúdo de uma única entidade (→ esquema ou bloco assertions) ou depende da relação entre várias entidades ou da configuração em nível de workspace (→ plugin de política). O padrão do linter Wasm é o mecanismo canônico para o caso transversal; catálogos corporativos podem distribuir plugins de política personalizados que consomem a mesma interface de contrato de plugin que o plugin padrão de disciplina de publicação.

Disciplina de prefixos de anotação

O namespace de anotações carrega uma semântica de origem — prefixos diferentes sinalizam públicos diferentes e autoridades de governança diferentes. Autores de catálogo, equipes de plataforma corporativas e a própria plataforma Aggrega escrevem anotações no mesmo dicionário plano; é o prefixo que mantém os públicos distintos.

PrefixoOrigemPúblicoMutabilidade
aggrega.ai/ (sem subdomínio)Reservado: emitido apenas pelo compilador do AggregaFerramentas internas, marcação de procedênciaNão pode ser escrito pelo usuário; anotações com o prefixo sem subdomínio declaradas em conteúdo do usuário são rejeitadas no momento da publicação
<sub-domain>.aggrega.ai/ (por exemplo, component.aggrega.ai/, feature.aggrega.ai/, compliance.aggrega.ai/)Convenção do catálogoArquitetos que escrevem entidades do catálogo; plugins de política Wasm que consomem os rótulosOs publicadores do catálogo escrevem; os consumidores leem
<enterprise-domain>/ (por exemplo, acme.com/, my-org.io/)Camada corporativaEquipes de plataforma corporativas; plugins Wasm corporativosOs autores corporativos escrevem; o compilador da plataforma as ignora como metadados opacos
<community-domain>/ (por exemplo, cncf.io/, kubernetes.io/)Ecossistema externoFerramentas entre ecossistemas que leem rótulos conhecidosGovernado pela comunidade

O prefixo aggrega.ai/ sem subdomínio tem a disciplina mais rígida: ele é reservado apenas a anotações emitidas pela plataforma. O compilador emite aggrega.ai/compiler-version, aggrega.ai/component-id, aggrega.ai/recipe-uri, aggrega.ai/boundary-path e chaves de procedência relacionadas na saída renderizada; conteúdo do usuário que declara diretamente uma anotação aggrega.ai/<key> é rejeitado no momento da publicação. A disciplina impede que anotações escritas pelo usuário colidam com a procedência emitida pela plataforma.

Os prefixos de subdomínio sob <sub-domain>.aggrega.ai/ são o espaço das convenções do catálogo. A biblioteca padrão usa component.aggrega.ai/type (o rótulo da ontologia cloud-native), feature.aggrega.ai/kind (a partição das Feature entre operacionais e de credenciais), compliance.aggrega.ai/* (os rótulos do eixo de conformidade) e sub-namespaces delimitados semelhantes. Cada subdomínio é governado por um público específico do catálogo: component.aggrega.ai/* pelos autores de entidades Component, feature.aggrega.ai/* pelos autores de entidades Feature, compliance.aggrega.ai/* pelo público das políticas de conformidade. Leituras entre subdomínios (um plugin Wasm que lê de vários sub-namespaces) são permitidas, mas raras; cada plugin normalmente se restringe a um único sub-namespace.

Os prefixos de domínio corporativo (acme.com/..., my-org.io/...) são a superfície de extensão da plataforma. O compilador do Aggrega os trata como metadados opacos; os plugins Wasm corporativos os consomem. As empresas escrevem a estrutura de prefixos que se ajustar à sua governança — plana (acme.com/owner: team-payments), de subdomínio (security.acme.com/scope: pii) ou hierárquica (org.acme.com/billing-center: finance). A plataforma não restringe o layout dos prefixos corporativos; a única regra é que os prefixos corporativos não colidam com aggrega.ai/ nem com seus subdomínios.

A disciplina importa porque as anotações se propagam em cascata — anotações escritas no subsistema de um Aggregate se propagam para cada componente do subsistema, as anotações próprias de uma instância de componente prevalecem sobre as do seu subsistema, e as anotações de um módulo chegam aos componentes do próprio módulo; anotações em uma fronteira de uma Release se propagam para cada componente da fronteira. Uma anotação de provedor chega à saída renderizada por qualquer um dos lados, e onde ambos escrevem a mesma chave, o valor aplicado é o da Release. Sem disciplina de prefixos, uma anotação do lado do Aggregate poderia sobrescrever silenciosamente uma chave de procedência emitida pela plataforma, ou uma anotação corporativa poderia colidir com uma chave de convenção do catálogo. A tabela de prefixos torna os públicos explícitos e torna aplicável, no momento da publicação, a regra de prevenção de colisões.

Consulte language-reference/vocabulary/labels-and-annotations.md para a enumeração das superfícies de anotação por entidade e a semântica de cascata em três compartimentos (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).