Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Boundary-übergreifendes Routing

Diese Seite erklärt eine Idee, das Umschreiben der Adresse, die eine Komponente erhält, wenn das, womit sie sich verbindet, anderswo läuft, und ist kein ausführbarer Workspace. Boundary-übergreifende Vernetzung zeigt sie in einem Workspace, den Sie bauen; schreiben Sie ihn in einen eigenen Ordner mit:

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

Danach gibt er die als Nächstes auszuführenden Befehle aus:

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

Wenn zwei Komponenten in unterschiedlichen Boundaries platziert sind, ist der host, den das Ziel veröffentlicht, eine Zeichenkette, die der Build nicht interpretieren kann: Er kann nicht erkennen, ob die Zeichenkette von der anderen Seite aus erreichbar ist. Boundary-übergreifendes Routing ist daher ein an den Aufrufer angebundenes Feature, das angibt, welche injizierte Variable umgeschrieben werden muss, und ein FeatureRecipe je Provider, das angibt, wie sie umzuschreiben ist. Die Bausteine, aus denen es besteht, haben eigene Seiten: injectMapping in entities/featurerecipe.md, Boundary-Annotationen in entities/release.md und der Vertrag aus provides / inject / uses in vocabulary/topology-triad.md.

Der Operator bindet das Feature an den Aufrufer an

In der Kubernetes-Variante des Beispiels liegen Adminer und seine Datenbank in zwei Boundaries, jede in einem eigenen Namespace, und Adminer erhält die Adresse der Datenbank in ADMINER_DEFAULT_SERVER. Der Operator bindet core/k8s-dns-resolver aus der Standardbibliothek im Release an Adminer an und nennt diese Variable; das Aggregate ändert sich nicht. Aus release-helm.yaml, ohne Kommentare:

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"

Das FeatureRecipe schreibt die Variable um, bevor der Aufrufer gerendert wird

Das Manifest bindet das Feature an helm/k8s-dns-resolver. Sein injectMapping läuft, nachdem die Variablen, die jede Verbindung liefert, an ihrem Platz sind, und bevor das eigene Recipe des Aufrufers rendert: Es liest die Variable, findet die Verbindung, die sie geliefert hat, liest den Namespace des Ziels aus den Annotationen dieser Verbindung und schreibt die Variable mit dem Namespace qualifiziert zurück, default, wenn das Ziel keinen deklariert:

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 }}

Die Datenbank veröffentlicht also ihren bloßen Servicenamen, und Adminer erhält ihn als db-default.backend. Nur die Variable des Aufrufers wird umgeschrieben: Der veröffentlichte host des Ziels bleibt unverändert, und ein Aufrufer im eigenen Namespace des Ziels erreicht es weiterhin über den bloßen Namen. Ein target_var, das zu keiner Verbindung passt, injiziert nichts. Die Variante des Beispiels für Docker Compose überquert dieselbe Nahtstelle auf andere Weise, mit core/compose-bridge aus der Standardbibliothek.

Ein Pipeline-Schritt, von der Plugin-Seite aus gesehen

Ein injectMapping ist ein Template, das der Build selbst auswertet. Ein FeatureRecipe oder ein Recipe kann außerdem eine pipeline: aus Schritten deklarieren, die jeweils nach dem Rendern von einem WebAssembly-Plugin ausgeführt werden. Ein Schritt erhält seine with:-Eingabe, bereits gegen den Kontext der Anbindung als Template ausgewertet, und die nach Schlüsseln adressierte Menge der gerenderten Dokumente; er gibt RFC-6902-Patches gegen diese Dokumente zurück, alle Ressourcen, die er als Nebeneffekte hinzufügt, Diagnosen in der gemeinsamen Form, in der jeder Socket berichtet, und Ausgaben, die ein späterer Schritt lesen kann. Beide Richtungen werden in der kanonischen Binärkodierung übertragen; der Wasm-Plugin-Vertrag ist die genaue Form beider, und Wann man zu einem Pipeline-Schritt greift sagt, wann ein Schritt das richtige Werkzeug ist.