Une politique qui arrête un build lorsque des données à accès restreint atteignent un modèle managé sans masquage
Un parc informatique exécute un assistant de sinistres qui traite des données client à accès restreint, et un assistant helpdesk qui n’en traite aucune. Tous deux envoient leur trafic vers le modèle à l’API managée d’OpenAI via une passerelle d’IA interne au cluster. La règle maison du parc informatique :
Les données d’une classe n’atteignent pas un composant d’une autre classe le long d’un chemin du graphe de build, sauf si une Feature déclassifiante est rattachée sur ce chemin.
Cet espace de travail rattache cette règle comme politique sur le graphe de build et construit trois Releases d’un Aggregate. Dans l’une, les requêtes de l’assistant de sinistres passent par une passerelle qui les masque, et le build aboutit. Dans les deux autres, ce n’est pas le cas, et le build s’arrête avant que quoi que ce soit ne soit rendu, la politique nommant les deux extrémités du chemin.
La règle est écrite trois fois, une fois pour chaque moteur de politiques sur lequel elle s’exécute — les moteurs Rego et CEL compilés dans la CLI, et OPA — et les trois copies concordent sur chaque build ici. Un script à côté des Releases construit les neuf combinaisons et vérifie chaque résultat.
Ce qu’il construit
| instance | Component du catalogue | ce qu’il est ici |
|---|---|---|
assistant | local/ai-agent/claims-assistant | l’assistant de sinistres : l’agent LangGraph de la bibliothèque standard, déclaré dans le catalogue de cet espace de travail avec un label en plus — la classe des données qu’il traite |
helpdesk | core/ai-agent/langgraph | l’assistant helpdesk, qui ne porte aucune classe |
checkpointer | core/datastore/valkey | où les deux assistants conservent leur état d’exécution |
masking-gateway | core/gateway/litellm | une passerelle d’IA qui sert un alias, chat, avec core/data-masking rattachée |
plain-gateway | core/gateway/litellm | la même passerelle sans rien de rattaché |
gpt | core/ai-model/openai | l’API managée d’OpenAI, atteinte comme référence : rien ne s’exécute pour elle dans le cluster |
analyzer, anonymizer | core/security/presidio-analyzer, core/security/presidio-anonymizer | les services de reconnaissance qu’appelle le masquage |
Les deux passerelles sont câblées à gpt via leur socket models, chacune présentant la clé du modèle sur cette connexion. Le rattachement de masquage liste ce qu’il faut masquer : un motif pour les numéros de sinistre du parc informatique, et les types d’entités PERSON et EMAIL_ADDRESS. Les deux assistants déclarent le socket model que déclare leur Component, qui admet un modèle ou une passerelle servant une API de modèle, et le laissent non lié : chaque Release le câble.
Les trois Releases
Les Releases ne diffèrent que par la passerelle par laquelle passe le trafic vers le modèle de chaque assistant :
| Release | le trafic de l’assistant de sinistres | le trafic de l’assistant helpdesk | le build |
|---|---|---|---|
release-masked.yaml | via masking-gateway | via plain-gateway | aboutit |
release-unmasked.yaml | via plain-gateway | via plain-gateway | s’arrête |
release-masking-off-route.yaml | via plain-gateway | via masking-gateway | s’arrête |
Chaque Release lie le socket model des deux assistants à une passerelle que déclare l’Aggregate. C’est du câblage d’arêtes au sein d’un socket que déclare le Component, ce qu’une Release peut faire ; cela n’ajoute aucun composant et ne modifie aucune valeur.
Générer l’exemple
Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.
Écrivez l’exemple dans un nouveau dossier qui porte son nom :
aggrega scaffold --example policy-data-class-routeElle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :
cd policy-data-class-routeBuild
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 1Remplacez governance-rego.yaml par governance-cel.yaml ou governance-opa.yaml pour exécuter la même règle sur un autre moteur.
--config désigne le fichier de configuration global pour cette exécution. Il est lu à la place de celui que la machine lirait sinon — le fichier que désigne AGGREGA_CONFIG, ou l’emplacement par défaut — et le .aggrega-config.yaml propre à cet espace de travail se superpose toujours à lui. Ainsi, pour cette exécution, rien de ce que vous conservez dans votre propre fichier global ne s’applique : un autre rattachement de gouvernance, un default_registry, un paramètre hors ligne. Les informations d’identification que vous avez enregistrées avec aggrega login ne font pas partie de ce fichier et s’appliquent toujours. Le fichier de l’espace de travail déclare les répertoires du catalogue et aucun rattachement de gouvernance qui lui soit propre ; une liste qu’il déclarerait remplacerait celle que contient le fichier désigné, si bien que le rattachement du fichier désigné est celui qui s’exécute.
Une politique de gouvernance se rattache par la configuration, pas par une Release — une Release n’a aucun champ pour cela — c’est pourquoi le moteur est choisi par build plutôt que par Release.
Deux éléments doivent être en place avant un premier build :
- Le catalogue de la bibliothèque standard.
.aggrega-config.yamlliste lecatalog/propre à cet espace de travail, qui contient l’assistant de sinistres et l’entité Plugin du moteur OPA. Tout le reste, y compris les entités Plugin des moteurs Rego et CEL, se résout depuis le registre du hub ci-dessous, ou depuis un extrait du catalogue désigné avec--catalog. - Le registre du hub. La réalisation du masquage des données écrit ses garde-fous par un plugin qui n’est livré ni avec le compilateur ni avec le catalogue, l’étape de configuration de la passerelle
pipeline-step/litellm-gateway-config, et le build le récupère depuis le registre que désignedefault_registry,hub.aggrega.ai.
--auto-pull remplit le fichier de verrouillage de chaque Release pendant le build ; les fichiers de verrouillage et la sortie rendue sont générés, pas livrés.
Avec un assistant IA
Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.
Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier Workspace ne contient pas encore de dossier `policy-data-class-route`, appelez une fois l’outil `scaffold` avec `example` défini sur `policy-data-class-route` et sans `dir` : il écrit l’exemple dans un nouveau dossier `policy-data-class-route`. Appelez ensuite l’outil `cli-build`, qui exécute `aggrega build` et accepte son option `--config`, une fois pour chaque Release, dans cet ordre — `release-masked.yaml`, `release-unmasked.yaml` et `release-masking-off-route.yaml` — en définissant à chaque fois `workspace_root` sur `policy-data-class-route`, `release` sur ce fichier, `auto_pull` sur true et `config` sur `governance-rego.yaml`. Le deuxième et le troisième doivent être refusés : lisez-moi donc chaque refus. Indiquez-moi quels fichiers le premier build a écrits ; ils se trouvent sous `policy-data-class-route/dist/`.L’arrêt
release-unmasked.yaml, avec chaque moteur. Le moteur 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 violationLe moteur 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 violationLe build se termine avec 1 et n’écrit aucun dist/ : la politique est évaluée sur le graphe de build avant que quoi que ce soit ne soit rendu. E0005 est le diagnostic que porte un refus de politique — voir la référence des diagnostics. release-masking-off-route.yaml affiche le même refus, avec chaque moteur.
Lisez la phrase comme le chemin qu’elle a trouvé. assistant détient des données restricted. Son trafic vers le modèle atteint gpt, que la politique classe public, via plain-gateway, et rien sur ce chemin — ni l’assistant, ni la passerelle, ni le modèle — ne porte une Feature que la politique compte comme déclassifiante. Deux classes de rangs différents se rencontrent sur un même chemin sans rien entre elles, donc la politique refuse le build.
La commande pull rend aussi la Release, pour trouver les entrées externes qu’elle doit épingler, et rencontre là le même refus ; c’est pourquoi les lignes omises ci-dessus portent la phrase une seconde fois. Le fichier de verrouillage est tout de même écrit.
La satisfaire : la passerelle de masquage sur le chemin
release-masked.yaml route l’assistant de sinistres via masking-gateway, et chaque moteur le laisse se construire, <workspace> désignant le dossier de cet exemple :
[… 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>/distLa passerelle de masquage se trouve désormais sur le seul chemin de l’assistant de sinistres vers le modèle, et la politique l’y lit : sur ce chemin, un composant porte un rattachement dont le type figure dans le paramètre declassifying_features de la politique, au point où les classes diffèrent ou avant. Le chemin se lit dans la sortie rendue : dist/helm/assistant-deployment.yaml envoie l’assistant de sinistres vers la passerelle de masquage, et dist/helm/helpdesk-deployment.yaml envoie le helpdesk vers la passerelle 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]Le masquage lui-même se trouve dans la configuration de la passerelle de masquage, la clé 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 configuration de la passerelle simple n’a aucune entrée de garde-fou.
La politique ne change rien à ce qui est rendu. L’arborescence release-masked de chaque moteur est identique octet pour octet à la même Release construite sans politique rattachée. La politique est rattachée au rôle ir-verdict, un rôle de verdict : elle renvoie une acceptation ou un refus, et le code qui transmet un verdict n’a aucun moyen d’en appliquer un comme modification, si bien qu’une politique placée là peut arrêter un build et ne peut pas le réécrire pour le rendre conforme.
La politique vérifie que le masquage est rattaché sur le chemin, pas ce qu’il masque. Un rattachement listant un motif auquel ne correspondent les données de personne la satisfait aussi bien que celui-ci. Ce que liste un rattachement de masquage relève du propre jugement du parc informatique, exercé là où le rattachement est écrit.
Pourquoi les Releases déplacent le chemin, pas le rattachement
Une Release peut rattacher une Feature, mais un rattachement écrit dans une Release ne porte pas de values, et core/data-masking garde ce qu’elle masque — patterns et entities — dans values, et s’arrête sur un rattachement qui ne liste ni l’un ni l’autre. Le masquage est donc rattaché dans l’Aggregate, sur masking-gateway, et il se trouve dans le graphe de chacun des trois builds :
- dans
release-masked.yaml, il se trouve sur le chemin de l’assistant de sinistres, et le build aboutit ; - dans
release-unmasked.yaml, il ne se trouve sur le chemin d’aucun assistant, et le build s’arrête ; - dans
release-masking-off-route.yaml, il se trouve sur le chemin du helpdesk, et le build s’arrête de nouveau.
Les deuxième et troisième builds portent le même rattachement et ne diffèrent que par le chemin sur lequel il se trouve. Les deux s’arrêtent, donc la politique lit le chemin, elle ne compte pas les rattachements du build.
Ce que lit la politique
Tout cela provient du graphe de build que le compilateur remet à un rattachement ir-verdict, et tout son sens des paramètres du rattachement :
- Les chemins que le compilateur énumère,
input.precalculated_paths: chacun une liste ordonnée de composants reliés par des arêtesuses. Surrelease-unmasked.yaml, l’un d’eux estassistant → plain-gateway → gpt. La politique lit chaque chemin depuis son premier composant, ce qui suffit, car le compilateur énumère les chemins partant de chaque composant. Elle-même n’énumère rien. - La classe de chaque composant. La valeur du label que désigne
class_label,compliance.aggrega.ai/data-class, là où un composant le porte : seulassistantle porte, avecrestricted. Sinon, la classe de la première entrée declasses_by_labeldont le composant porte le label et la valeur. - Les rattachements de chaque composant,
input.graph.spec.feature_values_mapping. La listeattached_featurespropre au chemin n’est délibérément pas lue : elle nomme chaque Feature rattachée n’importe où sur le chemin, et ne peut donc pas dire si l’une d’elles se trouve entre les deux composants en question.
Un composant sans classe est ignoré. De même pour le sens dans lequel un chemin est tracé — une connexion porte une requête dans un sens et sa réponse dans l’autre — et pour les classes que les paramètres placent au même rang.
La classe du modèle vient de son label d’hébergement. gpt ne porte aucun label de classe. Son Component, core/ai-model/openai, porte component.aggrega.ai/hosting: managed, l’affirmation du catalogue selon laquelle le service est exploité par son fournisseur, hors du cluster, et les paramètres associent cela à une classe :
classes_by_label: - label: component.aggrega.ai/hosting value: managed class: publicUn modèle managé conserve tout ce qui lui est envoyé, ce que ce parc informatique traite comme public. Un modèle auto-hébergé tel que core/ai-model/vllm, et chacune des deux passerelles ici, porte plutôt self-hosted, et donc aucune classe.
Les chemins sont bornés. Le compilateur liste un nombre borné de chemins depuis chaque composant de départ et ne liste rien au-delà de la borne, donc sur un graphe comportant davantage de chemins, un chemin peut rester non lu et le build passer. Un chemin que la politique lit est réel ; l’absence d’un chemin ne prouve pas qu’il n’existe pas. Voir les rôles de verdict.
Les classes appartiennent à la politique, pas au compilateur
Le compilateur porte compliance.aggrega.ai/data-class jusqu’au graphe de build comme une chaîne et n’y lit aucun sens. Il ne sait pas que restricted est plus sensible que public, ni que l’un ou l’autre de ces mots signifie quoi que ce soit. Les classes et leur hiérarchie sont des paramètres de la politique, identiques dans les trois fichiers de moteur :
class_label: compliance.aggrega.ai/data-classrank: public: 0 internal: 1 restricted: 2Un parc informatique doté de son propre vocabulaire y substitue le sien : ses classes et leur ordre sous rank, le label dans lequel il les conserve sous class_label, ses dérivations sous classes_by_label, et les Features qu’il accepte comme déclassifiantes sous declassifying_features. Modifiez les trois fichiers de moteur de la même façon, car une différence entre eux est une différence entre les verdicts des moteurs. Une classe portée par un composant que rank ne liste pas arrête le build au lieu d’être lue comme une absence de classe, si bien qu’une faute d’orthographe est signalée au lieu de passer. Avec le label de l’assistant de sinistres écrit Restricted, chaque moteur refuse release-masked.yaml ; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull affiche le refus ci-dessous, et le fichier de chaque autre moteur affiche le même, précédé du nom de ce moteur :
[… 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 classe est portée par le Component propre à cet espace de travail, et non par celui de la bibliothèque standard. Qu’un assistant traite des données à accès restreint est une affirmation sur la façon dont un parc informatique l’utilise, et non sur LangGraph ; local/ai-agent/claims-assistant étend donc core/ai-agent/langgraph, hérite de son contrat et ajoute ce seul label. Un Aggregate ne peut pas poser de label sur une instance de composant, si bien qu’une classe est toujours une propriété du Component sous lequel une instance est déclarée. Si l’assistant de sinistres est plutôt déclaré comme l’agent de la bibliothèque standard, aucun composant ne porte de label de classe, et release-unmasked.yaml se construit avec chaque moteur, octet pour octet comme sans politique : le modèle dérive toujours public, mais il n’existe pas de seconde classe à rencontrer.
Trois moteurs, la règle écrite trois fois
| moteur | rattaché par | la règle |
|---|---|---|
| le moteur Rego compilé dans la CLI | governance-rego.yaml | policies/data-class-paths.rego, désigné sous with.sources |
| le moteur CEL compilé dans la CLI | governance-cel.yaml | policies/data-class-paths.cel, désigné sous with.sources |
| OPA, derrière le guest adaptateur de référence | governance-opa.yaml | policies/data-class-paths-opa.rego, compilé dans le guest |
Les trois copies sont un quasi-doublon délibéré. Chacune est écrite indépendamment à partir de la règle, si bien qu’un build sur lequel les moteurs divergent montre la divergence : le même build qui s’arrête avec un moteur et aboutit avec un autre est le signal. Aucune n’est générée à partir d’une autre, et elles ne doivent pas être fusionnées en une implémentation partagée, ce qui ferait concorder les moteurs par construction et masquerait la différence que ce dispositif existe pour détecter. Chaque fichier commence en le disant.
Elles diffèrent là où les moteurs diffèrent :
- La copie CEL ne peut pas lier un nom à une valeur ni parcourir les positions d’une liste, donc ses paramètres portent une entrée de plus,
positions, les positions 0 à 15 auxquelles les composants d’un chemin sont lus. Un chemin plus long arrête le build, en nommant son point de départ, plutôt que d’être lu en partie. - La copie OPA est compilée à l’avance avec la chaîne d’outils propre à OPA et intégrée au guest à côté de
catalog/plugin/governance/opa/1.0.0/plugin.yaml, si bien que son rattachement fournit des paramètres et aucun fichier de politique. L’adaptateur ne fournit aucune des fonctions intégrées qu’OPA laisse à son hôte, donc cette copie joint ses messages avecconcatlà où la copie du moteur Rego les formate avecsprintf. La modifier ne change aucun build tant que le guest n’est pas reconstruit, ci-dessous.
Les rattachements Rego et CEL nomment les entités Plugin que le catalogue de la bibliothèque standard contient pour les deux moteurs compilés dans la CLI, governance/rego:0.9.0 et governance/cel:0.9.0, et le moteur qui s’exécute est celui compilé dans le binaire qui exécute le build. L’entité Plugin d’OPA, dans catalog/plugin/governance/, est une déclaration propre à cet espace de travail en version 1.0.0, donc son rattachement nomme governance/opa:1.0.0. Un refus est précédé du dernier segment de la référence du rattachement, sans sa version — policy plugin "rego", "cel" ou "opa" — et chaque build rattache un seul moteur, donc le refus qu’il affiche nomme ce moteur. Le guest OPA est lu à côté de son entité à chaque build, et comme rien n’enregistre son digest, chaque build qui l’utilise avertit qu’il s’exécute sans vérification.
Vérifier chaque build
Cette auto-vérification s’exécute dans un checkout du dépôt de la documentation, qui contient l’utilitaire de build partagé qu’elle utilise ; une copie écrite par aggrega scaffold --example ne contient pas cet utilitaire.
./check.shcheck.sh construit les trois Releases avec les trois moteurs via ./build-release.sh, et compare chaque résultat à celui que décrit cette page. Un arrêt doit se terminer avec un code non nul et E0005, dont le message est la phrase ci-dessus, et aucun autre refus à côté ; un build abouti doit se terminer avec 0 et écrire les mêmes fichiers, octet pour octet, que la même Release construite sans politique, qu’il construit d’abord comme référence. Chaque moteur est tenu à la même phrase. Il affiche une ligne par build et se termine avec 1 si un résultat diffère, en affichant la sortie de ce build :
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.Il a besoin de ce dont a besoin un build unique : le catalogue de la bibliothèque standard et le registre du hub. Il utilise le binaire que résout ./build-release.sh, donc AGGREGA_BIN le choisit ; les arguments placés après -- atteignent chaque build, donc ./check.sh -- --offline l’exécute sans réseau une fois que tout ce qu’il récupère est en cache. Il refuse de démarrer tant qu’un dist/ se trouve dans ce répertoire, parce qu’il compare les arborescences qu’écrivent les builds, et il n’en laisse aucune derrière lui. Son code de sortie constitue tout le verdict, donc un pipeline peut l’exécuter au lieu de construire chaque Release séparément.
Reconstruire le guest OPA
catalog/plugin/governance/opa/1.0.0/governance--opa.wasm est le guest adaptateur OPA de référence du kit de plugin, rust/examples/policy-opa-wasm dans le dépôt aggrega-pdk, avec le module qu’OPA compile à partir de policies/data-class-paths-opa.rego à la place de celui de l’adaptateur. Il a été construit à partir de aggrega-pdk à afd9ac6c6800c34c6c47a2030f580c9681387047 et de aggrega-abi, le crate ABI sur lequel l’adaptateur se construit, à 2ececa8d3b598243f023a2a6c80b351c8d1411a1, avec rustc 1.97.1, autour du module que compile OPA 1.21.1.
D’abord le module, depuis ce répertoire. Désigner la règle par son chemin relatif à ce répertoire garde ce chemin, et rien de la machine, dans le module :
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 compile les mêmes octets à partir de la même source, quel que soit le répertoire où se trouve cet espace de travail.
Puis le guest, dans un répertoire temporaire $BUILD, donné comme chemin absolu, contenant les deux dépôts côte à côte, la dépendance par chemin de l’adaptateur allant de l’un à l’autre. Les trois correspondances de chemins tiennent hors du guest le répertoire de build, le home de cargo et les sources propres de la chaîne d’outils :
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-wasip1et copiez $BUILD/target/wasm32-wasip1/release/policy_opa_wasm_rust.wasm vers catalog/plugin/governance/opa/1.0.0/governance--opa.wasm.
Le guest est la sortie du build cargo telle quelle. Le script de build propre à l’adaptateur exécute aussi une passe facultative de réduction de taille, qui est omise ici : elle réécrit les données du guest, et sans elle le module reste dans le guest octet pour octet. Cela vous permet de comparer ce que contient un guest à ce en quoi la règle se compile :
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# TrueLes octets propres du guest dépendent aussi du répertoire dans lequel ses crates ont été construits, et de la chaîne d’outils, donc une reconstruction ailleurs donne un guest équivalent avec un autre sha256. Celui livré ici est eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.
Là où le compilateur n’interprète pas
Le compilateur achemine le label de classe jusqu’au graphe de build comme une chaîne, énumère les chemins sur les arêtes uses que l’Aggregate et les Releases ont déclarées, et remet les deux à la politique. Il n’attribue aucun rang à une classe, ne sait pas que managed signifie que les données quittent le cluster pour un fournisseur, et ne sait pas que core/data-masking masque quoi que ce soit. Chacune de ces significations relève des paramètres de la politique, et c’est ce qui permet à un parc informatique doté d’autres classes, d’autres labels et d’autres Features déclassifiantes de faire tourner le même mécanisme sans modification. Pour le socket auquel la politique est rattachée — les rôles, la charge utile, les niveaux de gravité des verdicts — voir le socket de politiques, et pour la place de la politique dans le produit, Gouvernance et conformité.
Fichiers
aggregate.yaml— les deux assistants, leur checkpointer, les deux passerelles, le modèle et la paire de services de reconnaissance ; le masquage rattaché àmasking-gateway; le socketmodeld’aucun des deux assistants n’est lié.manifest.yaml— lie chaque type de composant et les deux types de Feature à leurs Recipes Kubernetes, et l’assistant de sinistres à la Recipe de l’agent de base. Partagé par les trois Releases.release-masked.yaml,release-unmasked.yaml,release-masking-off-route.yaml— les trois acheminements, et le Secret depuis lequel la clé de chaque passerelle est lue.catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml— l’assistant de sinistres,core/ai-agent/langgraphavec le label de classe ajouté.catalog/plugin/governance/opa/1.0.0/plugin.yaml— l’entité Plugin du moteur OPA, avec son guest,governance--opa.wasm, à côté.policies/data-class-paths.rego,policies/data-class-paths.cel,policies/data-class-paths-opa.rego— la règle, une fois par moteur.governance-rego.yaml,governance-cel.yaml,governance-opa.yaml— un fichier pour--configpar moteur, chacun rattachant la règle àir-verdictavec les mêmes paramètres..aggrega-config.yaml— la pile de recherche du catalogue et le registre ; aucun rattachement de gouvernance.build-release.sh— construit une Release, en affichant la commandeaggrega buildéquivalente.check.sh— construit les neuf et vérifie chaque résultat.