Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Una policy che arresta una build quando dati riservati raggiungono un modello gestito senza mascheramento

Un parco IT esegue un assistente per i sinistri che tratta dati riservati dei clienti e un assistente di helpdesk che non ne tratta nessuno. Entrambi inviano il proprio traffico verso il modello all’API gestita di OpenAI attraverso un AI gateway interno al cluster. La regola interna del parco IT:

I dati di una classe non raggiungono un componente di un’altra classe lungo un percorso del grafo di build, a meno che su quel percorso non sia associata una Feature declassificante.

Questo workspace associa quella regola come policy sul grafo di build ed esegue la build di tre Releases di un Aggregate. In una, le richieste dell’assistente per i sinistri passano attraverso un gateway che le maschera, e la build si completa. Nelle altre due no, e la build si arresta prima che qualcosa venga renderizzato, con la policy che nomina entrambi i capi del percorso.

La regola è scritta tre volte, una per ciascun motore di policy su cui viene eseguita — i motori Rego e CEL compilati nella CLI, e OPA — e le tre copie concordano su ogni build qui. Uno script accanto alle Releases esegue la build di tutte e nove le combinazioni e verifica ciascun esito.

Che cosa costruisce

istanzaComponent del catalogoche cosa è qui
assistantlocal/ai-agent/claims-assistantl’assistente per i sinistri: l’agente LangGraph della libreria standard, dichiarato nel catalogo di questo workspace con un’etichetta in più — la classe dei dati che tratta
helpdeskcore/ai-agent/langgraphl’assistente di helpdesk, che non porta alcuna classe
checkpointercore/datastore/valkeydove entrambi gli assistenti conservano il proprio stato di esecuzione
masking-gatewaycore/gateway/litellmun AI gateway che serve un alias, chat, con core/data-masking associata
plain-gatewaycore/gateway/litellmlo stesso gateway senza nulla di associato
gptcore/ai-model/openail’API gestita di OpenAI, raggiunta come riferimento: nel cluster non viene eseguito nulla per essa
analyzer, anonymizercore/security/presidio-analyzer, core/security/presidio-anonymizeri servizi di riconoscimento che il mascheramento chiama

Entrambi i gateway sono cablati a gpt tramite il loro socket models, e ciascuno presenta la chiave del modello su quella connessione. L’associazione di mascheramento elenca che cosa mascherare: un pattern per i numeri di sinistro del parco IT e i tipi di entità PERSON e EMAIL_ADDRESS. I due assistenti dichiarano il socket model che il loro Component dichiara, che ammette un modello o un gateway che serve un’API di modelli, e lo lasciano non legato: ogni Release lo cabla.

Le tre Releases

Le Releases differiscono solo per il gateway attraverso cui passa il traffico verso il modello di ciascun assistente:

Releaseil traffico dell’assistente per i sinistriil traffico dell’assistente di helpdeskil build
release-masked.yamlattraverso masking-gatewayattraverso plain-gatewayva a buon fine
release-unmasked.yamlattraverso plain-gatewayattraverso plain-gatewaysi arresta
release-masking-off-route.yamlattraverso plain-gatewayattraverso masking-gatewaysi arresta

Ogni Release lega il socket model dei due assistenti a un gateway che l’Aggregate dichiara. Si tratta di cablaggio degli archi all’interno di un socket che il Component dichiara, cosa che una Release può fare; non aggiunge alcun componente e non modifica alcun valore.

Generare l’esempio

Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

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

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:

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

Sostituisci governance-rego.yaml con governance-cel.yaml o governance-opa.yaml per eseguire la stessa regola su un altro motore.

--config indica il file di configurazione globale per quell’esecuzione. Viene letto al posto di quello che la macchina leggerebbe altrimenti — il file indicato da AGGREGA_CONFIG, o la posizione predefinita — e il .aggrega-config.yaml proprio di questo workspace si sovrappone comunque a esso. Quindi, per quell’esecuzione, nulla di ciò che tieni nel tuo file globale si applica: un’altra associazione di governance, un default_registry, un’impostazione offline. Una credenziale che hai salvato con aggrega login non fa parte di quel file e si applica comunque. Il file del workspace dichiara le directory del catalogo e nessuna associazione di governance propria; un elenco che dichiarasse sostituirebbe quello contenuto nel file indicato, quindi l’associazione nel file indicato è quella che viene eseguita.

Una policy di governance si associa tramite la configurazione, non tramite una Release — una Release non ha alcun campo per essa — ed è per questo che il motore si sceglie per build anziché per Release.

Prima di una prima build devono essere presenti due cose:

  • Il catalogo della libreria standard. .aggrega-config.yaml elenca il catalog/ proprio di questo workspace, che contiene l’assistente per i sinistri e l’entità Plugin del motore OPA. Tutto il resto, comprese le entità Plugin dei motori Rego e CEL, si risolve dal registry dell’hub descritto sotto, oppure da un checkout del catalogo indicato con --catalog.
  • Il registry dell’hub. La realizzazione del mascheramento dei dati scrive i propri guardrail tramite un plugin che non è distribuito né con il compilatore né con il catalogo, il passo di configurazione del gateway pipeline-step/litellm-gateway-config, e la build lo scarica dal registry indicato da default_registry, hub.aggrega.ai.

--auto-pull riempie il lockfile di ogni Release durante la build; i lockfile e l’output renderizzato sono generati, non distribuiti.

Con un assistente AI

Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella Workspace non contiene ancora una cartella `policy-data-class-route`, chiama una volta lo strumento `scaffold` con `example` impostato a `policy-data-class-route` e senza `dir`: scrive l’esempio in una nuova cartella `policy-data-class-route`. Poi chiama lo strumento `cli-build`, che esegue `aggrega build` e accetta il suo flag `--config`, una volta per ogni Release, in quest’ordine — `release-masked.yaml`, `release-unmasked.yaml` e `release-masking-off-route.yaml` — ogni volta con `workspace_root` impostato a `policy-data-class-route`, `release` impostato a quel file, `auto_pull` impostato a true e `config` impostato a `governance-rego.yaml`. La seconda e la terza devono essere rifiutate, quindi leggimi ogni rifiuto. Dimmi quali file ha scritto la prima build; si trovano in `policy-data-class-route/dist/`.

L’arresto

release-unmasked.yaml, con ciascun motore. Il motore 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

Il motore 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

La build termina con 1 e non scrive alcun dist/: la policy viene valutata sul grafo di build prima che qualcosa venga renderizzato. E0005 è la diagnostica che porta il rifiuto di una policy — vedi il riferimento delle diagnostiche. release-masking-off-route.yaml stampa lo stesso rifiuto, con ciascun motore.

Leggi la frase come il percorso che ha trovato. assistant contiene dati restricted. Il suo traffico verso il modello raggiunge gpt, che la policy classifica come public, attraverso plain-gateway, e nulla su quel percorso — né l’assistente, né il gateway, né il modello — porta una Feature che la policy consideri declassificante. Due classi di rango diverso si incontrano su un percorso senza nulla tra loro, quindi la policy rifiuta la build.

Anche il comando pull renderizza la Release, per trovare gli input esterni che devono essere fissati, e incontra lì lo stesso rifiuto; per questo le righe omesse sopra riportano la frase una seconda volta. Il lockfile viene comunque scritto.

Soddisfarla: il gateway di mascheramento sul percorso

release-masked.yaml instrada l’assistente per i sinistri attraverso masking-gateway, e ogni motore ne consente la build, con <workspace> al posto della cartella di questo esempio:

[… 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

Il gateway di mascheramento si trova ora sull’unico percorso dell’assistente per i sinistri verso il modello, e la policy lo legge lì: su quel percorso, un componente porta un’associazione il cui tipo è elencato dall’impostazione declassifying_features della policy, nel punto in cui le classi differiscono o prima. Il percorso si legge dall’output renderizzato: dist/helm/assistant-deployment.yaml manda l’assistente per i sinistri al gateway di mascheramento, e dist/helm/helpdesk-deployment.yaml manda l’helpdesk a quello semplice.

# 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]

Il mascheramento vero e proprio si trova nella configurazione del gateway di mascheramento, la chiave config.yaml di 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]

La configurazione del gateway semplice non ha alcuna voce di guardrail.

La policy non cambia nulla in ciò che viene renderizzato. L’albero release-masked di ciascun motore è identico byte per byte a quello della stessa Release costruita senza alcuna policy associata. La policy è associata al ruolo ir-verdict, un ruolo di verdetto: restituisce un’accettazione o un rifiuto, e il codice che inoltra un verdetto non ha alcun modo di applicarne uno come modifica, quindi una policy in quella posizione può fermare una build e non può riscriverla per renderla conforme.

La policy verifica che il mascheramento sia associato sul percorso, non che cosa maschera. Un’associazione che elenca un pattern a cui non corrispondono i dati di nessuno la soddisfa tanto quanto questa. Ciò che un’associazione di mascheramento elenca è un giudizio proprio del parco IT, espresso là dove l’associazione viene scritta.

Perché le Releases spostano il percorso, non l’associazione

Una Release può associare una Feature, ma un’associazione scritta in una Release non porta values, e core/data-masking tiene ciò che maschera — patterns ed entities — in values, e si arresta su un’associazione che non elenca nessuno dei due. Per questo il mascheramento è associato nell’Aggregate, su masking-gateway, ed è nel grafo di ciascuna delle tre build:

  • in release-masked.yaml si trova sul percorso dell’assistente per i sinistri, e la build si completa;
  • in release-unmasked.yaml non si trova sul percorso di alcun assistente, e la build si arresta;
  • in release-masking-off-route.yaml si trova sul percorso dell’helpdesk, e la build si arresta di nuovo.

La seconda e la terza build portano la stessa associazione e differiscono solo per il percorso su cui si trova. Entrambe si arrestano, quindi la policy legge il percorso, non conta le associazioni nella build.

Che cosa legge la policy

Tutto proviene dal grafo di build che il compilatore consegna a un’associazione ir-verdict, e tutto il suo significato dalle impostazioni dell’associazione:

  • I percorsi che il compilatore enumera, input.precalculated_paths: ciascuno un elenco ordinato di componenti uniti da archi uses. Su release-unmasked.yaml uno di essi è assistant → plain-gateway → gpt. La policy legge ogni percorso dal suo primo componente, il che basta perché il compilatore enumera i percorsi che partono da ogni componente. La policy stessa non enumera nulla.
  • La classe di ciascun componente. Il valore dell’etichetta indicata da class_label, compliance.aggrega.ai/data-class, dove un componente la porta: solo assistant la porta, con restricted. Altrimenti, la classe della prima voce di classes_by_label di cui il componente porta etichetta e valore.
  • Le associazioni di ciascun componente, input.graph.spec.feature_values_mapping. L’elenco attached_features del percorso stesso deliberatamente non viene letto: nomina ogni Feature associata in qualsiasi punto del percorso, quindi non può dire se una si trovi tra i due componenti in questione.

Un componente senza classe viene ignorato. Lo stesso vale per la direzione in cui è tracciato un percorso — una connessione porta una richiesta in un senso e la sua risposta nell’altro — e per le classi a cui le impostazioni danno lo stesso rango.

La classe del modello deriva dalla sua etichetta di hosting. gpt non porta alcuna etichetta di classe. Il suo Component, core/ai-model/openai, porta component.aggrega.ai/hosting: managed, l’affermazione del catalogo secondo cui il servizio è gestito dal suo provider, fuori dal cluster, e le impostazioni la mappano a una classe:

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

Un modello gestito conserva qualsiasi cosa gli venga inviata, cosa che questo parco IT tratta come pubblica. Un modello in self-hosting come core/ai-model/vllm, e ciascuno dei due gateway qui, porta invece self-hosted, e quindi nessuna classe.

I percorsi sono limitati. Il compilatore elenca un numero limitato di percorsi da ciascun componente di partenza e non elenca nulla oltre il limite, quindi su un grafo con più percorsi di così un percorso può restare non letto e la build passare. Un percorso che la policy legge è reale; l’assenza di uno non è la prova che non esista. Vedi i ruoli di verdetto.

Le classi sono della policy, non del compilatore

Il compilatore porta compliance.aggrega.ai/data-class nel grafo di build come stringa e non vi attribuisce alcun significato. Non sa che restricted è più sensibile di public, né che l’una o l’altra parola significhi qualcosa. Le classi e il loro ordinamento sono impostazioni della policy, le stesse in tutti e tre i file dei motori:

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

Un parco IT con un proprio vocabolario sostituisce il suo: le sue classi e il loro ordine sotto rank, l’etichetta in cui le tiene sotto class_label, le sue derivazioni sotto classes_by_label e le Features che accetta come declassificanti sotto declassifying_features. Modifica allo stesso modo tutti e tre i file dei motori, poiché una differenza tra di essi è una differenza tra i verdetti dei motori. Una classe portata da un componente che rank non elenca arresta la build invece di essere letta come assenza di classe, così un errore di ortografia viene segnalato invece di passare. Con l’etichetta dell’assistente per i sinistri scritta Restricted, ogni motore rifiuta release-masked.yaml; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull stampa il rifiuto riportato sotto, e il file di ciascun altro motore stampa lo stesso, intestato con il nome di quel motore:

[… 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

La classe è portata dal Component proprio di questo workspace, non da quello della libreria standard. Se un assistente tratta dati riservati è un’affermazione su come un parco IT lo usa, non su LangGraph, quindi local/ai-agent/claims-assistant estende core/ai-agent/langgraph, ne eredita il contratto e aggiunge quell’unica etichetta. Un Aggregate non può mettere un’etichetta su un’istanza di componente, quindi una classe è sempre una proprietà del Component con cui un’istanza è dichiarata. Con l’assistente per i sinistri dichiarato invece come l’agente della libreria standard, nessun componente porta un’etichetta di classe, e la build di release-unmasked.yaml riesce con ogni motore, byte per byte identica a quella senza policy: il modello deriva ancora public, ma non c’è una seconda classe da incontrare.

Tre motori, la regola scritta tre volte

motoreassociato tramitela regola
il motore Rego compilato nella CLIgovernance-rego.yamlpolicies/data-class-paths.rego, indicato sotto with.sources
il motore CEL compilato nella CLIgovernance-cel.yamlpolicies/data-class-paths.cel, indicato sotto with.sources
OPA, dietro il guest adattatore di riferimentogovernance-opa.yamlpolicies/data-class-paths-opa.rego, compilato nel guest

Le tre copie sono un quasi-duplicato deliberato. Ciascuna è scritta a sé a partire dalla regola, così una build su cui i motori non concordano mostra il disaccordo: la stessa build che si arresta con un motore e si completa con un altro è il segnale. Nessuna è generata da un’altra, e non vanno unite in un’unica implementazione condivisa, che renderebbe i motori concordi per costruzione e nasconderebbe la differenza che tutto questo esiste per cogliere. Ogni file si apre dicendolo.

Differiscono dove differiscono i motori:

  • La copia CEL non può legare un nome a un valore né scorrere le posizioni di un elenco, quindi le sue impostazioni portano una voce in più, positions, le posizioni da 0 a 15 in cui vengono letti i componenti di un percorso. Un percorso più lungo arresta la build, indicando dove inizia, invece di essere letto in parte.
  • La copia OPA è compilata in anticipo con la toolchain di OPA e incorporata nel guest accanto a catalog/plugin/governance/opa/1.0.0/plugin.yaml, quindi la sua associazione fornisce impostazioni e nessun file di policy. L’adattatore non fornisce nessuno dei builtin che OPA lascia al proprio host, quindi questa copia unisce i suoi messaggi con concat dove la copia del motore Rego li formatta con sprintf. Modificarla non cambia alcuna build finché il guest non viene ricompilato, come descritto sotto.

Le associazioni Rego e CEL nominano le entità Plugin che il catalogo della libreria standard contiene per i due motori compilati nella CLI, governance/rego:0.9.0 e governance/cel:0.9.0, e il motore che viene eseguito è quello compilato nel binario che esegue la build. L’entità Plugin di OPA, in catalog/plugin/governance/, è una dichiarazione propria di questo workspace alla versione 1.0.0, quindi la sua associazione nomina governance/opa:1.0.0. Un rifiuto è intestato con l’ultimo segmento del riferimento dell’associazione, senza la versione — policy plugin "rego", "cel" o "opa" — e ogni build associa un solo motore, quindi il rifiuto che stampa nomina quel motore. Il guest OPA viene letto accanto alla sua entità a ogni build, e poiché nulla ne registra il digest, ogni build che lo usa avvisa che viene eseguito senza verifica.

Verificare ogni build

Questo controllo automatico viene eseguito in un checkout del repository della documentazione, che contiene lo script di build condiviso che usa; una copia scritta da aggrega scaffold --example non porta con sé quello script.

Terminal window
./check.sh

check.sh esegue la build delle tre Releases con i tre motori tramite ./build-release.sh e confronta ciascun esito con quello descritto da questa pagina. Un arresto deve terminare con un codice diverso da zero con E0005, il cui messaggio è la frase riportata sopra, e nessun altro rifiuto accanto; una build completata deve terminare con 0 e scrivere gli stessi file, byte per byte, della stessa Release costruita senza policy, di cui esegue prima la build come riferimento. Ogni motore è tenuto alla stessa frase. Stampa una riga per build e termina con 1 se un esito differisce, stampando l’output di quella 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.

Ha bisogno di ciò che serve a una singola build: il catalogo della libreria standard e il registry dell’hub. Usa il binario che ./build-release.sh risolve, quindi AGGREGA_BIN lo sceglie; gli argomenti dopo -- arrivano a ogni build, quindi ./check.sh -- --offline lo esegue senza rete una volta che tutto ciò che scarica è in cache. Si rifiuta di partire finché in questa directory si trova un dist/, perché confronta gli alberi che le build scrivono, e non ne lascia nessuno dietro di sé. Il suo stato di uscita è l’intero verdetto, quindi una pipeline può eseguirlo al posto di eseguire la build di ogni Release separatamente.

Ricompilare il guest OPA

catalog/plugin/governance/opa/1.0.0/governance--opa.wasm è il guest adattatore OPA di riferimento del kit per plugin, rust/examples/policy-opa-wasm nel repository aggrega-pdk, con il modulo che OPA compila da policies/data-class-paths-opa.rego al posto di quello proprio dell’adattatore. È stato compilato da aggrega-pdk a afd9ac6c6800c34c6c47a2030f580c9681387047 e aggrega-abi, il crate ABI su cui si basa la build dell’adattatore, a 2ececa8d3b598243f023a2a6c80b351c8d1411a1, con rustc 1.97.1, attorno al modulo che OPA 1.21.1 compila.

Prima il modulo, da questa directory. Indicare la regola con il suo percorso relativo a questa directory mantiene nel modulo quel percorso, e nulla della macchina:

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

OPA 1.21.1 compila gli stessi byte dalla stessa sorgente in qualunque directory si trovi questo workspace.

Poi il guest, in una directory temporanea $BUILD, indicata come percorso assoluto, che contiene i due repository affiancati, con la dipendenza per percorso dell’adattatore che va dall’uno all’altro. Le tre mappature dei percorsi tengono fuori dal guest la directory di build, la home di cargo e i sorgenti propri della toolchain:

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 copia $BUILD/target/wasm32-wasip1/release/policy_opa_wasm_rust.wasm in catalog/plugin/governance/opa/1.0.0/governance--opa.wasm.

Il guest è l’output della build di cargo così com’è. Lo script di build proprio dell’adattatore esegue anche un passaggio facoltativo di riduzione delle dimensioni, che qui viene saltato: riscrive i dati del guest, e senza di esso il modulo resta nel guest byte per byte. Questo ti permette di confrontare ciò che un guest contiene con ciò in cui la regola viene compilata:

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

Anche i byte propri del guest dipendono dalla directory in cui sono stati compilati i suoi crate, e dalla toolchain, quindi una ricompilazione altrove produce un guest equivalente con un altro sha256. Quello distribuito qui è eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.

Dove il compilatore non interpreta

Il compilatore porta l’etichetta di classe nel grafo di build come stringa, enumera i percorsi lungo gli archi uses che l’Aggregate e le Releases hanno dichiarato, e consegna entrambi alla policy. Non assegna un rango a una classe, non sa che managed significa che i dati lasciano il cluster verso un provider, e non sa che core/data-masking nasconde qualcosa. Ognuno di quei significati sta nelle impostazioni della policy, ed è questo che permette a un parco IT con altre classi, altre etichette e altre Features declassificanti di far funzionare lo stesso meccanismo senza modifiche. Per il socket a cui la policy è associata — i ruoli, il payload, le severità dei verdetti — vedi il socket delle policy, e per la collocazione delle policy nel prodotto, Governance e conformità.

File

  • aggregate.yaml — i due assistenti, il loro checkpointer, i due gateway, il modello e la coppia di servizi di riconoscimento; il mascheramento associato a masking-gateway; il socket model di nessuno dei due assistenti legato.
  • manifest.yaml — lega ogni tipo di componente ed entrambi i tipi di Feature alle loro Recipes Kubernetes, e l’assistente per i sinistri alla Recipe dell’agente di base. Condiviso dalle tre Releases.
  • release-masked.yaml, release-unmasked.yaml, release-masking-off-route.yaml — i tre instradamenti, e il Secret da cui viene letta la chiave di ciascun gateway.
  • catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml — l’assistente per i sinistri, core/ai-agent/langgraph con l’aggiunta dell’etichetta di classe.
  • catalog/plugin/governance/opa/1.0.0/plugin.yaml — l’entità Plugin del motore OPA, con il suo guest, governance--opa.wasm, accanto.
  • policies/data-class-paths.rego, policies/data-class-paths.cel, policies/data-class-paths-opa.rego — la regola, una volta per motore.
  • governance-rego.yaml, governance-cel.yaml, governance-opa.yaml — un file per --config per ciascun motore, ognuno dei quali associa la regola in ir-verdict con le stesse impostazioni.
  • .aggrega-config.yaml — lo stack di ricerca del catalogo e il registry; nessuna associazione di governance.
  • build-release.sh — esegue il build di una Release, mostrando il comando aggrega build equivalente.
  • check.sh — esegue la build di tutte e nove e verifica ciascun esito.