Ir al contenido
AggregaAggrega
Seleccionar idioma: Español
Esta página se tradujo automáticamente. Lee el original en inglés.

Enrutamiento entre límites

Esta página explica una idea, la reescritura de la dirección que recibe un componente cuando aquello a lo que se conecta se ejecuta en otro lugar, y no es un workspace ejecutable. Redes entre límites la muestra en un workspace que compilas; escríbelo en una carpeta propia con:

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

Después imprime los comandos que hay que ejecutar a continuación:

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

Cuando dos componentes se colocan en límites distintos, el host que publica el destino es una cadena que la compilación no puede interpretar: no puede saber si la cadena es alcanzable desde el otro lado. Por eso el enrutamiento entre límites es una Feature vinculada al llamante, que indica qué variable inyectada necesita reescribirse, y una FeatureRecipe para cada proveedor, que indica cómo reescribirla. Las piezas con las que se construye tienen páginas propias: injectMapping en entities/featurerecipe.md, las anotaciones de límite en entities/release.md, y el contrato provides / inject / uses en vocabulary/topology-triad.md.

El operador vincula la Feature al llamante

En la variante Kubernetes del ejemplo, Adminer y su base de datos están en dos límites, cada uno en un namespace propio, y Adminer recibe la dirección de la base de datos en ADMINER_DEFAULT_SERVER. El operador vincula el core/k8s-dns-resolver de la biblioteca estándar a Adminer en la Release y nombra esa variable; el Aggregate no cambia. De release-helm.yaml, sin los comentarios:

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 reescribe la variable antes de que se renderice el llamante

El Manifest asocia la Feature a helm/k8s-dns-resolver. Su injectMapping se ejecuta después de que las variables que entrega cada conexión estén en su lugar y antes de que se renderice la Recipe propia del llamante: lee la variable, encuentra la conexión que la entregó, lee el namespace del destino en las anotaciones de esa conexión y vuelve a escribir la variable calificada con el namespace, default cuando el destino no declara ninguno:

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

Así, la base de datos publica su nombre de servicio sin calificar, y Adminer lo recibe como db-default.backend. Solo se reescribe la variable del llamante: el host publicado del destino no cambia, y un llamante en el propio namespace del destino sigue alcanzándolo por el nombre sin calificar. Un target_var que no coincide con ninguna conexión no inyecta nada. La variante Docker Compose del ejemplo cruza la misma juntura de otra manera, con el core/compose-bridge de la biblioteca estándar.

Un paso de pipeline, desde el lado del plugin

Un injectMapping es una plantilla que la compilación evalúa por sí misma. Una FeatureRecipe o una Recipe también puede declarar un pipeline: de pasos, cada uno ejecutado por un plugin de WebAssembly después del renderizado. Un paso recibe su entrada with:, ya evaluada como plantilla contra el contexto de la vinculación, y el conjunto indexado por clave de los documentos renderizados; devuelve parches RFC 6902 contra esos documentos, los recursos que añade como efectos secundarios, diagnósticos en la forma compartida en la que informa cada socket, y salidas que un paso posterior puede leer. Ambas direcciones viajan en la codificación binaria canónica; el contrato de plugins Wasm es la forma exacta de cada una, y Cuándo recurrir a un paso de pipeline indica cuándo un paso es la herramienta adecuada.