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

Features et politiques

Cette page explique une seule idée, rattacher un comportement à un composant et vérifier le résultat avec une politique, et ne constitue pas un espace de travail exécutable. Une politique qui arrête un build lorsque des données restreintes atteignent un modèle géré sans être masquées montre les deux dans un espace de travail que vous construisez ; écrivez-le dans un dossier à vous avec :

Terminal window
aggrega scaffold --example policy-data-class-route

Elle affiche ensuite les prochaines commandes à exécuter :

Terminal window
cd policy-data-class-route
aggrega build --release release-masked.yaml --config governance-rego.yaml --auto-pull
aggrega build --release release-unmasked.yaml --config governance-rego.yaml --auto-pull # halts; exits 1
aggrega build --release release-masking-off-route.yaml --config governance-rego.yaml --auto-pull # halts; exits 1

Une Feature est rattachée, et réalisée par une FeatureRecipe

Une Feature est un comportement qu’un composant ne porte pas de lui-même — un masquage, une sauvegarde, un ingress, un identifiant — et qu’un auteur lui rattache sous features:. Qui la rattache découle de qui décide de ses entrées : le développeur rattache, dans l’Aggregate, une Feature dont le comportement fait partie de ce qu’est l’application ; l’opérateur rattache, dans la Release, une Feature dont les entrées sont toutes opérationnelles. Dans les deux cas, le Manifest lie chaque Feature à une FeatureRecipe, qui décide comment elle est réalisée pour la cible.

Dans l’exemple, le développeur rattache la core/data-masking de la bibliothèque standard à une passerelle d’IA et liste ce qu’il faut masquer, à partir de aggregate.yaml sans ses commentaires :

masking-gateway:
type: core/gateway/litellm
values:
model: chat
features:
masking:
type: core/data-masking
values:
patterns:
- name: claim_number
regex: '\bCLM-[0-9]{8}\b'
entities: [PERSON, EMAIL_ADDRESS]

Le développeur ne nomme aucune adresse, aucun garde-fou ni aucun paramètre de fournisseur. Le Manifest lie core/data-masking à helm/data-masking-litellm, qui écrit le masquage dans la configuration que produit la propre Recipe de la passerelle, au moyen d’étapes du pipeline de plugins qui clôt le rendu, et ajoute à côté un module que la passerelle charge. Tous les autres fichiers que la compilation écrit sont identiques octet pour octet à ceux d’une compilation sans l’attachement.

Ce que le rattachement ne fait pas est énoncé avec autant de soin que ce qu’il fait : le texte auquel aucun motif ne correspond et que l’outil de reconnaissance ne détecte pas passe inchangé, la passerelle et les deux services de reconnaissance voient le texte original, et le trafic qui ne passe pas par la passerelle n’est pas touché. Les commentaires de la FeatureRecipe listent ce que cette passerelle refuse et ce qu’elle transmet tel qu’il a été envoyé.

Les étiquettes décident où une Feature peut aller

Les étiquettes sont l’identité sémantique d’un composant, et elles pilotent le placement d’une Feature, les sélecteurs de sockets et les politiques sans aucune modification du compilateur. Le champ appliesTo d’une Feature est un sélecteur d’étiquettes portant sur le composant auquel elle est rattachée. core/data-masking déclare appliesTo: "dataplane.aggrega.ai/content-masking", une clé seule, qui correspond à tout composant portant cette étiquette, quelle que soit sa valeur ; core/gateway/litellm la porte, avec la valeur entity-recognition. Un sélecteur peut aussi correspondre à des valeurs, component.aggrega.ai/type in (server, worker), ou exclure une étiquette, !model.aggrega.ai/capability ; les exigences d’un même sélecteur, séparées par des virgules, doivent toutes être satisfaites, et la Feature ne se rattache qu’à un composant auquel elles correspondent. Rattachement par étiquettes donne la grammaire complète des sélecteurs.

Deux autres déclarations contraignent les rattachements :

  • Interopérabilité. Une Feature peut nommer des Features avec lesquelles elle ne peut pas partager un composant. core/data-masking déclare interoperability.conflictsWith: [core/semantic-caching], de sorte qu’un build dans lequel un composant finit par porter les deux — rattachées au composant lui-même, ou à un sous-système ou à une frontière qui le contient — s’arrête avant le rendu.
  • Obligations de présence. Un Component peut exiger qu’un rattachement d’un type donné soit présent. Le example/compute/service du catalogue porte l’annotation features.aggrega.ai/requiredType.monitoring: core/prometheus-exporter, de sorte qu’un build dans lequel une de ses instances ne porte aucune core/prometheus-exporter, à quelque niveau que ce soit, s’arrête en nommant l’exigence monitoring. Répétez la clé avec un autre suffixe pour exiger un second type ; voir entities/component.md « Presence mandates (Obligations de présence) » pour la différence entre une obligation et un emplacement de rattachement.

Une Feature se place sur le composant dont elle modifie le comportement. core/caller-allowlist est rattachée à un serveur de modèles, et non aux passerelles autorisées à l’appeler ; Un serveur de modèles que seule sa passerelle peut appeler le construit.

Une politique lit le graphe construit

Les politiques sont rattachées par l’opérateur sous plugins.governance dans la configuration de l’espace de travail, chaque rattachement dans un rôle. Une politique au rôle label-transform ajoute des étiquettes au graphe ; une politique au rôle ir-verdict le juge et peut arrêter le build. Le moteur Rego exécute les deux ; il est compilé dans la CLI, et governance/rego est son entité Plugin dans le catalogue de la bibliothèque standard.

La première règle ci-dessous étiquette chaque passerelle qui analyse la charge utile de modèle qu’elle transmet comme un point où les prompts partent vers un fournisseur de modèles. À ce rôle, les nœuds se trouvent dans input.graph.nodes :

# policies/egress-tagging.rego: attached at the label-transform role
package aggrega.tagging
import rego.v1
labels contains {"node": id, "key": "compliance.aggrega.ai/egress", "value": "model-provider"} if {
some id, node in input.graph.nodes
node.labels["gateway.aggrega.ai/intelligence"] == "semantic"
}

La seconde arrête tout chemin passant par une telle passerelle qui ne porte aucun masquage :

# policies/model-egress.rego: attached at the ir-verdict role
package aggrega.security
import rego.v1
deny contains msg if {
some path in input.precalculated_paths
some egress in path.nodes
input.graph.spec.nodes[egress].labels["compliance.aggrega.ai/egress"] == "model-provider"
not "core/data-masking" in path.attached_features
msg := sprintf(
"BLOCKED: path %v sends model traffic through %v without core/data-masking attached.",
[concat(" -> ", path.nodes), egress]
)
}

L’id d’un nœud est la clé sous laquelle il se trouve dans input.graph.spec.nodes ; attached_features liste les types de Feature rattachés à n’importe quel nœud du chemin, donc l’appartenance se teste avec in ; la règle vérifie que le masquage est rattaché, et non ce qu’il liste ; et une décision collectée sous deny est signalée avec la sévérité halt, qui arrête le build. Une règle portant sur des chemins ne voit un nœud que là où une arête l’atteint ou le quitte, donc une politique qui doit aussi couvrir un nœud non connecté lit les nœuds eux-mêmes.

L’opérateur rattache le moteur une fois par rôle, chaque rattachement avec son propre fichier de politique ; un chemin relatif sous sources se résout par rapport au répertoire du fichier de configuration, et la transformation s’exécute avant le verdict :

.aggrega-config.yaml
plugins:
governance:
- uri: governance/rego:0.9.0
role: label-transform
with:
sources:
- policies/egress-tagging.rego
- uri: governance/rego:0.9.0
role: ir-verdict
with:
sources:
- policies/model-egress.rego

La page du socket de gouvernance est la surface de rédaction complète : la charge utile que chaque rôle expose, les clés de décision et la façon de nommer les vôtres. L’exemple Politiques qui façonnent les étiquettes rattache une politique qui façonne les étiquettes à côté des deux plugins d’étiquetage intégrés, et en effectue le build.