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

Scrivere un proprio plugin di governance

Questa pagina accompagna un plugin di governance dallo scheletro di adattatore del kit di sviluppo per plugin fino a una build che esso rifiuta. Copi lo scheletro, vi scrivi una regola, compili il .wasm, chiami a mano ciascuno dei suoi export sui file di payload forniti con lo scheletro, lo dichiari come entità Plugin nel catalogo proprio del tuo workspace, lo associ a un ruolo e lo guardi fermare una build che viola la regola.

È il complemento pratico di due pagine: il socket di governance, che documenta i quattro ruoli, il payload che ciascuno porta e i verdetti su cui agisce l’host, e la guida per sviluppatori di plugin, che documenta l’entità Plugin e il suo ciclo di vita. Creare un provider è lo stesso tipo di percorso per un guest di provider.

Sui blocchi di questa pagina. Ogni blocco che mostra un output è stato copiato da un’esecuzione reale dei passaggi seguenti, nell’ordine in cui compaiono, secondo la convenzione sull’output: un blocco è completo, oppure è un estratto che segnala dove sono state omesse delle righe. Due segnaposto stanno per percorsi assoluti che differiscono su ogni macchina: <guest> è la directory della tua copia dello scheletro, e <workspace> la directory del workspace in cui il plugin è associato.

Cosa ti serve

  • La toolchain di Go, che compila in WebAssembly senza strumenti aggiuntivi.
  • Un checkout del kit di sviluppo per plugin, che contiene lo scheletro, e del pacchetto ABI su cui il kit si basa: il go.mod della tua copia punta a entrambi.
  • Il binario aggrega.

Il kit fornisce lo stesso scheletro per Rust, in rust/examples/governance-adapter-skeleton, e per TypeScript, in typescript/examples/governance-adapter-skeleton. Ciascuno contiene gli stessi quattro file di payload, e una copia non modificata di ciascuno risponde loro allo stesso modo; ogni comando aggrega di questa pagina si applica a entrambi con il nome del rispettivo artefatto, e il README di ciascuno ne descrive la compilazione.

La struttura del risultato finito

Un plugin di governance è composto da due artefatti, come qualsiasi plugin: un guest .wasm, e un’entità Plugin che lo porta in un catalogo. Associarlo è una voce nella configurazione del workspace. Nel compilatore non cambia nulla.

Le due directory con cui si conclude questa guida, meno ciò che una build scrive nel workspace:

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 regola che il plugin applica è comune: un workspace nomina le categorie di componenti che non distribuisce — qui devtool, la categoria di una console di amministrazione — e una build che porta un componente di una di esse si arresta, nominandolo.

1. Copiare lo scheletro

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

Il go.mod dello scheletro raggiunge il kit e il pacchetto ABI tramite percorsi relativi alla posizione in cui si trova all’interno del kit, quindi una copia esterna al kit deve nominarli da sé. Assegna al modulo un percorso tuo e fai puntare le due righe replace ai tuoi checkout:

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

Il go.sum dello scheletro resta così com’è.

2. Compilarlo e chiamare a mano ciascun ruolo

Compila la copia prima di modificare qualsiasi cosa, così la prima cosa che esegui è un cablaggio che non hai scritto tu:

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

aggrega plugin run-local carica un guest da un percorso, verifica che l’export che nomini sia uno di quelli dichiarati dall’autodescrizione describe() del guest — e, con --type governance, che il guest si dichiari un plugin di governance — lo chiama con un payload che fornisci tu e stampa la risposta. Lo scheletro fornisce un file di payload per ruolo, ciascuno un input piccolo e valido per il proprio export. Il payload è scritto in JSON; il formato di trasmissione di ogni ruolo di governance porta una codifica binaria, quindi il comando converte il payload in quella codifica prima di chiamare l’export e stampa la risposta dell’export come 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 legge il proprio guest e il proprio payload dai percorsi che gli fornisci e non ha bisogno di alcun workspace, quindi può essere eseguito da qualsiasi directory.

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

Ogni risposta ha la forma che il suo ruolo può restituire: annotazioni da aggiungere, modifiche alle etichette e verdetti. I due ruoli di trasformazione non restituiscono nulla, e ciascun ruolo di verdetto restituisce un verdetto info — una nota che registra un’osservazione e lascia invariato l’esito di una build. Quella nota è la prova del cablaggio dello scheletro. Ogni file di payload porta i due input di un’associazione così come una build li consegna: un file di policy, rules.policy, sotto sources, e un oggetto settings. La nota dice che entrambi hanno raggiunto il punto di giunzione — l’unica funzione che il resto dello scheletro chiama con qualunque cosa il ruolo abbia ricevuto.

Ecco il payload che leggerà la regola qui sotto, ir-verdict-payload.json, completo:

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

È l’input del ruolo ir-verdict: un grafo di build con un solo componente, i percorsi di instradamento enumerati sul grafo, e i campi sources e settings dell’associazione. Ogni campo è descritto nella pagina di riferimento del ruolo, lo schema del socket di policy, e il grafo stesso nella pagina schema del grafo di build; gli altri tre file seguono lo schema annotation-transform, lo schema del mutatore e, per verdict_render, il RenderPolicyInput dello schema del socket di policy.

3. Scrivere una regola

La regola si trova in evaluator.go, il punto di giunzione dello scheletro. Ogni ruolo decodifica il proprio payload, lo scrive come documento JSON e chiama Evaluate con i file di policy dell’associazione, le sue impostazioni, quel documento e il nome della decisione che vuole ottenere. I ruoli di verdetto chiedono a turno tre decisioni — deny, warn e audit — e riportano le risposte di ciascuna alla severità halt, warn e info; i due ruoli di trasformazione chiedono annotations e labels. Quindi una regola che arresta una build risponde a deny.

Sostituisci evaluator.go con:

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 resta, perché i file dei ruoli costruiscono con esso il loro elenco di programmi. Il resto è la regola, e quattro suoi aspetti meritano una lettura attenta.

  • Legge il payload con i nomi che gli dà il formato di trasmissione. I nodi si trovano in graph.spec.nodes, indicizzati per id di nodo, ciascuno con le proprie labels — lo stesso percorso che Che cosa espone il payload di ciascun ruolo fornisce a una policy Rego come input.graph.spec.nodes. Una regola scritta per questo ruolo non legge nulla negli altri: il payload di render-verdict non porta alcun grafo, quindi lì il ciclo non trova alcun nodo.
  • Ciò che vieta spetta all’operatore, non al plugin. Le categorie provengono dalle settings dell’associazione, quindi lo stesso .wasm serve un workspace che vieta devtool e uno che non vieta nulla.
  • Ordina prima di rispondere. L’output di una build è identico byte per byte tra esecuzioni con input identico, e un guest che rispondesse nell’ordine di una mappa Go lo infrangerebbe dall’interno.
  • Fallisce in modo esplicito. Impostazioni o un payload che non riesce a leggere restituiscono un errore anziché un elenco vuoto, e il ruolo trasforma quell’errore in una chiamata fallita. Un elenco vuoto è una policy che non ha trovato nulla da dire; una chiamata fallita è una chiamata che non è stata eseguita, e una build distingue le due cose solo se lo fa il guest.

La regola non legge mai programs. La regola di questo plugin è compilata nel guest, quindi un’associazione fornisce impostazioni e nessun file di policy — la stessa forma di un guest costruito attorno a un motore precompilato, e l’opposto di uno che carica le proprie regole da sources.

Infine, di’ che cos’è il plugin. In main.go, modifica la descrizione in descriptor():

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

Il generatore di entità della sezione 6 la copia nell’entità Plugin.

4. Compilare di nuovo e leggere la risposta della regola

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

Chiama di nuovo i quattro export sugli stessi file:

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 nota segnaposto è sparita da entrambi i ruoli di verdetto, e nessuno dei due restituisce un verdetto: le settings del payload fornito non vietano alcuna categoria, quindi la regola lo consente. Un elenco results vuoto è il modo in cui un ruolo di verdetto dice che la build può procedere.

Per veder scattare la regola, fornisci impostazioni che vietano ciò che il payload contiene. Copia ir-verdict-payload.json in my-payload.json e sostituisci le sue settings con:

"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 decisione deny arriva come un verdetto halt che porta il messaggio proprio della regola. In una build, un halt la arresta con quel messaggio come motivo.

5. Quando un payload non corrisponde

Il comando converte ogni campo che il payload contiene nel tipo dichiarato dalla sua forma, e rifiuta un campo che non riesce a convertire prima che il guest venga eseguito. Scrivi le labels di un nodo come elenco anziché come oggetto, in una copia chiamata 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 [

Il comando termina con un codice diverso da zero, e il guest non viene mai chiamato.

La conversione verifica il tipo di ogni campo che il payload contiene; non verifica che il payload contenga ogni campo richiesto dalla forma. Un payload a cui ne manca uno viene convertito e consegnato al guest comunque, e un guest la cui regola legge quel campo non vi trova nulla. Quindi verifica un payload scritto a mano rispetto alla pagina di riferimento del suo schema: il silenzio del comando non dice che il payload è completo.

6. Dichiararlo come entità Plugin nel catalogo del tuo workspace

I campi di contratto dell’entità vengono letti dal guest anziché scritti a mano, quindi l’entità non può dichiarare un export che il binario non ha. L’identità la fornisci tu in un piccolo 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

L’entità generata:

# 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 è quella che il build.sh dello scheletro imprime nel guest, 0.1.0 a meno che AGGREGA_PLUGIN_VERSION non ne indichi un’altra; pluginType e i quattro export sono ciò che riporta describe(). Un plugin di governance non dichiara alcuna capacità: ciò che può restituire dipende dal ruolo a cui è associato, non dall’entità.

Mentre sviluppi un plugin non c’è nulla di pubblicato da recuperare, quindi una build lo legge da una directory di catalogo, con il .wasm accanto alla sua entità. Il file accanto all’entità prende il nome dal tipo di plugin e dal nome dell’entità, nella directory in cui si trova il documento dell’entità — per 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

Copia il file anziché creare un collegamento a esso. Un collegamento in quella posizione viene seguito solo fino a un punto all’interno del workspace — oppure, per una directory di catalogo elencata fuori dal workspace, fino a un punto all’interno di quella directory; uno che porta oltre arresta la build e il pull, nominando il collegamento, come spiega il confine del workspace. Un pull che non trova alcun .wasm con quel nome si arresta e nomina il file che si aspettava, come descrive A plugin’s .wasm is not on this machine (Il file Wasm di un plugin non è su questa macchina).

7. Il workspace che il plugin protegge

Il workspace è un piccolo negozio: un’API, e i documenti che la costruiscono con Docker Compose. Il suo catalogo contiene anche la console di amministrazione che la regola rifiuterà, un Component la cui categoria è 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. Associarlo ed eseguire la build

Un operatore associa un plugin di governance nella configurazione del workspace, nominando il ruolo e le impostazioni dell’associazione. .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 nomina l’entità per tipo di plugin, nome e versione. Il ruolo è ir-verdict, quindi l’host chiama verdict_ir con il grafo di build una volta costruito il grafo e prima che venga renderizzato qualsiasi cosa. auto_pull consente alla build di risolvere da sé la Release, quindi la prima build non richiede un passo separato.

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

Il negozio non contiene alcun componente devtool, quindi la regola consente la build, e l’output Compose finisce in dist/compose/docker-compose.yaml.

L’avviso è previsto, e resta finché il plugin è locale. Dice che il guest è stato eseguito senza alcun digest del contenuto registrato con cui verificarlo — ed è la verità per un guest compilato un minuto fa e letto da accanto alla sua entità a ogni build. Un plugin associato a un ruolo di verdetto non modella alcun output, quindi un pull non registra alcun digest per esso da una directory di catalogo; è pubblicare il plugin e fare riferimento all’entità pubblicata che ne registra uno.

9. Introdurre una violazione

Aggiungi la console di amministrazione all’Aggregate e collocala nella 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

La build si arresta prima di renderizzare qualsiasi cosa e non scrive alcuna dist/. Il messaggio è la frase propria della regola, preceduta dal nome del plugin, così un autore che lo legge sa quale componente rimuovere e quale policy lo ha chiesto. Il plugin non ha rimosso la console, non l’ha rinominata né ha renderizzato la build senza di essa: un ruolo di verdetto accetta o rifiuta, e l’host non applica mai la sua risposta come modifica.

Che cosa cambiare in seguito

  • Più regole, o un linguaggio di policy. Una regola scritta in Go è compilata nel guest. Per caricare invece le regole da file, leggi programs in Evaluate — i sources dell’associazione, ciascuno con il proprio nome di base e il proprio testo — e passali a un motore. L’ABI è propria di Aggrega descrive un guest che avvolge un motore di policy esterno.
  • Altri ruoli. Lo stesso Evaluate serve ogni ruolo; rispondere a annotations o labels fa sì che il plugin modelli una build in un ruolo di trasformazione. Le forme delle decisioni sono nel README dello scheletro, e ciò che ogni ruolo può modificare è indicato sotto i quattro ruoli.
  • Meno export. Un plugin che serve solo ir-verdict elimina gli altri file di ruolo e le loro voci in descriptor(). Un’associazione che indirizza un ruolo verso un export che il guest non dichiara viene allora rifiutata per nome, prima che il guest venga eseguito.
  • Impostazioni tipizzate. Un guest può dichiarare uno JSON Schema per le proprie impostazioni in describe(), e l’host convalida allora le impostazioni di un’associazione rispetto a esso prima che il guest venga eseguito; vedi Impostazioni tipizzate.
  • Pubblicazione, che trasforma la disposizione in directory di catalogo in un artefatto fissato per digest che una Release risolve e verifica. La guida per sviluppatori di plugin copre quel ciclo di vita.