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

Gouvernance et conformité

Ce chapitre définit comment les équipes de plateforme imposent la conformité de l’entreprise dans chaque build — via le socket de gouvernance, les bases et les schémas du catalogue, et les conventions que suivent les auteurs du catalogue — sans coder de politique en dur dans le compilateur. Les événements du cycle de vie Day-2 sont le sujet de Cycles de vie Day-2.

Modèles de gouvernance et de conformité en entreprise

Un défi central de l’ingénierie de plateforme consiste à imposer la gouvernance de l’entreprise (comme la conformité SOC 2, le suivi des centres de coûts FinOps et une attribution stricte des responsabilités) sans polluer le catalogue open source.

Si Aggrega codait en dur une logique propre à un domaine dans ses composants officiels, il cesserait d’être un compilateur sans parti pris et dégénérerait en framework à parti pris. À l’inverse, si la conformité est entièrement laissée au développeur, les tags critiques seront mal orthographiés, oubliés ou contournés.

Pour résoudre ce problème, Aggrega fournit les mécanismes de sockets Wasm pour la conformité, tandis que l’entreprise dicte la politique. Les entreprises obtiennent une gouvernance zero-trust en adoptant deux contrats sociaux distincts au sein de leur écosystème.

1. « Bring Your Own Baseline » (BYOB) + porte de validation Wasm

Pour les données statiques fournies par le développeur (comme l’équipe propriétaire ou la classification des données), les entreprises ne devraient jamais s’appuyer directement sur le catalogue open source brut. À la place, l’architecte de plateforme écrit une base d’entreprise — les champs que tout composant interne doit porter, déclarés une seule fois dans une entrée de SchemaLibrary — et utilise un rôle de verdict de gouvernance pour en imposer l’usage.

Le contrat du catalogue : L’entreprise crée une base qui exige des tags spécifiques mais ne provisionne aucune infrastructure.

apiVersion: aggrega.ai/v1beta1
kind: SchemaLibrary
metadata:
name: CorporateBaseline
version: 1.0.0
spec:
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]

Chaque composant interne (p. ex. acme/datastore/postgres) référence l’entrée depuis son propre schema: et ajoute les valeurs qui lui sont propres, de sorte que les champs partagés et les champs propres au composant sont validés ensemble :

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: acme/datastore/postgres
version: 1.0.0
labels:
component.aggrega.ai/type: stateful-server
spec:
schema:
values:
$ref: "CorporateBaseline#/schemas/Ownership"
properties:
database: { type: string }
required: [database]

La base est une entrée de bibliothèque plutôt qu’un Component de base, car un Component qui écrit extends: reçoit le schema: de sa base en entier et ne déclare aucune valeur propre (voir Héritage et discipline de publication).

Le garde-fou de validation Wasm : Pour empêcher un développeur de contourner le catalogue interne et de tirer un composant core/postgres nu directement depuis le hub public, l’entreprise enregistre un plugin de validation topologique. Il est évalué pendant l’analyse statique — après l’assemblage du graphe et avant le rendu de tout artefact —, c’est pourquoi il voit toute la topologie plutôt qu’un composant à la fois.

# Evaluated by the governance ir-verdict role over the assembled graph
package 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])
}

Une décision que la politique collecte sous sa clé de refus est un rejet, et le build s’arrête sur elle.

Interdire les connexions libres : Un développeur peut câbler une arête via un socket que le catalogue n’a pas déclaré — un socket ad hoc (voir dependency-resolution). Cette ouverture est délibérée, tout comme le fait que le compilateur n’a aucune opinion à son sujet : une organisation qui veut que chaque connexion passe par un socket déclaré par ses architectes l’exprime sous forme de politique au lieu de compter sur le compilateur. Chaque arête du graphe porte socket_declaration, qui vaut declared ou ad-hoc, si bien que la règle tient en une ligne :

# Evaluated by the governance ir-verdict role over the assembled graph
package 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])
}

La valeur est toujours présente sur chaque arête, quelle que soit la façon dont l’arête a été écrite, de sorte qu’une politique n’a jamais à lire un champ absent comme « declared ». Et elle constitue un axe à part : elle indique d’où vient le socket, et non qui a tracé l’arête, si bien qu’elle se combine avec origin_feature et origin_release au lieu de les recouvrir — une politique peut interdire les connexions libres tout en permettant à la Release de câbler celles qui sont déclarées.

Gouvernance d’entreprise centralisée (évaluer la réalité complète) : Les mécanismes hors bande (comme CODEOWNERS sur un dépôt git) examinent les fichiers qui changent, pas l’architecture vers laquelle ils se compilent. Les rôles de verdict de gouvernance jugent l’architecture elle-même. Comme le compilateur AOT construit le graphe IR en aplatissant à la fois l’Aggregate du développeur et la Release de l’opérateur de plateforme, une politique au rôle ir-verdict évalue la réalité complète avant que les artefacts physiques ne soient générés, et une politique au rôle render-verdict évalue les artefacts eux-mêmes. Les politiques peuvent arrêter fatalement le build si un développeur demande un Component non approuvé, ou — en lisant la provenance aggrega.ai/recipe-uri apposée sur chaque objet rendu — si le Manifest associe un composant à une Recipe non approuvée.

2. La porte de mutation Wasm (conformité dynamique)

Les développeurs ne devraient pas être obligés de saisir manuellement des tags de conformité liés à l’environnement (par ex. environment: production ou soc2_in_scope: true) dans leur Aggregate, car ceux-ci changent selon la cible GitOps.

Pour les métadonnées dynamiques, les entreprises utilisent la Mutation Gate — le rôle label-transform du socket de gouvernance, qui s’exécute pendant la construction de la topologie. Une fois le graphe développé, et avant que l’analyse statique ne l’évalue, le compilateur exécute le plugin Wasm que l’entreprise a attaché. Ce plugin lit l’environnement de la Release, les étiquettes que les nœuds déclarent déjà et les valeurs que déclare l’instance de chaque nœud, et nomme les étiquettes que les nœuds du build doivent porter — ainsi les métadonnées requises atteignent le composant sans que le développeur les saisisse (par ex. l’étiquette compliance.aggrega.ai/data-class: restricted décidée à partir de l’environnement de la Release, ou datastore.aggrega.ai/engine: vector décidée à partir des extensions déclarées d’une base de données). Les valeurs sont en lecture seule : le plugin décide des étiquettes et de rien d’autre.

Une politique à ce rôle nomme l’étiquette — le nœud, la clé et la valeur qu’elle prend — au lieu d’écrire l’instruction de modification que le build applique. La raison compte pour quiconque en écrit une : l’instruction désigne une étiquette par un chemin, et une clé d’étiquette Aggrega contient couramment un /, qui est le séparateur de chemin, si bien qu’un chemin écrit à la main désignerait un emplacement imbriqué au lieu d’une seule étiquette. Le build désigne l’étiquette que la décision nomme, et la projection des nœuds que reçoit ce rôle les place un niveau moins profond qu’un verdict portant sur tout le graphe.

# Evaluated by the governance label-transform role, during topology construction
package 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"
}

Comme ces tags sont injectés en mémoire dans le dictionnaire de métadonnées standard avant le début du rendu, les plugins de rendu Wasm peuvent les lire pour générer de manière conditionnelle des configurations physiques spécifiques — des ressources AWS ou Kubernetes durcies, par exemple — au fil du rendu des artefacts.

Énoncer une règle une seule fois : les attachements de gouvernance ont la portée de l’espace de travail. Les deux modèles ci-dessus s’écrivent par composant et par Feature, mais l’attachement de gouvernance qui les impose, non. Un plugin de gouvernance est attaché à la clé plugins.governance de la configuration de l’espace de travail, et cet attachement lie chaque build de l’espace de travail. Une règle d’entreprise est donc énoncée à un seul endroit : l’équipe plateforme attache le plugin une fois, et aucun composant, Aggregate ou Release n’a à y adhérer, à le mentionner ou à être modifié pour qu’il s’applique. C’est ce qui fait du garde-fou de validation du modèle 1 une réponse complète plutôt qu’une convention propre à chaque projet — un développeur qui contourne le catalogue interne et demande un core/postgres nu est évalué par la même politique attachée que tout le monde, car la politique est une propriété de l’espace de travail et non du composant qu’il a choisi.

Une règle de l’espace de travail rejette ; elle ne réécrit pas le contrat du développeur. La portée est universelle, et l’effet est délibérément limité à un verdict. Une règle qui s’applique partout arrête un build qui l’enfreint, en indiquant ce qu’il faut corriger, et ne peut pas à la place modifier le composant fautif pour le rendre conforme. Cette limite est ce qui garde le mécanisme débogable à l’échelle de tout le parc : un build soit respecte les règles que déclare l’espace de travail, soit s’arrête avec un message qui pointe vers la ligne écrite, et la sortie rendue ne contient jamais une contrainte ou une ressource qu’aucun fichier écrit n’a demandée. Lorsqu’une entreprise veut réellement que le graphe soit modifié plutôt que jugé, elle attache un rôle de transformation — le modèle 2 ci-dessus — et cette modification se limite à ce pour quoi l’opérateur l’a attaché, c’est pourquoi elle est un acte explicite de l’équipe plateforme et non une réécriture invisible.

La conséquence pratique pour une équipe plateforme qui boucle la boucle de la conformité : exprimer la forme qu’une charge utile doit avoir sous forme de contraintes de schéma sur une base d’entreprise, exprimer les règles inter-entités qu’exige le parc sous forme de rôle de verdict attaché, et exprimer les métadonnées dérivées que le développeur ne devrait jamais saisir sous forme de rôle de transformation attaché. Les trois sont déclarés une fois et s’appliquent à chaque build, et aucun n’exige que le développeur sache qu’ils existent.

3. Préserver l’intelligence métier (les configurations et la sûreté)

Comme le compilateur Aggrega est sans parti pris, il ne possède aucune connaissance codée en dur des frameworks d’IA, des budgets de tokens ou du partitionnement de la mémoire. À la place, les schémas cloud-native génériques servent de réceptacle vide. Au lieu d’être codée en dur dans le cœur du compilateur, l’intelligence métier hautement spécialisée est répartie sur l’ensemble de l’écosystème extensible d’Aggrega. Elle est encapsulée dans le catalogue de la plateforme au moyen de components, features et recipes spécialisés. Les développeurs préservent leur intention applicative propre dans leurs blocs values et uses — strictement encadrés par les déclarations schema: de l’architecte (forme compacte ou JSON Schema 2020-12 complet) et ses sockets usesSchema — tandis que la traduction physique de cette intelligence est exécutée par des plugins WebAssembly propres à chaque cible.

A. Modéliser des implémentations propres à un domaine (validées par des schémas scindés)

Les architectes de plateforme peuvent tirer parti du pipeline de schémas scindés pour modéliser toute architecture complexe, en toute indépendance du cœur du compilateur :

  • Logique d’exécution opaque (values) : Si une entreprise déploie un AI Gateway, le développeur configure le comportement propre de la passerelle — sur la passerelle d’IA de la bibliothèque standard, la map models qui publie chaque alias qu’un appelant peut demander et l’amont vers lequel chacun se résout. Le cœur du compilateur n’analyse pas ces concepts. Ils résident en sécurité dans la charge utile opaque values, strictement validée par la déclaration schema: du composant. Le compilateur transmet simplement cette charge utile au plugin Wasm pour générer la configuration de la passerelle. Les contrôles que partagent plusieurs produits de passerelle, comme une chaîne de repli, un nombre de tentatives ou le choix entre des entrées publiant le même alias, sont des Features attachées à la passerelle plutôt que des valeurs sur celle-ci, chacune réalisée pour une passerelle dans les termes propres à cette passerelle.
  • Cartographie des dépendances topologiques (uses) : Là où un framework d’IA raccorde un agent à ses outils ou à une base de données vectorielle, ce raccordement détermine qui parle à qui, il est donc déclaré dans le pilier uses ; une liste de noms conservée dans values, comme tools_allowed de la bibliothèque standard, est une convention qui ne trace aucune arête. Le compilateur trace ces arêtes explicites telles quelles dans le graphe IR. Cela permet aux plugins de rendu Wasm en aval de générer par programme les politiques réseau et les frontières physiques nécessaires pour sécuriser les connexions, sans que le compilateur comprenne le framework d’IA sous-jacent.
  • Structures de données complexes (par ex. CoALA) : Au lieu d’être limités à une seule liste plate de cibles, les architectes déclarent dans usesSchema autant de sockets qu’une structure en requiert, chacun avec son propre sélecteur et son propre valueSchema par arête. Par exemple, pour mettre en œuvre le framework CoALA, un architecte peut déclarer semantic_memory, episodic_memory et working_memory comme des sockets distincts, de sorte que chaque stockage de mémoire soit une cible topologique distincte. Les moteurs de politiques génériques évaluent ces arêtes structurées pour imposer des garde-fous de contrôle d’accès granulaires pour chaque lobe cognitif distinct.

B. Mécanismes fondamentaux de sécurité et d’indirection

Si la charge utile est sans parti pris, le schéma générique impose des mécanismes structurels stricts qui favorisent une génération sécurisée des artefacts :

  • Le modèle attachement-et-non-valeur : la convention de la bibliothèque standard veut qu’un identifiant secret soit demandé comme attachement, jamais écrit dans un bloc values où il serait un littéral en ligne que le compilateur transporte tel quel. Un attachement d’identifiant nomme un type de Feature d’identifiant (une Feature portant l’étiquette feature.aggrega.ai/kind: secret) et utilise ses propres values pour décrire la requête adressée à un magasin de secrets. L’acheminement des identifiants est alors une liaison tardive indépendante des capacités, et le cœur du compilateur ne résout ni n’expose jamais le matériel secret — il transmet le pointeur fourni par la Recipe d’Ops. Il s’agit d’une convention que le catalogue et les schémas encouragent, et non d’une vérification du compilateur : le compilateur n’interprète pas ce que signifie une feuille values, si bien qu’un auteur qui insère le matériel en ligne l’insère en ligne. Ce que le schéma garantit effectivement, c’est que la surface d’attachement existe et qu’elle est typée.
  • Vérification abstraite de la confiance : Comme le bloc values est largement extensible, les architectes peuvent rendre obligatoires des directives abstraites comme tls_pinning ou required_signatures: 2 (pour un consensus par quorum). Le cœur du compilateur transmet tels quels ces objets validés par le schéma dans le graphe IR plat. Un plugin de rendu Wasm personnalisé peut alors lire ces valeurs pour générer des artefacts destinés à des portes d’approbation Human-in-the-Loop (HITL) au niveau matériel. Si une application tente de contourner les règles de consensus, le proxy physiquement déployé bloque l’exécution jusqu’à la réception d’une approbation par webhook.

C. Sûreté opérationnelle avancée (spec.interoperability)

Pour protéger les charges de travail fragiles contre des mutations d’infrastructure conflictuelles, le schéma générique Feature définit un contrôle d’interopérabilité :

  • spec.interoperability.conflictsWith — une liste des Features qui ne peuvent pas atteindre le même composant que celle-ci. Le compilateur arrête le build avant le rendu lorsque les attachements dont un composant finit par disposer — rassemblés depuis chaque portée qui l’atteint : le composant lui-même, un sous-système ou une frontière qui le contient, son entrée de composant dans la Release et l’expansion pilotée par les annotations — contiennent cette Feature et une Feature qu’elle nomme. C’est une comparaison entre les noms que l’auteur de la Feature a déclarés et les Features que porte le composant, sans qu’aucun sens ne soit prêté ni aux uns ni aux autres : l’incompatibilité relève du jugement de l’auteur, et le compilateur y tient le build. Une seule déclaration suffit, les noms sont comparés quelles que soient leurs versions, et deux Features attachées à des frontières sœurs qui ne partagent aucun composant ne se rencontrent jamais.

4. Gouvernance des frontières réseau (convention de refus par défaut)

Les développeurs n’écrivent pas directement les politiques réseau ; les frontières réseau requises sont cartographiées par le graphe de la représentation intermédiaire (IR) du compilateur, qui porte chaque arête topologique entre les composants déclarés dans l’Aggregate.

  • Frontières internes. Le compilateur trace le graphe IR plat et ne restreint rien lui-même : sans politique, chaque connexion que le réseau du cluster autorise reste joignable. La convention veut qu’une politique écrite pour un composant n’autorise une connexion que là où l’Aggregate déclare une arête pour elle, en plus de ce que nomme le rattachement propre de la politique, et refuse toute autre connexion dans la direction que la politique régit.
  • La réalisation de la bibliothèque standard. Le catalogue de la bibliothèque standard réalise la convention sous la forme de deux Features que l’opérateur rattache à un composant dans la Release, une pour chaque direction d’une connexion : core/caller-allowlist n’admet les connexions que depuis les composants dont les arêtes uses pointent vers lui, et core/egress-allowlist ne permet au composant de se connecter qu’aux composants vers lesquels pointent ses propres arêtes et au DNS du cluster. Sur la cible helm, chacune est réalisée par une FeatureRecipe qui écrit une NetworkPolicy Kubernetes à partir des arêtes que le compilateur lui transmet, en désignant les pods de chaque composant d’après ce que le rendu propre de ce composant a émis — les sélecteurs et les labels que portent ses charges de travail, le namespace dans lequel elles sont émises et les ports que déclarent leurs conteneurs —, de sorte qu’aucun label ni port n’est répété à la main. Chacune admet aussi les pods propres du composant et ce que la Release nomme sur le rattachement : les sources extérieures à l’Aggregate du côté entrant et, du côté sortant, des plages d’adresses pour une cible que le cluster n’exécute pas, qui ne produit aucun pod à sélectionner et n’est admise que par plage, sur n’importe quel port. Le compilateur ne peut pas inspecter le cluster, si bien que chacune arrête le build jusqu’à ce que la Release affirme que le plugin réseau du cluster applique les politiques réseau ; compose n’a pas de politique réseau, et un build qui y rattache l’une ou l’autre s’arrête.
  • Ingress public (contrôle de périmètre agnostique). L’ingress public est régi par les règles propres de l’entreprise dans un rôle de verdict de gouvernance. Une équipe de sécurité d’entreprise peut écrire une politique qui évalue le type d’ontologie cloud-native d’un nœud et rejette le build si un développeur tente de rattacher une fonctionnalité public-ingress à un nœud worker ou task. Le compilateur n’interprète pas ce que signifie « public » ; il applique la sortie booléenne de la porte de validation Wasm.

5. Estampillage de la provenance à la compilation

Le compilateur construit un enregistrement de provenance pendant la compilation, qui capture la version du compilateur et les versions de l’Aggregate, du Manifest et de la Release qu’il a compilés — et aucun horodatage, de sorte que l’enregistrement ne rompt jamais une sortie identique octet pour octet. Le renderer helm émet la version du compilateur sous la forme du label aggrega.ai/compiler-version sur les manifestes Kubernetes générés, et le renderer helm-chart sur les fichiers de template qu’une Recipe ajoute à un chart, puisqu’il copie sans modification les templates propres au chart ; les équipes de sécurité d’entreprise l’utilisent pour identifier quels artefacts rendus ont été construits par quelle version du compilateur — important lorsqu’une vulnérabilité est découverte dans une version précise du compilateur et que les artefacts concernés doivent être audités.

Le fournisseur compose appose les mêmes clés de provenance comme labels de service, le fournisseur terraform comme fichier de provenance dans chaque module qu’il assemble, et le fournisseur cloudformation sous Metadata de chaque ressource ; l’enregistrement de provenance en mémoire existe pour chaque compilation.

6. Métadonnées et annotations comme surface d’extension

Le compilateur Go est agnostique vis-à-vis des concepts propres à un domaine — frameworks d’IA, moteurs de base de données, idiomes Kubernetes — et ne travaille que sur des opérations plates au niveau du graphe sur l’IR. Pour piloter l’écosystème sans coder en dur de logique propre à un domaine dans le binaire Go, la plateforme utilise des labels et des annotations de métadonnées standard comme surface d’extension pour l’intelligence métier.

Le compilateur ne lit aucune annotation propre à un domaine. Il regroupe toutes les annotations fournies par les développeurs et les labels de duck typing dans le graphe IR plat et transmet ces métadonnées telles quelles aux plugins de gouvernance et de rendu. L’écosystème WebAssembly interprète les métadonnées et exécute la logique requise — évaluer des politiques de conformité, injecter des tags dans des artefacts cloud-native ou déclencher l’expansion de fonctionnalités — indépendamment du cœur du compilateur.

Cela garde la surface d’extensibilité large (n’importe qui peut écrire un plugin Wasm qui lit un nouveau préfixe d’annotation) tout en gardant le cœur du compilateur stable : aucune nouvelle version du cœur n’est nécessaire pour que l’écosystème ajoute une nouvelle annotation propre à un domaine.

Ce qu’une politique lit d’un rattachement

Un rôle de verdict qui évalue le graphe IR reçoit le graphe entier — chaque valeur qu’un auteur a déclarée sensible étant retenue, comme décrit ci-dessous — et cela inclut chaque rattachement que porte chaque nœud, indexé par le nom que l’auteur lui a donné — ou, pour un rattachement écrit sur l’une des connexions du nœud, par l’alias de la connexion et l’emplacement joints par un point. L’intérêt de porter le détail des rattachements plutôt qu’un résumé est qu’Aggrega n’a aucune opinion à résumer : le compilateur achemine les rattachements sans juger ce qu’ils contiennent, si bien que les faits dont une politique a besoin pour les juger sont les faits qu’une politique reçoit.

Pour chaque rattachement, le graphe porte :

  • Le type de Feature qu’il demande, et la version du catalogue résolue pour lui. Le type est la chaîne que l’auteur a écrite, telle quelle — une référence épinglée à une version et une référence nue sont des chaînes différentes pour un même référent, si bien qu’une politique qui compare des types doit s’attendre à l’une ou l’autre graphie.
  • Les labels de catalogue de la Feature rattachée, tels quels. Non filtrés, non normalisés, dans l’ordre où l’entité de catalogue les déclare. Une politique lit exactement ce que l’auteur du catalogue a écrit, y compris des labels de l’invention propre de l’auteur dont Aggrega n’a aucune connaissance.
  • Les annotations de catalogue de la Feature rattachée, telles quelles. Les metadata.annotations propres de l’entité Feature, portées exactement dans les mêmes conditions que ses labels — non filtrées, non normalisées, dans l’ordre déclaré par l’entité —, de sorte qu’une clé d’annotation dans le namespace propre d’un auteur arrive telle qu’elle a été écrite. C’est un sujet différent de l’annotation qui a fait exister en premier lieu un rattachement issu d’une expansion par annotation : le graphe signale cette origine séparément, et un rattachement écrit dans un bloc features: porte les annotations de l’entité sans signaler aucune origine d’expansion.
  • L’emplacement de rattachement déclaré qu’il remplit. Un emplacement featuresSchema est rempli en rattachant une Feature sous le nom de l’emplacement, si bien qu’un rattachement qui nomme un emplacement déclaré par son Component signale le nom de cet emplacement, et qu’un rattachement qui n’en remplit aucun signale free. Un rattachement écrit sur une connexion remplit un emplacement que déclare le socket de la connexion, et signale le nom de cet emplacement ; comme un socket n’admet aucun autre nom, il ne signale jamais free. La valeur est le nom de l’emplacement plutôt qu’un indicateur, car savoir quel point de liaison a été rempli est généralement la moitié la plus utile de la réponse.
  • La connexion sur laquelle il a été écrit, le cas échéant. Un rattachement écrit sur l’une des connexions du composant porte le socket et l’alias de cette connexion, qui nomment l’arête du graphe sur laquelle il est présenté — et, à travers cette arête, le composant auquel il est présenté. Un rattachement du bloc propre du composant n’en porte aucun. La connexion est portée sous forme de donnée plutôt que laissée à déduire du nom du rattachement, qui contient l’alias et non le socket.
  • S’il traite du matériel qu’un auteur a déclaré sensible, et lesquelles de ses clés de livraison portent ce matériel. Les deux sont dérivés de déclarations — une feuille sensitive dans le schéma d’une Feature, un emplacement sensitive sur le Component consommateur, qu’il s’agisse d’un emplacement qu’il déclare pour ses propres rattachements ou d’un emplacement sur le socket par lequel une connexion est câblée — jamais de l’inspection d’une valeur.
  • Ses values, son infra et son mappage de livraison, ainsi que le fait de savoir si le rattachement a été écrit dans un bloc features: ou apporté par une expansion pilotée par les annotations — chaque valeur qu’un auteur a déclarée sensible étant retenue, comme le décrit le paragraphe suivant.

Une politique est informée de l’endroit où se trouve le matériel déclaré sensible, et ce matériel ne lui est jamais remis. Chaque feuille que le graphe marque comme déclarée sensible — dans les values ou l’infra de n’importe quel rattachement, quels que soient la portée ou la connexion sur lesquelles il a été écrit, dans l’infra d’un rattachement de frontière, dans les values et l’infra propres d’un nœud, et dans les values et l’infra propres d’une connexion — parvient à la politique sous la forme d’un marqueur à clé unique, {"aggrega_withheld": "declared"}, à la place de la valeur. La clé subsiste, si bien qu’une politique voit toujours quelles feuilles porte une charge utile ; le marquage qui nomme ces feuilles subsiste, si bien qu’une politique voit toujours lesquelles d’entre elles portent du matériel déclaré ; et chaque fait énuméré ci-dessus arrive comme avant, avec chaque valeur qu’aucune déclaration ne marque. Aucun des faits sur lesquels une politique raisonne — ce qu’est un rattachement, ce qu’il remplit, à quoi il est présenté, ce que son entité de catalogue dit de lui et où transite son matériel secret — n’est une valeur qu’un auteur peut déclarer sensible, et le matériel lui-même est la seule chose dont une politique n’a pas besoin pour juger où il va. C’est la même rétention que celle qu’applique la ligne de commande lorsqu’elle affiche le graphe et que celle qu’applique le démon lorsqu’il répond à la demande qu’un éditeur lui en fait. Ces surfaces rendent les valeurs à une personne qui les demande explicitement ; la copie d’une politique n’offre pas une telle demande. Elle ne s’applique qu’à la copie de la politique : le graphe à partir duquel le build effectue le rendu n’est pas modifié, si bien qu’aucun octet rendu ne change.

Les labels d’un rattachement lient le compilateur en un seul endroit, et il ne s’agit pas d’une décision de politique : un emplacement peut déclarer un selector, et un remplissage dont les labels ne le satisfont pas arrête le build. Au-delà de ce contrôle, les labels n’orientent rien — la façon dont une valeur est acheminée et livrée est la même quels que soient les labels que porte une Feature. Ainsi, une politique qui lit un label lit des métadonnées que le compilateur a transportées sans les interpréter, et ne remet pas en cause une branche interne au compilateur.

Les annotations de catalogue d’une Feature ne la lient nulle part : aucun comportement du compilateur ne dépend d’elles, et un emplacement ne déclare aucune contrainte sur elles comme il peut le faire sur les labels. Elles sont transportées, et rien d’autre.

Les règles que cela permet d’écrire, dont aucune n’est établie par le compilateur à votre place :

  • Interdire le rattachement libre. Un parc qui exige que chaque rattachement remplisse un point de liaison déclaré rejette tout rattachement qui signale free. C’est la contrepartie de l’ouverture de la surface de rattachement : la composition est libre par défaut, et un opérateur qui ne la veut pas libre le dit.
  • Refuser la livraison par valeur de matériel sensible. Aggrega émet un avertissement lorsqu’une donnée déclarée sensible transite par une clé de livraison sous forme de littéral, et n’arrête jamais le build — la famille des identifiants par valeur est délibérée. Un opérateur qui veut que cet avertissement devienne un refus l’exprime ici.
  • Décider vous-même de ce qui compte comme identifiant. La bibliothèque standard marque ses Features d’identifiants avec un label de famille, et lire ce label est une façon de raisonner à leur sujet. Un prédicat plus large ou plus étroit — un label interne, une règle de nommage, un ensemble de types approuvés — est tout aussi disponible, car ce sont les labels qui arrivent et non un verdict à leur sujet.
  • Conditionner sur tout ce que votre catalogue enregistre dans ses propres métadonnées. Un parc qui conserve le statut de revue, la résidence des données ou la propriété sous forme d’annotations sur ses entités Feature peut les exiger de chaque rattachement. Une règle fondée sur une annotation dont Aggrega n’a jamais entendu parler fonctionne exactement aussi bien qu’une règle fondée sur une clé qu’il fournit, car les annotations arrivent telles qu’elles ont été écrites — ce qui signifie aussi qu’une Feature et un Component sont jugés sur le même pied, chacun d’après les métadonnées de catalogue que déclare sa propre entité.
  • Régir ce qu’un composant présente et à qui. Un identifiant écrit sur une connexion nomme cette connexion, et l’arête de la connexion nomme sa cible, si bien qu’un parc peut refuser un identifiant présenté à un composant situé hors d’une zone de confiance qu’il marque d’un label qui lui est propre — un jugement qui nécessite les deux extrémités de la connexion, ce qu’aucun fait sur le seul composant consommateur ne fournit.

Un rôle de verdict accepte ou rejette ; il ne réécrit jamais. Le build soit se poursuit sans changement, soit s’arrête avec le message du verdict, si bien qu’une politique ne peut pas rendre discrètement conforme un graphe non conforme.

Le détail des rattachements parvient à une politique qui évalue le graphe IR. Une politique qui évalue des artefacts rendus reçoit ces artefacts et aucun graphe, ce qui est une propriété de cette entrée plutôt qu’une restriction qui lui est appliquée : les deux étapes répondent à des questions différentes, et la topologie des rattachements ne fait pas partie des questions que l’on peut poser à une sortie rendue.

Exprimer les règles du parc dans un langage de politiques

Les patterns ci-dessus décrivent ce que fait un rattachement de gouvernance ; cette section porte sur ce qu’une entreprise écrit pour l’obtenir. Une équipe plateforme qui a cinquante règles à énoncer ne veut pas cinquante plugins. Elle veut ses règles sous forme de contenu — des fichiers qu’elle relit, versionne et livre comme n’importe quel autre artefact — avec un seul moteur rattaché pour les évaluer.

C’est ce que fournit un moteur de langage de politiques rattaché au socket, et deux d’entre eux sont livrés dans le compilateur précisément à cette fin : un moteur Rego et un moteur CEL. Un opérateur en rattache un, déclare les fichiers de politiques qu’il doit charger, et les règles s’exécutent : aucune chaîne d’outils externe, rien n’est récupéré au moment du build, et aucune logique de politique dans le compilateur. L’évaluation a lieu dans l’invité WebAssembly, là où réside toute l’intelligence métier.

Le même moteur sert chaque rôle de gouvernance, si bien qu’un parc couvre toute sa surface avec un seul plugin rattaché et plusieurs rattachements de celui-ci :

  • Juger l’architecture. Rattachée au graphe de build, une politique lit chaque nœud, arête et rattachement que détient le compilateur, ainsi que les chemins de routage énumérés à côté, et signale ce qui doit arrêter le build. C’est là que se trouvent un invariant de topologie, une règle d’autorisation entre frontières ou une règle de flux d’identifiants.
  • Juger la sortie. Rattachée aux artefacts rendus, une politique lit les fichiers que le build a produits — sous forme de texte, et sous forme de documents analysés là où le format a été analysé avant la politique — et rend compte du résultat concret.
  • Fournir des métadonnées dérivées. Rattachée pour façonner les labels, une politique décide quels labels portent les nœuds du build, à partir de l’environnement de la Release et de ce que les nœuds déclarent déjà. C’est le mécanisme que décrit le pattern 2 ci-dessus, la règle étant exprimée comme contenu de politique plutôt que comme un plugin construit à cet effet.
  • Ajouter une capacité que le développeur n’a pas saisie. Rattachée pour injecter des annotations, une politique ajoute des annotations aux composants du build ; une annotation sous une clé pour laquelle le Manifest enregistre une liaison s’étend en un rattachement de Feature, si bien qu’une règle d’entreprise peut fournir l’enveloppe dont un composant a besoin au lieu de simplement rejeter son absence. Une décision écrit toute valeur qu’un opérateur pourrait écrire sur cette annotation — une chaîne, ou un objet de sous-clés pour une liaison qui en achemine plusieurs — et le build la lit exactement comme il lit la même valeur écrite dans la Release. Elle ne peut qu’ajouter : une valeur qui supprimerait une annotation ou s’en retirerait est refusée, et une valeur injectée que le build ne peut pas acheminer ou que la Feature liée n’admet pas est refusée en nommant le plugin qui l’a injectée.

Une règle lit ce que porte la charge utile et rapporte sa décision sous une clé nommée :

# Evaluated by a governance verdict role over the assembled graph
package 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])
}

Une règle qui suit les données le long du graphe lit les routes que la charge utile énumère. language-reference/examples/policy-data-class-route/ en est une, de bout en bout : elle arrête un build dans lequel un composant qui détient des données d’une classe atteint un composant d’une autre classe le long d’une route sur laquelle aucune Feature de déclassification n’est rattachée, et le même Aggregate aboutit lorsqu’une Release fait passer ce trafic par une passerelle qui porte core/data-masking. Le compilateur porte le label de classe comme une chaîne et ne classe rien — les classes, leur ordre et les Features qui comptent comme déclassifiantes sont les paramètres du rattachement. La règle est écrite une fois pour chacun de trois moteurs — les deux compilés dans la CLI, et OPA derrière l’invité adaptateur de référence — chaque copie indépendamment, si bien qu’un build sur lequel deux moteurs sont en désaccord montre ce désaccord.

Le vocabulaire propre d’une politique est préservé. Les sévérités sur lesquelles agit le socket forment un ensemble fermé, mais les noms sous lesquels une politique regroupe ses décisions appartiennent à la politique. Les noms par défaut sont les noms conventionnels qu’un corpus Rego utilise déjà, et un opérateur dont les politiques nomment leurs décisions autrement déclare le mappage dans les paramètres du rattachement — si bien qu’un parc qui maintient déjà une bibliothèque de politiques adopte le socket sans la réécrire. Le mappage est typé par le schéma que le plugin déclare pour ses paramètres, si bien qu’un mappage mal formé arrête le build avant qu’aucune politique ne s’exécute, au lieu de mal acheminer un verdict.

Toute une bibliothèque de politiques voyage comme un seul rattachement. Un ensemble de politiques peut être rattaché fichier par fichier, ou comme une archive unique contenant à la fois ses fichiers de politiques et ses documents de données, que l’invité ouvre. Une archive qui ne peut pas être lue est signalée comme telle, en nommant le fichier — jamais comme un ensemble de politiques qui n’a abouti à aucune décision, car « la bibliothèque était illisible » ne doit jamais être impossible à distinguer de « la bibliothèque a autorisé le build ».

Une politique non évaluable arrête le build. Lorsqu’une politique ne peut pas être évaluée, le rattachement échoue et le build s’arrête avec une erreur qui nomme le plugin, délibérément distincte d’un verdict qui arrête le build. Les deux cas ne doivent pas être confondus, et aucun des deux n’est une autorisation.

L’ensemble de la surface de rédaction — la charge utile que chaque rôle expose, les clés de décision, le mappage vers les sévérités et la façon de rattacher une archive — se trouve dans language-reference/plugins/policy-socket.md.

Héritage et discipline de publication

L’héritage via extends: est le mécanisme de catalogue qui permet aux architectes de plateforme de construire des entités enfants spécialisées au-dessus de baselines partagées. Les deux types de catalogue se séparent sur leurs piliers de données. Les schémas parent et enfant d’une Feature se composent au chargement du workspace, produisant un schéma unifié avec une provenance par feuille. Un Component qui étend n’écrit aucun contenu de pilier : il écrit le marqueur littéral schema: inherited et reçoit le bloc schema: de sa base exactement tel que la base l’a écrit, à toute profondeur d’une chaîne.

C’est ce qui règle la question de gouvernance que soulève une baseline partagée — quelles contraintes un enfant peut déclarer par rapport à sa base. Pour un Component, la réponse est structurelle plutôt que contrôlée : le contrat déclaré de l’enfant est simplement celui de la base, si bien qu’une contrainte de la base ne peut pas être assouplie, supprimée ou retypée par un enfant, et qu’aucun contrôle au moment de la publication n’est nécessaire pour garder la baseline intacte. Un enfant qui a légitimement besoin d’une règle plus stricte que celle que déclare sa base l’exprime comme une entrée ajoutée dans son bloc assertions:, qui se compose à côté des règles de la base au lieu de les remplacer.

Ce qu’un Component enfant compose, c’est la structure : ses emplacements de rattachement (featuresSchema), ses sockets de topologie (usesSchema), sa liste d’autorisation d’auto-injection (inject) et ses assertions nommées fusionnent tous le long de la chaîne, une entrée redéclarée remplaçant purement et simplement celle de la base.

Placement des règles : quelles règles vont dans le plugin de politique et lesquelles dans le schéma par Component

Le plugin de discipline de publication est l’endroit des règles transversales qui s’appliquent à tout le catalogue : règles de chaîne d’approvisionnement (par exemple, « toute Recipe doit implements: un Component qui existe dans le catalogue »), règles de conformité d’entreprise (par exemple, « tout Component avec compliance.aggrega.ai/scope: pci-dss doit extends: la baseline pci de l’entreprise »). Ces règles touchent plusieurs entités, évaluent le workspace comme un tout ou appliquent des conventions au moment de la publication plutôt qu’au moment du build.

La déclaration schema: par Component / par Feature est l’endroit des contraintes par entité : types, plages, motifs et énumérations par champ ; règles entre champs exprimées dans le bloc assertions: dédié. Ces contraintes sont locales à une entité et voyagent avec elle à travers le catalogue.

La séparation n’est pas arbitraire. Une règle comme « tout champ obligatoire doit être présent » est une contrainte par entité qui a sa place dans les tableaux required:. Une règle comme « toute entité enfant qui étend un parent pci-dss doit déclarer un label de gouvernance au niveau du workspace » est une règle inter-entités que le plugin de politique applique. Les deux classes de règles ne se chevauchent jamais parce qu’elles répondent à des questions différentes : le schéma valide « cette instance correspond-elle à son contrat » ; le plugin de politique valide « ce catalogue satisfait-il les règles transversales que le workspace exige ».

Lors de la rédaction d’une nouvelle règle de gouvernance, la question du placement est la suivante : la règle dépend-elle uniquement du contenu d’une seule entité (→ schéma ou bloc assertions), ou dépend-elle de la relation entre plusieurs entités ou d’une configuration au niveau du workspace (→ plugin de politique). Le pattern du linter Wasm est le mécanisme canonique pour le cas transversal ; les catalogues d’entreprise peuvent distribuer des plugins de politique personnalisés qui consomment la même interface de contrat de plugin que le plugin standard de discipline de publication.

Discipline des préfixes d’annotation

L’espace de noms des annotations porte une sémantique d’origine — des préfixes différents signalent des publics différents et des autorités de gouvernance différentes. Les auteurs de catalogues, les équipes plateforme des entreprises et la plateforme Aggrega elle-même écrivent tous des annotations dans le même dictionnaire plat ; c’est le préfixe qui maintient les publics distincts.

PréfixeOriginePublicMutabilité
aggrega.ai/ (nu)Réservé : émis uniquement par le compilateur AggregaOutillage interne, marquage de provenanceNon modifiable par l’utilisateur ; les annotations à préfixe nu déclarées dans le contenu utilisateur sont rejetées au moment de la publication
<sub-domain>.aggrega.ai/ (par ex. component.aggrega.ai/, feature.aggrega.ai/, compliance.aggrega.ai/)Convention de catalogueArchitectes qui écrivent les entités du catalogue ; plugins de politique Wasm qui consomment les labelsLes éditeurs du catalogue écrivent ; les consommateurs lisent
<enterprise-domain>/ (par ex. acme.com/, my-org.io/)Surcouche d’entrepriseÉquipes plateforme des entreprises ; plugins Wasm d’entrepriseLes auteurs de l’entreprise écrivent ; le compilateur de la plateforme les ignore en tant que métadonnées opaques
<community-domain>/ (par ex. cncf.io/, kubernetes.io/)Écosystème externeOutillage inter-écosystèmes qui lit des labels bien connusGouverné par la communauté

Le préfixe nu aggrega.ai/ porte la discipline la plus stricte : il est réservé aux seules annotations émises par la plateforme. Le compilateur émet aggrega.ai/compiler-version, aggrega.ai/component-id, aggrega.ai/recipe-uri, aggrega.ai/boundary-path et les clés de provenance associées sur la sortie rendue ; le contenu utilisateur qui déclare directement une annotation aggrega.ai/<key> est rejeté au moment de la publication. Cette discipline empêche les annotations écrites par l’utilisateur d’entrer en collision avec la provenance émise par la plateforme.

Les préfixes de sous-domaine sous <sub-domain>.aggrega.ai/ constituent l’espace des conventions de catalogue. La bibliothèque standard utilise component.aggrega.ai/type (le label de l’ontologie cloud-native), feature.aggrega.ai/kind (la partition des Feature entre opérationnelles et d’identifiants), compliance.aggrega.ai/* (les labels de l’axe de conformité) et des sous-espaces de noms délimités similaires. Chaque sous-domaine est gouverné par un public précis du catalogue : component.aggrega.ai/* par les auteurs des entités Component, feature.aggrega.ai/* par les auteurs des entités Feature, compliance.aggrega.ai/* par le public des politiques de conformité. Les lectures entre sous-domaines (un plugin Wasm qui lit plusieurs sous-espaces de noms) sont permises mais rares ; chaque plugin se limite généralement à un seul sous-espace de noms.

Les préfixes de domaine d’entreprise (acme.com/..., my-org.io/...) constituent la surface d’extension de la plateforme. Le compilateur Aggrega les traite comme des métadonnées opaques ; les plugins Wasm d’entreprise les consomment. Les entreprises écrivent la structure de préfixes qui convient à leur gouvernance — plate (acme.com/owner: team-payments), en sous-domaine (security.acme.com/scope: pii) ou hiérarchique (org.acme.com/billing-center: finance). La plateforme ne contraint pas l’organisation des préfixes d’entreprise ; la seule règle est que les préfixes d’entreprise n’entrent pas en collision avec aggrega.ai/ ou ses sous-domaines.

Cette discipline compte parce que les annotations se propagent en cascade — les annotations écrites sur le sous-système d’un Aggregate se propagent à chaque composant du sous-système, les annotations propres d’une instance de composant l’emportent sur celles de son sous-système, et les annotations d’un module atteignent les composants propres du module ; les annotations sur une frontière d’une Release se propagent à chaque composant de la frontière. Une annotation de fournisseur atteint la sortie rendue depuis l’un ou l’autre côté, et là où les deux écrivent la même clé, c’est la valeur de la Release qui s’applique. Sans discipline des préfixes, une annotation côté Aggregate pourrait écraser silencieusement une clé de provenance émise par la plateforme, ou une annotation d’entreprise pourrait entrer en collision avec une clé de convention de catalogue. Le tableau des préfixes rend les publics explicites et rend la règle de prévention des collisions applicable au moment de la publication.

Consultez language-reference/vocabulary/labels-and-annotations.md pour l’énumération des surfaces d’annotation par entité et la sémantique de cascade à trois compartiments (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).