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

Uma política que interrompe uma compilação quando dados restritos chegam sem mascaramento a um modelo gerido

Um parque executa um assistente de sinistros que trata dados restritos de clientes e um assistente de helpdesk que não trata nenhum. Ambos enviam o seu tráfego de modelo para a API gerida da OpenAI através de um gateway de IA dentro do cluster. A regra interna do parque:

Os dados de uma classe não chegam a um componente de outra classe ao longo de uma rota do grafo de compilação, a menos que uma Feature desclassificadora esteja anexada nessa rota.

Este espaço de trabalho anexa essa regra como política sobre o grafo de compilação e compila três Releases de um Aggregate. Numa, os pedidos do assistente de sinistros passam por um gateway que os mascara, e a compilação é concluída. Nas outras duas, não passam, e a compilação é interrompida antes de qualquer coisa ser renderizada, com a política a nomear as duas pontas da rota.

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

O que constrói

instânciaComponent do catálogoo que é aqui
assistantlocal/ai-agent/claims-assistanto assistente de sinistros: o agente LangGraph da biblioteca standard, declarado no catálogo deste espaço de trabalho com uma etiqueta a mais — a classe dos dados que trata
helpdeskcore/ai-agent/langgrapho assistente de helpdesk, que não tem nenhuma classe
checkpointercore/datastore/valkeyonde os dois assistentes guardam o seu estado de execução
masking-gatewaycore/gateway/litellmum gateway de IA que serve um alias, chat, com core/data-masking anexada
plain-gatewaycore/gateway/litellmo mesmo gateway sem nada anexado
gptcore/ai-model/openaia API gerida 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 através do seu socket models, cada um apresentando a chave do modelo nessa ligação. O anexo de mascaramento lista o que mascarar: um padrão para os números de sinistro do parque 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 deixam-no sem associação: cada Release liga-o.

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 helpdeska compilação
release-masked.yamlatravés de masking-gatewayatravés de plain-gatewayé concluída
release-unmasked.yamlatravés de plain-gatewayatravés de plain-gatewayé interrompida
release-masking-off-route.yamlatravés de plain-gatewayatravés de masking-gatewayé interrompida

Cada Release associa o socket model dos dois assistentes a um gateway que o Aggregate declara. Trata-se de ligação de arestas dentro de um socket que o Component declara, o que uma Release pode fazer; não acrescenta nenhum componente nem altera nenhum valor.

Gerar o exemplo

É possível compilar este exemplo com os comandos abaixo, ou pedir ao assistente de IA que o compile.

Escreva o exemplo numa nova pasta com o nome dele:

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

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta:

Terminal window
cd policy-data-class-route

Compilação

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

Basta substituir governance-rego.yaml por governance-cel.yaml ou governance-opa.yaml para executar a mesma regra noutro motor.

--config indica o ficheiro de configuração global para essa execução. É lido em vez daquele que a máquina leria de outro modo — o ficheiro que AGGREGA_CONFIG indica, ou a localização predefinida — e o próprio .aggrega-config.yaml deste espaço de trabalho continua a sobrepor-se a ele. Assim, para essa execução, nada do que guarda no seu próprio ficheiro global se aplica: outro anexo de governação, um default_registry, uma definição offline. Uma credencial que tenha guardado com aggrega login não faz parte desse ficheiro e continua a aplicar-se. O ficheiro do espaço de trabalho declara os diretórios do catálogo e nenhum anexo de governação próprio; uma lista que declarasse substituiria a que o ficheiro indicado contém, pelo que o anexo no ficheiro indicado é o que é executado.

Uma política de governação é anexada pela configuração, não por uma Release — uma Release não tem nenhum campo para isso — e é por isso que o motor é escolhido por compilação, e não por Release.

Duas coisas têm de estar disponíveis antes de uma primeira compilação:

  • O catálogo da biblioteca standard. .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 motor OPA. Todo o resto, incluindo as entidades Plugin dos motores Rego e CEL, é resolvido a partir do registo do hub descrito abaixo, ou de um checkout do catálogo indicado com --catalog.
  • O registo do hub. A realização do mascaramento de dados escreve os seus guardrails através 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 a compilação obtém-no do registo que default_registry indica, hub.aggrega.ai.

--auto-pull preenche o ficheiro de bloqueio de cada Release durante a compilação; os ficheiros 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-lhe este prompt.

Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por iniciativa 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`: esta escreve o exemplo numa nova pasta `policy-data-class-route`. Em seguida, chame a ferramenta `cli-build`, que executa `aggrega build` e aceita a respetiva flag `--config`, uma vez para cada Release, por esta ordem — `release-masked.yaml`, `release-unmasked.yaml` e `release-masking-off-route.yaml` — de cada vez com `workspace_root` definido como `policy-data-class-route`, `release` definido como esse ficheiro, `auto_pull` definido como true e `config` definido como `governance-rego.yaml`. A segunda e a terceira devem ser recusadas, por isso leia-me cada recusa. Indique-me que ficheiros a primeira compilação escreveu; encontram-se em `policy-data-class-route/dist/`.

A interrupção

release-unmasked.yaml, com cada motor. O motor 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 motor 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

A compilação termina com 1 e não escreve nenhum dist/: a política é avaliada sobre o grafo de compilação antes de qualquer coisa ser renderizada. E0005 é o diagnóstico que uma recusa de política transporta — consulte-se a referência de diagnósticos. release-masking-off-route.yaml imprime a mesma recusa, com cada motor.

Leia-se a frase como a rota que ela encontrou. assistant contém dados restricted. O seu tráfego de modelo chega a gpt, que a política classifica como public, através de plain-gateway, e nada nessa rota — nem o assistente, nem o gateway, nem o modelo — tem uma Feature que a política conte como desclassificadora. Duas classes com níveis diferentes encontram-se numa rota sem nada entre elas, pelo que a política recusa a compilação.

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

Satisfazê-la: o gateway de mascaramento na rota

release-masked.yaml encaminha o assistente de sinistros através de masking-gateway, e todos os motores permitem a compilação, com <workspace> a representar 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é ao modelo, e a política lê-o aí: nessa rota, um componente tem um anexo cujo tipo a definição declassifying_features da política lista, no ponto em que as classes diferem ou antes dele. A rota lê-se 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 altera nada no que é renderizado. A árvore release-masked de cada motor é idêntica byte a byte à da mesma Release compilada sem nenhuma política anexada. A política está anexada ao papel ir-verdict, um papel de veredicto: devolve uma aceitação ou uma recusa, e o caminho que despacha um veredicto não tem forma de aplicar um como alteração, pelo que uma política aí pode parar uma compilação e não pode reescrevê-la para a tornar conforme.

A política verifica que o mascaramento está anexado na rota, não o que ele mascara. Um anexo que lista um padrão a que os dados de ninguém correspondem satisfá-la tão bem como este. O que um anexo de mascaramento lista é o juízo próprio do parque, feito onde o anexo é escrito.

Porque é que as Releases movem a rota, não o anexo

Uma Release pode anexar uma Feature, mas um anexo escrito numa Release não tem values, e core/data-masking guarda o que mascara — patterns e entities — em values, interrompendo um anexo que não liste nenhum dos dois. Por isso, o mascaramento é anexado no Aggregate, em masking-gateway, e está no grafo de cada uma das três compilações:

  • em release-masked.yaml, fica na rota do assistente de sinistros, e a compilação é concluída;
  • em release-unmasked.yaml, não fica na rota de nenhum assistente, e a compilação é interrompida;
  • em release-masking-off-route.yaml, fica na rota do helpdesk, e a compilação é interrompida novamente.

A segunda e a terceira compilações têm o mesmo anexo e diferem apenas na rota em que ele está. Ambas são interrompidas, pelo que a política está a ler a rota, não a contar anexos na compilação.

O que a política lê

Tudo isso vem do grafo de compilação que o compilador entrega a um anexo ir-verdict, e todo o seu significado, das definições do anexo:

  • 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 da etiqueta que class_label indica, compliance.aggrega.ai/data-class, onde um componente a tem: apenas assistant a tem, com restricted. Caso contrário, a classe da primeira entrada de classes_by_label cuja etiqueta e valor o componente tem.
  • Os anexos de cada componente, input.graph.spec.feature_values_mapping. A própria lista attached_features da rota deliberadamente não é lida: nomeia cada Feature anexada em qualquer ponto da rota, pelo que não pode dizer se alguma 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 ligação leva um pedido num sentido e a sua resposta no outro — e para as classes que as definições colocam no mesmo nível.

A classe do modelo vem da sua etiqueta de alojamento. gpt não tem nenhuma etiqueta de classe. O seu Component, core/ai-model/openai, tem component.aggrega.ai/hosting: managed, a declaração do catálogo de que o serviço é operado pelo seu fornecedor, fora do cluster, e as definições mapeiam isso para uma classe:

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

Um modelo gerido retém tudo o que lhe é enviado, o que este parque trata como público. Um modelo auto-alojado como core/ai-model/vllm, e qualquer um dos dois gateways aqui, tem antes self-hosted, 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, pelo que, num grafo com mais rotas do que isso, uma rota pode ficar por ler e a compilação passar. Uma rota que a política lê é real; a ausência de uma não prova que ela não existe. Consulte-se os papéis de veredicto.

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

O compilador leva compliance.aggrega.ai/data-class ao grafo de compilação como uma cadeia de caracteres e não lhe atribui nenhum significado. Não sabe que restricted é mais sensível do que public, nem que qualquer das palavras signifique algo. As classes e a sua hierarquia são definições da política, as mesmas nos três ficheiros de motor:

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

Um parque com o seu próprio vocabulário usa o seu: as suas classes e a sua ordem em rank, a etiqueta em que as guarda em class_label, as suas derivações em classes_by_label e as Features que aceita como desclassificadoras em declassifying_features. Os três ficheiros de motor devem ser alterados da mesma forma, já que uma diferença entre eles é uma diferença entre os veredictos dos motores. Uma classe que um componente tenha e que rank não liste interrompe a compilação em vez de ser lida como ausência de classe, pelo que um erro ortográfico é comunicado em vez de passar. Com a etiqueta do assistente de sinistros escrita Restricted, todos os motores recusam release-masked.yaml; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull imprime a recusa abaixo, e o ficheiro de cada um dos outros motores imprime a mesma, encabeçada com o nome desse motor:

[… 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 é dada pelo Component próprio deste espaço de trabalho, não pelo da biblioteca standard. Se um assistente trata dados restritos é uma afirmação sobre a forma como um parque o usa, não sobre o LangGraph, pelo que local/ai-agent/claims-assistant estende core/ai-agent/langgraph, herda o seu contrato e acrescenta essa única etiqueta. Um Aggregate não pode colocar uma etiqueta numa instância de componente, pelo que uma classe é sempre uma propriedade do Component com o qual uma instância é declarada. Com o assistente de sinistros declarado antes como o agente da biblioteca standard, nenhum componente tem uma etiqueta de classe, e release-unmasked.yaml compila com todos os motores, byte a byte igual ao que compila sem política: o modelo continua a derivar public, mas não há uma segunda classe para ele encontrar.

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

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

As três cópias são um quase duplicado deliberado. Cada uma é escrita por si a partir da regra, de modo que uma compilação em que os motores discordam mostra a discordância: a mesma compilação a ser interrompida com um motor e concluída com outro é o sinal. Nenhuma é gerada a partir de outra, e não devem ser fundidas numa única implementação partilhada, o que faria os motores concordar por construção e esconderia a diferença que isto existe para detetar. Cada ficheiro começa por dizê-lo.

Diferem onde os motores diferem:

  • A cópia CEL não consegue associar um nome a um valor nem percorrer as posições de uma lista, pelo que as suas definições têm 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 a compilação, indicando onde 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, pelo que o seu anexo fornece definições e nenhum ficheiro de política. O adaptador não fornece nenhuma das funções internas que o OPA deixa a cargo do anfitrião, pelo que esta cópia junta as suas mensagens com concat onde a cópia do motor Rego as formata com sprintf. Editá-la não altera nenhuma compilação até o guest ser reconstruído, abaixo.

Os anexos Rego e CEL nomeiam as entidades Plugin que o catálogo da biblioteca standard contém para os dois motores compilados na CLI, governance/rego:0.9.0 e governance/cel:0.9.0, e o motor que é executado é o compilado no binário que executa a compilação. 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, pelo que o seu anexo nomeia governance/opa:1.0.0. Uma recusa é encabeçada pelo último segmento da referência do anexo, sem a versão — policy plugin "rego", "cel" ou "opa" — e cada compilação anexa um único motor, pelo que a recusa que imprime nomeia esse motor. O guest do OPA é lido ao lado da sua entidade em cada compilação, e como nada regista o seu digest, cada compilação com ele avisa que é executado sem verificação.

Verificar cada compilação

Esta autoverificação é executada num checkout do repositório da documentação, que contém o script auxiliar de compilação partilhado que usa; uma cópia escrita por aggrega scaffold --example não inclui esse script auxiliar.

Terminal window
./check.sh

check.sh compila as três Releases com os três motores através de ./build-release.sh e compara cada resultado com o que esta página descreve. Uma interrupção tem de terminar com código diferente de zero com E0005, cuja mensagem é a frase acima, e nenhuma outra recusa ao lado; uma compilação concluída tem de terminar com 0 e escrever os mesmos ficheiros, byte a byte, que a mesma Release compilada sem política, que compila primeiro como referência. Todos os motores são avaliados pela mesma frase. Imprime uma linha por compilação e termina com 1 se algum resultado diferir, imprimindo a saída dessa compilação:

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.

Precisa do que uma única compilação precisa: o catálogo da biblioteca standard e o registo do hub. Usa o binário que ./build-release.sh resolve, pelo que AGGREGA_BIN o escolhe; os argumentos depois de -- chegam a cada compilação, pelo que ./check.sh -- --offline o executa sem rede depois de tudo o que obtém estar em cache. Recusa-se a arrancar enquanto houver um dist/ neste diretório, porque compara as árvores que as compilações escrevem, e não deixa nenhuma para trás. O seu estado de saída é o veredicto inteiro, pelo que um pipeline pode executá-lo em vez de compilar cada Release separadamente.

Reconstruir 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 em vez do módulo próprio do adaptador. Foi compilado a partir de aggrega-pdk em afd9ac6c6800c34c6c47a2030f580c9681387047 e de aggrega-abi, o crate de ABI sobre 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. Indicar 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, num diretório temporário $BUILD, indicado como caminho absoluto, que contém os dois repositórios lado a lado, com a dependência por caminho do adaptador a ir de um para o outro. Os três mapeamentos de caminho mantêm o diretório de compilação, 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 copiar $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 da compilação do cargo tal como sai. O próprio script de compilação do adaptador também executa uma passagem opcional de redução de tamanho, que é ignorada aqui: reescreve os dados do guest, e sem ela o módulo permanece no guest byte a byte. Isso permite verificar 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 os seus crates foram compilados, e da toolchain, pelo que uma reconstrução noutro local é um guest equivalente com outro sha256. O distribuído aqui é eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.

Onde o compilador não interpreta

O compilador leva a etiqueta de classe ao grafo de compilação como uma cadeia de caracteres, enumera rotas sobre as arestas uses que o Aggregate e as Releases declararam, e entrega ambos à política. Não atribui nível a uma classe, não sabe que managed significa que os dados saem do cluster para um fornecedor, e não sabe que core/data-masking oculta seja o que for. Cada um desses significados está nas definições da política, e é isso que permite a um parque com outras classes, outras etiquetas e outras Features desclassificadoras executar o mesmo mecanismo sem alterações. Para o socket a que a política está anexada — os papéis, o payload, as severidades do veredicto — ver o socket de políticas, e para o lugar da política no produto, Governação e conformidade.

Ficheiros

  • aggregate.yaml — os dois assistentes, o seu checkpointer, os dois gateways, o modelo e o par de serviços de reconhecimento; o mascaramento anexado 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 respetivas Recipes Kubernetes, e o assistente de sinistros à Recipe do agente base. Partilhado pelas três Releases.
  • release-masked.yaml, release-unmasked.yaml, release-masking-off-route.yaml — os três encaminhamentos, e o Secret a partir do qual é lida a chave de cada gateway.
  • catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml — o assistente de sinistros, core/ai-agent/langgraph com a etiqueta de classe acrescentada.
  • catalog/plugin/governance/opa/1.0.0/plugin.yaml — a entidade Plugin do motor 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 motor.
  • governance-rego.yaml, governance-cel.yaml, governance-opa.yaml — um ficheiro para --config por motor, cada um a anexar a regra em ir-verdict com as mesmas definições.
  • .aggrega-config.yaml — a pilha de pesquisa do catálogo e o registo; nenhum anexo de governação.
  • build-release.sh — compila uma Release, mostrando o comando aggrega build equivalente.
  • check.sh — faz as nove compilações e verifica cada resultado.