Una política que detiene una compilación cuando datos restringidos llegan sin enmascarar a un modelo gestionado
Una organización ejecuta un asistente de siniestros que maneja datos restringidos de clientes y un asistente de helpdesk que no maneja ninguno. Ambos envían su tráfico hacia el modelo a la API gestionada de OpenAI a través de un gateway de IA dentro del clúster. La regla interna de la organización:
Los datos de una clase no llegan a un componente de otra clase a lo largo de una ruta del grafo de compilación, salvo que haya una Feature desclasificadora vinculada en esa ruta.
Este espacio de trabajo vincula esa regla como política sobre el grafo de compilación y compila tres Releases de un Aggregate. En una, las solicitudes del asistente de siniestros pasan por un gateway que las enmascara, y la compilación se completa. En las otras dos no, y la compilación se detiene antes de que se renderice nada, con la política nombrando ambos extremos de la ruta.
La regla está escrita tres veces, una por cada motor de políticas en el que se ejecuta — los motores Rego y CEL compilados en la CLI, y OPA — y las tres copias coinciden en cada compilación de este ejemplo. Un script junto a las Releases compila las nueve combinaciones y comprueba cada resultado.
Lo que construye
| instancia | Component del catálogo | qué es aquí |
|---|---|---|
assistant | local/ai-agent/claims-assistant | el asistente de siniestros: el agente LangGraph de la biblioteca estándar, declarado en el catálogo de este espacio de trabajo con una etiqueta añadida — la clase de los datos que maneja |
helpdesk | core/ai-agent/langgraph | el asistente de helpdesk, que no lleva ninguna clase |
checkpointer | core/datastore/valkey | donde ambos asistentes guardan su estado de ejecución |
masking-gateway | core/gateway/litellm | un gateway de IA que sirve un alias, chat, con core/data-masking vinculada |
plain-gateway | core/gateway/litellm | el mismo gateway sin nada vinculado |
gpt | core/ai-model/openai | la API gestionada de OpenAI, alcanzada como referencia: nada se ejecuta para ella en el clúster |
analyzer, anonymizer | core/security/presidio-analyzer, core/security/presidio-anonymizer | los servicios de reconocimiento a los que llama el enmascaramiento |
Ambos gateways están conectados a gpt mediante su socket models, y cada uno presenta la clave del modelo en esa conexión. La vinculación de enmascaramiento enumera qué enmascarar: un patrón para los números de siniestro de la organización y los tipos de entidad PERSON y EMAIL_ADDRESS. Los dos asistentes declaran el socket model que declara su Component, que admite un modelo o un gateway que sirve una API de modelos, y lo dejan sin enlazar: cada Release lo conecta.
Las tres Releases
Las Releases solo se diferencian en el gateway por el que pasa el tráfico hacia el modelo de cada asistente:
| Release | el tráfico del asistente de siniestros | el tráfico del asistente de helpdesk | la compilación |
|---|---|---|---|
release-masked.yaml | a través de masking-gateway | a través de plain-gateway | se completa |
release-unmasked.yaml | a través de plain-gateway | a través de plain-gateway | se detiene |
release-masking-off-route.yaml | a través de plain-gateway | a través de masking-gateway | se detiene |
Cada Release enlaza el socket model de los dos asistentes con un gateway que declara el Aggregate. Eso es conexión de aristas dentro de un socket que declara el Component, algo que una Release puede hacer; no añade ningún componente ni cambia ningún valor.
Generar el ejemplo
Puedes compilar este ejemplo con los comandos de abajo, o hacer que tu asistente de IA lo compile por ti.
Escribe el ejemplo en una carpeta nueva con su nombre:
aggrega scaffold --example policy-data-class-routeDespués imprime los comandos que hay que ejecutar a continuación. El primero entra en la carpeta nueva:
cd policy-data-class-routeCompilación
aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pullaggrega build --release release-unmasked.yaml --config governance-rego.yaml --auto-pull # halts; exits 1aggrega build --release release-masking-off-route.yaml --config governance-rego.yaml --auto-pull # halts; exits 1Sustituye governance-rego.yaml por governance-cel.yaml o governance-opa.yaml para ejecutar la misma regla en otro motor.
--config nombra el archivo de configuración global para esa ejecución. Se lee en lugar del que la máquina leería en otro caso — el archivo que nombra AGGREGA_CONFIG, o la ubicación predeterminada — y el propio .aggrega-config.yaml de este espacio de trabajo sigue superponiéndose a él. Así que, para esa ejecución, no se aplica nada de lo que guardes en tu propio archivo global: otra vinculación de gobernanza, un default_registry, un ajuste sin conexión. Una credencial que hayas guardado con aggrega login no forma parte de ese archivo y sigue aplicándose. El archivo del espacio de trabajo declara los directorios del catálogo y ninguna vinculación de gobernanza propia; una lista que declarase sustituiría a la que contiene el archivo nombrado, por lo que la vinculación del archivo nombrado es la que se ejecuta.
Una política de gobernanza se vincula mediante la configuración, no mediante una Release — una Release no tiene ningún campo para ello — y por eso el motor se elige por compilación y no por Release.
Antes de una primera compilación tienen que estar disponibles dos cosas:
- El catálogo de la biblioteca estándar.
.aggrega-config.yamlenumera elcatalog/propio de este espacio de trabajo, que contiene el asistente de siniestros y la entidad Plugin del motor OPA. Todo lo demás, incluidas las entidades Plugin de los motores Rego y CEL, se resuelve desde el registro del hub que se describe a continuación, o desde un checkout del catálogo indicado con--catalog. - El registro del hub. La realización del enmascaramiento de datos escribe sus guardrails mediante un plugin que no se distribuye ni con el compilador ni con el catálogo, el paso de configuración del gateway
pipeline-step/litellm-gateway-config, y la compilación lo descarga del registro que nombradefault_registry,hub.aggrega.ai.
--auto-pull rellena el archivo de bloqueo de cada Release durante la compilación; los archivos de bloqueo y la salida renderizada se generan, no se distribuyen.
Con un asistente de IA
Un asistente de IA configurado con las herramientas de Aggrega puede hacer lo mismo: pégale este prompt.
Usa solo las herramientas de Aggrega y no crees ninguna carpeta por tu cuenta. Si la carpeta Workspace aún no contiene una carpeta `policy-data-class-route`, llama una vez a la herramienta `scaffold` con `example` establecido en `policy-data-class-route` y sin `dir`: escribe el ejemplo en una nueva carpeta `policy-data-class-route`. Luego llama a la herramienta `cli-build`, que ejecuta `aggrega build` y acepta su flag `--config`, una vez por cada Release, en este orden — `release-masked.yaml`, `release-unmasked.yaml` y `release-masking-off-route.yaml` — cada vez con `workspace_root` establecido en `policy-data-class-route`, `release` establecido en ese archivo, `auto_pull` establecido en true y `config` establecido en `governance-rego.yaml`. La segunda y la tercera deben ser rechazadas, así que léeme cada rechazo. Dime qué archivos escribió la primera compilación; están en `policy-data-class-route/dist/`.La detención
release-unmasked.yaml, con cada motor. El 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 violationEl 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 violationOPA:
[… 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 violationLa compilación termina con 1 y no escribe ningún dist/: la política se evalúa sobre el grafo de compilación antes de que se renderice nada. E0005 es el diagnóstico que lleva el rechazo de una política — consulta la referencia de diagnósticos. release-masking-off-route.yaml imprime el mismo rechazo, con cada motor.
Lee la frase como la ruta que encontró. assistant contiene datos restricted. Su tráfico hacia el modelo llega a gpt, que la política clasifica como public, a través de plain-gateway, y nada en esa ruta — ni el asistente, ni el gateway, ni el modelo — lleva una Feature que la política cuente como desclasificadora. Dos clases con rango distinto se encuentran en una ruta sin nada entre ellas, así que la política rechaza la compilación.
El comando pull también renderiza la Release, para encontrar las entradas externas que necesita fijar, y encuentra allí el mismo rechazo; por eso las líneas omitidas más arriba llevan la frase una segunda vez. El archivo de bloqueo se escribe de todos modos.
Cumplirla: el gateway de enmascaramiento en la ruta
release-masked.yaml enruta el asistente de siniestros a través de masking-gateway, y todos los motores permiten su compilación, con <workspace> en lugar de la carpeta de este ejemplo:
[… 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>/distEl gateway de enmascaramiento está ahora en la única ruta del asistente de siniestros hacia el modelo, y la política lo lee allí: en esa ruta, un componente lleva una vinculación cuyo tipo enumera el ajuste declassifying_features de la política, en el punto donde las clases difieren o antes. La ruta se lee en la salida renderizada: dist/helm/assistant-deployment.yaml envía el asistente de siniestros al gateway de enmascaramiento, y dist/helm/helpdesk-deployment.yaml envía el helpdesk al simple.
# dist/helm/assistant-deployment.yaml, the env of the assistant's containerenv: [… 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 containerenv: [… 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]El enmascaramiento en sí está en la configuración del gateway de enmascaramiento, la clave 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: trueguardrails: - 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]La configuración del gateway simple no tiene ninguna entrada de guardrail.
La política no cambia nada de lo que se renderiza. El árbol release-masked de cada motor es idéntico byte a byte a la misma Release compilada sin ninguna política vinculada. La política está vinculada al rol ir-verdict, un rol de veredicto: devuelve una aceptación o un rechazo, y el código que despacha un veredicto no tiene forma de aplicar uno como cambio, así que una política ahí puede detener una compilación y no puede reescribirla para que cumpla.
La política comprueba que el enmascaramiento esté vinculado en la ruta, no lo que enmascara. Una vinculación que enumera un patrón con el que no coinciden los datos de nadie la cumple tan bien como esta. Lo que enumera una vinculación de enmascaramiento es el propio criterio de la organización, aplicado donde se escribe la vinculación.
Por qué las Releases mueven la ruta, no la vinculación
Una Release puede vincular una Feature, pero una vinculación escrita en una Release no lleva values, y core/data-masking guarda lo que enmascara — patterns y entities — en values, y se detiene ante una vinculación que no enumera ninguno de los dos. Por eso el enmascaramiento se vincula en el Aggregate, en masking-gateway, y está en el grafo de cada una de las tres compilaciones:
- en
release-masked.yamlestá en la ruta del asistente de siniestros, y la compilación se completa; - en
release-unmasked.yamlno está en la ruta de ningún asistente, y la compilación se detiene; - en
release-masking-off-route.yamlestá en la ruta del helpdesk, y la compilación se detiene de nuevo.
La segunda y la tercera compilación llevan la misma vinculación y solo se diferencian en la ruta de quién está. Ambas se detienen, así que la política lee la ruta, no cuenta vinculaciones en la compilación.
Lo que lee la política
Todo procede del grafo de compilación que el compilador entrega a una vinculación ir-verdict, y todo su significado, de los ajustes de la vinculación:
- Las rutas que enumera el compilador,
input.precalculated_paths: cada una, una lista ordenada de componentes unidos por aristasuses. Enrelease-unmasked.yaml, una de ellas esassistant → plain-gateway → gpt. La política lee cada ruta desde su primer componente, lo cual basta porque el compilador enumera las rutas que salen de cada componente. Ella misma no enumera nada. - La clase de cada componente. El valor de la etiqueta que nombra
class_label,compliance.aggrega.ai/data-class, donde un componente la lleva: soloassistantla lleva, conrestricted. En caso contrario, la clase de la primera entrada declasses_by_labelcuya etiqueta y cuyo valor lleva el componente. - Las vinculaciones de cada componente,
input.graph.spec.feature_values_mapping. La propia listaattached_featuresde la ruta no se lee deliberadamente: nombra cada Feature vinculada en cualquier punto de la ruta, por lo que no puede decir si una está entre los dos componentes en cuestión.
Un componente sin clase se omite. También se omiten la dirección en la que se traza una ruta — una conexión lleva una solicitud en un sentido y su respuesta en el otro — y las clases a las que los ajustes dan el mismo rango.
La clase del modelo procede de su etiqueta de alojamiento. gpt no lleva ninguna etiqueta de clase. Su Component, core/ai-model/openai, lleva component.aggrega.ai/hosting: managed, la afirmación del catálogo de que el servicio lo opera su proveedor, fuera del clúster, y los ajustes lo asignan a una clase:
classes_by_label: - label: component.aggrega.ai/hosting value: managed class: publicUn modelo gestionado conserva todo lo que se le envía, lo que esta organización trata como público. Un modelo autoalojado como core/ai-model/vllm, y cualquiera de los dos gateways de aquí, lleva en cambio self-hosted, y por tanto ninguna clase.
Las rutas están acotadas. El compilador enumera un número acotado de rutas desde cada componente de partida y no enumera nada más allá de esa cota, así que en un grafo con más rutas, una ruta puede quedar sin leer y la compilación pasar. Una ruta que la política lee es real; la ausencia de una no prueba que no exista. Consulta los roles de veredicto.
Las clases son de la política, no del compilador
El compilador lleva compliance.aggrega.ai/data-class al grafo de compilación como una cadena y no le atribuye ningún significado. No sabe que restricted es más sensible que public, ni que ninguna de las dos palabras signifique algo. Las clases y su jerarquía son ajustes de la política, los mismos en los tres archivos de motor:
class_label: compliance.aggrega.ai/data-classrank: public: 0 internal: 1 restricted: 2Una organización con su propio vocabulario lo sustituye por el suyo: sus clases y su orden bajo rank, la etiqueta en la que las guarda bajo class_label, sus derivaciones bajo classes_by_label y las Features que acepta como desclasificadoras bajo declassifying_features. Cambia los tres archivos de motor por igual, ya que una diferencia entre ellos es una diferencia entre los veredictos de los motores. Una clase que lleva un componente y que rank no enumera detiene la compilación en lugar de leerse como ausencia de clase, de modo que un error ortográfico se notifica en lugar de pasar. Con la etiqueta del asistente de siniestros escrita Restricted, todos los motores rechazan release-masked.yaml; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull imprime el rechazo que aparece a continuación, y el archivo de cada otro motor imprime el mismo, encabezado con el nombre de ese 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 violationLa clase la lleva el Component propio de este espacio de trabajo, no el de la biblioteca estándar. Que un asistente maneje datos restringidos es una afirmación sobre cómo lo usa una organización, no sobre LangGraph, por lo que local/ai-agent/claims-assistant extiende core/ai-agent/langgraph, hereda su contrato y añade esa única etiqueta. Un Aggregate no puede poner una etiqueta en una instancia de componente, así que una clase es siempre una propiedad del Component con el que se declara una instancia. Si el asistente de siniestros se declara en cambio como el agente de la biblioteca estándar, ningún componente lleva una etiqueta de clase, y release-unmasked.yaml se compila con todos los motores, byte a byte igual que sin política: el modelo sigue derivando public, pero no hay una segunda clase con la que encontrarse.
Tres motores, la regla escrita tres veces
| motor | vinculado mediante | la regla |
|---|---|---|
| el motor Rego compilado en la CLI | governance-rego.yaml | policies/data-class-paths.rego, nombrado bajo with.sources |
| el motor CEL compilado en la CLI | governance-cel.yaml | policies/data-class-paths.cel, nombrado bajo with.sources |
| OPA, detrás del guest adaptador de referencia | governance-opa.yaml | policies/data-class-paths-opa.rego, compilado en el guest |
Las tres copias son un casi duplicado deliberado. Cada una se escribe por separado a partir de la regla, de modo que una compilación en la que los motores discrepan muestra la discrepancia: la misma compilación que se detiene con un motor y se completa con otro es la señal. Ninguna se genera a partir de otra, y no deben fusionarse en una única implementación compartida, que haría coincidir a los motores por construcción y ocultaría la diferencia que esto existe para detectar. Cada archivo empieza diciéndolo.
Difieren donde difieren los motores:
- La copia CEL no puede enlazar un nombre a un valor ni recorrer las posiciones de una lista, así que sus ajustes llevan una entrada más,
positions, las posiciones de 0 a 15 en las que se leen los componentes de una ruta. Una ruta más larga detiene la compilación, indicando dónde empieza, en lugar de leerse en parte. - La copia OPA se compila de antemano con la propia cadena de herramientas de OPA y se integra en el guest junto a
catalog/plugin/governance/opa/1.0.0/plugin.yaml, por lo que su vinculación aporta ajustes y ningún archivo de política. El adaptador no proporciona ninguna de las funciones integradas que OPA deja a su host, así que esta copia une sus mensajes conconcatdonde la copia del motor Rego los formatea consprintf. Editarla no cambia ninguna compilación hasta que se recompila el guest, más abajo.
Las vinculaciones Rego y CEL nombran las entidades Plugin que el catálogo de la biblioteca estándar contiene para los dos motores compilados en la CLI, governance/rego:0.9.0 y governance/cel:0.9.0, y el motor que se ejecuta es el compilado en el binario que ejecuta la compilación. La entidad Plugin de OPA, en catalog/plugin/governance/, es una declaración propia de este espacio de trabajo en la versión 1.0.0, por lo que su vinculación nombra governance/opa:1.0.0. Un rechazo se encabeza con el último segmento de la referencia de la vinculación, sin su versión — policy plugin "rego", "cel" o "opa" — y cada compilación vincula un solo motor, así que el rechazo que imprime nombra ese motor. El guest de OPA se lee junto a su entidad en cada compilación, y como nada registra su digest, cada compilación con él advierte de que se ejecuta sin verificar.
Comprobar cada compilación
Esta autocomprobación se ejecuta en un checkout del repositorio de la documentación, que contiene el script auxiliar de compilación compartido que usa; una copia escrita por aggrega scaffold --example no incluye ese script auxiliar.
./check.shcheck.sh compila las tres Releases con los tres motores mediante ./build-release.sh y comprueba cada resultado frente al que describe esta página. Una detención debe terminar con un código distinto de cero con E0005, cuyo mensaje es la frase de arriba, y ningún otro rechazo junto a él; una compilación completada debe terminar con 0 y escribir los mismos archivos, byte a byte, que la misma Release compilada sin política, que compila primero como referencia. Todos los motores se ajustan a la misma frase. Imprime una línea por compilación y termina con 1 si algún resultado difiere, imprimiendo la salida de esa compilación:
ENGINE RELEASE EXIT EXPECTED VERDICT------------------------------------------------------------------------------------------none release-masked.yaml 0 reference OKrego release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policyrego release-unmasked.yaml 1 halt OK: E0005, the expected sentencerego release-masking-off-route.yaml 1 halt OK: E0005, the expected sentencecel release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policycel release-unmasked.yaml 1 halt OK: E0005, the expected sentencecel release-masking-off-route.yaml 1 halt OK: E0005, the expected sentenceopa release-masked.yaml 0 pass OK: completed, byte-identical to the build with no policyopa release-unmasked.yaml 1 halt OK: E0005, the expected sentenceopa release-masking-off-route.yaml 1 halt OK: E0005, the expected sentence
check: every build ended as expected.Necesita lo que necesita una sola compilación: el catálogo de la biblioteca estándar y el registro del hub. Usa el binario que resuelve ./build-release.sh, así que AGGREGA_BIN lo elige; los argumentos después de -- llegan a cada compilación, así que ./check.sh -- --offline lo ejecuta sin red una vez que todo lo que descarga está en caché. Se niega a arrancar mientras haya un dist/ en este directorio, porque compara los árboles que escriben las compilaciones, y no deja ninguno atrás. Su código de salida es todo el veredicto, así que una pipeline puede ejecutarlo en lugar de compilar cada Release por separado.
Recompilar el guest de OPA
catalog/plugin/governance/opa/1.0.0/governance--opa.wasm es el guest adaptador de OPA de referencia del kit de plugins, rust/examples/policy-opa-wasm en el repositorio aggrega-pdk, con el módulo que OPA compila a partir de policies/data-class-paths-opa.rego en lugar del propio del adaptador. Se compiló a partir de aggrega-pdk en afd9ac6c6800c34c6c47a2030f580c9681387047 y de aggrega-abi, el crate de ABI con el que se compila el adaptador, en 2ececa8d3b598243f023a2a6c80b351c8d1411a1, con rustc 1.97.1, en torno al módulo que compila OPA 1.21.1.
Primero el módulo, desde este directorio. Nombrar la regla por su ruta relativa a este directorio mantiene esa ruta, y nada de la máquina, en el módulo:
opa build -t wasm -e data_class_paths/deny policies/data-class-paths-opa.rego -o bundle.tar.gztar -xzf bundle.tar.gz -O /policy.wasm > policy.wasmrm bundle.tar.gzsha256sum policy.wasm# 321e8a1f150a7ef7625e174cf636967b6c0e1f7bd39c3b7fa1010838ce35c871 policy.wasmOPA 1.21.1 compila los mismos bytes a partir del mismo código fuente, sea cual sea el directorio en el que esté este espacio de trabajo.
Después, el guest, en un directorio temporal $BUILD, dado como ruta absoluta, que contiene los dos repositorios uno al lado del otro, con la dependencia por ruta del adaptador yendo de uno a otro. Las tres asignaciones de rutas mantienen fuera del guest el directorio de compilación, el home de cargo y las fuentes propias de la cadena de herramientas:
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-wasip1y copia $BUILD/target/wasm32-wasip1/release/policy_opa_wasm_rust.wasm en catalog/plugin/governance/opa/1.0.0/governance--opa.wasm.
El guest es la salida de la compilación de cargo tal cual. El propio script de compilación del adaptador ejecuta también una pasada opcional de reducción de tamaño, que aquí se omite: reescribe los datos del guest, y sin ella el módulo permanece en el guest byte a byte. Eso te permite comprobar lo que contiene un guest frente a aquello en lo que se compila la regla:
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# TrueLos propios bytes del guest dependen también del directorio en el que se compilaron sus crates, y de la cadena de herramientas, así que una recompilación en otro lugar es un guest equivalente con otro sha256. El que se distribuye aquí es eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.
Dónde el compilador no interpreta
El compilador lleva la etiqueta de clase al grafo de compilación como una cadena, enumera rutas sobre las aristas uses que declararon el Aggregate y las Releases, y entrega ambas cosas a la política. No asigna rango a una clase, no sabe que managed significa que los datos salen del clúster hacia un proveedor, y no sabe que core/data-masking oculta nada. Cada uno de esos significados está en los ajustes de la política, y eso es lo que permite a una organización con otras clases, otras etiquetas y otras Features desclasificadoras ejecutar el mismo mecanismo sin cambios. Para el socket al que se vincula la política — los roles, la carga útil, las severidades del veredicto — consulta el socket de políticas, y para el lugar que ocupa la política en el producto, Gobernanza y cumplimiento.
Archivos
aggregate.yaml— los dos asistentes, su checkpointer, los dos gateways, el modelo y el par de servicios de reconocimiento; el enmascaramiento vinculado amasking-gateway; el socketmodelde ninguno de los dos asistentes enlazado.manifest.yaml— enlaza cada tipo de componente y ambos tipos de Feature con sus Recipes de Kubernetes, y el asistente de siniestros con la Recipe del agente base. Compartido por las tres Releases.release-masked.yaml,release-unmasked.yaml,release-masking-off-route.yaml— los tres enrutamientos, y el Secret del que se lee la clave de cada gateway.catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml— el asistente de siniestros,core/ai-agent/langgraphcon la etiqueta de clase añadida.catalog/plugin/governance/opa/1.0.0/plugin.yaml— la entidad Plugin del motor OPA, con su guest,governance--opa.wasm, al lado.policies/data-class-paths.rego,policies/data-class-paths.cel,policies/data-class-paths-opa.rego— la regla, una vez por motor.governance-rego.yaml,governance-cel.yaml,governance-opa.yaml— un archivo para--configpor motor, cada uno de los cuales vincula la regla enir-verdictcon los mismos ajustes..aggrega-config.yaml— la pila de búsqueda del catálogo y el registro; ninguna vinculación de gobernanza.build-release.sh— compila una Release, mostrando el comandoaggrega buildequivalente.check.sh— compila las nueve y comprueba cada resultado.