Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Eine Richtlinie, die einen Build abbricht, wenn vertrauliche Daten unmaskiert ein verwaltetes Modell erreichen

Eine IT-Landschaft betreibt einen Schadensassistenten, der vertrauliche Kundendaten verarbeitet, und einen Helpdesk-Assistenten, der keine verarbeitet. Beide senden ihren Modell-Traffic über ein clusterinternes AI-Gateway an die verwaltete API von OpenAI. Die Hausregel der IT-Landschaft:

Daten einer Klasse erreichen eine Komponente einer anderen Klasse entlang einer Route des Build-Graphen nicht, es sei denn, auf dieser Route ist ein deklassifizierendes Feature angebunden.

Dieser Workspace bindet diese Regel als Richtlinie über dem Build-Graphen an und baut drei Releases eines Aggregate. In einem laufen die Anfragen des Schadensassistenten über ein Gateway, das sie maskiert, und der Build wird abgeschlossen. In den anderen beiden nicht, und der Build bricht ab, bevor etwas gerendert wird, wobei die Richtlinie beide Enden der Route nennt.

Die Regel ist dreimal geschrieben, einmal für jede Richtlinien-Engine, auf der sie läuft — die in die CLI kompilierten Rego- und CEL-Engines sowie OPA —, und die drei Kopien stimmen bei jedem Build hier überein. Ein Skript neben den Releases baut alle neun Kombinationen und prüft jedes Ergebnis.

Was es baut

InstanzKatalog-Componentwas es hier ist
assistantlocal/ai-agent/claims-assistantder Schadensassistent: der LangGraph-Agent der Standardbibliothek, im Katalog dieses Workspace mit einem zusätzlichen Label deklariert — der Klasse der Daten, die er verarbeitet
helpdeskcore/ai-agent/langgraphder Helpdesk-Assistent, der keine Klasse trägt
checkpointercore/datastore/valkeywo beide Assistenten ihren Laufzustand speichern
masking-gatewaycore/gateway/litellmein AI-Gateway, das einen Alias bereitstellt, chat, mit angebundenem core/data-masking
plain-gatewaycore/gateway/litellmdasselbe Gateway ohne jede Anbindung
gptcore/ai-model/openaidie verwaltete API von OpenAI, als Referenz erreicht: Im Cluster läuft dafür nichts
analyzer, anonymizercore/security/presidio-analyzer, core/security/presidio-anonymizerdie Erkennungsdienste, die die Maskierung aufruft

Beide Gateways sind über ihren Socket models mit gpt verdrahtet, und jedes präsentiert auf dieser Verbindung den Schlüssel des Modells. Die Maskierungs-Anbindung listet auf, was maskiert werden soll: ein Muster für die Schadennummern der IT-Landschaft sowie die Entitätstypen PERSON und EMAIL_ADDRESS. Die beiden Assistenten deklarieren den Socket model, den ihre Component deklariert und der ein Modell oder ein Gateway zulässt, das eine Modell-API bereitstellt, und lassen ihn ungebunden: Jedes Release verdrahtet ihn.

Die drei Releases

Die Releases unterscheiden sich nur darin, über welches Gateway der Modell-Traffic jedes Assistenten läuft:

Releaseder Traffic des Schadensassistentender Traffic des Helpdesk-Assistentender Build
release-masked.yamlüber masking-gatewayüber plain-gatewayschließt ab
release-unmasked.yamlüber plain-gatewayüber plain-gatewaybricht ab
release-masking-off-route.yamlüber plain-gatewayüber masking-gatewaybricht ab

Jedes Release bindet den Socket model der beiden Assistenten an ein Gateway, das das Aggregate deklariert. Das ist Verdrahtung von Kanten innerhalb eines Sockets, den die Component deklariert, was ein Release tun darf; es fügt keine Komponente hinzu und ändert keinen Wert.

Das Beispiel generieren

Sie können dieses Beispiel mit den folgenden Befehlen bauen oder es von Ihrem KI-Assistenten für Sie bauen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

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

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner:

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

Ersetzen Sie governance-rego.yaml durch governance-cel.yaml oder governance-opa.yaml, um dieselbe Regel auf einer anderen Engine auszuführen.

--config benennt die globale Konfigurationsdatei für diesen Lauf. Sie wird anstelle derjenigen gelesen, die die Maschine sonst lesen würde — der Datei, die AGGREGA_CONFIG benennt, oder des Standardorts —, und die eigene .aggrega-config.yaml dieses Workspace legt sich weiterhin darüber. Für diesen Lauf gilt also nichts, was Sie in Ihrer eigenen globalen Datei hinterlegt haben: eine andere Governance-Anbindung, eine default_registry, eine Offline-Einstellung. Zugangsdaten, die Sie mit aggrega login gespeichert haben, gehören nicht zu dieser Datei und gelten weiterhin. Die Workspace-Datei deklariert die Katalogverzeichnisse und keine eigene Governance-Anbindung; eine Liste, die sie deklarierte, würde die der benannten Datei ersetzen, sodass die Anbindung in der benannten Datei diejenige ist, die läuft.

Eine Governance-Richtlinie wird über die Konfiguration angebunden, nicht über ein Release — ein Release hat dafür kein Feld —, weshalb die Engine pro Build und nicht pro Release gewählt wird.

Vor einem ersten Build müssen zwei Dinge vorhanden sein:

  • Der Katalog der Standardbibliothek. .aggrega-config.yaml listet das eigene catalog/ dieses Workspace auf, das den Schadensassistenten und die Plugin-Entität der OPA-Engine enthält. Alles andere, einschließlich der Plugin-Entitäten der Rego- und CEL-Engines, wird aus der unten beschriebenen Hub-Registry aufgelöst oder aus einem Checkout des Katalogs, der mit --catalog benannt wird.
  • Die Hub-Registry. Die Realisierung der Datenmaskierung schreibt ihre Guardrails über ein Plugin, das weder mit dem Compiler noch mit dem Katalog ausgeliefert wird, den Gateway-Konfigurationsschritt pipeline-step/litellm-gateway-config, und der Build lädt es aus der Registry, die default_registry benennt, hub.aggrega.ai.

--auto-pull füllt die Lockfile jedes Release während des Builds; Lockfiles und die gerenderte Ausgabe werden erzeugt, nicht ausgeliefert.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie ihm diesen Prompt ein.

Verwenden Sie ausschließlich die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `policy-data-class-route` enthält, rufen Sie das Tool `scaffold` einmal auf, mit `example` auf `policy-data-class-route` gesetzt und ohne `dir`: Es schreibt das Beispiel in einen neuen Ordner `policy-data-class-route`. Rufen Sie dann das Tool `cli-build`, das `aggrega build` ausführt und dessen Flag `--config` annimmt, einmal für jedes Release auf, in dieser Reihenfolge — `release-masked.yaml`, `release-unmasked.yaml` und `release-masking-off-route.yaml` — jedes Mal mit `workspace_root` auf `policy-data-class-route`, `release` auf die jeweilige Datei, `auto_pull` auf true und `config` auf `governance-rego.yaml` gesetzt. Der zweite und der dritte Build sollen abgelehnt werden; lesen Sie mir also jede Ablehnung vor. Nennen Sie mir die Dateien, die der erste Build geschrieben hat; sie liegen unter `policy-data-class-route/dist/`.

Der Abbruch

release-unmasked.yaml, unter jeder Engine. Die Rego-Engine:

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

Die CEL-Engine:

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

Der Build endet mit 1 und schreibt kein dist/: Die Richtlinie wird über den Build-Graphen ausgewertet, bevor etwas gerendert wird. E0005 ist die Diagnose, die eine Zurückweisung durch eine Richtlinie trägt — siehe die Diagnosereferenz. release-masking-off-route.yaml gibt unter jeder Engine dieselbe Zurückweisung aus.

Lesen Sie den Satz als die Route, die sie gefunden hat. assistant hält Daten der Klasse restricted. Sein Modell-Traffic erreicht über plain-gateway das Modell gpt, das die Richtlinie als public einstuft, und nichts auf dieser Route — weder der Assistent noch das Gateway noch das Modell — trägt ein Feature, das die Richtlinie als deklassifizierend zählt. Zwei unterschiedlich eingestufte Klassen treffen auf einer Route aufeinander, ohne dass etwas zwischen ihnen liegt, daher weist die Richtlinie den Build zurück.

Auch der Pull-Befehl rendert das Release, um alle externen Eingaben zu finden, die festgelegt werden müssen, und stößt dort auf dieselbe Zurückweisung; deshalb tragen die oben ausgelassenen Zeilen den Satz ein zweites Mal. Die Lockfile wird trotzdem geschrieben.

Sie erfüllen: das Maskierungs-Gateway auf der Route

release-masked.yaml routet den Schadensassistenten über masking-gateway, und jede Engine lässt den Build zu, wobei <workspace> für den Ordner dieses Beispiels steht:

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

Das Maskierungs-Gateway liegt jetzt auf der einzigen Route des Schadensassistenten zum Modell, und die Richtlinie liest es dort: Auf dieser Route trägt eine Komponente eine Anbindung, deren Typ die Einstellung declassifying_features der Richtlinie auflistet, an oder vor der Stelle, an der sich die Klassen unterscheiden. Die Route lässt sich an der gerenderten Ausgabe ablesen: dist/helm/assistant-deployment.yaml schickt den Schadensassistenten zum Maskierungs-Gateway, und dist/helm/helpdesk-deployment.yaml schickt den Helpdesk zum einfachen.

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

Die Maskierung selbst steht in der Konfiguration des Maskierungs-Gateways, dem Schlüssel config.yaml von 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]

Die Konfiguration des einfachen Gateways hat überhaupt keine Guardrail-Einträge.

Die Richtlinie ändert nichts an dem, was gerendert wird. Der Baum release-masked jeder Engine ist byteidentisch mit demselben Release, das ohne angebundene Richtlinie gebaut wurde. Die Richtlinie ist an der Rolle ir-verdict angebunden, einer Verdikt-Rolle: Sie gibt eine Annahme oder eine Zurückweisung zurück, und der Pfad, der ein Verdikt weiterleitet, hat keine Möglichkeit, eines als Änderung anzuwenden, daher kann eine Richtlinie dort einen Build stoppen und ihn nicht in Konformität umschreiben.

Die Richtlinie prüft, dass die Maskierung auf der Route angebunden ist, nicht, was sie maskiert. Eine Anbindung, die ein Muster auflistet, auf das keinerlei Daten passen, erfüllt sie genauso gut wie diese. Was eine Maskierungs-Anbindung auflistet, ist das eigene Urteil der IT-Landschaft, gefällt dort, wo die Anbindung geschrieben wird.

Warum die Releases die Route verschieben, nicht die Anbindung

Ein Release kann ein Feature anbinden, aber eine in einem Release geschriebene Anbindung trägt keine values, und core/data-masking hält das, was es maskiert — patterns und entities —, in values und bricht bei einer Anbindung ab, die keines von beiden auflistet. Deshalb ist die Maskierung im Aggregate angebunden, an masking-gateway, und sie ist im Graphen jedes der drei Builds:

  • in release-masked.yaml liegt sie auf der Route des Schadensassistenten, und der Build wird abgeschlossen;
  • in release-unmasked.yaml liegt sie auf der Route keines Assistenten, und der Build bricht ab;
  • in release-masking-off-route.yaml liegt sie auf der Route des Helpdesks, und der Build bricht erneut ab.

Der zweite und der dritte Build tragen dieselbe Anbindung und unterscheiden sich nur darin, auf wessen Route sie liegt. Beide brechen ab, also liest die Richtlinie die Route, statt Anbindungen im Build zu zählen.

Was die Richtlinie liest

All das stammt aus dem Build-Graphen, den der Compiler einer Anbindung ir-verdict übergibt, und seine gesamte Bedeutung aus den Einstellungen der Anbindung:

  • Die Routen, die der Compiler aufzählt, input.precalculated_paths: jede eine geordnete Liste von Komponenten, die durch Kanten vom Typ uses verbunden sind. Bei release-unmasked.yaml ist eine davon assistant → plain-gateway → gpt. Die Richtlinie liest jede Route ab ihrer ersten Komponente, was genügt, weil der Compiler die Routen aufzählt, die von jeder Komponente ausgehen. Selbst zählt sie nichts auf.
  • Die Klasse jeder Komponente. Der Wert des Labels, das class_label benennt, compliance.aggrega.ai/data-class, wo eine Komponente es trägt: Nur assistant tut das, mit restricted. Andernfalls die Klasse des ersten Eintrags von classes_by_label, dessen Label und Wert die Komponente trägt.
  • Die Anbindungen jeder Komponente, input.graph.spec.feature_values_mapping. Die eigene Liste attached_features der Route wird bewusst nicht gelesen: Sie nennt jedes Feature, das irgendwo auf der Route angebunden ist, und kann daher nicht sagen, ob eines zwischen den beiden betreffenden Komponenten liegt.

Eine Komponente ohne Klasse wird übergangen. Ebenso die Richtung, in der eine Route gezeichnet ist — eine Verbindung trägt eine Anfrage in die eine Richtung und ihre Antwort in die andere —, und Klassen, die die Einstellungen gleich einstufen.

Die Klasse des Modells stammt aus seinem Hosting-Label. gpt trägt kein Klassen-Label. Seine Component, core/ai-model/openai, trägt component.aggrega.ai/hosting: managed, die Aussage des Katalogs, dass der Dienst von seinem Provider außerhalb des Clusters betrieben wird, und die Einstellungen ordnen dies einer Klasse zu:

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

Ein verwaltetes Modell behält alles, was an es gesendet wird, was diese IT-Landschaft als öffentlich behandelt. Ein selbst gehostetes Modell wie core/ai-model/vllm und jedes der beiden Gateways hier trägt stattdessen self-hosted und damit keine Klasse.

Die Routen sind begrenzt. Der Compiler listet von jeder Startkomponente eine begrenzte Anzahl von Routen auf und listet nichts jenseits dieser Schranke, sodass auf einem Graphen mit mehr Routen eine Route ungelesen bleiben und der Build durchgehen kann. Eine Route, die die Richtlinie liest, ist real; das Fehlen einer Route ist kein Beweis dafür, dass sie nicht existiert. Siehe die Verdikt-Rollen.

Die Klassen gehören der Richtlinie, nicht dem Compiler

Der Compiler trägt compliance.aggrega.ai/data-class als String in den Build-Graphen und liest keine Bedeutung hinein. Er weiß nicht, dass restricted sensibler ist als public, oder dass eines der beiden Wörter überhaupt etwas bedeutet. Die Klassen und ihre Rangfolge sind Einstellungen der Richtlinie, in allen drei Engine-Dateien gleich:

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

Eine IT-Landschaft mit eigenem Vokabular setzt ihr eigenes ein: ihre Klassen und deren Reihenfolge unter rank, das Label, in dem sie sie führt, unter class_label, ihre Ableitungen unter classes_by_label und die Features, die sie als deklassifizierend akzeptiert, unter declassifying_features. Ändern Sie alle drei Engine-Dateien gleich, denn ein Unterschied zwischen ihnen ist ein Unterschied zwischen den Verdikten der Engines. Eine Klasse, die eine Komponente trägt und die rank nicht auflistet, bricht den Build ab, statt als keine Klasse gelesen zu werden, sodass ein Schreibfehler gemeldet wird, statt durchzugehen. Wenn das Label des Schadensassistenten Restricted geschrieben ist, weist jede Engine release-masked.yaml zurück; aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull gibt die unten stehende Zurückweisung aus, und die Datei jeder anderen Engine gibt dieselbe aus, überschrieben mit dem Namen dieser Engine:

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

Die Klasse wird von der eigenen Component dieses Workspace getragen, nicht von der der Standardbibliothek. Ob ein Assistent vertrauliche Daten verarbeitet, ist eine Aussage darüber, wie eine IT-Landschaft ihn nutzt, nicht über LangGraph, daher erweitert local/ai-agent/claims-assistant die Basis core/ai-agent/langgraph, erbt deren Vertrag und fügt das eine Label hinzu. Ein Aggregate kann kein Label auf eine Komponenteninstanz setzen, daher ist eine Klasse immer eine Eigenschaft der Component, als die eine Instanz deklariert ist. Wird der Schadensassistent stattdessen als Agent der Standardbibliothek deklariert, trägt keine Komponente ein Klassen-Label, und release-unmasked.yaml wird unter jeder Engine gebaut, Byte für Byte so, wie es ohne Richtlinie gebaut wird: Das Modell leitet weiterhin public ab, aber es gibt keine zweite Klasse, auf die es treffen könnte.

Drei Engines, die Regel dreimal geschrieben

Engineangebunden überdie Regel
die in die CLI kompilierte Rego-Enginegovernance-rego.yamlpolicies/data-class-paths.rego, unter with.sources benannt
die in die CLI kompilierte CEL-Enginegovernance-cel.yamlpolicies/data-class-paths.cel, unter with.sources benannt
OPA, hinter dem Referenz-Adapter-Guestgovernance-opa.yamlpolicies/data-class-paths-opa.rego, in den Guest kompiliert

Die drei Kopien sind ein bewusstes Beinahe-Duplikat. Jede ist eigenständig aus der Regel geschrieben, sodass ein Build, bei dem die Engines uneins sind, die Uneinigkeit zeigt: Derselbe Build, der unter einer Engine abbricht und unter einer anderen abgeschlossen wird, ist das Signal. Keine ist aus einer anderen generiert, und sie dürfen nicht zu einer gemeinsamen Implementierung zusammengeführt werden, die die Engines konstruktionsbedingt übereinstimmen ließe und den Unterschied verbergen würde, den dies aufdecken soll. Jede Datei sagt das gleich zu Beginn.

Sie unterscheiden sich dort, wo sich die Engines unterscheiden:

  • Die CEL-Kopie kann keinen Namen an einen Wert binden und nicht über die Positionen einer Liste laufen, daher tragen ihre Einstellungen einen Eintrag mehr, positions, die Positionen 0 bis 15, an denen die Komponenten einer Route gelesen werden. Eine längere Route bricht den Build ab und nennt, wo sie beginnt, statt teilweise gelesen zu werden.
  • Die OPA-Kopie wird vorab mit OPAs eigener Toolchain kompiliert und in den Guest neben catalog/plugin/governance/opa/1.0.0/plugin.yaml eingebacken, daher liefert ihre Anbindung Einstellungen und keine Richtliniendatei. Der Adapter stellt keines der Builtins bereit, die OPA seinem Host überlässt, daher verbindet diese Kopie ihre Meldungen mit concat, wo die Kopie der Rego-Engine sie mit sprintf formatiert. Eine Änderung an ihr ändert keinen Build, bis der Guest neu gebaut wird, wie unten beschrieben.

Die Rego- und CEL-Anbindungen nennen die Plugin-Entitäten, die der Katalog der Standardbibliothek für die beiden in die CLI kompilierten Engines führt, governance/rego:0.9.0 und governance/cel:0.9.0, und die Engine, die läuft, ist die in das Binary kompilierte, das den Build ausführt. Die Plugin-Entität von OPA in catalog/plugin/governance/ ist die eigene Deklaration dieses Workspace in Version 1.0.0, daher nennt ihre Anbindung governance/opa:1.0.0. Eine Zurückweisung wird mit dem letzten Segment der Referenz der Anbindung überschrieben, ohne Version — policy plugin "rego", "cel" oder "opa" —, und jeder Build bindet eine Engine an, sodass die Zurückweisung, die er ausgibt, diese Engine nennt. Der OPA-Guest wird bei jedem Build neben seiner Entität gelesen, und da nichts seinen Digest festhält, warnt jeder Build mit ihm, dass er unverifiziert läuft.

Jeden Build prüfen

Diese Selbstprüfung läuft in einem Checkout des Dokumentations-Repositorys, das das gemeinsame Build-Hilfsskript enthält, das sie verwendet; eine von aggrega scaffold --example geschriebene Kopie enthält dieses Hilfsskript nicht.

Terminal window
./check.sh

check.sh baut die drei Releases unter den drei Engines über ./build-release.sh und prüft jedes Ergebnis gegen das, das diese Seite beschreibt. Ein Abbruch muss mit einem Wert ungleich null und E0005 enden, dessen Meldung der Satz oben ist, und ohne eine weitere Zurückweisung daneben; ein abgeschlossener Build muss mit 0 enden und Byte für Byte dieselben Dateien schreiben wie dasselbe Release ohne Richtlinie, das es zuerst als Referenz baut. Jede Engine wird an demselben Satz gemessen. Es gibt eine Zeile pro Build aus und endet mit 1, wenn ein Ergebnis abweicht, wobei es die Ausgabe dieses Builds ausgibt:

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.

Es benötigt, was ein einzelner Build benötigt: den Katalog der Standardbibliothek und die Hub-Registry. Es verwendet das Binary, das ./build-release.sh auflöst, sodass AGGREGA_BIN es auswählt; Argumente nach -- erreichen jeden Build, sodass ./check.sh -- --offline es ohne Netzwerk ausführt, sobald alles, was es lädt, im Cache liegt. Es weigert sich zu starten, solange ein dist/ in diesem Verzeichnis liegt, weil es die Bäume vergleicht, die die Builds schreiben, und es hinterlässt keinen. Sein Exit-Status ist das ganze Verdikt, sodass eine Pipeline es ausführen kann, statt jedes Release einzeln zu bauen.

Den OPA-Guest neu bauen

catalog/plugin/governance/opa/1.0.0/governance--opa.wasm ist der Referenz-OPA-Adapter-Guest aus dem Plugin-Kit, rust/examples/policy-opa-wasm im Repository aggrega-pdk, mit dem Modul, das OPA aus policies/data-class-paths-opa.rego kompiliert, anstelle des eigenen Moduls des Adapters. Er wurde aus aggrega-pdk bei afd9ac6c6800c34c6c47a2030f580c9681387047 und aggrega-abi, dem ABI-Crate, gegen das der Adapter gebaut wird, bei 2ececa8d3b598243f023a2a6c80b351c8d1411a1 gebaut, mit rustc 1.97.1, um das Modul herum, das OPA 1.21.1 kompiliert.

Zuerst das Modul, aus diesem Verzeichnis. Die Regel über ihren Pfad relativ zu diesem Verzeichnis zu benennen, hält diesen Pfad, und nichts von der Maschine, im Modul:

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 kompiliert aus derselben Quelle dieselben Bytes, in welchem Verzeichnis dieser Workspace auch liegt.

Dann der Guest, in einem temporären Verzeichnis $BUILD, als absoluter Pfad angegeben, das die beiden Repositories nebeneinander enthält, wobei die Pfadabhängigkeit des Adapters vom einen zum anderen reicht. Die drei Pfadzuordnungen halten das Build-Verzeichnis, das Cargo-Home und die eigenen Quellen der Toolchain aus dem Guest heraus:

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

und kopieren Sie $BUILD/target/wasm32-wasip1/release/policy_opa_wasm_rust.wasm nach catalog/plugin/governance/opa/1.0.0/governance--opa.wasm.

Der Guest ist die Ausgabe des Cargo-Builds, so wie sie anfällt. Das eigene Build-Skript des Adapters führt außerdem einen optionalen Größenreduktionsdurchlauf aus, der hier übersprungen wird: Er schreibt die Daten des Guest um, und ohne ihn bleibt das Modul Byte für Byte im Guest. So können Sie prüfen, was ein Guest enthält, verglichen mit dem, wozu die Regel kompiliert wird:

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

Auch die eigenen Bytes des Guest hängen vom Verzeichnis ab, in dem seine Crates gebaut wurden, und von der Toolchain, sodass ein Neubau anderswo ein gleichwertiger Guest mit einem anderen sha256 ist. Der hier ausgelieferte ist eb53965efd7e812ecc933c7b681936c87aa0d242b28628a957f44a6a8072ec93.

Wo der Compiler nicht interpretiert

Der Compiler trägt das Klassen-Label als String in den Build-Graphen, zählt die Routen über die Kanten vom Typ uses auf, die das Aggregate und die Releases deklariert haben, und übergibt beides der Richtlinie. Er stuft keine Klasse ein, weiß nicht, dass managed bedeutet, dass die Daten den Cluster in Richtung eines Providers verlassen, und weiß nicht, dass core/data-masking irgendetwas verbirgt. Jede dieser Bedeutungen liegt in den Einstellungen der Richtlinie, und genau das lässt eine IT-Landschaft mit anderen Klassen, anderen Labels und anderen deklassifizierenden Features dieselbe Mechanik unverändert betreiben. Zum Socket, an den die Richtlinie angebunden ist — den Rollen, der Payload, den Schweregraden der Verdikte —, siehe den Richtlinien-Socket, und dazu, wo Richtlinien im Produkt ihren Platz haben, Governance und Compliance.

Dateien

  • aggregate.yaml — die beiden Assistenten, ihr Checkpointer, die beiden Gateways, das Modell und das Paar der Erkennungsdienste; die Maskierung an masking-gateway angebunden; der Socket model keines der beiden Assistenten gebunden.
  • manifest.yaml — bindet jeden Komponententyp und beide Feature-Typen an ihre Kubernetes-Recipes, den Schadensassistenten an das Recipe des Basis-Agenten. Von den drei Releases gemeinsam genutzt.
  • release-masked.yaml, release-unmasked.yaml, release-masking-off-route.yaml — die drei Routings und das Secret, aus dem der Schlüssel jedes Gateways gelesen wird.
  • catalog/component/local/ai-agent/claims-assistant/1.0.0/component.yaml — der Schadensassistent, core/ai-agent/langgraph mit dem hinzugefügten Klassen-Label.
  • catalog/plugin/governance/opa/1.0.0/plugin.yaml — die Plugin-Entität der OPA-Engine, mit ihrem Guest, governance--opa.wasm, daneben.
  • policies/data-class-paths.rego, policies/data-class-paths.cel, policies/data-class-paths-opa.rego — die Regel, einmal pro Engine.
  • governance-rego.yaml, governance-cel.yaml, governance-opa.yaml — eine Datei für --config pro Engine, von denen jede die Regel bei ir-verdict mit denselben Einstellungen anbindet.
  • .aggrega-config.yaml — der Such-Stack des Katalogs und die Registry; keine Governance-Anbindung.
  • build-release.sh — baut ein Release und gibt dabei den entsprechenden aggrega build-Befehl aus.
  • check.sh — baut alle neun und prüft jedes Ergebnis.