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

Roteamento entre fronteiras

Esta página explica uma ideia, a reescrita do endereço que um componente recebe quando aquilo a que ele se conecta é executado em outro lugar, e não é um workspace executável. Rede entre fronteiras a mostra em um workspace que você compila; escreva-o em uma pasta sua com:

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

Em seguida ele 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 string que o build não consegue interpretar: ele não consegue saber se a string é alcançável a partir do outro lado. O roteamento entre fronteiras é, portanto, uma Feature vinculada a quem chama, que diz qual variável injetada precisa ser reescrita, e uma FeatureRecipe para cada provedor, que diz como reescrevê-la. As peças de que ele é 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 vincula a Feature a quem chama

Na variante Kubernetes do exemplo, o Adminer e seu banco de dados ficam em duas fronteiras, cada uma em um namespace próprio, e o Adminer recebe o endereço do banco de dados em ADMINER_DEFAULT_SERVER. O operador vincula o core/k8s-dns-resolver da biblioteca padrão ao Adminer na Release e nomeia essa variável; o Aggregate não muda. Do 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. Seu injectMapping é executado depois que as variáveis que cada conexão entrega estão no lugar e antes que a Recipe própria de quem chama renderize: ele lê a variável, encontra a conexão que a entregou, lê o namespace do destino nas anotações dessa conexão e escreve a variável de volta 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, o banco de dados publica seu nome de serviço simples, e o Adminer o recebe como db-default.backend. Somente a variável de quem chama é reescrita: o host publicado do destino não muda, e quem chama a partir do próprio namespace do destino ainda o alcança pelo nome simples. Um target_var que não corresponde a nenhuma conexã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.

Uma etapa de pipeline, do lado do plugin

Um injectMapping é um template que o próprio build avalia. Uma FeatureRecipe ou uma Recipe também pode declarar um pipeline: de etapas, cada uma executada por um plugin WebAssembly após a renderização. Uma etapa recebe sua entrada with:, já processada como template em relação ao contexto da vinculação, e o conjunto indexado por chave dos documentos renderizados; ela retorna patches RFC 6902 sobre esses documentos, os recursos que adiciona como efeitos colaterais, diagnósticos no formato compartilhado em que todo socket reporta, e saídas que uma etapa posterior pode ler. As duas direções trafegam na codificação binária canônica; o contrato de plugins Wasm é o formato exato de cada uma, e Quando recorrer a uma etapa de pipeline diz quando uma etapa é a ferramenta certa.