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

Uma política que interrompe um build quando dados restritos chegam sem mascaramento a um modelo gerenciado

Uma organização executa um assistente de sinistros que lida com dados restritos de clientes e um assistente de helpdesk que não lida com nenhum. Ambos enviam seu tráfego de modelo à API gerenciada da OpenAI por meio de um gateway de IA dentro do cluster. A regra interna da organização:

Dados de uma classe não chegam a um componente de outra classe ao longo de uma rota do grafo de build, a menos que uma Feature desclassificadora esteja vinculada nessa rota.

Este espaço de trabalho vincula essa regra como política sobre o grafo de build e faz o build de três Releases de um Aggregate. Em uma, as requisições do assistente de sinistros passam por um gateway que as mascara, e o build é concluído. Nas outras duas, não passam, e o build é interrompido antes que qualquer coisa seja renderizada, com a política nomeando as duas pontas da rota.

A regra é escrita três vezes, uma para cada mecanismo de políticas em que é executada — os mecanismos Rego e CEL compilados na CLI, e o OPA — e as três cópias concordam em cada build aqui. Um script ao lado das Releases faz o build das nove combinações e verifica cada resultado.

O que ele constrói

instânciaComponent do catálogoo que é aqui
assistantlocal/ai-agent/claims-assistanto assistente de sinistros: o agente LangGraph da biblioteca padrão, declarado no catálogo deste espaço de trabalho com um rótulo a mais — a classe dos dados com que lida
helpdeskcore/ai-agent/langgrapho assistente de helpdesk, que não carrega nenhuma classe
checkpointercore/datastore/valkeyonde os dois assistentes mantêm seu estado de execução
masking-gatewaycore/gateway/litellmum gateway de IA que serve um alias, chat, com core/data-masking vinculada
plain-gatewaycore/gateway/litellmo mesmo gateway sem nada vinculado
gptcore/ai-model/openaia API gerenciada da OpenAI, alcançada como referência: nada é executado para ela no cluster
analyzer, anonymizercore/security/presidio-analyzer, core/security/presidio-anonymizeros serviços de reconhecimento que o mascaramento chama

Os dois gateways estão ligados a gpt por meio do seu socket models, cada um apresentando a chave do modelo nessa conexão. A vinculação de mascaramento lista o que mascarar: um padrão para os números de sinistro da organização e os tipos de entidade PERSON e EMAIL_ADDRESS. Os dois assistentes declaram o socket model que o seu Component declara, que admite um modelo ou um gateway que serve uma API de modelos, e o deixam sem associação: cada Release o liga.

As três Releases

As Releases diferem apenas no gateway por onde passa o tráfego de modelo de cada assistente:

Releaseo tráfego do assistente de sinistroso tráfego do assistente de helpdesko build
release-masked.yamlpor meio de masking-gatewaypor meio de plain-gatewayé concluído
release-unmasked.yamlpor meio de plain-gatewaypor meio de plain-gatewayé interrompido
release-masking-off-route.yamlpor meio de plain-gatewaypor meio de masking-gatewayé interrompido

Cada Release associa o socket model dos dois assistentes a um gateway que o Aggregate declara. Isso é ligação de arestas dentro de um socket que o Component declara, o que uma Release pode fazer; não adiciona nenhum componente e não altera nenhum valor.

Gerar o exemplo

Você pode fazer o build deste exemplo com os comandos abaixo, ou pedir ao seu assistente de IA que faça o build por você.

Escreva o exemplo em uma nova pasta com o nome dele:

Terminal window
aggrega scaffold --example policy-data-class-route

Em seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova:

Terminal window
cd policy-data-class-route

Build

Terminal window
aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull
aggrega build --release release-unmasked.yaml --config governance-rego.yaml --auto-pull # halts; exits 1
aggrega build --release release-masking-off-route.yaml --config governance-rego.yaml --auto-pull # halts; exits 1

Troque governance-rego.yaml por governance-cel.yaml ou governance-opa.yaml para executar a mesma regra em outro mecanismo.

--config nomeia o arquivo de configuração global para essa execução. Ele é lido no lugar daquele que a máquina leria de outra forma — o arquivo que AGGREGA_CONFIG nomeia, ou o local padrão — e o próprio .aggrega-config.yaml deste espaço de trabalho continua se sobrepondo a ele. Portanto, para essa execução, nada do que você mantém no seu próprio arquivo global se aplica: outra vinculação de governança, um default_registry, uma configuração offline. Uma credencial que você armazenou com aggrega login não faz parte desse arquivo e continua valendo. O arquivo do espaço de trabalho declara os diretórios do catálogo e nenhuma vinculação de governança própria; uma lista que ele declarasse substituiria a que o arquivo nomeado contém, então a vinculação no arquivo nomeado é a que é executada.

Uma política de governança é vinculada pela configuração, não por uma Release — uma Release não tem campo para isso — e é por isso que o mecanismo é escolhido por build, e não por Release.

Duas coisas precisam estar disponíveis antes de um primeiro build:

  • O catálogo da biblioteca padrão. .aggrega-config.yaml lista o catalog/ próprio deste espaço de trabalho, que contém o assistente de sinistros e a entidade Plugin do mecanismo OPA. Todo o resto, incluindo as entidades Plugin dos mecanismos Rego e CEL, é resolvido a partir do registro do hub descrito abaixo, ou de um checkout do catálogo indicado com --catalog.
  • O registro do hub. A realização do mascaramento de dados escreve seus guardrails por meio de um plugin que não é distribuído nem com o compilador nem com o catálogo, a etapa de configuração do gateway pipeline-step/litellm-gateway-config, e o build o baixa do registro que default_registry nomeia, hub.aggrega.ai.

--auto-pull preenche o arquivo de bloqueio de cada Release durante o build; os arquivos de bloqueio e a saída renderizada são gerados, não distribuídos.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole este prompt nele.

Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta Workspace ainda não contiver uma pasta `policy-data-class-route`, chame uma vez a ferramenta `scaffold` com `example` definido como `policy-data-class-route` e sem `dir`: ela grava o exemplo em uma nova pasta `policy-data-class-route`. Em seguida, chame a ferramenta `cli-build`, que executa `aggrega build` e aceita a flag `--config` dele, uma vez para cada Release, nesta ordem — `release-masked.yaml`, `release-unmasked.yaml` e `release-masking-off-route.yaml` — cada vez com `workspace_root` definido como `policy-data-class-route`, `release` definido como esse arquivo, `auto_pull` definido como true e `config` definido como `governance-rego.yaml`. O segundo e o terceiro devem ser recusados, então leia para mim cada recusa. Diga-me quais arquivos o primeiro build gravou; eles ficam em `policy-data-class-route/dist/`.

A interrupção

release-unmasked.yaml, com cada mecanismo. O mecanismo Rego:

[… omitted: the pull's lines, and a lint notice about core/referenced-secret]
[POLICY_ERROR E0005]
policy plugin "rego" rejected the build: assistant (restricted) reaches gpt (public) with no declassifying Feature attached between them
caused by: policy violation

O mecanismo CEL:

[… omitted: the pull's lines, and a lint notice about core/referenced-secret]
[POLICY_ERROR E0005]
policy plugin "cel" rejected the build: assistant (restricted) reaches gpt (public) with no declassifying Feature attached between them
caused by: policy violation

OPA:

[… omitted: a warning that the OPA guest runs unverified, the pull's lines, and a lint notice about core/referenced-secret]
[POLICY_ERROR E0005]
policy plugin "opa" rejected the build: assistant (restricted) reaches gpt (public) with no declassifying Feature attached between them
caused by: policy violation

O build termina com 1 e não escreve nenhum dist/: a política é avaliada sobre o grafo de build antes que qualquer coisa seja renderizada. E0005 é o diagnóstico que uma recusa de política carrega — veja a referência de diagnósticos. release-masking-off-route.yaml imprime a mesma recusa, com cada mecanismo.

Leia a frase como a rota que ela encontrou. assistant contém dados restricted. Seu tráfego de modelo chega a gpt, que a política classifica como public, por meio de plain-gateway, e nada nessa rota — nem o assistente, nem o gateway, nem o modelo — carrega uma Feature que a política conte como desclassificadora. Duas classes com níveis diferentes se encontram em uma rota sem nada entre elas, então a política recusa o build.

O comando pull também renderiza a Release, para encontrar as entradas externas que precisa fixar, e encontra ali a mesma recusa; é por isso que as linhas omitidas acima trazem a frase uma segunda vez. O arquivo de bloqueio é escrito mesmo assim.

Satisfazendo-a: o gateway de mascaramento na rota

release-masked.yaml roteia o assistente de sinistros por meio de masking-gateway, e todos os mecanismos permitem o build, com <workspace> representando a pasta deste exemplo:

[… omitted: the pull's lines, a lint notice, under OPA a warning that its guest runs unverified, and the total build time]
Build completed: 17 files written to <workspace>/dist

O gateway de mascaramento está agora na única rota do assistente de sinistros até o modelo, e a política o lê ali: nessa rota, um componente carrega uma vinculação cujo tipo a configuração declassifying_features da política lista, no ponto em que as classes diferem ou antes dele. A rota pode ser lida na saída renderizada: dist/helm/assistant-deployment.yaml envia o assistente de sinistros para o gateway de mascaramento, e dist/helm/helpdesk-deployment.yaml envia o helpdesk para o simples.

# dist/helm/assistant-deployment.yaml, the env of the assistant's container
env:
[… omitted: the recursion limit]
- name: OPENAI_BASE_URL
value: http://masking-gateway-default:4000/v1
[… omitted: the alias, the checkpointer's address and the graph's entrypoint]
# dist/helm/helpdesk-deployment.yaml, the env of the helpdesk's container
env:
[… omitted: the recursion limit]
- name: OPENAI_BASE_URL
value: http://plain-gateway-default:4000/v1
[… omitted: the alias, the checkpointer's address and the graph's entrypoint]

O mascaramento em si está na configuração do gateway de mascaramento, a chave config.yaml de dist/helm/masking-gateway/litellm-gateway-config/configmap.yaml:

[… omitted: the routing table]
litellm_settings:
callbacks:
- /etc/litellm-request-guard/request_field_filter.filter
turn_off_message_logging: true
guardrails:
-
guardrail_name: masking-gateway-masking
litellm_params:
default_on: true
guardrail: litellm_content_filter
mode: pre_call
patterns:
-
action: MASK
name: claim_number
pattern: "\\bCLM-[0-9]{8}\\b"
pattern_type: regex
skip_tool_message_in_guardrail: true
[… omitted: three more guardrail entries masking the same pattern and the two entity types, and the request guard's settings]

A configuração do gateway simples não tem nenhuma entrada de guardrail.

A política não muda nada no que é renderizado. A árvore release-masked de cada mecanismo é idêntica byte a byte à da mesma Release com build feito sem nenhuma política vinculada. A política é vinculada ao papel ir-verdict, um papel de veredito: ela retorna uma aceitação ou uma recusa, e o caminho que despacha um veredito não tem como aplicar um como alteração, então uma política ali pode parar um build e não pode reescrevê-lo para torná-lo conforme.

A política verifica que o mascaramento está vinculado na rota, não o que ele mascara. Uma vinculação que lista um padrão ao qual os dados de ninguém correspondem a satisfaz tão bem quanto esta. O que uma vinculação de mascaramento lista é o próprio julgamento da organização, feito onde a vinculação é escrita.

Por que as Releases movem a rota, não a vinculação

Uma Release pode vincular uma Feature, mas uma vinculação escrita em uma Release não carrega values, e core/data-masking mantém o que mascara — patterns e entities — em values, interrompendo uma vinculação que não lista nenhum dos dois. Por isso o mascaramento é vinculado no Aggregate, em masking-gateway, e está no grafo de cada um dos três builds:

  • em release-masked.yaml, ele fica na rota do assistente de sinistros, e o build é concluído;
  • em release-unmasked.yaml, ele não fica na rota de nenhum assistente, e o build é interrompido;
  • em release-masking-off-route.yaml, ele fica na rota do helpdesk, e o build é interrompido novamente.

O segundo e o terceiro builds carregam a mesma vinculação e diferem apenas na rota em que ela está. Ambos são interrompidos, então a política está lendo a rota, não contando vinculações no build.

O que a política lê

Tudo isso vem do grafo de build que o compilador entrega a uma vinculação ir-verdict, e todo o seu significado, das configurações da vinculação:

  • As rotas que o compilador enumera, input.precalculated_paths: cada uma, uma lista ordenada de componentes unidos por arestas uses. Em release-unmasked.yaml, uma delas é assistant → plain-gateway → gpt. A política lê cada rota a partir do seu primeiro componente, o que basta porque o compilador enumera as rotas que saem de cada componente. Ela própria não enumera nada.
  • A classe de cada componente. O valor do rótulo que class_label nomeia, compliance.aggrega.ai/data-class, onde um componente o carrega: apenas assistant o carrega, com restricted. Caso contrário, a classe da primeira entrada de classes_by_label cujo rótulo e valor o componente carrega.
  • As vinculações de cada componente, input.graph.spec.feature_values_mapping. A própria lista attached_features da rota deliberadamente não é lida: ela nomeia cada Feature vinculada em qualquer ponto da rota, então não pode dizer se uma delas fica entre os dois componentes em questão.

Um componente sem classe é ignorado. O mesmo vale para a direção em que uma rota é traçada — uma conexão leva uma requisição em um sentido e sua resposta no outro — e para as classes que as configurações colocam no mesmo nível.

A classe do modelo vem do seu rótulo de hospedagem. gpt não carrega nenhum rótulo de classe. Seu Component, core/ai-model/openai, carrega component.aggrega.ai/hosting: managed, a declaração do catálogo de que o serviço é operado pelo seu provedor, fora do cluster, e as configurações mapeiam isso para uma classe:

classes_by_label:
- label: component.aggrega.ai/hosting
value: managed
class: public

Um modelo gerenciado retém tudo o que lhe é enviado, o que esta organização trata como público. Um modelo auto-hospedado como core/ai-model/vllm, e qualquer um dos dois gateways aqui, carrega self-hosted em vez disso, e portanto nenhuma classe.

As rotas são limitadas. O compilador lista um número limitado de rotas a partir de cada componente inicial e não lista nada além do limite, então, em um grafo com mais rotas do que isso, uma rota pode ficar sem ser lida e o build passar. Uma rota que a política lê é real; a ausência de uma não prova que ela não existe. Veja os papéis de veredito.

As classes são da política, não do compilador

O compilador leva compliance.aggrega.ai/data-class ao grafo de build como uma string e não lhe atribui nenhum significado. Ele não sabe que restricted é mais sensível que public, nem que qualquer uma das palavras signifique algo. As classes e sua hierarquia são configurações da política, as mesmas nos três arquivos de mecanismo:

class_label: compliance.aggrega.ai/data-class
rank:
public: 0
internal: 1
restricted: 2

Uma organização com seu próprio vocabulário usa o seu: suas classes e sua ordem em rank, o rótulo em que as mantém em class_label, suas derivações em classes_by_label e as Features que aceita como desclassificadoras em declassifying_features. Altere os três arquivos de mecanismo da mesma forma, já que uma diferença entre eles é uma diferença entre os vereditos dos mecanismos. Uma classe que um componente carrega e que rank não lista interrompe o build em vez de ser lida como ausência de classe, então um erro de grafia é relatado em vez de passar. Com o rótulo do assistente de sinistros escrito Restricted, todos os mecanismos recusam release-masked.yaml; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull imprime a recusa abaixo, e o arquivo de cada outro mecanismo imprime a mesma, encabeçada com o nome desse mecanismo:

[… omitted: under OPA a warning that its guest runs unverified, the pull's lines, and a lint notice about core/referenced-secret]
[POLICY_ERROR E0005]
policy plugin "rego" rejected the build: assistant carries the data class "Restricted", which the policy's rank setting does not list; correct the class or rank it
caused by: policy violation

A classe é carregada pelo Component próprio deste espaço de trabalho, não pelo da biblioteca padrão. Se um assistente lida com dados restritos é uma afirmação sobre como uma organização o usa, não sobre o LangGraph, então local/ai-agent/claims-assistant estende core/ai-agent/langgraph, herda seu contrato e adiciona esse único rótulo. Um Aggregate não pode colocar um rótulo em uma instância de componente, então uma classe é sempre uma propriedade do Component com o qual uma instância é declarada. Com o assistente de sinistros declarado, em vez disso, como o agente da biblioteca padrão, nenhum componente carrega um rótulo de classe, e release-unmasked.yaml faz build com todos os mecanismos, byte a byte igual ao build sem política: o modelo ainda deriva public, mas não há uma segunda classe para ele encontrar.

Três mecanismos, a regra escrita três vezes

mecanismovinculado pora regra
o mecanismo Rego compilado na CLIgovernance-rego.yamlpolicies/data-class-paths.rego, nomeado em with.sources
o mecanismo CEL compilado na CLIgovernance-cel.yamlpolicies/data-class-paths.cel, nomeado em with.sources
OPA, por trás do guest adaptador de referênciagovernance-opa.yamlpolicies/data-class-paths-opa.rego, compilado no guest

As três cópias são uma quase duplicata deliberada. Cada uma é escrita por conta própria a partir da regra, de modo que um build em que os mecanismos discordam mostra a discordância: o mesmo build sendo interrompido com um mecanismo e concluído com outro é o sinal. Nenhuma é gerada a partir de outra, e elas não devem ser mescladas em uma única implementação compartilhada, o que faria os mecanismos concordarem por construção e esconderia a diferença que isso existe para detectar. Cada arquivo começa dizendo isso.

Elas diferem onde os mecanismos diferem:

  • A cópia CEL não consegue associar um nome a um valor nem percorrer as posições de uma lista, então suas configurações carregam uma entrada a mais, positions, as posições de 0 a 15 em que os componentes de uma rota são lidos. Uma rota mais longa interrompe o build, indicando onde ela começa, em vez de ser lida em parte.
  • A cópia OPA é compilada antecipadamente com a própria toolchain do OPA e embutida no guest ao lado de catalog/plugin/governance/opa/1.0.0/plugin.yaml, então sua vinculação fornece configurações e nenhum arquivo de política. O adaptador não fornece nenhuma das funções internas que o OPA deixa a cargo do host, então esta cópia junta suas mensagens com concat onde a cópia do mecanismo Rego as formata com sprintf. Editá-la não altera nenhum build até que o guest seja reconstruído, abaixo.

As vinculações Rego e CEL nomeiam as entidades Plugin que o catálogo da biblioteca padrão contém para os dois mecanismos compilados na CLI, governance/rego:0.9.0 e governance/cel:0.9.0, e o mecanismo que é executado é o compilado no binário que executa o build. A entidade Plugin do OPA, em catalog/plugin/governance/, é uma declaração própria deste espaço de trabalho na versão 1.0.0, então sua vinculação nomeia governance/opa:1.0.0. Uma recusa é encabeçada pelo último segmento da referência da vinculação, sem a versão — policy plugin "rego", "cel" ou "opa" — e cada build vincula um único mecanismo, então a recusa que ele imprime nomeia esse mecanismo. O guest do OPA é lido ao lado da sua entidade em cada build, e como nada registra o seu digest, cada build com ele avisa que ele é executado sem verificação.

Verificando cada build

Esta autoverificação é executada em um checkout do repositório da documentação, que contém o script auxiliar de build compartilhado que ela usa; uma cópia escrita por aggrega scaffold --example não traz esse script auxiliar.

Terminal window
./check.sh

check.sh faz o build das três Releases com os três mecanismos por meio de ./build-release.sh e compara cada resultado com o que esta página descreve. Uma interrupção deve terminar com código diferente de zero com E0005, cuja mensagem é a frase acima, e nenhuma outra recusa ao lado; um build concluído deve terminar com 0 e escrever os mesmos arquivos, byte a byte, que a mesma Release com build feito sem política, cujo build ele faz primeiro como referência. Todos os mecanismos são cobrados pela mesma frase. Ele imprime uma linha por build e termina com 1 se algum resultado diferir, imprimindo a saída desse build:

ENGINE RELEASE EXIT EXPECTED VERDICT
------------------------------------------------------------------------------------------
none release-masked.yaml 0 reference OK
rego release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policy
rego release-unmasked.yaml 1 halt OK: E0005, the expected sentence
rego release-masking-off-route.yaml 1 halt OK: E0005, the expected sentence
cel release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policy
cel release-unmasked.yaml 1 halt OK: E0005, the expected sentence
cel release-masking-off-route.yaml 1 halt OK: E0005, the expected sentence
opa release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policy
opa release-unmasked.yaml 1 halt OK: E0005, the expected sentence
opa release-masking-off-route.yaml 1 halt OK: E0005, the expected sentence
check: every build ended as expected.

Ele precisa do que um único build precisa: o catálogo da biblioteca padrão e o registro do hub. Ele usa o binário que ./build-release.sh resolve, então AGGREGA_BIN o escolhe; os argumentos após -- chegam a cada build, então ./check.sh -- --offline o executa sem rede depois que tudo o que ele baixa estiver em cache. Ele se recusa a iniciar enquanto houver um dist/ neste diretório, porque compara as árvores que os builds escrevem, e não deixa nenhuma para trás. Seu status de saída é o veredito inteiro, então um pipeline pode executá-lo no lugar de fazer o build de cada Release separadamente.

Reconstruindo o guest do OPA

catalog/plugin/governance/opa/1.0.0/governance--opa.wasm é o guest adaptador de OPA de referência do kit de plugins, rust/examples/policy-opa-wasm no repositório aggrega-pdk, com o módulo que o OPA compila a partir de policies/data-class-paths-opa.rego no lugar do módulo próprio do adaptador. Ele foi compilado a partir de aggrega-pdk em afd9ac6c6800c34c6c47a2030f580c9681387047 e de aggrega-abi, o crate de ABI contra o qual o adaptador é compilado, em 2ececa8d3b598243f023a2a6c80b351c8d1411a1, com rustc 1.97.1, em torno do módulo que o OPA 1.21.1 compila.

Primeiro o módulo, a partir deste diretório. Nomear a regra pelo seu caminho relativo a este diretório mantém esse caminho, e nada da máquina, no módulo:

Terminal window
opa build -t wasm -e data_class_paths/deny policies/data-class-paths-opa.rego -o bundle.tar.gz
tar -xzf bundle.tar.gz -O /policy.wasm > policy.wasm
rm bundle.tar.gz
sha256sum policy.wasm
# 321e8a1f150a7ef7625e174cf636967b6c0e1f7bd39c3b7fa1010838ce35c871 policy.wasm

O OPA 1.21.1 compila os mesmos bytes a partir da mesma fonte, qualquer que seja o diretório em que este espaço de trabalho esteja.

Depois, o guest, em um diretório temporário $BUILD, informado como caminho absoluto, contendo os dois repositórios lado a lado, com a dependência por caminho do adaptador indo de um para o outro. Os três mapeamentos de caminho mantêm o diretório de build, o home do cargo e as fontes próprias da toolchain fora do guest:

Terminal window
mkdir -p "$BUILD/aggrega-pdk" "$BUILD/aggrega-abi"
git -C <aggrega-pdk checkout> archive afd9ac6c6800c34c6c47a2030f580c9681387047 | tar -x -C "$BUILD/aggrega-pdk"
git -C <aggrega-abi checkout> archive 2ececa8d3b598243f023a2a6c80b351c8d1411a1 | tar -x -C "$BUILD/aggrega-abi"
cp policy.wasm "$BUILD/aggrega-pdk/rust/examples/policy-opa-wasm/policy.wasm"
cd "$BUILD/aggrega-pdk/rust/examples/policy-opa-wasm"
SRC="$(rustc +stable --print sysroot)/lib/rustlib/src/rust"
HASH="$(rustc +stable -vV | awk '/^commit-hash: /{print $2}')"
RUSTFLAGS="--remap-path-prefix=$BUILD=/build --remap-path-prefix=${CARGO_HOME:-$HOME/.cargo}=/cargo --remap-path-prefix=$SRC=/rustc/$HASH" \
CARGO_TARGET_DIR="$BUILD/target" \
cargo +stable build --locked --release --target wasm32-wasip1

e copie $BUILD/target/wasm32-wasip1/release/policy_opa_wasm_rust.wasm para catalog/plugin/governance/opa/1.0.0/governance--opa.wasm.

O guest é a saída do build do cargo como ela vem. O próprio script de build do adaptador também executa uma passagem opcional de redução de tamanho, que é ignorada aqui: ela reescreve os dados do guest, e sem ela o módulo permanece no guest byte a byte. Isso permite que você confira o que um guest contém em relação ao que a regra gera ao ser compilada:

Terminal window
python3 -c 'import sys; print(open(sys.argv[1], "rb").read() in open(sys.argv[2], "rb").read())' \
policy.wasm catalog/plugin/governance/opa/1.0.0/governance--opa.wasm
# True

Os próprios bytes do guest também dependem do diretório em que seus crates foram compilados, e da toolchain, então uma reconstrução em outro lugar é um guest equivalente com outro sha256. O distribuído aqui é eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.

Onde o compilador não interpreta

O compilador leva o rótulo de classe ao grafo de build como uma string, enumera rotas sobre as arestas uses que o Aggregate e as Releases declararam, e entrega ambos à política. Ele não atribui nível a uma classe, não sabe que managed significa que os dados saem do cluster em direção a um provedor, e não sabe que core/data-masking oculta nada. Cada um desses significados está nas configurações da política, e é isso que permite a uma organização com outras classes, outros rótulos e outras Features desclassificadoras executar o mesmo mecanismo sem alterações. Para o socket ao qual a política é vinculada — os papéis, o payload, as severidades do veredito — veja o socket de políticas, e para o lugar da política no produto, Governança e conformidade.

Arquivos

  • aggregate.yaml — os dois assistentes, o checkpointer deles, os dois gateways, o modelo e o par de serviços de reconhecimento; o mascaramento vinculado a masking-gateway; o socket model de nenhum dos dois assistentes associado.
  • manifest.yaml — associa cada tipo de componente e ambos os tipos de Feature às suas Recipes Kubernetes, e o assistente de sinistros à Recipe do agente base. Compartilhado pelas três Releases.
  • release-masked.yaml, release-unmasked.yaml, release-masking-off-route.yaml — os três roteamentos, e o Secret do qual a chave de cada gateway é lida.
  • catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml — o assistente de sinistros, core/ai-agent/langgraph com o rótulo de classe adicionado.
  • catalog/plugin/governance/opa/1.0.0/plugin.yaml — a entidade Plugin do mecanismo OPA, com o seu guest, governance--opa.wasm, ao lado.
  • policies/data-class-paths.rego, policies/data-class-paths.cel, policies/data-class-paths-opa.rego — a regra, uma vez por mecanismo.
  • governance-rego.yaml, governance-cel.yaml, governance-opa.yaml — um arquivo para --config por mecanismo, cada um vinculando a regra em ir-verdict com as mesmas configurações.
  • .aggrega-config.yaml — a pilha de busca do catálogo e o registry; nenhuma vinculação de governança.
  • build-release.sh — faz o build de uma Release, exibindo o comando aggrega build equivalente.
  • check.sh — faz todos os nove builds e verifica cada resultado.