Governação e conformidade
Este capítulo define como as equipas de plataforma impõem a conformidade empresarial em todas as compilações — através do socket de governação, das baselines e dos esquemas 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 tema de Ciclos de vida Day-2.
Padrões de governação e conformidade empresariais
Um desafio central da engenharia de plataformas é impor a governação empresarial (como a conformidade SOC 2, o acompanhamento de centros de custo FinOps e um mapeamento estrito de propriedade) sem poluir o catálogo open source.
Se o Aggrega codificasse lógica específica de domínio nos seus componentes oficiais, deixaria de ser um compilador sem opiniões próprias e degeneraria numa framework com opiniões. Por outro lado, se a conformidade ficar inteiramente a cargo do programador, etiquetas críticas serão mal escritas, esquecidas ou contornadas.
Para resolver isto, o Aggrega fornece os mecanismos de sockets Wasm para a conformidade, enquanto a empresa dita a política. As empresas alcançam uma governação de confiança zero adotando dois contratos sociais distintos no seu ecossistema.
1. «Bring Your Own Baseline» (BYOB) + barreira de validação Wasm
Para dados estáticos fornecidos pelo programador (como a propriedade por equipa ou a classificação de dados), as empresas nunca devem depender diretamente do catálogo open source em bruto. Em vez disso, o Platform Architect escreve uma baseline empresarial — os campos que cada componente interno tem de ter, declarados uma única vez numa entrada de SchemaLibrary — e utiliza um papel de veredicto de governação para impor a sua utilização.
O contrato do catálogo: a empresa cria uma baseline que exige etiquetas específicas mas não aprovisiona nenhuma infraestrutura.
apiVersion: aggrega.ai/v1beta1kind: SchemaLibrarymetadata: name: CorporateBaseline version: 1.0.0spec: 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 acrescenta os valores que lhe são próprios, pelo que os campos partilhados e os campos próprios do componente são validados em conjunto:
apiVersion: aggrega.ai/v1beta1kind: Componentmetadata: name: acme/datastore/postgres version: 1.0.0 labels: component.aggrega.ai/type: stateful-serverspec: schema: values: $ref: "CorporateBaseline#/schemas/Ownership" properties: database: { type: string } required: [database]A baseline é uma entrada de biblioteca e não um Component base porque um Component que escreve extends: recebe o schema: da sua base por inteiro e não declara valores próprios (ver Herança e disciplina de publicação).
A salvaguarda de validação Wasm: para impedir que um programador contorne o catálogo interno e obtenha diretamente do hub público um componente core/postgres nu, a empresa regista um plugin de validação topológica. É avaliado durante a análise estática — depois de o grafo estar montado e antes de qualquer artefacto ser renderizado —, razão pela qual vê toda a topologia em vez de um componente de cada vez.
# Evaluated by the governance ir-verdict role over the assembled graphpackage 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 reúne sob a sua chave deny é uma rejeição, e a compilação é interrompida por ela.
Proibir ligações livres: um programador pode ligar uma aresta através de um socket que o catálogo não declarou — um socket ad hoc (ver dependency-resolution). Essa abertura é deliberada, tal como o é o facto de o compilador não ter opinião sobre ela: uma organização que queira que todas as ligações passem por um socket declarado pelos seus Architects exprime isso como política, em vez de depender do compilador. Cada aresta do grafo transporta socket_declaration, que indica declared ou ad-hoc, pelo que a regra ocupa uma linha:
# Evaluated by the governance ir-verdict role over the assembled graphpackage 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 todas as arestas, seja qual for a forma como a aresta foi escrita, pelo que uma política nunca tem de ler um campo ausente como «declarado». E é um eixo próprio: diz de onde veio o socket, não quem traçou a aresta, pelo que se compõe com origin_feature e origin_release em vez de se sobrepor a eles — uma política pode proibir ligações livres e continuar a permitir que a Release ligue as declaradas.
Governação empresarial centralizada (avaliar a realidade completa): os mecanismos fora de banda (como CODEOWNERS num repositório git) revêem os ficheiros que mudam, não a arquitetura em que são compilados. Os papéis de veredicto de governação julgam a própria arquitetura. Como o compilador AOT constrói o grafo IR achatando tanto o Aggregate do programador como a Release do Platform Operator, uma política no papel ir-verdict avalia a realidade completa antes de serem gerados artefactos físicos, e uma no papel render-verdict avalia os próprios artefactos. As políticas podem interromper fatalmente a compilação se um programador pedir 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. A barreira de mutação Wasm (conformidade dinâmica)
Os programadores não devem ser obrigados a escrever manualmente etiquetas de conformidade ambientais (por exemplo, environment: production ou soc2_in_scope: true) no seu Aggregate, uma vez que estas mudam consoante o destino GitOps.
Para metadados dinâmicos, as empresas utilizam a barreira de mutação — o papel label-transform do socket de governação, que corre durante a construção da topologia. Depois de o grafo ser expandido, e antes de a análise estática o avaliar, o compilador executa o plugin Wasm que a empresa anexou. Esse plugin lê o ambiente da Release, as etiquetas que os nós já declaram e os valores que a instância de cada nó declara, e nomeia as etiquetas que os nós da compilação devem transportar — para que os metadados necessários cheguem ao componente sem que o programador os escreva (por exemplo, a etiqueta compliance.aggrega.ai/data-class: restricted decidida a partir do ambiente da Release, ou datastore.aggrega.ai/engine: vector decidida a partir das extensões declaradas de uma base de dados). Os valores são só de leitura: o plugin decide etiquetas e nada mais.
Uma política neste papel nomeia a etiqueta — o nó, a chave e o valor que assume — em vez de escrever a instrução de edição que a compilação aplica. A razão importa a quem a escreve: a instrução endereça uma etiqueta por caminho, e uma chave de etiqueta do Aggrega contém habitualmente uma /, que é o separador de caminhos, pelo que um caminho escrito à mão endereçaria uma localização aninhada em vez de uma etiqueta. A compilação endereça a etiqueta que a decisão nomeia, e a projeção dos nós que este papel recebe coloca-os um nível menos fundo do que um veredicto sobre o grafo inteiro.
# Evaluated by the governance label-transform role, during topology constructionpackage 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 estas etiquetas são injetadas em memória no dicionário de metadados normal antes de a renderização começar, 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 artefactos são renderizados.
Enunciar uma regra uma única vez: os anexos de governação têm âmbito de espaço de trabalho. Os dois padrões acima são escritos por componente e por Feature, mas o anexo de governação que os impõe não o é. Um plugin de governação é anexado na chave plugins.governance da configuração do espaço de trabalho, e esse anexo vincula todas as compilações do espaço de trabalho. Uma regra empresarial é, portanto, enunciada exatamente num único local: a equipa de plataforma anexa o plugin uma vez, e nenhum componente, Aggregate ou Release tem de aderir, mencioná-lo ou ser editado para que se aplique. É isto que faz da salvaguarda de validação do padrão 1 uma resposta completa, e não uma convenção por projeto — um programador que contorne o catálogo interno e peça um core/postgres nu é avaliado pela mesma política anexada que todos os outros, porque a política é uma propriedade do espaço de trabalho e não do componente que escolheu.
Uma regra de espaço de trabalho rejeita; não reescreve o contrato do programador. O âmbito é universal, e o efeito limita-se deliberadamente a um veredicto. Uma regra que se aplica em todo o lado interrompe uma compilação que a viole, nomeando o que corrigir, e não pode, em vez disso, emendar o componente infrator para o pôr em conformidade. Esse limite é o que mantém o mecanismo depurável à escala do património: uma compilação ou corresponde às regras que o espaço de trabalho 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 ficheiro escrito tenha pedido. Quando uma empresa quer, de facto, que o grafo seja alterado em vez de julgado, anexa um papel de transformação — o padrão 2 acima —, e essa alteração fica limitada àquilo para que o operador o anexou, razão pela qual é um ato explícito da equipa de plataforma e não uma reescrita invisível.
A consequência prática para uma equipa de plataforma que fecha o círculo da conformidade: exprimir a forma que um payload tem de ter como restrições de esquema numa baseline empresarial, exprimir as regras entre entidades que o património exige como um papel de veredicto anexado e exprimir os metadados derivados que o programador nunca deve escrever como um papel de transformação anexado. Os três são declarados uma vez e aplicam-se a todas as compilações, e nenhum deles exige que o programador saiba que existem.
3. Preservar a inteligência de domínio (as configurações e a segurança)
Como o compilador Aggrega é sem opiniões próprias, 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 da cloud funcionam como um recipiente vazio. Em vez de ser codificada no núcleo do compilador, a inteligência de domínio altamente especializada está distribuída por todo o ecossistema extensível do Aggrega. Está encapsulada no catálogo da plataforma através de components, features e recipes especializados. Os programadores preservam a intenção específica da sua aplicação nos seus blocos values e uses — estritamente regidos pelas declarações schema: do Architect (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. Modelar implementações específicas de domínio (validadas através de esquemas divididos)
Os Platform Architects podem tirar partido do pipeline de esquemas divididos para modelar qualquer arquitetura complexa, de forma totalmente independente do compilador central:
- Lógica de execução opaca (
values): se uma empresa implementar um AI Gateway, o programador configura o comportamento próprio do gateway — no AI gateway da biblioteca padrão, o mapamodelsque publica cada alias que um chamador pode pedir e o upstream para o qual cada um se resolve. O compilador central não analisa estes conceitos. Residem em segurança no payload opacovalues, estritamente validado pela declaraçãoschema:do componente. O compilador limita-se a passar este payload ao plugin Wasm para gerar a configuração do gateway. Os controlos que vários produtos de gateway partilham, como uma cadeia de fallback, um número de retries ou a escolha entre entradas que publicam o mesmo alias, são Features anexadas ao gateway e não valores nele, sendo cada uma realizada para um gateway nos termos próprios desse gateway. - Mapeamento de dependências topológicas (
uses): quando um framework de IA liga um agente às suas ferramentas ou a um datastore vetorial, essa ligação dita quem fala com quem, pelo que é declarada no pilaruses; uma lista de nomes guardada emvalues, comotools_allowedda biblioteca padrão, é uma convenção que não traça nenhuma aresta. O compilador traça estas arestas explícitas no grafo IR literalmente. Isto permite que os plugins de renderização Wasm seguintes gerem programaticamente as políticas de rede e as fronteiras físicas necessárias para proteger as ligações, sem que o compilador compreenda o framework de IA subjacente. - Estruturas de dados complexas (por exemplo, CoALA): em vez de se limitarem a uma única lista plana de destinos, os Architects declaram em
usesSchematantos sockets quantos uma estrutura precise, cada um com o seu próprio seletor e o seu própriovalueSchemapor aresta. Por exemplo, para implementar o framework CoALA, um Architect pode declararsemantic_memory,episodic_memoryeworking_memorycomo sockets distintos, para que cada armazenamento de memória seja um destino topológico distinto. Os motores de políticas genéricos avaliam estas arestas estruturadas para exigir guardrails de controlo de acesso granulares para cada lobo cognitivo distinto.
B. Mecanismos centrais de segurança e indireção
Embora o payload seja sem opiniões próprias, o esquema genérico impõe mecanismos estruturais estritos que suportam uma geração segura de artefactos:
- O padrão anexo-e-não-valor: a convenção da biblioteca padrão é que uma credencial seja pedida como um anexo, nunca escrita num bloco
values, onde seria um literal inline que o compilador transporta literalmente. Um anexo de credencial nomeia umtypede Feature de credencial (uma etiquetada comfeature.aggrega.ai/kind: secret) e usa os seus própriosvaluespara descrever a consulta a um armazenamento de segredos. O encaminhamento de credenciais é então uma associação tardia agnóstica em relação às capacidades, e o compilador central nunca resolve nem expõe o material — encaminha o ponteiro que a Recipe de Ops forneceu. Isto é 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 significa uma folha devalues, pelo que um autor que escreva o material inline o escreve inline. O que o esquema garante é que a superfície de anexos existe e é tipada. - Verificação abstrata de confiança: como o bloco
valuesé amplamente extensível, os Architects podem exigir diretivas abstratas comotls_pinningourequired_signatures: 2(para consenso por quórum). O compilador central passa estes objetos validados pelo esquema para o grafo IR plano, literalmente. Um plugin de renderização Wasm personalizado pode então ler estes valores para gerar artefactos para barreiras de aprovação Human-in-the-Loop (HITL) ao nível do hardware. Se uma aplicação tentar contornar as regras de consenso, o proxy implementado fisicamente bloqueia a execução até ser recebida uma aprovação por webhook.
C. Segurança operacional avançada (spec.interoperability)
Para proteger cargas de trabalho frágeis de mutações de infraestrutura em conflito, o esquema genérico de Feature define um controlo de interoperabilidade:
spec.interoperability.conflictsWith— uma lista das Features que não podem chegar ao mesmo componente que esta. O compilador interrompe a compilação antes de renderizar quando os anexos com que um componente acaba — reunidos de todos os âmbitos que o alcançam: o próprio componente, um subsistema ou uma fronteira que o contenha, a sua entrada de componente na Release e a expansão guiada por anotações — contêm esta Feature e uma que ela nomeie. É uma comparação dos nomes que o autor da Feature declarou com as Features que o componente transporta, sem nenhum significado atribuído a uns ou a outras: a incompatibilidade é o juízo do autor, e o compilador sujeita a compilação a ele. Basta uma declaração, os nomes são comparados quaisquer que sejam as suas versões, e duas Features anexadas a fronteiras irmãs que não partilham nenhum componente nunca se encontram.
4. Governação das fronteiras de rede (convenção de negação por predefinição)
Os programadores não escrevem políticas de rede diretamente; as fronteiras de rede necessárias são mapeadas pelo grafo de Representação Intermédia (IR) do compilador, que transporta cada aresta topológica entre os componentes declarados no Aggregate.
- Fronteiras internas. O compilador traça o grafo IR plano e não restringe nada por si: sem uma política, todas as ligações que a rede do cluster permite continuam alcançáveis. A convenção é que uma política escrita para um componente só permita uma ligação quando o Aggregate declara uma aresta para ela, além do que o próprio anexo da política nomeia, e negue todas as outras ligações no sentido 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 anexa a um componente na Release, uma para cada sentido de uma ligação:
core/caller-allowlistadmite ligações apenas dos componentes cujas arestasusesapontam para ele, ecore/egress-allowlistpermite ao componente ligar-se apenas aos componentes para os quais as suas próprias arestas apontam e ao DNS do cluster. No destino helm, cada uma é realizada por uma FeatureRecipe que escreve uma NetworkPolicy do Kubernetes a partir das arestas que o compilador lhe entrega, nomeando os pods de cada componente a partir do que a renderização desse próprio componente emitiu — os seletores e as etiquetas que as suas cargas de trabalho transportam, o namespace em que são emitidas e as portas que os seus contentores declaram —, pelo que nenhuma etiqueta ou porta é reescrita à mão. Cada uma admite também os próprios pods do componente e o que a Release nomeia no anexo: origens fora do Aggregate no lado de entrada e, no lado de saída, intervalos de endereços para um destino que o cluster não executa, que não renderiza pods a selecionar e só é admitido por intervalo, em qualquer porta. O compilador não consegue inspecionar o cluster, pelo que cada uma interrompe a compilação até que a Release afirme que o plugin de rede do cluster aplica políticas de rede; o compose não tem políticas de rede, e uma compilação que anexe qualquer uma delas aí é interrompida. - Entrada pública (controlo de perímetro agnóstico). A entrada pública é governada pelas regras personalizadas da empresa num papel de veredicto de governação. Uma equipa de segurança empresarial pode escrever uma política que avalia o tipo de ontologia nativa da cloud de um nó e rejeita a compilação se um programador tentar anexar uma feature
public-ingressa um nóworkeroutask. O compilador não interpreta o que significa «público»; aplica o resultado booleano da barreira de validação Wasm.
5. Carimbo de proveniência em tempo de compilação
O compilador constrói um registo de proveniência durante a compilação, que capta a versão do compilador e as versões do Aggregate, do Manifest e da Release que compilou — e nenhum carimbo temporal, pelo que o registo nunca quebra uma saída idêntica byte a byte. O renderizador helm emite a versão do compilador como a etiqueta aggrega.ai/compiler-version nos manifestos Kubernetes gerados, e o renderizador helm-chart nos ficheiros de template que uma Recipe acrescenta a um chart, já que copia sem alterações os templates próprios do chart; as equipas de segurança empresariais usam-no para identificar que artefactos renderizados foram compilados por que versão do compilador — algo importante quando é descoberta uma vulnerabilidade numa versão específica do compilador e os artefactos afetados têm de ser auditados.
O provider compose carimba as mesmas chaves de proveniência como etiquetas de serviço, o provider terraform como um ficheiro de proveniência em cada módulo que monta, e o provider cloudformation sob o Metadata de cada recurso; o registo de proveniência em memória existe para cada 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, motores de bases de dados, idiomas do Kubernetes — e trabalha apenas com operações planas ao nível do grafo sobre a IR. Para impulsionar o ecossistema sem codificar lógica específica de domínio no binário Go, a plataforma usa etiquetas e anotações de metadados normais 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. Agrupa todas as anotações fornecidas pelo programador e as etiquetas de duck-typing no grafo IR plano e passa estes metadados literalmente aos plugins de governação e de renderização. O ecossistema WebAssembly interpreta os metadados e executa a lógica necessária — avaliar políticas de conformidade, injetar etiquetas em artefactos nativos da cloud ou desencadear a expansão de features — independentemente do compilador central.
Isto mantém ampla a superfície de extensibilidade (qualquer pessoa pode escrever um plugin Wasm que leia um novo prefixo de anotação), mantendo ao mesmo tempo estável o compilador central: não é necessária nenhuma versão do núcleo para que o ecossistema acrescente uma nova anotação específica de domínio.
O que uma política lê sobre um anexo
Um papel de veredicto que avalia o grafo IR recebe o grafo inteiro — com todos os valores que um autor declarou sensíveis retidos, como descrito abaixo —, e isso inclui todos os anexos que cada nó transporta, indexados pelo nome que o autor lhes deu — ou, para um anexo escrito numa das ligações do nó, pelo alias da ligação e pelo slot unidos por um ponto. A razão de transportar o detalhe dos anexos em vez de um resumo é que o Aggrega não tem nenhuma opinião a resumir: o compilador encaminha os anexos sem julgar o que contêm, pelo que os factos de que uma política precisa para os julgar são os factos que lhe são dados.
Por anexo, o grafo transporta:
- O tipo de Feature que pede e a versão de catálogo resolvida para ele. O tipo é a cadeia que o autor escreveu, literalmente — uma referência com versão fixada e uma simples são cadeias diferentes para um mesmo referente, pelo que uma política que compare tipos deve contar com qualquer das grafias.
- As etiquetas de catálogo da Feature anexada, literalmente. Sem filtragem, sem normalização, pela ordem em que a entidade de catálogo as declara. Uma política lê exatamente o que o autor do catálogo escreveu, incluindo etiquetas da invenção do próprio autor de que o Aggrega não tem conhecimento.
- As anotações de catálogo da Feature anexada, literalmente. Os próprios
metadata.annotationsda entidade Feature, transportados exatamente nos mesmos termos que as suas etiquetas — sem filtragem, sem normalização, pela ordem declarada da entidade —, pelo que uma chave de anotação no namespace próprio de um autor chega tal como foi escrita. Isto é um assunto diferente da anotação que fez existir, à partida, um anexo expandido a partir de anotações: o grafo reporta essa origem em separado, e um anexo escrito num blocofeatures:transporta as anotações da entidade sem reportar qualquer origem de expansão. - Que slot de anexo declarado preenche. Um slot de
featuresSchemaé preenchido anexando uma Feature com o nome do slot, pelo que um anexo que nomeie um slot que o seu Component declara reporta o nome desse slot, e um que não preencha nenhum reportafree. Um anexo escrito numa ligação preenche um slot que o socket da ligação declara, e reporta o nome desse slot; como um socket não admite nenhum outro nome, nunca reportafree. O valor é o nome do slot e não um indicador, porque o ponto de associação preenchido é normalmente a metade mais útil da resposta. - Em que ligação foi escrito, se for o caso. Um anexo escrito numa das ligações do componente transporta o socket e o alias dessa ligação, que nomeiam a aresta do grafo em que é apresentado — e, através dessa aresta, o componente a que é apresentado. Um anexo do próprio bloco do componente não transporta nenhum. A ligação é transportada como dados, em vez de ficar para ser deduzida do nome do anexo, que contém o alias e não o socket.
- Se lida com material que um autor declarou sensível, e que chaves de entrega suas transportam esse material. Ambos são derivados de declarações — uma folha
sensitiveno esquema de uma Feature, um slotsensitiveno Component consumidor, seja um que declare para os seus próprios anexos ou um no socket através do qual uma ligação é feita —, nunca da inspeção de um valor. - Os seus
values, o seuinfrae o seu mapeamento de entrega, mais se o anexo foi escrito num blocofeatures:ou contribuído pela expansão guiada por anotações — com todos os valores que um autor declarou sensíveis retidos, como descreve o parágrafo seguinte.
A uma política é dito onde está o material declarado sensível, e nunca lhe é entregue o material. Cada folha que o grafo marca como declarada sensível — nos values ou no infra de qualquer anexo, seja qual for o âmbito ou a ligação em que foi escrito, no infra de um anexo de fronteira, nos próprios values e infra de um nó e nos próprios values e infra de uma ligação — chega à política como um marcador de chave única, {"aggrega_withheld": "declared"}, em vez do valor. A chave sobrevive, pelo que uma política continua a ver que folhas um payload transporta; a marcação que nomeia essas folhas sobrevive, pelo que uma política continua a ver quais delas transportam material declarado; e todos os factos listados acima chegam como antes, juntamente com todos os valores que nenhuma declaração marca. Nenhum dos factos sobre os quais uma política raciocina — o que é um anexo, o que preenche, a que é apresentado, o que a sua entidade de catálogo diz sobre ele e por onde viaja o seu material secreto — é 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 comandos aplica quando imprime o grafo e que o daemon aplica quando responde ao pedido de um editor por ele. Essas superfícies devolvem os valores a uma pessoa que os peça explicitamente; a cópia de uma política não oferece esse pedido. Aplica-se apenas à cópia da política: o grafo a partir do qual a compilação renderiza fica intacto, pelo que nenhum byte renderizado muda.
As etiquetas de um anexo vinculam o compilador num único local, e não se trata de uma decisão de política: um slot pode declarar um selector, e um preenchimento cujas etiquetas não o satisfaçam interrompe a compilação. Para além dessa barreira, as etiquetas não orientam nada — a forma como um valor é encaminhado e entregue é a mesma, sejam quais forem as etiquetas que uma Feature transporte. Assim, uma política que lê uma etiqueta está a ler metadados que o compilador transportou sem os interpretar, não a pôr em causa uma ramificação dentro dele.
As anotações de catálogo de uma Feature não a vinculam em local nenhum: nenhum comportamento do compilador se ramifica com base nelas, e um slot não declara sobre elas nenhuma restrição, como pode fazer sobre as etiquetas. São transportadas e nada mais.
Regras que isto torna possíveis de escrever, nenhuma das quais o compilador estabelece por si:
- Proibir anexos livres. Um património que exija que todos os anexos preencham um ponto de associação declarado rejeita qualquer anexo que reporte
free. É a contrapartida de a superfície de anexos se manter aberta: a composição é livre por predefinição, e um operador que não a queira livre di-lo. - Recusar a entrega por valor de material sensível. O Aggrega emite um aviso quando um dado declarado sensível viaja através de uma chave de entrega como literal, e nunca interrompe a compilação — a família de credenciais por valor é deliberada. Um operador que queira que esse aviso seja uma recusa exprime-o aqui.
- Decidir por si o que conta como credencial. A biblioteca padrão marca as suas Features de credenciais com uma etiqueta de família, e ler essa etiqueta é uma forma de raciocinar sobre elas. Um predicado mais amplo ou mais restrito — uma etiqueta interna, uma regra de nomenclatura, um conjunto de tipos aprovados — está igualmente disponível, porque são as etiquetas que chegam, e não um veredicto sobre elas.
- Condicionar a qualquer coisa que o catálogo registe nos seus próprios metadados. Um património que mantenha o estado de revisão, a residência dos dados ou a propriedade como anotações nas suas entidades Feature pode exigi-las a todos os anexos. Uma regra baseada numa anotação de que o Aggrega nunca ouviu falar funciona exatamente tão bem como uma baseada numa chave que ele distribui, porque as anotações chegam tal 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 a sua própria entidade declara.
- Governar o que um componente apresenta a quem. Uma credencial escrita numa ligação nomeia essa ligação, e a aresta da ligação nomeia o seu destino, pelo que um património pode recusar uma credencial apresentada a um componente fora de uma zona de confiança que marque com uma etiqueta própria — um juízo que precisa de ambas as extremidades da ligação, e que nenhum facto sobre o componente consumidor, por si só, fornece.
Um papel de veredicto aceita ou rejeita; nunca reescreve. A compilação ou prossegue inalterada ou é interrompida com a mensagem do veredicto, pelo que uma política não pode pôr silenciosamente em conformidade um grafo que não o esteja.
O detalhe dos anexos chega a uma política que avalia o grafo IR. Uma política que avalia artefactos renderizados recebe esses artefactos e nenhum grafo, o que é uma propriedade desse input e não uma restrição que lhe seja aplicada: as duas fases respondem a perguntas diferentes, e a topologia dos anexos não está entre as perguntas que se podem fazer à saída renderizada.
Exprimir as regras do património numa linguagem de políticas
Os padrões acima descrevem o que um anexo de governação faz; esta secção trata do que uma empresa escreve para o obter. Uma equipa de plataforma com cinquenta regras a enunciar não quer cinquenta plugins. Quer as suas regras como conteúdo — ficheiros que revê, versiona e distribui como qualquer outro artefacto — com um único motor anexado a avaliá-las.
É isso que um motor de linguagem de políticas anexado ao socket fornece, e dois deles vêm incluídos no compilador exatamente para este fim: um motor Rego e um motor CEL. Um operador anexa um, declara os ficheiros de políticas que deve carregar, e as regras correm: sem toolchain externa, sem nada obtido em tempo de compilação e sem lógica de políticas no compilador. A avaliação acontece dentro do convidado WebAssembly, que é onde vive toda a inteligência de domínio.
O mesmo motor serve todos os papéis de governação, pelo que um património cobre toda a sua superfície com um único plugin anexado e vários anexos dele:
- Julgar a arquitetura. Anexada sobre o grafo da compilação, uma política lê todos os nós, arestas e anexos que o compilador contém, mais os caminhos de encaminhamento enumerados ao lado deles, e reporta o que tem de parar a compilação. É aqui que vive um invariante de topologia, uma regra de autorização entre fronteiras ou uma regra de fluxo de credenciais.
- Julgar a saída. Anexada sobre os artefactos renderizados, uma política lê os ficheiros que a compilação produziu — como texto e, quando o formato foi analisado antes da política, como documentos analisados — e reporta sobre o resultado concreto.
- Fornecer metadados derivados. Anexada para moldar etiquetas, uma política decide que etiquetas os nós da compilação transportam, a partir do ambiente da Release e do que os nós já declaram. É 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 construído para o efeito.
- Acrescentar uma capacidade que o programador não escreveu. Anexada para injetar anotações, uma política acrescenta anotações aos componentes da compilação; uma anotação sob uma chave para a qual o Manifest regista uma associação expande-se num anexo de Feature, pelo que uma regra empresarial pode fornecer o invólucro de que um componente precisa em vez de se limitar a rejeitar a sua ausência. Uma decisão escreve qualquer valor que um operador poderia escrever nessa anotação — uma cadeia, ou um objeto de subchaves para uma associação que encaminha várias — e a compilação lê-o exatamente como lê o mesmo valor escrito na Release. Só pode acrescentar: um valor que removeria uma anotação ou a excluiria é recusado, e um valor injetado que a compilação não consegue encaminhar ou que a Feature associada não admite é recusado nomeando o plugin que o injetou.
Uma regra lê o que o payload transporta e reporta a sua decisão sob uma chave nomeada:
# Evaluated by a governance verdict role over the assembled graphpackage 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: interrompe uma compilação em que um componente que contém dados de uma classe alcança um componente de outra classe ao longo de uma rota sem nenhuma Feature de desclassificação anexada, e o mesmo Aggregate conclui quando uma Release encaminha esse tráfego através de um gateway que transporte core/data-masking. O compilador transporta a etiqueta de classe como uma cadeia e não ordena nada — as classes, a sua ordem e as Features que contam como desclassificação são definições do anexo. 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, pelo que uma compilação em que dois motores discordem mostra a discordância.
O vocabulário próprio de uma política é preservado. As severidades sobre as quais o socket atua são um conjunto fechado, mas os nomes sob os quais uma política reúne as suas decisões pertencem à política. Os nomes predefinidos são os convencionais que um corpus Rego já usa, e um operador cujas políticas nomeiem as suas decisões de outra forma declara o mapeamento nas definições do anexo — pelo que um património que já mantém uma biblioteca de políticas adota o socket sem a reescrever. O mapeamento é tipado pelo esquema que o plugin declara para as suas definições, pelo que um mapeamento malformado interrompe a compilação antes de correr qualquer política, em vez de encaminhar mal um veredicto.
Uma biblioteca de políticas inteira viaja como um único anexo. Um conjunto de políticas pode ser anexado ficheiro a ficheiro, ou como um único arquivo que contém os seus ficheiros de políticas e os seus documentos de dados em conjunto, que o convidado abre. Um arquivo que não possa ser lido é reportado como tal, nomeando o ficheiro — nunca como um conjunto de políticas que não chegou a nenhuma decisão, porque «a biblioteca era ilegível» nunca pode ser indistinguível de «a biblioteca permitiu a compilação».
Uma política que não pode ser avaliada para a compilação. Quando uma política não pode ser avaliada, o anexo falha e a compilação é interrompida com uma falha que nomeia o plugin, deliberadamente distinta de um veredicto que para a compilação. Os dois casos não podem ser confundidos, e nenhum deles é uma permissão.
A superfície de autoria completa — o payload que cada papel expõe, as chaves de decisão, o mapeamento para severidades e a forma de anexar um arquivo — está em language-reference/plugins/policy-socket.md.
Herança e disciplina de publicação
A herança através de extends: é o mecanismo de catálogo que permite aos Platform Architects construir entidades filhas especializadas sobre baselines partilhadas. Os dois tipos de catálogo separam-se nos seus pilares de dados. Os esquemas do pai e do filho de uma Feature compõem-se no momento do carregamento do espaço de trabalho, produzindo um esquema unificado com proveniência por folha. Um Component que estende não escreve nenhum conteúdo de pilar: escreve o marcador literal schema: inherited e recebe o bloco schema: da sua base exatamente como a base o escreveu, a todas as profundidades de uma cadeia.
É isso que resolve a questão de governação que uma baseline partilhada levanta — que restrições pode um filho declarar em relação à sua base. Para um Component, a resposta é estrutural e não de policiamento: o contrato declarado do filho simplesmente é o da base, pelo que uma restrição da base não pode ser afrouxada, eliminada ou retipada por um filho, e não é necessária nenhuma verificação no momento da publicação para manter a baseline intacta. Um filho que precise legitimamente de uma regra mais apertada do que a que a sua base declara exprime-a como uma entrada adicional no seu bloco assertions:, que se compõe ao lado das regras da base em vez de as substituir.
O que um Component filho compõe, de facto, é estrutura: os seus slots de anexo (featuresSchema), sockets de topologia (usesSchema), allowlist de autoinjeção (inject) e assertions nomeadas fundem-se todos ao longo da cadeia, substituindo uma entrada redeclarada a da base por inteiro.
Colocação das regras: que regras vivem no plugin de políticas 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 abastecimento (por exemplo, «cada Recipe tem de fazer implements: de um Component que exista no catálogo»), regras de conformidade empresarial (por exemplo, «cada Component com compliance.aggrega.ai/scope: pci-dss têm de fazer extends: da baseline pci empresarial»). Estas regras atravessam várias entidades, avaliam o espaço de trabalho como uma unidade ou impõem convenções no momento da publicação em vez de no momento da compilação.
A declaração schema: por Component / por Feature é o lugar das restrições por entidade: tipos, intervalos, padrões e enumerações por campo; regras entre campos expressas no bloco assertions: dedicado. Estas 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 «todos os campos obrigatórios têm de estar presentes» é uma restrição por entidade que pertence aos arrays required:. Uma regra como «todas as entidades filhas que estendam um pai pci-dss têm de declarar uma etiqueta de governação ao nível do espaço de trabalho» é uma regra entre entidades que o plugin de políticas impõe. 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íticas valida «este catálogo satisfaz as regras transversais que o espaço de trabalho exige?».
Ao escrever uma nova regra de governação, a questão da colocação é: a regra depende apenas do conteúdo de uma única entidade (→ esquema ou bloco de asserções) ou depende da relação entre várias entidades ou da configuração ao nível do espaço de trabalho (→ plugin de políticas)? O padrão de linter Wasm é o mecanismo canónico para o caso transversal; os catálogos empresariais podem distribuir plugins de políticas personalizados que consomem a mesma interface de contrato de plugins que o plugin de disciplina de publicação normal.
Disciplina de prefixos de anotações
O namespace de anotações transporta uma semântica de origem — prefixos diferentes sinalizam públicos diferentes e autoridades de governação diferentes. Os autores de catálogos, as equipas de plataforma empresariais e a própria plataforma Aggrega escrevem todos anotações no mesmo dicionário plano; o prefixo é o que mantém os públicos distintos.
| Prefixo | Origem | Público | Mutabilidade |
|---|---|---|---|
aggrega.ai/ (simples) | Reservado: emitido apenas pelo compilador Aggrega | Ferramentas internas, carimbo de proveniência | Não editável pelo utilizador; as anotações com o prefixo simples declaradas em conteúdo do utilizador 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álogo | Architects que escrevem entidades de catálogo; plugins de políticas Wasm que consomem as etiquetas | O editor do catálogo escreve; os consumidores leem |
<enterprise-domain>/ (por exemplo, acme.com/, my-org.io/) | Camada empresarial | Equipas de plataforma empresariais; plugins Wasm empresariais | Os autores da empresa escrevem; o compilador da plataforma ignora-as como metadados opacos |
<community-domain>/ (por exemplo, cncf.io/, kubernetes.io/) | Ecossistema externo | Ferramentas transversais a ecossistemas que leem etiquetas conhecidas | Governado pela comunidade |
O prefixo simples aggrega.ai/ tem a disciplina mais forte: está 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 proveniência relacionadas na saída renderizada; o conteúdo do utilizador que declare diretamente uma anotação aggrega.ai/<key> é rejeitado no momento da publicação. A disciplina impede que anotações escritas pelo utilizador colidam com a proveniê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 (a etiqueta da ontologia nativa da cloud), feature.aggrega.ai/kind (a partição de Features operacional-versus-credencial), compliance.aggrega.ai/* (as etiquetas do eixo de conformidade) e sub-namespaces com âmbito 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. As leituras entre subdomínios (um plugin Wasm que lê de vários sub-namespaces) são permitidas mas raras; cada plugin limita-se tipicamente a um sub-namespace.
Os prefixos de domínio empresarial (acme.com/..., my-org.io/...) são a superfície de extensão da plataforma. O compilador Aggrega trata-os como metadados opacos; os plugins Wasm empresariais consomem-nos. As empresas escrevem a estrutura de prefixos que melhor se adequa à sua governação — plana (acme.com/owner: team-payments), por subdomínio (security.acme.com/scope: pii) ou hierárquica (org.acme.com/billing-center: finance). A plataforma não restringe a organização dos prefixos empresariais; a única regra é que os prefixos empresariais não colidam com aggrega.ai/ nem com os seus subdomínios.
A disciplina é importante porque as anotações se propagam em cascata — as anotações escritas no subsistema de um Aggregate propagam-se a todos os componentes 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 próprios componentes do módulo; as anotações numa fronteira da Release propagam-se a todos os componentes da fronteira. Uma anotação de fornecedor chega à saída renderizada a partir de qualquer um dos lados, e onde ambos escrevem a mesma chave é aplicado o valor da Release. Sem disciplina de prefixos, uma anotação do lado do Aggregate poderia substituir silenciosamente uma chave de proveniência emitida pela plataforma, ou uma anotação empresarial poderia colidir com uma chave de convenção do catálogo. A tabela de prefixos torna os públicos explícitos e a regra de prevenção de colisões aplicável no momento da publicação.
Ver language-reference/vocabulary/labels-and-annotations.md para a enumeração da superfície de anotações por entidade e a semântica de cascata em três compartimentos (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).