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.moddella 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 guestshop/ 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.yamlLa 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
cp -r /path/to/aggrega-pdk/go/examples/governance-adapter-skeleton category-guardcd category-guardIl 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/goIl 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:
./build.shWrote <guest>/dist/governance-adapter-skeleton-go.wasmaggrega 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.
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.
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \ --type governance --export mutate --with @label-payload.json{ "patches": []}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" } ]}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 proprielabels— lo stesso percorso che Che cosa espone il payload di ciascun ruolo fornisce a una policy Rego comeinput.graph.spec.nodes. Una regola scritta per questo ruolo non legge nulla negli altri: il payload dirender-verdictnon porta alcun grafo, quindi lì il ciclo non trova alcun nodo. - Ciò che vieta spetta all’operatore, non al plugin. Le categorie provengono dalle
settingsdell’associazione, quindi lo stesso.wasmserve un workspace che vietadevtoole 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
./build.shWrote <guest>/dist/governance-adapter-skeleton-go.wasmChiama di nuovo i quattro export sugli stessi file:
aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \ --type governance --export transform_annotations --with @annotation-payload.jsonaggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \ --type governance --export mutate --with @label-payload.jsonaggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \ --type governance --export verdict_ir --with @ir-verdict-payload.jsonaggrega 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" ] }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" ]aggrega plugin run-local --plugin dist/governance-adapter-skeleton-go.wasm \ --type governance --export verdict_ir --with @wrong-payload.jsonunder 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/v1beta1kind: Pluginmetadata: name: category-guardaggrega plugin gen-catalog --plugin dist/governance-adapter-skeleton-go.wasm \ --overlay overlay.yaml --output-dir ../shop/catalog/plugingenerated ../shop/catalog/plugin/governance/category-guard/0.1.0/plugin.yamlL’entità generata:
# Generated from the plugin by `aggrega plugin gen-catalog`. You may narrow its capability lists; edit nothing else here.apiVersion: aggrega.ai/v1beta1kind: Pluginmetadata: 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_renderversion è 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:
cp dist/governance-adapter-skeleton-go.wasm \ ../shop/catalog/plugin/governance/category-guard/0.1.0/governance--category-guard.wasmCopia 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/v1beta1kind: Componentmetadata: name: example/compute/api version: 1.0.0 description: The shop's HTTP API. labels: component.aggrega.ai/type: server component.aggrega.ai/category: computespec: 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/v1beta1kind: Componentmetadata: 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: devtoolspec: 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/v1beta1kind: Recipemetadata: 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/v1beta1kind: Recipemetadata: 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/v1beta1kind: Aggregatemetadata: name: shop version: "1.0.0" description: The shop's API.spec: components: api: type: example/compute/apimanifest.yaml:
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: 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.0release.yaml:
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: 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: - catalogauto_pull: trueplugins: governance: - uri: governance/category-guard:0.1.0 role: ir-verdict with: settings: forbidden_categories: - devtoolL’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.
cd ../shopaggrega 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 recordedPull 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>/distIl 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: {}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 violationLa 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
programsinEvaluate— isourcesdell’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
Evaluateserve ogni ruolo; rispondere aannotationsolabelsfa 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-verdictelimina gli altri file di ruolo e le loro voci indescriptor(). 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.
Riferimenti correlati
- Il socket di governance — i quattro ruoli, i loro payload, le severità dei verdetti e come un operatore associa un plugin.
- Contratto dei Plugin — le forme di input e di output di ogni socket, e la codifica che ciascuna porta.
- Guida per sviluppatori di plugin Wasm — l’entità
Plugin, la superficie delle capacità e il ciclo di vita di pubblicazione. - Creare un provider — lo stesso percorso per un guest di provider.
- Leggere l’output in queste pagine — la convenzione seguita dai blocchi di output qui sopra.