Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Portugal)
Esta página foi traduzida automaticamente. Ler o original em inglês.

Encaminhamento entre fronteiras

Esta página explica uma ideia, a reescrita do endereço que um componente recebe quando aquilo a que se liga é executado noutro local, e não é um workspace executável. Rede entre fronteiras mostra-a num workspace que se compila; pode escrevê-lo numa pasta própria com:

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

Depois, imprime os próximos comandos a executar:

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 dois componentes são colocados em fronteiras diferentes, o host que o destino publica é uma cadeia de carateres que a compilação não consegue interpretar: não consegue saber se a cadeia é alcançável a partir do outro lado. O encaminhamento entre fronteiras é, por isso, uma Feature anexada a quem chama, que indica que variável injetada tem de ser reescrita, e uma FeatureRecipe para cada fornecedor, que indica como reescrevê-la. As peças de que é feito têm páginas próprias: injectMapping em entities/featurerecipe.md, as anotações de fronteira em entities/release.md, e o contrato provides / inject / uses em vocabulary/topology-triad.md.

O operador anexa a Feature a quem chama

Na variante Kubernetes do exemplo, o Adminer e a sua base de dados ficam em duas fronteiras, cada uma num namespace próprio, e o Adminer recebe o endereço da base de dados em ADMINER_DEFAULT_SERVER. O operador anexa o core/k8s-dns-resolver da biblioteca padrão ao Adminer na Release e nomeia essa variável; o Aggregate não muda. De release-helm.yaml, sem os comentários:

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"

A FeatureRecipe reescreve a variável antes de quem chama ser renderizado

O Manifest associa a Feature a helm/k8s-dns-resolver. O seu injectMapping é executado depois de as variáveis que cada ligação entrega estarem no lugar e antes de a Recipe própria de quem chama renderizar: lê a variável, encontra a ligação que a entregou, lê o namespace do destino nas anotações dessa ligação e volta a escrever a variável qualificada com o namespace, default quando o destino não declara nenhum:

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

Assim, a base de dados publica o seu nome de serviço simples, e o Adminer recebe-o como db-default.backend. Só a variável de quem chama é reescrita: o host publicado do destino mantém-se inalterado, e quem chama a partir do próprio namespace do destino continua a alcançá-lo pelo nome simples. Um target_var que não corresponde a nenhuma ligação não injeta nada. A variante Docker Compose do exemplo atravessa a mesma junção de outra forma, com o core/compose-bridge da biblioteca padrão.

Um passo de pipeline, do lado do plugin

Um injectMapping é um template que a própria compilação avalia. Uma FeatureRecipe ou uma Recipe também pode declarar um pipeline: de passos, cada um executado por um plugin WebAssembly após a renderização. Um passo recebe a sua entrada with:, já processada como template em relação ao contexto do anexo, e o conjunto indexado por chave dos documentos renderizados; devolve patches RFC 6902 sobre esses documentos, os recursos que acrescenta como efeitos secundários, diagnósticos no formato partilhado em que todos os sockets reportam, e saídas que um passo posterior pode ler. Ambos os sentidos circulam na codificação binária canónica; o contrato dos plugins Wasm é o formato exato de cada um, e Quando recorrer a um passo de pipeline indica quando um passo é a ferramenta certa.