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

Tipi di input della Recipe

Questa pagina spiega un’idea, i tre input da cui una Recipe esegue il rendering e come si sommano, e non è un workspace eseguibile. MariaDB + Adminer — un esempio eseguibile a doppio target realizza un componente con una Recipe sintetizzata, un chart recuperato e degli artefatti accanto a essi; scrivilo in una cartella tua con:

Terminal window
aggrega scaffold --example mariadb-adminer

Poi stampa i prossimi comandi da eseguire:

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

Una Recipe ha tre input e ne usa qualsiasi combinazione:

  • un Workload (workload:), la descrizione propria del build di container, porte, volumi e servizi, che il provider sintetizza nelle risorse del target — un Deployment e un Service su Kubernetes, un servizio su Docker Compose;
  • una sorgente (source:), un chart, un modulo o un template di cui il provider esegue il rendering, alimentata dal valuesMapping della Recipe;
  • artefatti (artifacts:), file che la Recipe scrive così come sono, dopo il templating, accanto a ciò che producono gli altri due.

Il modo in cui i tre si compongono è descritto in Composizione degli input della Recipe; la superficie propria del Workload è entities/workload.md, e il contesto che ogni template legge — .values, .infra, .context, .locals, .features — è vocabulary/data-pillars.md.

Le Recipes seguenti implementano un Component che il workspace dichiara per conto proprio, local/compute/api-server, con un image e un port tra i suoi values, replicas tra il suo infra, e host, port e protocol tra ciò che pubblica.

Un Workload da solo

Senza source: e senza artifacts:, il Workload guida l’intero output:

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

Per un componente chiamato api, il provider helm scrive un Deployment e un ClusterIP Service. Le variabili che le connessioni consegnano arrivano in .context.inject.env e vengono scritte nel container.

Un Workload e degli artefatti

Gli artefatti aggiungono file a cui il Workload fa riferimento. Un Workload con un secondo container che monta una ConfigMap, e la ConfigMap come artefatto:

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

Un artefatto legge il Workload in .workload invece di ripeterne i valori: una porta del container gli arriva come un oggetto che contiene il suo numero sotto port, in qualunque forma il Workload l’abbia scritta. La ConfigMap prende il nome da .context.rendered_name, il nome che il provider helm dà alle risorse del componente, seguito da un suffisso che porta un local; un local non può leggere il nome renderizzato, quindi il volume e l’artefatto uniscono ciascuno le due parti, e il nome che il volume monta è il nome che l’artefatto scrive.

Una sorgente e degli artefatti

Una Recipe può eseguire il rendering di un chart recuperato e aggiungere accanto a esso file propri. Qui core/datastore/mariadb del catalogo è realizzato dal chart di un fornitore, e un artefatto aggiunge un ServiceMonitor di 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

Il chart etichetta le proprie risorse con il nome della release che il build gli dà, quindi il selettore è costruito da .context.rendered_name; uno costruito da .context.instance_id non corrisponderebbe a nulla per un componente il cui nome contiene un underscore o una maiuscola. La chiave di un artefatto è il nome del suo file di output, usato così com’è scritto, e il build si arresta se anche il chart renderizza un file con quel nome.

Un Workload tenuto in un file a sé

workload: e una voce artifacts: possono ciascuno importare un file invece di contenere il testo inline:

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

Il file Workload importato viene elaborato come template con lo stesso contesto di uno inline. Un file che una voce artifacts: importa viene fissato prima che un build lo legga: aggrega pin <recipe-dir>/recipe.yaml scrive un entity.lock accanto alla Recipe che registra il digest del file, e un build si arresta, nominando quel comando, finché il lock non registra alcun pin per il file o il file non vi corrisponde più. Import da una libreria di Workload — un corpo Workload condiviso tramite $import costruisce una Recipe il cui Workload è importato.