Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Écrire votre propre plugin de gouvernance

Cette page accompagne un plugin de gouvernance du squelette d’adaptateur du kit de développement de plugins jusqu’à un build qu’il refuse. Vous copiez le squelette, y écrivez une règle, compilez le .wasm, appelez à la main chacun de ses exports sur les fichiers de charge utile que fournit le squelette, le déclarez comme entité Plugin dans le catalogue propre à votre espace de travail, le rattachez à un rôle, et le regardez arrêter un build qui enfreint la règle.

C’est le compagnon pratique de deux pages : le socket de gouvernance, qui documente les quatre rôles, la charge utile que porte chacun et les verdicts sur lesquels agit l’hôte, et le guide du développeur de plugins, qui documente l’entité Plugin et son cycle de vie. Créer un fournisseur est le même type de parcours pour un guest de fournisseur.

À propos des blocs de cette page. Chaque bloc montrant une sortie a été copié d’une exécution réelle des étapes ci-dessous, dans l’ordre où elles apparaissent, en suivant la convention de sortie : un bloc est soit complet, soit un extrait qui marque où des lignes ont été omises. Deux espaces réservés représentent des chemins absolus qui diffèrent sur chaque machine : <guest> est le répertoire de votre copie du squelette, et <workspace> le répertoire de l’espace de travail dans lequel le plugin est rattaché.

Ce dont vous avez besoin

  • La chaîne d’outils Go, qui compile vers WebAssembly sans outillage supplémentaire.
  • Une copie locale du kit de développement de plugins, qui contient le squelette, et du paquet ABI sur lequel repose le kit : le go.mod de votre copie pointe vers les deux.
  • Le binaire aggrega.

Le kit fournit le même squelette pour Rust, dans rust/examples/governance-adapter-skeleton, et pour TypeScript, dans typescript/examples/governance-adapter-skeleton. Chacun contient les quatre mêmes fichiers de charge utile, et une copie non modifiée de chacun y répond de la même façon ; chaque commande aggrega de cette page s’applique à l’un comme à l’autre avec son propre nom d’artefact, et le README de chacun indique comment le compiler.

La structure du résultat final

Un plugin de gouvernance se compose de deux artefacts, comme tout plugin : un guest .wasm, et une entité Plugin qui le porte dans un catalogue. Le rattacher représente une entrée dans la configuration de l’espace de travail. Rien ne change dans le compilateur.

Les deux répertoires auxquels aboutit ce parcours, moins ce qu’un build écrit dans l’espace de travail :

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

La règle qu’applique le plugin est courante : un espace de travail nomme les catégories de composants qu’il ne livre pas — ici devtool, la catégorie d’une console d’administration — et un build qui porte un composant de l’une d’elles s’arrête, en le nommant.

1. Copier le squelette

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

Le go.mod du squelette atteint le kit et le paquet ABI par des chemins relatifs à l’endroit où il se trouve dans le kit, si bien qu’une copie hors du kit doit les nommer elle-même. Donnez au module un chemin à vous et faites pointer les deux lignes replace vers vos copies locales :

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

Le go.sum du squelette reste tel quel.

2. Le compiler et appeler chaque rôle à la main

Compilez la copie avant de modifier quoi que ce soit, afin que la première chose que vous exécutez soit un câblage que vous n’avez pas écrit :

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

aggrega plugin run-local charge un guest depuis un chemin, vérifie que l’export que vous nommez est l’un de ceux que déclare l’auto-description describe() du guest — et, avec --type governance, que le guest se déclare comme un plugin de gouvernance — l’appelle avec une charge utile que vous fournissez, et affiche la réponse. Le squelette livre un fichier de charge utile par rôle, chacun étant une entrée petite et valide pour son export. La charge utile s’écrit en JSON ; le format de transmission de chaque rôle de gouvernance porte un encodage binaire, si bien que la commande convertit la charge utile dans cet encodage avant d’appeler l’export, et affiche la réponse de l’export en JSON.

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 lit son guest et sa charge utile depuis les chemins que vous lui donnez et n’a besoin d’aucun espace de travail, si bien qu’il peut être exécuté depuis n’importe quel répertoire.

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"
}
]
}

Chaque réponse a la forme que son rôle est autorisé à renvoyer : des annotations à ajouter, des modifications de labels et des verdicts. Les deux rôles de transformation ne renvoient rien, et chaque rôle de verdict renvoie un verdict info — une note qui enregistre une observation et laisse inchangée l’issue d’un build. Cette note est la preuve de câblage du squelette. Chaque fichier de charge utile porte les deux entrées d’un rattachement telles qu’un build les remet : un fichier de politique, rules.policy, sous sources, et un objet settings. La note indique que les deux ont atteint le point d’articulation — l’unique fonction que le reste du squelette appelle avec tout ce que le rôle a reçu.

Voici la charge utile que lira la règle ci-dessous, ir-verdict-payload.json, complète :

{
"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
}
}

C’est l’entrée du rôle ir-verdict : un graphe de build contenant un seul composant, les chemins de routage énumérés sur le graphe, ainsi que les sources et les settings du rattachement. Chaque champ est décrit sur la page de référence du rôle, le schéma du socket de politique, et le graphe lui-même sur le schéma du graphe de build ; les trois autres fichiers suivent le schéma annotation-transform, le schéma du mutateur et, pour verdict_render, le RenderPolicyInput du schéma du socket de politique.

3. Écrire une règle

La règle réside dans evaluator.go, le point d’articulation du squelette. Chaque rôle décode sa charge utile, l’écrit sous forme de document JSON et appelle Evaluate avec les fichiers de politique du rattachement, ses paramètres, ce document et le nom de la décision qu’il veut obtenir. Les rôles de verdict demandent tour à tour trois décisions — deny, warn et audit — et signalent les réponses de chacune au niveau de gravité halt, warn et info ; les deux rôles de transformation demandent annotations et labels. Une règle qui arrête un build répond donc à deny.

Remplacez evaluator.go par :

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 reste, car les fichiers de rôle construisent leur liste de programmes avec lui. Le reste est la règle, et quatre de ses aspects méritent une lecture attentive.

  • Elle lit la charge utile sous les noms que lui donne le format de transmission. Les nœuds se trouvent dans graph.spec.nodes, indexés par id de nœud, chacun avec ses labels — le même chemin que Ce qu’expose la charge utile de chaque rôle donne à une politique Rego sous la forme input.graph.spec.nodes. Une règle écrite pour ce rôle ne lit rien dans les autres : la charge utile de render-verdict ne porte aucun graphe, si bien que la boucle n’y trouve aucun nœud.
  • Ce qu’elle interdit relève de l’opérateur, pas du plugin. Les catégories proviennent des settings du rattachement, si bien que le même .wasm sert un espace de travail qui interdit devtool et un autre qui n’interdit rien.
  • Elle trie avant de répondre. La sortie d’un build est identique octet pour octet d’une exécution à l’autre pour une entrée identique, et un guest qui répondrait dans l’ordre d’une table Go briserait cela de l’intérieur.
  • Elle échoue bruyamment. Des paramètres ou une charge utile qu’elle ne peut pas lire renvoient une erreur plutôt qu’une liste vide, et le rôle transforme cette erreur en un appel en échec. Une liste vide est une politique qui n’a rien trouvé à dire ; un appel en échec est un appel qui ne s’est pas exécuté, et un build ne distingue les deux que si le guest le fait.

La règle ne lit jamais programs. La règle de ce plugin est compilée dans le guest, si bien qu’un rattachement fournit des paramètres et aucun fichier de politique — la même forme qu’un guest construit autour d’un moteur précompilé, et l’inverse d’un guest qui charge ses règles depuis sources.

Enfin, indiquez ce qu’est le plugin. Dans main.go, modifiez la description dans descriptor() :

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

Le générateur d’entités de la section 6 la copie dans l’entité Plugin.

4. Recompiler et lire la réponse de la règle

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

Appelez de nouveau les quatre exports sur les mêmes fichiers :

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": []
}

La note provisoire a disparu des deux rôles de verdict, et aucun ne renvoie de verdict : les settings de la charge utile livrée n’interdisent aucune catégorie, si bien que la règle l’autorise. Une liste results vide est la façon dont un rôle de verdict indique que le build peut se poursuivre.

Pour voir la règle se déclencher, donnez-lui des paramètres qui interdisent ce que porte la charge utile. Copiez ir-verdict-payload.json vers my-payload.json et remplacez ses settings par :

"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"
}
]
}

La décision deny arrive sous la forme d’un verdict halt portant le message propre à la règle. Dans un build, un halt l’arrête avec ce message pour motif.

5. Quand une charge utile ne convient pas

La commande convertit chaque champ que porte la charge utile dans le type que déclare sa forme, et refuse un champ qu’elle ne peut pas convertir avant que le guest ne s’exécute. Écrivez les labels d’un nœud sous forme de liste au lieu d’un objet, dans une copie nommée 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 [

La commande se termine avec un code non nul, et le guest n’est jamais appelé.

La conversion vérifie le type de chaque champ que porte la charge utile ; elle ne vérifie pas que la charge utile porte chaque champ que la forme exige. Une charge utile à laquelle il en manque un est convertie et remise au guest malgré tout, et un guest dont la règle lit ce champ n’y trouve rien. Vérifiez donc une charge utile écrite à la main par rapport à la page de référence de son schéma : le silence de la commande ne dit pas que la charge utile est complète.

6. Le déclarer comme entité Plugin dans le catalogue de votre espace de travail

Les champs de contrat de l’entité sont lus à partir du guest plutôt qu’écrits à la main, si bien que l’entité ne peut pas revendiquer un export que le binaire n’a pas. Vous fournissez l’identité dans une petite surcouche, 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

L’entité générée :

# 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 est celle que le build.sh du squelette inscrit dans le guest, 0.1.0 à moins que AGGREGA_PLUGIN_VERSION n’en nomme une autre ; pluginType et les quatre exports sont ce que signale describe(). Un plugin de gouvernance ne déclare aucune capacité : ce qu’il peut renvoyer découle du rôle auquel il est rattaché, et non de l’entité.

Tant que vous développez un plugin, il n’y a rien de publié à récupérer, si bien qu’un build le lit depuis un répertoire de catalogue, avec le .wasm à côté de son entité. Le fichier à côté de l’entité est nommé d’après le type de plugin et le nom de l’entité, dans le répertoire où se trouve le document de l’entité — pour 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

Copiez le fichier plutôt que de créer un lien vers lui. Un lien à cet endroit n’est suivi que jusqu’à un emplacement à l’intérieur de l’espace de travail — ou, pour un répertoire de catalogue listé en dehors de l’espace de travail, jusqu’à un emplacement à l’intérieur de ce répertoire ; un lien qui mène plus loin arrête le build et le pull en nommant le lien, comme l’expose la frontière du workspace. Un pull qui ne trouve aucun .wasm sous ce nom s’arrête et nomme le fichier qu’il attendait, comme le décrit A plugin’s .wasm is not on this machine (Le fichier Wasm d’un plugin n’est pas sur cette machine).

7. L’espace de travail que le plugin protège

L’espace de travail est une petite boutique : une API, et les documents qui la construisent avec Docker Compose. Son catalogue porte aussi la console d’administration que la règle refusera, un Component dont la catégorie est devtool.

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. Le rattacher et lancer le build

Un opérateur rattache un plugin de gouvernance dans la configuration de l’espace de travail, en nommant le rôle et les paramètres du rattachement. .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

L’uri nomme l’entité par son type de plugin, son nom et sa version. Le rôle est ir-verdict, si bien que l’hôte appelle verdict_ir avec le graphe de build une fois le graphe construit et avant que quoi que ce soit ne soit rendu. auto_pull permet au build de résoudre lui-même la Release, si bien que le premier build ne nécessite aucune étape distincte.

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

La boutique ne porte aucun composant devtool, si bien que la règle autorise le build, et la sortie Compose arrive dans dist/compose/docker-compose.yaml.

L’avertissement est attendu, et il demeure tant que le plugin est local. Il indique que le guest s’est exécuté sans aucun digest de contenu enregistré par rapport auquel le vérifier — ce qui est exact pour un guest compilé il y a une minute et lu à côté de son entité à chaque build. Un plugin rattaché à un rôle de verdict ne façonne aucune sortie, si bien qu’un pull n’enregistre aucun digest pour lui depuis un répertoire de catalogue ; c’est en publiant le plugin et en référençant l’entité publiée qu’on en enregistre un.

9. Introduire une violation

Ajoutez la console d’administration à l’Aggregate, et placez-la dans la 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

Le build s’arrête avant de rendre quoi que ce soit, et n’écrit aucun dist/. Le message est la phrase propre à la règle, précédée du nom du plugin, si bien qu’un auteur qui le lit sait quel composant retirer et quelle politique l’a demandé. Le plugin n’a pas retiré la console, ne l’a pas renommée et n’a pas rendu le build sans elle : un rôle de verdict accepte ou rejette, et l’hôte n’applique jamais sa réponse comme une modification.

Ce qu’il faut changer ensuite

  • Davantage de règles, ou un langage de politique. Une règle écrite en Go est compilée dans le guest. Pour charger plutôt des règles depuis des fichiers, lisez programs dans Evaluate — les sources du rattachement, chacune avec son nom de base et son texte — et remettez-les à un moteur. L’ABI appartient à Aggrega décrit un guest qui enveloppe un moteur de politiques externe.
  • D’autres rôles. Le même Evaluate sert chaque rôle ; répondre à annotations ou à labels fait façonner un build par le plugin à un rôle de transformation. Les formes de décision se trouvent dans le README du squelette, et ce que chaque rôle peut modifier se trouve dans les quatre rôles.
  • Moins d’exports. Un plugin qui ne sert que ir-verdict supprime les autres fichiers de rôle et leurs entrées dans descriptor(). Un rattachement qui dirige un rôle vers un export que le guest ne déclare pas est alors refusé par son nom, avant que le guest ne s’exécute.
  • Paramètres typés. Un guest peut déclarer un JSON Schema pour ses paramètres dans describe(), et l’hôte valide alors les paramètres d’un rattachement par rapport à lui avant que le guest ne s’exécute ; voir Paramètres typés.
  • La publication, qui transforme l’agencement en répertoire de catalogue en un artefact épinglé par digest qu’une Release résout et vérifie. Le guide du développeur de plugins couvre ce cycle de vie.