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

Tipos de entrada da Recipe

Esta página explica uma ideia, as três entradas a partir das quais uma Recipe renderiza e como se somam, e não é um espaço de trabalho executável. MariaDB + Adminer — um exemplo executável com dois destinos realiza um componente com uma Recipe sintetizada, um chart obtido e artefactos ao lado deles; pode escrevê-lo numa pasta própria com:

Terminal window
aggrega scaffold --example mariadb-adminer

Depois, imprime os próximos comandos a executar:

Terminal window
cd mariadb-adminer
aggrega pull --release release-compose.yaml
aggrega build --release release-compose.yaml

Uma Recipe tem três entradas e usa qualquer combinação delas:

  • um Workload (workload:), a descrição própria da compilação de contentores, portas, volumes e serviços, que o fornecedor sintetiza nos recursos do destino — um Deployment e um Service no Kubernetes, um serviço no Docker Compose;
  • uma origem (source:), um chart, um módulo ou um template que o fornecedor renderiza, alimentada pelo valuesMapping da Recipe;
  • artefactos (artifacts:), ficheiros que a Recipe escreve tal como estão, após o processamento de templates, ao lado do que os outros dois produzem.

A forma como os três se compõem é exposta em Composição das entradas da Recipe; a superfície própria do Workload é entities/workload.md, e o contexto que todos os templates leem — .values, .infra, .context, .locals, .features — é vocabulary/data-pillars.md.

As Recipes abaixo implementam um Component que o espaço de trabalho declara para si próprio, local/compute/api-server, com um image e um port entre os seus values, replicas entre o seu infra, e host, port e protocol entre o que publica.

Um Workload sozinho

Sem source: e sem artifacts:, o Workload determina toda a saída:

kind: Recipe
metadata:
name: api-server-helm
spec:
capability: helm
implements: local/compute/api-server:1.0.0
locals:
port: "{{ optional .values `port` 8080 }}"
provides:
host: "{{ .context.rendered_name }}-http"
port: "{{ .locals.port }}"
protocol: http
workload: |
apiVersion: aggrega.ai/v1beta1
kind: Workload
replicas: {{ optional .infra `replicas` 1 }}
containers:
main:
image: "{{ .values.image }}"
variables:
{{- range $k, $v := .context.inject.env }}
{{ $k }}: "{{ $v }}"
{{- end }}
ports:
web: {{ .locals.port }}
services:
http:
type: ClusterIP
ports:
web: {{ .locals.port }}

Para um componente chamado api, o fornecedor helm escreve um Deployment e um Service ClusterIP. As variáveis que as ligações entregam chegam a .context.inject.env e são escritas no contentor.

Um Workload e artefactos

Os artefactos acrescentam ficheiros a que o Workload faz referência. Um Workload com um segundo contentor que monta um ConfigMap, e o ConfigMap como artefacto:

spec:
locals:
proxy_cm: "proxy-config"
workload: |
apiVersion: aggrega.ai/v1beta1
kind: Workload
containers:
main:
image: "{{ .values.image }}"
ports:
web: 8080
proxy:
image: envoyproxy/envoy:v1.28
volumeMounts:
- name: proxy-config
path: /etc/envoy
readonly: true
volumes:
proxy-config:
configmap:
source: "{{ .context.rendered_name }}-{{ .locals.proxy_cm }}"
artifacts:
proxy-config.yaml: |
apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .context.rendered_name }}-{{ .locals.proxy_cm }}
data:
listen-port: "{{ .workload.containers.main.ports.web.port }}"

Um artefacto lê o Workload em .workload em vez de repetir os seus valores: uma porta de contentor chega-lhe como um objeto que contém o seu número em port, seja qual for a forma em que o Workload a escreveu. O ConfigMap recebe o nome de .context.rendered_name, o nome que o fornecedor helm dá aos recursos do componente, seguido de um sufixo que um local transporta; um local não pode ler o nome renderizado, pelo que o volume e o artefacto juntam cada um as duas partes, e o nome que o volume monta é o nome que o artefacto escreve.

Uma origem e artefactos

Uma Recipe pode renderizar um chart obtido e acrescentar ficheiros próprios ao lado dele. Aqui, core/datastore/mariadb do catálogo é realizado pelo chart de um fabricante, e um artefacto acrescenta um ServiceMonitor do Prometheus:

kind: Recipe
metadata:
name: mariadb-with-monitor
spec:
capability: helm
implements: core/datastore/mariadb:1.0.0
provides:
host: "{{ .context.rendered_name }}"
port: "{{ .infra.port }}"
protocol: mariadb
source:
kind: helm-oci-chart
url: oci://registry-1.docker.io/bitnamicharts/mariadb
version: "25.0.8"
valuesMapping: |
fullnameOverride: "{{ .context.rendered_name }}"
auth:
database: "{{ .values.database }}"
artifacts:
servicemonitor.yaml: |
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
name: {{ .context.rendered_name }}-monitor
spec:
selector:
matchLabels:
app.kubernetes.io/instance: {{ .context.rendered_name }}
endpoints:
- port: mysql
interval: 30s

O chart rotula os seus recursos com o nome de release que a compilação lhe atribui, pelo que o seletor é construído a partir de .context.rendered_name; um seletor construído a partir de .context.instance_id não corresponderia a nada para um componente cujo nome contenha um sublinhado ou uma maiúscula. A chave de um artefacto é o nome do seu ficheiro de saída, usado tal como está escrito, e a compilação é interrompida se o chart também renderizar um ficheiro com esse nome.

Um Workload mantido num ficheiro próprio

workload: e uma entrada artifacts: podem cada um importar um ficheiro em vez de conter o texto inline:

spec:
workload:
$import: ./workload/workload.yaml
artifacts:
networkpolicy:
$import: ./artifacts/networkpolicy.yaml

O ficheiro de Workload importado é processado como template com o mesmo contexto que um inline. Um ficheiro que uma entrada artifacts: importa é fixado antes de uma compilação o ler: aggrega pin <recipe-dir>/recipe.yaml escreve um entity.lock ao lado da Recipe que regista o digest do ficheiro, e uma compilação é interrompida, nomeando esse comando, enquanto o lock não registar nenhum pin para o ficheiro ou o ficheiro já não lhe corresponder. Importação de uma biblioteca de Workload — um corpo de Workload partilhado através de $import constrói uma Recipe cujo Workload é importado.