Governance e conformità
Questo capitolo definisce come i team di piattaforma impongono la conformità aziendale in ogni build — tramite il socket di governance, le baseline e gli schemi del catalogo e le convenzioni che gli autori del catalogo seguono — senza codificare le policy nel compilatore. Gli eventi del ciclo di vita Day-2 sono l’argomento di Cicli di vita Day-2.
Pattern di governance e conformità aziendale
Una sfida centrale del platform engineering è imporre la governance aziendale (come la conformità SOC 2, il tracciamento dei centri di costo FinOps e una mappatura rigorosa della proprietà) senza inquinare il catalogo open source.
Se Aggrega codificasse in modo rigido una logica specifica di dominio nei propri componenti ufficiali, smetterebbe di essere un compilatore privo di opinioni e degenererebbe in un framework con opinioni proprie. Al contrario, se la conformità viene lasciata interamente allo sviluppatore, i tag critici verranno scritti male, dimenticati o aggirati.
Per risolvere il problema, Aggrega fornisce i meccanismi dei socket Wasm per la conformità, mentre l’azienda detta la policy. Le aziende ottengono una governance zero-trust adottando due distinti contratti sociali all’interno del proprio ecosistema.
1. «Bring Your Own Baseline» (BYOB) + gate di convalida Wasm
Per i dati statici forniti dallo sviluppatore (come la proprietà del team o la classificazione dei dati), le aziende non dovrebbero mai affidarsi direttamente al catalogo open source grezzo. Invece, l’architetto della piattaforma scrive una baseline aziendale — i campi che ogni componente interno deve portare, dichiarati una sola volta in una voce di SchemaLibrary — e usa un ruolo di verdetto di governance per imporne l’uso.
Il contratto del catalogo: L’azienda crea una baseline che richiede tag specifici ma non effettua il provisioning di alcuna infrastruttura.
apiVersion: aggrega.ai/v1beta1kind: SchemaLibrarymetadata: name: CorporateBaseline version: 1.0.0spec: schemas: Ownership: type: object properties: owner: { type: string } cost_center: { type: string } # The developer MUST provide these, or the schema validator halts the build required: [owner, cost_center]Ogni componente interno (ad es. acme/datastore/postgres) fa riferimento alla voce dal proprio schema: e aggiunge i valori che gli sono propri, così i campi condivisi e i campi propri del componente vengono validati insieme:
apiVersion: aggrega.ai/v1beta1kind: Componentmetadata: name: acme/datastore/postgres version: 1.0.0 labels: component.aggrega.ai/type: stateful-serverspec: schema: values: $ref: "CorporateBaseline#/schemas/Ownership" properties: database: { type: string } required: [database]La baseline è una voce di libreria anziché un Component di base perché un Component che scrive extends: riceve per intero lo schema: della sua base e non dichiara valori propri (vedi Ereditarietà e disciplina di pubblicazione).
Il failsafe di convalida Wasm: Per impedire a uno sviluppatore di aggirare il catalogo interno e prelevare un componente core/postgres nudo direttamente dall’hub pubblico, l’azienda registra un plugin di convalida topologica. Viene valutato durante l’analisi statica — dopo che il grafo è stato assemblato e prima che qualsiasi artefatto venga renderizzato — ed è per questo che vede l’intera topologia invece di un componente alla volta.
# Evaluated by the governance ir-verdict role over the assembled graphpackage acme.governance
import rego.v1
deny contains msg if { some id, _ in input.graph.spec.nodes not input.graph.spec.values_mapping[id].owner msg := sprintf("node %v declares no owner; use a component whose schema references 'CorporateBaseline#/schemas/Ownership'.", [id])}Una decisione che la policy raccoglie sotto la propria chiave di diniego è un rifiuto, e la build si arresta su di essa.
Vietare le connessioni libere: Uno sviluppatore può collegare un arco tramite un socket che il catalogo non ha dichiarato — un socket ad hoc (vedi dependency-resolution). Questa apertura è voluta, e lo è anche il fatto che il compilatore non abbia alcuna opinione in merito: un’organizzazione che vuole che ogni connessione passi per un socket dichiarato dai propri architetti lo esprime come policy invece di affidarsi al compilatore. Ogni arco del grafo porta socket_declaration, che vale declared o ad-hoc, quindi la regola è una sola riga:
# Evaluated by the governance ir-verdict role over the assembled graphpackage acme.governance
import rego.v1
deny contains msg if { some e in input.graph.spec.edges e.socket_declaration == "ad-hoc" msg := sprintf("%v connects to %v through the free-form socket %v; declare the socket in the component type's usesSchema.", [e.source, e.target, e.socket])}Il valore è sempre presente su ogni arco, in qualunque modo l’arco sia stato scritto, quindi una policy non deve mai leggere un campo assente come «declared». Ed è un asse a sé: dice da dove viene il socket, non chi ha tracciato l’arco, quindi si compone con origin_feature e origin_release invece di sovrapporsi a essi — una policy può vietare le connessioni libere continuando a consentire alla Release di collegare quelle dichiarate.
Governance aziendale centralizzata (valutare la realtà completa): I meccanismi fuori banda (come CODEOWNERS su un repository git) esaminano i file che cambiano, non l’architettura in cui vengono compilati. I ruoli di verdetto di governance giudicano l’architettura stessa. Poiché il compilatore AOT costruisce il grafo IR appiattendo sia l’Aggregate dello sviluppatore sia la Release dell’operatore di piattaforma, una policy al ruolo ir-verdict valuta la realtà completa prima che vengano generati gli artefatti fisici, e una al ruolo render-verdict valuta gli artefatti stessi. Le policy possono arrestare fatalmente la build se uno sviluppatore richiede un Component non approvato, oppure — leggendo la provenienza aggrega.ai/recipe-uri impressa su ogni oggetto renderizzato — se il Manifest mappa un componente su una Recipe non approvata.
2. Il gate mutatore Wasm (conformità dinamica)
Gli sviluppatori non dovrebbero essere costretti a digitare manualmente nel proprio Aggregate i tag di conformità ambientali (ad es. environment: production o soc2_in_scope: true), poiché questi cambiano a seconda del target GitOps.
Per i metadati dinamici, le aziende utilizzano il Mutation Gate — il ruolo label-transform del socket di governance, che viene eseguito durante la costruzione della topologia. Dopo l’espansione del grafo, e prima che l’analisi statica lo valuti, il compilatore esegue il plugin Wasm che l’azienda ha collegato. Quel plugin legge l’ambiente della Release, le etichette che i nodi già dichiarano e i valori che l’istanza di ciascun nodo dichiara, e nomina le etichette che i nodi della build devono portare — così i metadati richiesti raggiungono il componente senza che lo sviluppatore li digiti (ad es. l’etichetta compliance.aggrega.ai/data-class: restricted decisa in base all’ambiente della Release, oppure datastore.aggrega.ai/engine: vector decisa in base alle estensioni dichiarate di un database). I valori sono di sola lettura: il plugin decide le etichette e nient’altro.
Una policy in questo ruolo nomina l’etichetta — il nodo, la chiave e il valore che assume — invece di scrivere l’istruzione di modifica che la build applica. Il motivo conta per chi ne scrive una: l’istruzione indirizza un’etichetta per percorso, e una chiave di etichetta Aggrega contiene abitualmente un /, che è il separatore di percorso, quindi un percorso scritto a mano indirizzerebbe una posizione annidata invece di una singola etichetta. La build indirizza l’etichetta che la decisione nomina, e la proiezione dei nodi che questo ruolo riceve li colloca un livello meno in profondità rispetto a un verdetto sull’intero grafo.
# Evaluated by the governance label-transform role, during topology constructionpackage acme.tagging
import rego.v1
labels contains {"node": id, "key": "acme.com/soc2-scope", "value": "true"} if { input.compilation_context.environment == "production" some id, node in input.graph.nodes node.labels["component.aggrega.ai/type"] == "stateful-server"}Poiché questi tag vengono iniettati in memoria nel dizionario di metadati standard prima che inizi il rendering, i plugin di rendering Wasm possono leggerli per generare in modo condizionale configurazioni fisiche specifiche — risorse AWS o Kubernetes rafforzate, per esempio — man mano che gli artefatti vengono renderizzati.
Enunciare una regola una sola volta: gli attachment di governance hanno ambito di workspace. I due pattern precedenti si scrivono per componente e per Feature, ma l’attachment di governance che li impone no. Un plugin di governance viene collegato alla chiave plugins.governance della configurazione del workspace, e quell’attachment vincola ogni build del workspace. Una regola aziendale è quindi enunciata in un solo punto: il team di piattaforma collega il plugin una volta, e nessun componente, Aggregate o Release deve aderire, menzionarlo o essere modificato perché si applichi. È questo che rende il failsafe di convalida del pattern 1 una risposta completa invece di una convenzione per progetto — uno sviluppatore che aggira il catalogo interno e richiede un core/postgres nudo viene valutato dalla stessa policy collegata di chiunque altro, perché la policy è una proprietà del workspace e non del componente scelto.
Una regola del workspace rifiuta; non riscrive il contratto dello sviluppatore. L’ambito è universale, e l’effetto è deliberatamente limitato a un verdetto. Una regola che si applica ovunque arresta una build che la viola, indicando cosa correggere, e non può invece emendare il componente in difetto per renderlo conforme. Questo confine è ciò che mantiene il meccanismo diagnosticabile su scala dell’intero parco: una build o corrisponde alle regole che il workspace dichiara o si ferma con un messaggio che punta alla riga scritta, e l’output renderizzato non contiene mai un vincolo o una risorsa che nessun file scritto abbia richiesto. Dove un’azienda vuole davvero che il grafo venga modificato invece che giudicato, collega un ruolo di trasformazione — il pattern 2 qui sopra — e quella modifica ha l’ambito di ciò per cui l’operatore l’ha collegato, ed è per questo che è un atto esplicito del team di piattaforma invece di una riscrittura invisibile.
La conseguenza pratica per un team di piattaforma che chiude il cerchio della conformità: esprimere la forma che un payload deve avere come vincoli di schema su una baseline aziendale, esprimere le regole tra entità che il parco richiede come ruolo di verdetto collegato, ed esprimere i metadati derivati che lo sviluppatore non dovrebbe mai digitare come ruolo di trasformazione collegato. Tutti e tre sono dichiarati una volta e si applicano a ogni build, e nessuno richiede che lo sviluppatore sappia che esistono.
3. Preservare l’intelligenza di dominio (le configurazioni e la sicurezza)
Poiché il compilatore Aggrega è privo di opinioni, non possiede alcuna conoscenza codificata di framework AI, budget di token o partizionamento della memoria. Invece, gli schemi cloud-native generici fungono da contenitore vuoto. Anziché essere codificata nel nucleo del compilatore, l’intelligenza di dominio altamente specializzata è distribuita sull’intero ecosistema estensibile di Aggrega. È incapsulata nel catalogo della piattaforma tramite components, features e recipes specializzati. Gli sviluppatori preservano il proprio intento applicativo specifico nei blocchi values e uses — rigorosamente governati dalle dichiarazioni schema: dell’architetto (forma compatta o JSON Schema 2020-12 completo) e dai socket usesSchema — mentre la traduzione fisica di tale intelligenza è eseguita da plugin WebAssembly specifici del target.
A. Modellare implementazioni specifiche di dominio (convalidate tramite schemi separati)
Gli architetti della piattaforma possono sfruttare la pipeline degli schemi separati per modellare qualsiasi architettura complessa, in modo del tutto indipendente dal nucleo del compilatore:
- Logica di esecuzione opaca (
values): Se un’azienda distribuisce un AI Gateway, lo sviluppatore configura il comportamento del gateway stesso — sul gateway AI della libreria standard, la mappamodelsche pubblica ogni alias che un chiamante può richiedere e l’upstream a cui ciascuno si risolve. Il nucleo del compilatore non analizza questi concetti. Risiedono al sicuro nel payload opacovalues, rigorosamente convalidato dalla dichiarazioneschema:del componente. Il compilatore passa semplicemente questo payload al plugin Wasm per generare la configurazione del gateway. I controlli che più prodotti gateway condividono, come una catena di fallback, un numero di tentativi o la scelta tra voci che pubblicano lo stesso alias, sono Features collegate al gateway invece che valori su di esso, ciascuna realizzata per un gateway nei termini propri di quel gateway. - Mappatura delle dipendenze topologiche (
uses): Dove un framework AI collega un agente ai suoi strumenti o a un datastore vettoriale, quel collegamento stabilisce chi parla con chi, quindi è dichiarato nel pilastrouses; un elenco di nomi tenuto invalues, cometools_alloweddella libreria standard, è una convenzione che non traccia alcun arco. Il compilatore traccia questi archi espliciti nel grafo IR testualmente. Ciò consente ai plugin di rendering Wasm a valle di generare programmaticamente le network policy e i confini fisici necessari a proteggere le connessioni, senza che il compilatore comprenda il framework AI sottostante. - Strutture dati complesse (ad es. CoALA): Invece di limitarsi a un unico elenco piatto di target, gli architetti dichiarano in
usesSchematanti socket quanti ne servono a una struttura, ciascuno con il proprio selettore e il propriovalueSchemaper arco. Per esempio, per implementare il framework CoALA, un architetto può dichiararesemantic_memory,episodic_memoryeworking_memorycome socket distinti, così che ogni archivio di memoria sia un target topologico distinto. I motori di policy generici valutano questi archi strutturati per imporre guardrail granulari di controllo degli accessi per ciascun lobo cognitivo distinto.
B. Meccanismi fondamentali di sicurezza e indirezione
Sebbene il payload sia privo di opinioni, lo schema generico impone rigorosi meccanismi strutturali che supportano una generazione sicura degli artefatti:
- Il pattern attachment-non-valore: la convenzione della libreria standard è che una credenziale venga richiesta come attachment, mai scritta in un blocco
valuesdove sarebbe un letterale inline che il compilatore trasporta testualmente. Un attachment di credenziale nomina untypedi Feature di credenziale (una con l’etichettafeature.aggrega.ai/kind: secret) e usa i proprivaluesper descrivere la query verso un secret store. L’instradamento delle credenziali è quindi un late binding indipendente dalle capability, e il nucleo del compilatore non risolve né espone mai il materiale — convoglia il puntatore fornito dalla Recipe di Ops. Questa è una convenzione che il catalogo e gli schemi incoraggiano, non un controllo del compilatore: il compilatore non interpreta il significato di una fogliavalues, quindi un autore che inserisce il materiale inline lo inserisce inline. Ciò che lo schema garantisce è che la superficie di attachment esiste ed è tipizzata. - Verifica astratta della fiducia: Poiché il blocco
valuesè ampiamente estensibile, gli architetti possono rendere obbligatorie direttive astratte cometls_pinningorequired_signatures: 2(per il consenso a quorum). Il nucleo del compilatore passa testualmente questi oggetti convalidati dallo schema nel grafo IR piatto. Un plugin di rendering Wasm personalizzato può quindi leggere questi valori per generare artefatti per gate di approvazione Human-in-the-Loop (HITL) a livello hardware. Se un’applicazione tenta di aggirare le regole di consenso, il proxy fisicamente distribuito blocca l’esecuzione finché non riceve un’approvazione via webhook.
C. Sicurezza operativa avanzata (spec.interoperability)
Per proteggere i carichi di lavoro fragili da mutazioni dell’infrastruttura in conflitto, lo schema generico Feature definisce un controllo di interoperabilità:
spec.interoperability.conflictsWith— un elenco delle Features che non possono raggiungere lo stesso componente di questa. Il compilatore arresta la build prima del rendering quando gli attachment che un componente finisce per avere — raccolti da ogni ambito che lo raggiunge: il componente stesso, un sottosistema o un confine che lo contiene, la sua voce di componente nella Release e l’espansione guidata dalle annotazioni — contengono questa Feature e una che essa nomina. È un confronto tra i nomi che l’autore della Feature ha dichiarato e le Features che il componente porta, senza attribuire significato né agli uni né alle altre: l’incompatibilità è il giudizio dell’autore, e il compilatore vi vincola la build. Basta una dichiarazione, i nomi vengono confrontati qualunque sia la loro versione, e due Features collegate a confini fratelli che non condividono alcun componente non si incontrano mai.
4. Governance dei confini di rete (convenzione di negazione predefinita)
Gli sviluppatori non scrivono direttamente le policy di rete; i confini di rete necessari sono mappati dal grafo della rappresentazione intermedia (IR) del compilatore, che porta ogni arco topologico tra i componenti dichiarati nell’Aggregate.
- Confini interni. Il compilatore disegna il grafo IR piatto e non limita nulla da sé: senza una policy, ogni connessione che la rete del cluster consente resta raggiungibile. La convenzione è che una policy scritta per un componente consenta una connessione solo dove l’Aggregate dichiara un arco per essa, oltre a ciò che nomina l’associazione propria della policy, e neghi ogni altra connessione nella direzione che la policy governa.
- La realizzazione della libreria standard. Il catalogo della libreria standard realizza la convenzione come due Features che l’operatore associa a un componente nella Release, una per ciascuna direzione di una connessione:
core/caller-allowlistammette connessioni solo dai componenti i cui archiusespuntano a esso, ecore/egress-allowlistconsente al componente di connettersi solo ai componenti a cui puntano i suoi archi e al DNS del cluster. Sul target helm ciascuna è realizzata da una FeatureRecipe che scrive una NetworkPolicy Kubernetes a partire dagli archi che il compilatore le passa, individuando i pod di ogni componente da ciò che il render di quel componente ha emesso — i selettori e le etichette che i suoi workload portano, il namespace in cui sono emessi e le porte che i loro container dichiarano — così nessuna etichetta o porta viene ripetuta a mano. Ciascuna ammette inoltre i pod del componente stesso e ciò che la Release nomina sull’associazione: sorgenti esterne all’Aggregate sul lato in ingresso e, sul lato in uscita, intervalli di indirizzi per un target che il cluster non esegue, il quale non produce pod da selezionare ed è ammesso solo per intervallo, su qualsiasi porta. Il compilatore non può ispezionare il cluster, quindi ciascuna arresta la build finché la Release non afferma che il plugin di rete del cluster applica le policy di rete; compose non ha policy di rete, e una build che vi associa una delle due si arresta. - Ingress pubblico (controllo del perimetro agnostico). L’ingress pubblico è governato dalle regole personalizzate dell’azienda in un ruolo di verdetto di governance. Un team di sicurezza aziendale può scrivere una policy che valuta il tipo di ontologia cloud-native di un nodo e rifiuta la build se uno sviluppatore tenta di associare una funzionalità
public-ingressa un nodoworkerotask. Il compilatore non interpreta che cosa significhi «pubblico»; applica l’output booleano del gate di validazione Wasm.
5. Marcatura della provenienza in fase di compilazione
Il compilatore costruisce un record di provenienza durante la compilazione, che registra la versione del compilatore e le versioni dell’Aggregate, del Manifest e della Release che ha compilato — e nessun timestamp, così il record non rompe mai l’output identico byte per byte. Il renderer helm emette la versione del compilatore come etichetta aggrega.ai/compiler-version sui manifest Kubernetes generati, e il renderer helm-chart sui file di template che una Recipe aggiunge a un chart, poiché copia invariati i template propri del chart; i team di sicurezza aziendali la usano per identificare quali artefatti renderizzati sono stati costruiti da quale versione del compilatore — importante quando viene scoperta una vulnerabilità in una specifica release del compilatore e gli artefatti interessati devono essere sottoposti ad audit.
Il provider compose imprime le stesse chiavi di provenienza come etichette di servizio, il provider terraform come file di provenienza in ogni modulo che assembla, e il provider cloudformation sotto Metadata di ogni risorsa; il record di provenienza in memoria esiste per ogni compilazione.
6. Metadati e annotazioni come superficie di estensione
Il compilatore Go è agnostico rispetto ai concetti specifici di dominio — framework di IA, motori di database, idiomi Kubernetes — e lavora solo su operazioni piatte a livello di grafo sull’IR. Per guidare l’ecosistema senza codificare in modo fisso logica specifica di dominio nel binario Go, la piattaforma usa etichette e annotazioni di metadati standard come superficie di estensione per l’intelligenza di dominio.
Il compilatore non legge alcuna annotazione specifica di dominio. Raccoglie tutte le annotazioni fornite dagli sviluppatori e le etichette di duck typing nel grafo IR piatto e passa questi metadati alla lettera ai plugin di governance e di rendering. L’ecosistema WebAssembly interpreta i metadati ed esegue la logica richiesta — valutando le policy di conformità, iniettando tag negli artefatti cloud-native o attivando l’espansione delle funzionalità — indipendentemente dal core del compilatore.
Questo mantiene ampia la superficie di estensibilità (chiunque può scrivere un plugin Wasm che legge un nuovo prefisso di annotazione) mantenendo stabile il core del compilatore: non serve alcuna release del core perché l’ecosistema aggiunga una nuova annotazione specifica di dominio.
Che cosa legge una policy su un’associazione
Un ruolo di verdetto che valuta il grafo IR riceve il grafo intero — con ogni valore che un autore ha dichiarato sensibile trattenuto, come descritto più avanti — e questo include ogni associazione che ciascun nodo porta, indicizzata dal nome che l’autore le ha dato — oppure, per un’associazione scritta su una delle connessioni del nodo, dall’alias della connessione e dallo slot uniti da un punto. Il motivo per cui si porta il dettaglio delle associazioni anziché un riepilogo è che Aggrega non ha alcuna opinione da riassumere: il compilatore instrada le associazioni senza giudicare ciò che contengono, quindi i fatti di cui una policy ha bisogno per giudicarle sono i fatti che a una policy vengono forniti.
Per ogni associazione, il grafo porta:
- Il tipo di Feature che richiede e la versione del catalogo risolta per essa. Il tipo è la stringa che l’autore ha scritto, alla lettera — un riferimento con versione fissata e uno senza sono stringhe diverse per un unico referente, quindi una policy che confronta tipi dovrebbe aspettarsi entrambe le grafie.
- Le etichette di catalogo della Feature associata, alla lettera. Non filtrate, non normalizzate, nell’ordine in cui l’entità di catalogo le dichiara. Una policy legge esattamente ciò che l’autore del catalogo ha scritto, incluse etichette di invenzione dell’autore di cui Aggrega non ha alcuna conoscenza.
- Le annotazioni di catalogo della Feature associata, alla lettera. I
metadata.annotationsdell’entità Feature stessa, portati esattamente alle stesse condizioni delle sue etichette — non filtrati, non normalizzati, nell’ordine dichiarato dall’entità — così una chiave di annotazione nel namespace proprio di un autore arriva così come è stata scritta. Si tratta di un argomento diverso dall’annotazione che ha fatto esistere in primo luogo un’associazione espansa da annotazione: il grafo riporta quell’origine separatamente, e un’associazione scritta in un bloccofeatures:porta le annotazioni dell’entità senza riportare alcuna origine di espansione. - Quale slot di associazione dichiarato riempie. Uno slot
featuresSchemasi riempie associando una Feature sotto il nome dello slot, quindi un’associazione che nomina uno slot dichiarato dal suo Component riporta il nome di quello slot, e una che non ne riempie nessuno riportafree. Un’associazione scritta su una connessione riempie uno slot dichiarato dal socket della connessione e riporta il nome di quello slot; poiché un socket non ammette altri nomi, non riporta maifree. Il valore è il nome dello slot anziché un flag, perché quale punto di binding è stato riempito è di solito la metà più utile della risposta. - Su quale connessione è stata scritta, se ce n’è una. Un’associazione scritta su una delle connessioni del componente porta il socket e l’alias di quella connessione, che nominano l’arco del grafo su cui viene presentata — e, attraverso quell’arco, il componente a cui viene presentata. Un’associazione del blocco proprio del componente non ne porta nessuno. La connessione viene portata come dato anziché essere lasciata da ricavare dal nome dell’associazione, che contiene l’alias e non il socket.
- Se gestisce materiale che un autore ha dichiarato sensibile, e quali delle sue chiavi di consegna portano quel materiale. Entrambi derivano da dichiarazioni — una foglia
sensitivenello schema di una Feature, uno slotsensitivesul Component consumatore, che sia uno che dichiara per le proprie associazioni o uno sul socket attraverso cui è cablata una connessione — mai dall’ispezione di un valore. - I suoi
values, il suoinfrae la sua mappatura di consegna, oltre a se l’associazione è stata scritta in un bloccofeatures:o fornita dall’espansione guidata dalle annotazioni — con ogni valore che un autore ha dichiarato sensibile trattenuto, come descrive il paragrafo successivo.
A una policy viene detto dove si trova il materiale dichiarato sensibile, e quel materiale non le viene mai consegnato. Ogni foglia che il grafo marca come dichiarata sensibile — nei values o nell’infra di qualsiasi associazione, in qualunque ambito o connessione sia stata scritta, nell’infra dell’associazione di un confine, nei values e nell’infra propri di un nodo e nei values e nell’infra propri di una connessione — raggiunge la policy come un marcatore a chiave singola, {"aggrega_withheld": "declared"}, al posto del valore. La chiave sopravvive, così una policy vede ancora quali foglie porta un payload; la marcatura che nomina quelle foglie sopravvive, così una policy vede ancora quali di esse portano materiale dichiarato; e ogni fatto elencato sopra arriva come prima, insieme a ogni valore che nessuna dichiarazione marca. Nessuno dei fatti su cui una policy ragiona — che cos’è un’associazione, che cosa riempie, a che cosa viene presentata, che cosa dice di essa la sua entità di catalogo e dove viaggia il suo materiale segreto — è un valore che un autore può dichiarare sensibile, e il materiale stesso è l’unica cosa di cui una policy non ha bisogno per giudicare dove va. È lo stesso trattenimento che la riga di comando applica quando stampa il grafo e che il daemon applica quando risponde alla richiesta di un editor. Quelle superfici restituiscono i valori a una persona che li chiede esplicitamente; la copia di una policy non offre una richiesta del genere. Si applica solo alla copia della policy: il grafo da cui la build esegue il rendering resta intatto, quindi nessun byte prodotto cambia.
Le etichette di un’associazione vincolano il compilatore in un solo punto, e non si tratta di una decisione di policy: uno slot può dichiarare un selector, e un riempimento le cui etichette non lo soddisfano arresta la build. Oltre quel controllo le etichette non orientano nulla — il modo in cui un valore viene instradato e consegnato è lo stesso qualunque etichetta porti una Feature. Quindi una policy che legge un’etichetta sta leggendo metadati che il compilatore ha portato senza interpretarli, non sta rimettendo in discussione un ramo al suo interno.
Le annotazioni di catalogo di una Feature non la vincolano in alcun punto: nessun comportamento del compilatore si dirama in base a esse, e uno slot non dichiara alcun vincolo su di esse come può fare sulle etichette. Vengono portate e nient’altro.
Regole che questo rende scrivibili, nessuna delle quali il compilatore stabilisce per te:
- Vietare l’associazione libera. Un’organizzazione che richiede a ogni associazione di riempire un punto di binding dichiarato rifiuta qualsiasi associazione che riporti
free. È la controparte del fatto che la superficie di associazione resta aperta: la composizione è libera per impostazione predefinita, e un operatore che non la vuole libera lo dichiara. - Rifiutare la consegna per valore di materiale sensibile. Aggrega emette un avviso quando un dato dichiarato sensibile viaggia attraverso una chiave di consegna come letterale, e non arresta mai la build — la famiglia delle credenziali per valore è voluta. Un operatore che vuole che quell’avviso diventi un rifiuto lo esprime qui.
- Decidere da te che cosa conta come credenziale. La libreria standard marca le sue Features di credenziali con un’etichetta di famiglia, e leggere quell’etichetta è un modo per ragionare su di esse. Un predicato più ampio o più ristretto — un’etichetta interna, una regola di denominazione, un insieme di tipi approvati — è ugualmente disponibile, perché arrivano le etichette anziché un verdetto su di esse.
- Applicare un controllo su qualunque cosa il tuo catalogo registri nei propri metadati. Un’organizzazione che conserva lo stato di revisione, la residenza dei dati o la titolarità come annotazioni sulle proprie entità Feature può richiederle a ogni associazione. Una regola basata su un’annotazione di cui Aggrega non ha mai sentito parlare funziona esattamente come una basata su una chiave che distribuisce, perché le annotazioni arrivano così come sono state scritte — il che significa anche che una Feature e un Component sono giudicati sullo stesso piano, ciascuno in base ai metadati di catalogo che la propria entità dichiara.
- Governare che cosa un componente presenta e a chi. Una credenziale scritta su una connessione nomina quella connessione, e l’arco della connessione nomina il suo target, quindi un’organizzazione può rifiutare una credenziale presentata a un componente esterno a una zona di fiducia che marca con un’etichetta propria — un giudizio che richiede entrambe le estremità della connessione, che nessun fatto sul solo componente consumatore fornisce.
Un ruolo di verdetto accetta o rifiuta; non riscrive mai. La build prosegue invariata oppure si arresta con il messaggio del verdetto, quindi una policy non può rendere conforme di nascosto un grafo non conforme.
Il dettaglio delle associazioni raggiunge una policy che valuta il grafo IR. Una policy che valuta gli artefatti prodotti riceve quegli artefatti e nessun grafo, il che è una proprietà di quell’input anziché una restrizione applicata a esso: le due fasi rispondono a domande diverse, e la topologia delle associazioni non è tra le domande che si possono porre all’output prodotto.
Esprimere le regole dell’organizzazione in un linguaggio di policy
I pattern sopra descrivono che cosa fa un’associazione di governance; questa sezione riguarda ciò che un’azienda scrive per ottenerla. Un team di piattaforma con cinquanta regole da enunciare non vuole cinquanta plugin. Vuole le sue regole come contenuto — file che revisiona, versiona e distribuisce come qualsiasi altro artefatto — con un unico motore associato che le valuta.
È ciò che fornisce un motore di linguaggio di policy associato al socket, e due di essi sono inclusi nel compilatore esattamente a questo scopo: un motore Rego e un motore CEL. Un operatore ne associa uno, dichiara i file di policy che deve caricare, e le regole vengono eseguite: nessuna toolchain esterna, nulla scaricato in fase di build e nessuna logica di policy nel compilatore. La valutazione avviene all’interno del guest WebAssembly, che è dove risiede tutta l’intelligenza di dominio.
Lo stesso motore serve ogni ruolo di governance, così un’organizzazione copre l’intera superficie con un solo plugin associato e diverse associazioni di esso:
- Giudicare l’architettura. Associata sul grafo di build, una policy legge ogni nodo, arco e associazione che il compilatore contiene, più i percorsi di instradamento enumerati accanto a essi, e riporta ciò che deve arrestare la build. È qui che risiedono un invariante di topologia, una regola di autorizzazione tra confini o una regola sul flusso delle credenziali.
- Giudicare l’output. Associata sugli artefatti prodotti, una policy legge i file che la build ha prodotto — come testo e come documenti analizzati dove il formato è stato analizzato prima della policy — e riferisce sul risultato concreto.
- Fornire metadati derivati. Associata per modellare le etichette, una policy decide quali etichette portano i nodi della build, in base all’ambiente della Release e a ciò che i nodi già dichiarano. È il meccanismo descritto dal pattern 2 sopra, con la regola espressa come contenuto di policy anziché come plugin costruito appositamente.
- Aggiungere una capacità che lo sviluppatore non ha scritto. Associata per iniettare annotazioni, una policy aggiunge annotazioni ai componenti della build; un’annotazione sotto una chiave per cui il Manifest registra un binding si espande in un’associazione di Feature, così una regola aziendale può fornire l’involucro di cui un componente ha bisogno anziché limitarsi a rifiutarne l’assenza. Una decisione scrive qualsiasi valore che un operatore potrebbe scrivere su quell’annotazione — una stringa, oppure un oggetto di sottochiavi per un binding che ne instrada diverse — e la build lo legge esattamente come legge lo stesso valore scritto nella Release. Può solo aggiungere: un valore che rimuoverebbe un’annotazione o la escluderebbe viene rifiutato, e un valore iniettato che la build non può instradare o che la Feature legata non ammette viene rifiutato indicando il plugin che lo ha iniettato.
Una regola legge ciò che il payload porta e riporta la sua decisione sotto una chiave con nome:
# Evaluated by a governance verdict role over the assembled graphpackage acme.security
import rego.v1
deny contains msg if { some id, node in input.graph.spec.nodes node.labels["compliance.aggrega.ai/data-class"] == "restricted" not node.labels["acme.com/owner"] msg := sprintf("node %v holds restricted data and declares no owner.", [id])}Una regola che segue i dati lungo il grafo legge i percorsi che il payload enumera. language-reference/examples/policy-data-class-route/ ne è un esempio, dall’inizio alla fine: arresta una build in cui un componente che contiene dati di una classe raggiunge un componente di un’altra classe lungo un percorso su cui non è associata alcuna Feature di declassificazione, e lo stesso Aggregate viene completato quando una Release instrada quel traffico attraverso un gateway che porta core/data-masking. Il compilatore porta l’etichetta di classe come stringa e non ordina nulla — le classi, il loro ordine e le Features che contano come declassificanti sono le impostazioni dell’associazione. La regola è scritta una volta per ciascuno di tre motori — i due compilati nella CLI e OPA dietro il guest adattatore di riferimento — ogni copia per conto suo, così una build su cui due motori sono in disaccordo mostra il disaccordo.
Il vocabolario proprio di una policy viene preservato. Le severità su cui agisce il socket sono un insieme chiuso, ma i nomi sotto cui una policy raccoglie le proprie decisioni appartengono alla policy. I nomi predefiniti sono quelli convenzionali che un corpus Rego già usa, e un operatore le cui policy nominano le decisioni in modo diverso dichiara la mappatura nelle impostazioni dell’associazione — così un’organizzazione che mantiene già una libreria di policy adotta il socket senza riscriverla. La mappatura è tipizzata dallo schema che il plugin dichiara per le proprie impostazioni, quindi una mappatura malformata arresta la build prima che venga eseguita qualsiasi policy anziché instradare male un verdetto.
Un’intera libreria di policy viaggia come un’unica associazione. Un insieme di policy può essere associato file per file, oppure come un singolo archivio che contiene insieme i suoi file di policy e i suoi documenti di dati, che il guest apre. Un archivio che non può essere letto viene segnalato come tale, nominando il file — mai come un insieme di policy che non ha raggiunto alcuna decisione, perché «la libreria era illeggibile» non deve mai essere indistinguibile da «la libreria ha consentito la build».
Una policy non valutabile arresta la build. Quando una policy non può essere valutata, l’associazione fallisce e la build si arresta con un errore che nomina il plugin, volutamente distinto da un verdetto che arresta la build. I due casi non devono essere confusi, e nessuno dei due è un via libera.
L’intera superficie di authoring — il payload che ogni ruolo espone, le chiavi di decisione, la mappatura sulle severità e il modo in cui si associa un archivio — si trova in language-reference/plugins/policy-socket.md.
Ereditarietà e disciplina di pubblicazione
L’ereditarietà tramite extends: è il meccanismo di catalogo che consente agli architetti di piattaforma di costruire entità figlie specializzate sopra baseline condivise. I due tipi di catalogo si separano sui loro pilastri di dati. Gli schemi padre e figlio di una Feature si compongono al caricamento del workspace, producendo uno schema unificato con provenienza per foglia. Un Component che estende non scrive alcun contenuto di pilastro: scrive il marcatore letterale schema: inherited e riceve il blocco schema: della sua base esattamente come la base lo ha scritto, a ogni profondità di una catena.
È questo che risolve la questione di governance sollevata da una baseline condivisa — quali vincoli un figlio può dichiarare rispetto alla sua base. Per un Component la risposta è strutturale anziché sorvegliata: il contratto dichiarato del figlio semplicemente è quello della base, quindi un vincolo della base non può essere allentato, eliminato o ritipizzato da un figlio, e non serve alcun controllo in fase di pubblicazione per mantenere intatta la baseline. Un figlio che ha legittimamente bisogno di una regola più stretta di quella dichiarata dalla sua base la esprime come voce aggiunta nel suo blocco assertions:, che si compone accanto alle regole della base anziché sostituirle.
Ciò che un Component figlio compone è la struttura: i suoi slot di associazione (featuresSchema), i socket di topologia (usesSchema), l’allowlist di self-inject (inject) e le assertions con nome si fondono tutti lungo la catena, con una voce ridichiarata che sostituisce integralmente quella della base.
Collocazione delle regole: quali regole stanno nel plugin di policy e quali nello schema per Component
Il plugin di disciplina di pubblicazione è la sede delle regole trasversali che si applicano a tutto il catalogo: regole di supply chain (ad esempio, «ogni Recipe deve fare implements: di un Component che esiste nel catalogo»), regole di conformità aziendali (ad esempio, «ogni Component con compliance.aggrega.ai/scope: pci-dss deve fare extends: della baseline pci aziendale»). Queste regole attraversano più entità, valutano il workspace come un’unità o applicano convenzioni in fase di pubblicazione anziché in fase di build.
La dichiarazione schema: per Component / per Feature è la sede dei vincoli per entità: tipi, intervalli, pattern ed enum per campo; regole tra campi espresse nel blocco assertions: dedicato. Questi vincoli sono locali a un’entità e viaggiano con essa attraverso il catalogo.
La suddivisione non è arbitraria. Una regola come «ogni campo obbligatorio deve essere presente» è un vincolo per entità che appartiene agli array required:. Una regola come «ogni entità figlia che estende un genitore pci-dss deve dichiarare un’etichetta di governance a livello di workspace» è una regola tra entità che il plugin di policy applica. Le due classi di regole non si sovrappongono mai perché rispondono a domande diverse: lo schema verifica «questa istanza corrisponde al proprio contratto»; il plugin di policy verifica «questo catalogo soddisfa le regole trasversali richieste dal workspace».
Quando si scrive una nuova regola di governance, la domanda sulla collocazione è: la regola dipende solo dal contenuto di una singola entità (→ schema o blocco assertions) oppure dipende dalla relazione tra più entità o dalla configurazione a livello di workspace (→ plugin di policy). Il pattern del linter Wasm è il meccanismo canonico per il caso trasversale; i cataloghi aziendali possono distribuire plugin di policy personalizzati che consumano la stessa interfaccia del contratto dei plugin usata dal plugin standard di disciplina di pubblicazione.
Disciplina dei prefissi delle annotazioni
Lo spazio dei nomi delle annotazioni porta con sé una semantica di origine — prefissi diversi segnalano destinatari diversi e autorità di governance diverse. Gli autori del catalogo, i team di piattaforma aziendali e la piattaforma Aggrega stessa scrivono tutti annotazioni nello stesso dizionario piatto; è il prefisso a mantenere distinti i destinatari.
| Prefisso | Origine | Destinatari | Mutabilità |
|---|---|---|---|
aggrega.ai/ (semplice) | Riservato: emesso solo dal compilatore Aggrega | Strumenti interni, marcatura della provenienza | Non scrivibile dall’utente; le annotazioni con il prefisso semplice dichiarate nei contenuti dell’utente vengono rifiutate al momento della pubblicazione |
<sub-domain>.aggrega.ai/ (ad es. component.aggrega.ai/, feature.aggrega.ai/, compliance.aggrega.ai/) | Convenzione del catalogo | Architetti che scrivono entità del catalogo; plugin di policy Wasm che consumano le etichette | Scrivono gli autori che pubblicano il catalogo; i consumatori leggono |
<enterprise-domain>/ (ad es. acme.com/, my-org.io/) | Overlay aziendale | Team di piattaforma aziendali; plugin Wasm aziendali | Scrivono gli autori aziendali; il compilatore della piattaforma le ignora come metadati opachi |
<community-domain>/ (ad es. cncf.io/, kubernetes.io/) | Ecosistema esterno | Strumenti trasversali agli ecosistemi che leggono etichette note | Governato dalla comunità |
Il prefisso semplice aggrega.ai/ porta la disciplina più rigida: è riservato alle sole annotazioni emesse dalla piattaforma. Il compilatore emette aggrega.ai/compiler-version, aggrega.ai/component-id, aggrega.ai/recipe-uri, aggrega.ai/boundary-path e le relative chiavi di provenienza sull’output renderizzato; i contenuti dell’utente che dichiarano direttamente un’annotazione aggrega.ai/<key> vengono rifiutati al momento della pubblicazione. La disciplina impedisce che le annotazioni scritte dall’utente entrino in collisione con la provenienza emessa dalla piattaforma.
I prefissi di sottodominio sotto <sub-domain>.aggrega.ai/ sono lo spazio delle convenzioni del catalogo. La libreria standard usa component.aggrega.ai/type (l’etichetta dell’ontologia cloud-native), feature.aggrega.ai/kind (la partizione delle Feature tra operative e di credenziali), compliance.aggrega.ai/* (le etichette dell’asse di conformità) e sotto-spazi dei nomi analoghi con un ambito definito. Ogni sottodominio è governato da uno specifico pubblico del catalogo: component.aggrega.ai/* dagli autori delle entità Component, feature.aggrega.ai/* dagli autori delle entità Feature, compliance.aggrega.ai/* dal pubblico delle policy di conformità. Le letture tra sottodomini diversi (un plugin Wasm che legge da più sotto-spazi dei nomi) sono consentite ma rare; in genere ogni plugin si limita a un solo sotto-spazio dei nomi.
I prefissi di dominio aziendale (acme.com/..., my-org.io/...) sono la superficie di estensione della piattaforma. Il compilatore Aggrega li tratta come metadati opachi; li consumano i plugin Wasm aziendali. Le aziende scrivono qualunque struttura di prefissi si adatti alla loro governance — piatta (acme.com/owner: team-payments), a sottodominio (security.acme.com/scope: pii) o gerarchica (org.acme.com/billing-center: finance). La piattaforma non vincola la disposizione dei prefissi aziendali; l’unica regola è che i prefissi aziendali non entrino in collisione con aggrega.ai/ o con i suoi sottodomini.
La disciplina conta perché le annotazioni si propagano a cascata — le annotazioni scritte sul sottosistema di un Aggregate si propagano a ogni componente del sottosistema, le annotazioni proprie di un’istanza di componente prevalgono su quelle del suo sottosistema, e le annotazioni di un modulo raggiungono i componenti propri del modulo; le annotazioni su un confine di una Release si propagano a ogni componente del confine. Un’annotazione del provider raggiunge l’output prodotto da entrambi i lati, e dove entrambi scrivono la stessa chiave si applica il valore della Release. Senza la disciplina dei prefissi, un’annotazione lato Aggregate potrebbe sovrascrivere silenziosamente una chiave di provenienza emessa dalla piattaforma, oppure un’annotazione aziendale potrebbe entrare in collisione con una chiave di convenzione del catalogo. La tabella dei prefissi rende espliciti i destinatari e rende applicabile al momento della pubblicazione la regola che previene le collisioni.
Consulta language-reference/vocabulary/labels-and-annotations.md per l’elenco delle superfici di annotazione di ciascuna entità e per la semantica della cascata a tre contenitori (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).