Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Instradamento tra confini

Questa pagina spiega un’idea, la riscrittura dell’indirizzo che un componente riceve quando ciò a cui si connette è in esecuzione altrove, e non è un workspace eseguibile. Rete tra confini la mostra in un workspace di cui esegui il build; scrivilo in una cartella tua con:

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

Poi stampa i prossimi comandi da eseguire:

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

Quando due componenti sono collocati in confini diversi, l’host che la destinazione pubblica è una stringa che il build non può interpretare: non può stabilire se la stringa sia raggiungibile dall’altro lato. L’instradamento tra confini è quindi una Feature associata al chiamante, che dice quale variabile iniettata deve essere riscritta, e una FeatureRecipe per ciascun provider, che dice come riscriverla. I pezzi di cui è composto hanno pagine proprie: injectMapping in entities/featurerecipe.md, le annotazioni di confine in entities/release.md, e il contratto provides / inject / uses in vocabulary/topology-triad.md.

L’operatore associa la Feature al chiamante

Nella variante Kubernetes dell’esempio, Adminer e il suo database si trovano in due confini, ciascuno in un namespace proprio, e Adminer riceve l’indirizzo del database in ADMINER_DEFAULT_SERVER. L’operatore associa ad Adminer, nella Release, il core/k8s-dns-resolver della libreria standard e nomina quella variabile; l’Aggregate non cambia. Dal release-helm.yaml, con i commenti omessi:

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 riscrive la variabile prima che il chiamante venga renderizzato

Il Manifest collega la Feature a helm/k8s-dns-resolver. Il suo injectMapping viene eseguito dopo che le variabili consegnate da ciascuna connessione sono al loro posto e prima che la Recipe propria del chiamante esegua il rendering: legge la variabile, trova la connessione che l’ha consegnata, legge il namespace della destinazione dalle annotazioni di quella connessione, e riscrive la variabile qualificata con il namespace, default quando la destinazione non ne dichiara alcuno:

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

Così il database pubblica il suo semplice nome di servizio, e Adminer lo riceve come db-default.backend. Viene riscritta solo la variabile del chiamante: l’host pubblicato dalla destinazione resta invariato, e un chiamante nel namespace stesso della destinazione la raggiunge ancora con il nome semplice. Un target_var che non corrisponde ad alcuna connessione non inietta nulla. La variante Docker Compose dell’esempio attraversa la stessa giunzione in un altro modo, con il core/compose-bridge della libreria standard.

Un passo di pipeline, dal lato del plugin

Un injectMapping è un template che il build valuta da sé. Una FeatureRecipe o una Recipe può anche dichiarare una pipeline: di passi, ciascuno eseguito da un plugin WebAssembly dopo il rendering. Un passo riceve il proprio input with:, già elaborato come template rispetto al contesto dell’associazione, e l’insieme indicizzato per chiave dei documenti renderizzati; restituisce patch RFC 6902 su quei documenti, le eventuali risorse che aggiunge come effetti collaterali, diagnostiche nella forma condivisa in cui riporta ogni socket, e output che un passo successivo può leggere. Entrambe le direzioni viaggiano nella codifica binaria canonica; il contratto dei plugin Wasm è la forma esatta di ciascuna, e Quando ricorrere a un passo di pipeline dice quando un passo è lo strumento giusto.