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

Routage entre frontières

Cette page explique une idée, la réécriture de l’adresse qu’un composant reçoit lorsque ce à quoi il se connecte s’exécute ailleurs, et n’est pas un workspace exécutable. Réseau entre frontières la montre dans un workspace dont vous effectuez le build ; écrivez-le dans un dossier à vous avec :

Terminal window
aggrega scaffold --example cross-boundary-networking

Elle affiche ensuite les prochaines commandes à exécuter :

Terminal window
cd cross-boundary-networking
aggrega pull --release release-compose.yaml --catalog catalog-compose
aggrega build --release release-compose.yaml --catalog catalog-compose
aggrega pull --release release-helm.yaml --catalog catalog-helm
aggrega build --release release-helm.yaml --catalog catalog-helm

Lorsque deux composants sont placés dans des frontières différentes, le host que publie la cible est une chaîne que le build ne peut pas interpréter : il ne peut pas savoir si la chaîne est joignable depuis l’autre côté. Le routage entre frontières est donc une Feature rattachée à l’appelant, qui indique quelle variable injectée doit être réécrite, et une FeatureRecipe pour chaque fournisseur, qui indique comment la réécrire. Les éléments qui le composent ont leurs propres pages : injectMapping dans entities/featurerecipe.md, les annotations de frontière dans entities/release.md, et le contrat provides / inject / uses dans vocabulary/topology-triad.md.

L’opérateur rattache la Feature à l’appelant

Dans la variante Kubernetes de l’exemple, Adminer et sa base de données se trouvent dans deux frontières, chacune dans son propre namespace, et Adminer reçoit l’adresse de la base de données dans ADMINER_DEFAULT_SERVER. L’opérateur rattache le core/k8s-dns-resolver de la bibliothèque standard à Adminer dans la Release et nomme cette variable ; l’Aggregate ne change pas. Extrait de release-helm.yaml, sans les commentaires :

spec:
boundaries:
frontend:
directory: frontend
annotations:
aggrega.ai/namespace: "frontend"
components:
adminer:
features:
dns-resolver:
type: core/k8s-dns-resolver:1.0.0
infra:
target_var: ADMINER_DEFAULT_SERVER
backend:
directory: backend
annotations:
aggrega.ai/namespace: "backend"

La FeatureRecipe réécrit la variable avant le rendu de l’appelant

Le Manifest lie la Feature à helm/k8s-dns-resolver. Son injectMapping s’exécute une fois en place les variables que livre chaque connexion, et avant que la Recipe propre de l’appelant n’effectue le rendu : il lit la variable, trouve la connexion qui l’a livrée, lit le namespace de la cible dans les annotations de cette connexion, et réécrit la variable qualifiée par le namespace, default lorsque la cible n’en déclare aucun :

spec:
capability: helm
implements: core/k8s-dns-resolver:1.0.0
injectMapping: |
{{- $base_host := optional .context.inject.env .infra.target_var "" }}
{{- $target_edge := dict }}
{{- range $alias, $edge := .context.uses }}
{{- if hasKey $edge.inject.env $.infra.target_var }}
{{- $target_edge = $edge }}
{{- end }}
{{- end }}
{{- $ns := "default" }}
{{- if $target_edge.annotations }}
{{- $raw := optional (optional (default dict $target_edge.annotations) "release" dict) "aggrega.ai/namespace" (optional (optional (default dict $target_edge.annotations) "aggregate" dict) "aggrega.ai/namespace" "") }}
{{- if $raw }}{{- $ns = $raw }}{{- end }}
{{- end }}
{{- if and $target_edge $base_host }}
env:
"{{ .infra.target_var }}": "{{ $base_host | replace "\\" "\\\\" | replace "\"" "\\\"" }}.{{ $ns }}"
{{- end }}

La base de données publie donc son simple nom de service, et Adminer le reçoit sous la forme db-default.backend. Seule la variable de l’appelant est réécrite : le host publié par la cible est inchangé, et un appelant situé dans le namespace propre de la cible l’atteint toujours par le simple nom. Un target_var qui ne correspond à aucune connexion n’injecte rien. La variante Docker Compose de l’exemple franchit la même jointure d’une autre manière, avec le core/compose-bridge de la bibliothèque standard.

Une étape de pipeline, du côté du plugin

Un injectMapping est un template que le build évalue lui-même. Une FeatureRecipe ou une Recipe peut aussi déclarer un pipeline: d’étapes, chacune exécutée par un plugin WebAssembly après le rendu. Une étape reçoit son entrée with:, déjà évaluée comme template sur le contexte du rattachement, et l’ensemble indexé par clé des documents rendus ; elle renvoie des patchs RFC 6902 sur ces documents, les éventuelles ressources qu’elle ajoute comme effets de bord, des diagnostics dans la forme commune dans laquelle chaque socket rend compte, et des sorties qu’une étape ultérieure peut lire. Les deux sens transitent dans l’encodage binaire canonique ; le contrat des plugins Wasm est la forme exacte de chacun, et Quand recourir à une étape de pipeline indique quand une étape est le bon outil.