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

Ein eigenes Governance-Plugin schreiben

Diese Seite führt ein Governance-Plugin vom Adapter-Gerüst des Plugin-Entwicklungskits bis zu einem Build, den es ablehnt. Sie kopieren das Gerüst, schreiben eine Regel hinein, bauen die Datei .wasm, rufen jeden seiner Exporte von Hand mit den Payload-Dateien auf, die das Gerüst mitliefert, deklarieren es als Entität Plugin im eigenen Katalog Ihres Workspace, binden es an einer Rolle an und sehen zu, wie es einen Build stoppt, der die Regel verletzt.

Sie ist das ausgearbeitete Gegenstück zu zwei Seiten: der Governance-Socket, der die vier Rollen, die Payload, die jede trägt, und die Verdikte dokumentiert, nach denen der Host handelt, und der Entwicklerleitfaden für Plugins, der die Entität Plugin und ihren Lebenszyklus dokumentiert. Einen Provider erstellen ist dieselbe Art von Durchgang für einen Provider-Guest.

Zu den Blöcken auf dieser Seite. Jeder Block, der eine Ausgabe zeigt, wurde aus einem echten Durchlauf der folgenden Schritte kopiert, in der Reihenfolge, in der sie erscheinen, gemäß der Ausgabekonvention: Ein Block ist entweder vollständig oder ein Auszug, der markiert, wo Zeilen ausgelassen wurden. Zwei Platzhalter stehen für absolute Pfade, die sich auf jedem Rechner unterscheiden: <guest> ist das Verzeichnis Ihrer Kopie des Gerüsts und <workspace> das Verzeichnis des Workspace, in dem das Plugin angebunden ist.

Was Sie brauchen

  • Die Go-Toolchain, die ohne zusätzliche Werkzeuge nach WebAssembly kompiliert.
  • Ein Checkout des Plugin-Entwicklungskits, das das Gerüst enthält, und des ABI-Pakets, auf dem das Kit aufbaut: Die go.mod Ihrer Kopie verweist auf beide.
  • Die Binärdatei aggrega.

Das Kit liefert dasselbe Gerüst für Rust unter rust/examples/governance-adapter-skeleton und für TypeScript unter typescript/examples/governance-adapter-skeleton mit. Jedes enthält dieselben vier Payload-Dateien, und eine unveränderte Kopie jedes Gerüsts beantwortet sie auf dieselbe Weise; jeder Befehl aggrega auf dieser Seite gilt für beide mit dem jeweils eigenen Artefaktnamen, und die README jedes Gerüsts beschreibt seinen Build.

Die Struktur des fertigen Ergebnisses

Ein Governance-Plugin besteht aus zwei Artefakten, wie jedes Plugin: einem Guest .wasm und einer Entität Plugin, die ihn in einen Katalog bringt. Es anzubinden ist ein Eintrag in der Workspace-Konfiguration. Am Compiler ändert sich nichts.

Die beiden Verzeichnisse, mit denen dieser Durchgang endet, ohne das, was ein Build in den Workspace schreibt:

category-guard/ your copy of the skeleton: the Go module that compiles to the .wasm
.gitignore
README.md the skeleton's own guide
go.mod
go.sum
main.go the describe() self-report and the shared plumbing
evaluator.go the seam, where the rule goes
annotations.go the annotation-transform role
labels.go the label-transform role
verdicts.go the ir-verdict and render-verdict roles
build.sh
annotation-payload.json
label-payload.json
ir-verdict-payload.json
render-verdict-payload.json
my-payload.json a copy you edit in section 4
wrong-payload.json a copy you break in section 5
overlay.yaml the identity you supply to the entity generator
dist/governance-adapter-skeleton-go.wasm the compiled guest
shop/ the workspace the plugin is attached in
catalog/component/example/compute/api/1.0.0/component.yaml
catalog/component/example/devtool/db-console/1.0.0/component.yaml
catalog/recipe/compose/api/1.0.0/recipe.yaml
catalog/recipe/compose/db-console/1.0.0/recipe.yaml
catalog/plugin/governance/category-guard/0.1.0/plugin.yaml
catalog/plugin/governance/category-guard/0.1.0/governance--category-guard.wasm
aggregate.yaml
manifest.yaml
release.yaml
.aggrega-config.yaml

Die Regel, die das Plugin durchsetzt, ist eine verbreitete: Ein Workspace nennt die Komponentenkategorien, die er nicht ausliefert — hier devtool, die Kategorie einer Administrationskonsole —, und ein Build, der eine Komponente einer dieser Kategorien trägt, stoppt und nennt sie.

1. Das Gerüst kopieren

Terminal window
cp -r /path/to/aggrega-pdk/go/examples/governance-adapter-skeleton category-guard
cd category-guard

Die go.mod des Gerüsts erreicht das Kit und das ABI-Paket über Pfade relativ zu der Stelle, an der sie im Kit liegt, sodass eine Kopie außerhalb des Kits sie selbst benennt. Geben Sie dem Modul einen eigenen Pfad, und richten Sie die beiden Zeilen replace auf Ihre Checkouts:

module example.com/category-guard
go 1.26.0
require (
github.com/aggrega-ai/aggrega-abi/go v0.0.0
github.com/aggrega-ai/aggrega-pdk/go v0.0.0
github.com/extism/go-pdk v1.1.3
)
replace github.com/aggrega-ai/aggrega-pdk/go => /path/to/aggrega-pdk/go
replace github.com/aggrega-ai/aggrega-abi/go => /path/to/aggrega-abi/go

Die go.sum des Gerüsts bleibt, wie sie ist.

2. Es bauen und jede Rolle von Hand aufrufen

Bauen Sie die Kopie, bevor Sie etwas ändern, sodass das Erste, was Sie ausführen, eine Verdrahtung ist, die Sie nicht selbst geschrieben haben:

Terminal window
./build.sh
Wrote <guest>/dist/governance-adapter-skeleton-go.wasm

aggrega plugin run-local lädt einen Guest aus einem Pfad, prüft, dass der Export, den Sie nennen, einer ist, den die Selbstauskunft describe() des Guest deklariert — und, mit --type governance, dass der Guest sich selbst als Governance-Plugin ausweist —, ruft ihn mit einer Payload auf, die Sie bereitstellen, und gibt die Antwort aus. Das Gerüst liefert eine Payload-Datei pro Rolle mit, jede eine kleine, gültige Eingabe für ihren Export. Die Payload wird als JSON geschrieben; das Übertragungsformat jeder Governance-Rolle trägt eine binäre Codierung, daher wandelt der Befehl die Payload in diese Codierung um, bevor er den Export aufruft, und gibt die Antwort des Exports als JSON aus.

Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export transform_annotations --with @annotation-payload.json
{
"injections": []
}

run-local liest seinen Guest und seine Payload aus den Pfaden, die Sie ihm geben, und benötigt keinen Workspace, daher kann es aus jedem beliebigen Verzeichnis ausgeführt werden.

Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export mutate --with @label-payload.json
{
"patches": []
}
Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_ir --with @ir-verdict-payload.json
{
"results": [
{
"severity": "info",
"message": "this adapter has no policy engine yet: the seam received rules.policy (43 bytes) and some settings"
}
]
}
Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_render --with @render-verdict-payload.json
{
"results": [
{
"severity": "info",
"message": "this adapter has no policy engine yet: the seam received rules.policy (43 bytes) and some settings"
}
]
}

Jede Antwort hat die Form, die ihre Rolle zurückgeben darf: hinzuzufügende Annotationen, Label-Änderungen und Verdikte. Die beiden Transformations-Rollen geben nichts zurück, und jede Verdikt-Rolle gibt ein Verdikt info zurück — einen Hinweis, der eine Beobachtung festhält und das Ergebnis eines Builds unverändert lässt. Dieser Hinweis ist der Nachweis des Gerüsts für die Verdrahtung. Jede Payload-Datei trägt die beiden Eingaben einer Anbindung so, wie ein Build sie übergibt: eine Richtliniendatei, rules.policy, unter sources, und ein Objekt settings. Der Hinweis besagt, dass beide die Nahtstelle erreicht haben — die eine Funktion, die der Rest des Gerüsts mit allem aufruft, was die Rolle erhalten hat.

Hier ist die Payload, die die Regel unten lesen wird, ir-verdict-payload.json, vollständig:

{
"graph": {
"apiVersion": "aggrega.ai/v1beta1",
"kind": "IR",
"metadata": {
"aggregate_name": "shop"
},
"spec": {
"nodes": {
"api": {
"component": "example/compute/api",
"resolved_version": "1.0.0",
"labels": {
"component.aggrega.ai/type": "server",
"component.aggrega.ai/category": "compute"
}
}
},
"edges": [],
"values_mapping": {},
"infra_mapping": {},
"feature_values_mapping": {},
"provenance": {
"schema_version": "aggrega.ai/v1beta1",
"compiler_version": "0.0.0",
"aggregate_version": "1.0.0",
"manifest_version": "1.0.0",
"release_version": "1.0.0"
}
}
},
"precalculated_paths": [],
"sources": [
{
"path": "rules.policy",
"content": "policy text, handed to the engine verbatim\n"
}
],
"settings": {
"max_nodes": 50
}
}

Sie ist die Eingabe der Rolle ir-verdict: ein Build-Graph mit einer einzigen Komponente, die über den Graphen aufgezählten Routing-Pfade sowie sources und settings der Anbindung. Jedes Feld ist auf der Referenzseite der Rolle beschrieben, Schema des Richtlinien-Sockets, der Graph selbst auf der Seite Schema des Build-Graphen; die anderen drei Dateien folgen dem Schema für annotation-transform, dem Mutator-Schema und, für verdict_render, dem RenderPolicyInput des Schemas des Richtlinien-Sockets.

3. Eine Regel schreiben

Die Regel steht in evaluator.go, der Nahtstelle des Gerüsts. Jede Rolle decodiert ihre Payload, schreibt sie als JSON-Dokument aus und ruft Evaluate mit den Richtliniendateien der Anbindung, ihren Einstellungen, diesem Dokument und dem Namen der Entscheidung auf, die sie zurückhaben will. Die Verdikt-Rollen fragen nacheinander drei Entscheidungen ab — deny, warn und audit — und melden die Antworten jeder davon mit dem Schweregrad halt, warn und info; die beiden Transformations-Rollen fragen annotations und labels ab. Eine Regel, die einen Build stoppt, antwortet also auf deny.

Ersetzen Sie evaluator.go durch:

package main
import (
"encoding/json"
"fmt"
"slices"
"sort"
)
// Program is one policy program the attachment carried.
type Program struct {
Path string
Text string
}
// categoryLabel is the label a catalog Component states its category in.
const categoryLabel = "component.aggrega.ai/category"
// Evaluate refuses every component whose category the attachment's settings
// list under forbidden_categories.
func Evaluate(programs []Program, settings json.RawMessage, payload json.RawMessage, decision string) ([]json.RawMessage, error) {
if decision != denyDecision {
return nil, nil
}
var config struct {
ForbiddenCategories []string `json:"forbidden_categories"`
}
if len(settings) > 0 {
if err := json.Unmarshal(settings, &config); err != nil {
return nil, fmt.Errorf("reading the settings: %w", err)
}
}
var input struct {
Graph struct {
Spec struct {
Nodes map[string]struct {
Labels map[string]string `json:"labels"`
} `json:"nodes"`
} `json:"spec"`
} `json:"graph"`
}
if err := json.Unmarshal(payload, &input); err != nil {
return nil, fmt.Errorf("reading the build graph: %w", err)
}
// A Go map has no order, so the node ids are sorted: identical input must
// yield an identical sequence of decisions.
ids := make([]string, 0, len(input.Graph.Spec.Nodes))
for id := range input.Graph.Spec.Nodes {
ids = append(ids, id)
}
sort.Strings(ids)
var decisions []json.RawMessage
for _, id := range ids {
category := input.Graph.Spec.Nodes[id].Labels[categoryLabel]
if !slices.Contains(config.ForbiddenCategories, category) {
continue
}
message, err := json.Marshal(fmt.Sprintf(
"component %q is a %s component, and this workspace ships none", id, category))
if err != nil {
return nil, err
}
decisions = append(decisions, message)
}
return decisions, nil
}

Program bleibt, weil die Rollendateien damit ihre Liste von Programmen bauen. Der Rest ist die Regel, und vier Dinge darin lohnen ein genaues Lesen.

  • Sie liest die Payload unter den Namen, die das Übertragungsformat ihr gibt. Die Knoten liegen unter graph.spec.nodes, nach Knoten-ID geschlüsselt, jeder mit seinen labels — derselbe Pfad, den Was die Payload jeder Rolle offenlegt einer Rego-Richtlinie als input.graph.spec.nodes gibt. Eine für diese Rolle geschriebene Regel liest bei den anderen nichts: Die Payload von render-verdict trägt keinen Graphen, daher findet die Schleife dort keinen Knoten.
  • Was sie verbietet, legt der Betreiber fest, nicht das Plugin. Die Kategorien stammen aus den settings der Anbindung, sodass dieselbe Datei .wasm einen Workspace bedient, der devtool verbietet, und einen, der nichts verbietet.
  • Sie sortiert, bevor sie antwortet. Die Ausgabe eines Builds ist über Läufe mit identischer Eingabe hinweg byte-identisch, und ein Guest, der in der Reihenfolge einer Go-Map antwortete, würde das von innen brechen.
  • Sie schlägt laut fehl. Einstellungen oder eine Payload, die sie nicht lesen kann, liefern einen Fehler statt einer leeren Liste, und die Rolle macht aus diesem Fehler einen fehlgeschlagenen Aufruf. Eine leere Liste ist eine Richtlinie, die nichts zu sagen fand; ein fehlgeschlagener Aufruf ist einer, der nicht lief, und ein Build unterscheidet beides nur, wenn der Guest es tut.

Die Regel liest programs nie. Die Regel dieses Plugins ist in den Guest kompiliert, sodass eine Anbindung Einstellungen und keine Richtliniendatei liefert — dieselbe Form wie ein Guest, der um eine vorkompilierte Engine herum gebaut ist, und das Gegenteil eines Guest, der seine Regeln aus sources lädt.

Sagen Sie zuletzt, was das Plugin ist. Ändern Sie in main.go die Beschreibung in descriptor():

Description: "Refuse a build that carries a component of a category the attachment forbids.",

Der Entitätsgenerator in Abschnitt 6 kopiert sie in die Entität Plugin.

4. Erneut bauen und die Antwort der Regel lesen

Terminal window
./build.sh
Wrote <guest>/dist/governance-adapter-skeleton-go.wasm

Rufen Sie die vier Exporte erneut mit denselben Dateien auf:

Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export transform_annotations --with @annotation-payload.json
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export mutate --with @label-payload.json
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_ir --with @ir-verdict-payload.json
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_render --with @render-verdict-payload.json
{
"injections": []
}
{
"patches": []
}
{
"results": []
}
{
"results": []
}

Der Platzhalter-Hinweis ist aus beiden Verdikt-Rollen verschwunden, und keine gibt ein Verdikt zurück: Die settings der mitgelieferten Payload verbieten keine Kategorie, also lässt die Regel sie zu. Eine leere Liste results ist die Art, wie eine Verdikt-Rolle sagt, dass der Build fortfahren darf.

Um die Regel auslösen zu sehen, geben Sie ihr Einstellungen, die verbieten, was die Payload trägt. Kopieren Sie ir-verdict-payload.json nach my-payload.json und ersetzen Sie deren settings durch:

"settings": {
"forbidden_categories": [
"compute"
]
}
Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_ir --with @my-payload.json
{
"results": [
{
"severity": "halt",
"message": "component \"api\" is a compute component, and this workspace ships none"
}
]
}

Die Entscheidung deny kommt als Verdikt halt an, das die eigene Meldung der Regel trägt. In einem Build stoppt ein halt diesen mit dieser Meldung als Grund.

5. Wenn eine Payload nicht passt

Der Befehl wandelt jedes Feld, das die Payload trägt, in den Typ um, den ihre Form deklariert, und lehnt ein Feld, das er nicht umwandeln kann, ab, bevor der Guest läuft. Schreiben Sie die labels eines Knotens als Liste statt als Objekt, in einer Kopie namens wrong-payload.json:

"labels": [
"server",
"compute"
]
Terminal window
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \
--type governance --export verdict_ir --with @wrong-payload.json
under key "api": expected JSON object, found [

Der Befehl endet mit einem Exit-Code ungleich null, und der Guest wird nie aufgerufen.

Die Umwandlung prüft den Typ jedes Felds, das die Payload trägt; sie prüft nicht, ob die Payload jedes Feld trägt, das die Form verlangt. Eine Payload, der eines fehlt, wird trotzdem umgewandelt und an den Guest übergeben, und ein Guest, dessen Regel dieses Feld liest, findet dort nichts. Prüfen Sie eine von Hand geschriebene Payload daher gegen die Referenzseite ihres Schemas: Das Schweigen des Befehls besagt nicht, dass die Payload vollständig ist.

6. Es als Entität Plugin im Katalog Ihres Workspace deklarieren

Die Vertragsfelder der Entität werden aus dem Guest ausgelesen, statt von Hand geschrieben zu werden, sodass die Entität keinen Export beanspruchen kann, den die Binärdatei nicht hat. Die Identität liefern Sie in einem kleinen Overlay, overlay.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Plugin
metadata:
name: category-guard
Terminal window
aggrega plugin gen-catalog --plugin dist/governance-adapter-skeleton-go.wasm \
--overlay overlay.yaml --output-dir ../shop/catalog/plugin
generated ../shop/catalog/plugin/governance/category-guard/0.1.0/plugin.yaml

Die erzeugte Entität:

# Generated from the plugin by `aggrega plugin gen-catalog`. You may narrow its capability lists; edit nothing else here.
apiVersion: aggrega.ai/v1beta1
kind: Plugin
metadata:
name: category-guard
version: 0.1.0
pluginType: governance
description: Refuse a build that carries a component of a category the attachment forbids.
spec:
abiVersion: v1beta1
exports:
- name: transform_annotations
- name: mutate
- name: verdict_ir
- name: verdict_render

version ist die Version, die das Skript build.sh des Gerüsts in den Guest einprägt, 0.1.0, sofern AGGREGA_PLUGIN_VERSION keine andere nennt; pluginType und die vier Exporte sind das, was describe() meldet. Ein Governance-Plugin deklariert keine Fähigkeiten: Was es zurückgeben darf, ergibt sich aus der Rolle, an der es angebunden ist, nicht aus der Entität.

Während Sie ein Plugin entwickeln, gibt es nichts Veröffentlichtes zu holen, daher liest ein Build es aus einem Katalogverzeichnis, mit der Datei .wasm neben seiner Entität. Die Datei neben der Entität wird nach dem Plugin-Typ und dem Namen der Entität benannt, in dem Verzeichnis, in dem das Dokument der Entität liegt — für governance/category-guard governance--category-guard.wasm:

Terminal window
cp dist/governance-adapter-skeleton-go.wasm \
../shop/catalog/plugin/governance/category-guard/0.1.0/governance--category-guard.wasm

Kopieren Sie die Datei, statt einen Link darauf anzulegen. Ein Link an dieser Stelle wird nur bis zu einem Ort innerhalb des Workspace verfolgt — oder, bei einem außerhalb des Workspace aufgeführten Katalogverzeichnis, bis zu einem Ort innerhalb dieses Verzeichnisses; einer, der weiter führt, stoppt den Build und den Pull und nennt den Link, wie die Workspace-Grenze darlegt. Ein Pull, der unter diesem Namen keine Datei .wasm findet, stoppt und nennt die Datei, die er erwartet hat, wie A plugin’s .wasm is not on this machine (Die Wasm-Datei zu einem Plugin ist nicht auf diesem Rechner) beschreibt.

7. Der Workspace, den das Plugin schützt

Der Workspace ist ein kleiner Shop: eine API und die Dokumente, die sie mit Docker Compose bauen. Sein Katalog enthält außerdem die Administrationskonsole, die die Regel ablehnen wird, eine Component, deren Kategorie devtool ist.

catalog/component/example/compute/api/1.0.0/component.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: example/compute/api
version: 1.0.0
description: The shop's HTTP API.
labels:
component.aggrega.ai/type: server
component.aggrega.ai/category: compute
spec:
schema:
infra:
port:
type: integer
default: 8080
description: The port the API listens on.

catalog/component/example/devtool/db-console/1.0.0/component.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: example/devtool/db-console
version: 1.0.0
description: A database administration console in the browser.
labels:
component.aggrega.ai/type: server
component.aggrega.ai/category: devtool
spec:
schema:
infra:
port:
type: integer
default: 8081
description: The port the console listens on.

catalog/recipe/compose/api/1.0.0/recipe.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: api
version: 1.0.0
description: Runs the API as a Docker Compose service.
spec:
capability: compose
implements: example/compute/api:1.0.0
workload: |
apiVersion: aggrega.ai/v1beta1
kind: Workload
containers:
main:
image: "registry.example.com/shop/api:1.0.0"
ports:
http: {{ .infra.port }}

catalog/recipe/compose/db-console/1.0.0/recipe.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: db-console
version: 1.0.0
description: Runs the database console as a Docker Compose service.
spec:
capability: compose
implements: example/devtool/db-console:1.0.0
workload: |
apiVersion: aggrega.ai/v1beta1
kind: Workload
containers:
main:
image: "adminer:4"
ports:
http: {{ .infra.port }}

aggregate.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: shop
version: "1.0.0"
description: The shop's API.
spec:
components:
api:
type: example/compute/api

manifest.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: shop-manifest
version: "1.0.0"
description: Binds each component type to its Docker Compose recipe.
spec:
mappings:
components:
type:
example/compute/api:1.0.0: api:1.0.0
example/devtool/db-console:1.0.0: db-console:1.0.0

release.yaml:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: shop-staging
environment: staging
version: "1.0.0"
spec:
aggregate: shop
manifest: shop-manifest
components:
api: {}

8. Es anbinden und bauen

Ein Betreiber bindet ein Governance-Plugin in der Workspace-Konfiguration an und nennt dabei die Rolle und die Einstellungen der Anbindung. .aggrega-config.yaml:

workspace:
catalog_dirs:
- catalog
auto_pull: true
plugins:
governance:
- uri: governance/category-guard:0.1.0
role: ir-verdict
with:
settings:
forbidden_categories:
- devtool

Die uri nennt die Entität über ihren Plugin-Typ, ihren Namen und ihre Version. Die Rolle ist ir-verdict, daher ruft der Host verdict_ir mit dem Build-Graphen auf, sobald der Graph gebaut ist und bevor irgendetwas gerendert wird. auto_pull lässt den Build das Release selbst auflösen, sodass der erste Build keinen separaten Schritt braucht.

Terminal window
cd ../shop
aggrega build --release release.yaml
warning: plugin "governance/category-guard" resolved from local with no recorded digest to check it against, so it runs unverified; it is read from beside its Plugin entity in a catalog directory on every build, and a pull records its digest only for a plugin attached at a transform role; otherwise publish the plugin and reference the published entity to have its digest recorded
Pull complete: release.lock (entities=7, source_artifacts=0, external_inputs=0)
[… omitted: a line reporting total build time, which differs on every run]
Build completed: 1 file written to <workspace>/dist

Der Shop enthält keine Komponente devtool, daher lässt die Regel den Build zu, und die Compose-Ausgabe landet in dist/compose/docker-compose.yaml.

Die Warnung ist erwartet, und sie bleibt, solange das Plugin lokal ist. Sie besagt, dass der Guest ohne einen aufgezeichneten Inhaltsdigest lief, gegen den er geprüft werden könnte — was für einen Guest zutrifft, der vor einer Minute gebaut und bei jedem Build von neben seiner Entität gelesen wurde. Ein an einer Verdikt-Rolle angebundenes Plugin gestaltet keine Ausgabe, daher zeichnet ein Pull aus einem Katalogverzeichnis keinen Digest dafür auf; erst das Veröffentlichen des Plugins und das Referenzieren der veröffentlichten Entität zeichnet einen auf.

9. Einen Verstoß einbauen

Fügen Sie die Administrationskonsole dem Aggregate hinzu, und platzieren Sie sie im Release:

spec:
components:
api:
type: example/compute/api
console:
type: example/devtool/db-console
components:
api: {}
console: {}
Terminal window
aggrega build --release release.yaml
[… omitted: the unverified-plugin warning, and the pull's lines saying the Release could not be rendered to discover its external inputs, which carry the refusal below]
[POLICY_ERROR E0005]
policy plugin "category-guard" rejected the build: component "console" is a devtool component, and this workspace ships none
caused by: policy violation

Der Build stoppt, bevor irgendetwas gerendert wird, und schreibt kein dist/. Die Meldung ist der eigene Satz der Regel, mit dem Namen des Plugins als Kopf, sodass ein Autor, der sie liest, weiß, welche Komponente zu entfernen ist und welche Richtlinie das verlangt hat. Das Plugin hat die Konsole weder entfernt noch umbenannt, noch den Build ohne sie gerendert: Eine Verdikt-Rolle akzeptiert oder lehnt ab, und der Host wendet ihre Antwort nie als Änderung an.

Was Sie als Nächstes ändern können

  • Mehr Regeln oder eine Richtliniensprache. Eine in Go geschriebene Regel ist in den Guest kompiliert. Um Regeln stattdessen aus Dateien zu laden, lesen Sie programs in Evaluate — die sources der Anbindung, jede mit ihrem Basisnamen und ihrem Text — und übergeben Sie sie an eine Engine. Die ABI gehört Aggrega beschreibt einen Guest, der eine fremde Richtlinien-Engine kapselt.
  • Andere Rollen. Dasselbe Evaluate bedient jede Rolle; auf annotations oder labels zu antworten, lässt das Plugin einen Build an einer Transformations-Rolle gestalten. Die Entscheidungsformen stehen in der README des Gerüsts, und was jede Rolle ändern darf, steht unter die vier Rollen.
  • Weniger Exporte. Ein Plugin, das nur ir-verdict bedient, löscht die anderen Rollendateien und ihre Einträge in descriptor(). Eine Anbindung, die eine Rolle auf einen Export richtet, den der Guest nicht deklariert, wird dann namentlich abgelehnt, bevor der Guest läuft.
  • Typisierte Einstellungen. Ein Guest kann in describe() ein JSON Schema für seine Einstellungen deklarieren, und der Host validiert dann die Einstellungen einer Anbindung dagegen, bevor der Guest läuft; siehe Typisierte Einstellungen.
  • Veröffentlichen, was die Anordnung im Katalogverzeichnis in ein per Digest fixiertes Artefakt verwandelt, das ein Release auflöst und verifiziert. Der Entwicklerleitfaden für Plugins behandelt diesen Lebenszyklus.