Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Recipe-Eingabearten

Diese Seite erklärt eine Idee, nämlich die drei Eingaben, aus denen ein Recipe rendert, und wie sie sich addieren, und ist kein ausführbarer Workspace. MariaDB + Adminer — ein ausführbares Beispiel mit zwei Zielen realisiert eine Komponente mit einem synthetisierten Recipe, einem abgerufenen Chart und Artefakten daneben; schreiben Sie es mit folgendem Befehl in einen eigenen Ordner:

Terminal window
aggrega scaffold --example mariadb-adminer

Danach gibt er die als Nächstes auszuführenden Befehle aus:

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

Ein Recipe hat drei Eingaben und verwendet eine beliebige Kombination davon:

  • eine Workload (workload:), die eigene Beschreibung des Builds von Containern, Ports, Volumes und Diensten, die der Provider in die Ressourcen des Ziels synthetisiert — ein Deployment und ein Service auf Kubernetes, ein Dienst auf Docker Compose;
  • eine Quelle (source:), ein Chart, ein Modul oder ein Template, das der Provider rendert, gespeist aus dem valuesMapping des Recipe;
  • Artefakte (artifacts:), Dateien, die das Recipe nach dem Templating unverändert neben das schreibt, was die anderen beiden erzeugen.

Wie sich die drei zusammensetzen, ist in Komposition der Recipe-Eingaben dargelegt; die eigene Oberfläche der Workload ist entities/workload.md, und der Kontext, den jedes Template liest — .values, .infra, .context, .locals, .features —, ist vocabulary/data-pillars.md.

Die folgenden Recipes implementieren eine Component, die der Workspace für sich selbst deklariert, local/compute/api-server, mit einem image und einem port unter ihren values, replicas unter ihrem infra und host, port und protocol unter dem, was sie veröffentlicht.

Eine Workload allein

Ohne source: und ohne artifacts: steuert die Workload die gesamte Ausgabe:

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

Für eine Komponente namens api schreibt der helm-Provider ein Deployment und einen ClusterIP-Service. Die Variablen, die die Verbindungen liefern, kommen bei .context.inject.env an und werden in den Container geschrieben.

Eine Workload und Artefakte

Artefakte fügen Dateien hinzu, auf die die Workload verweist. Eine Workload mit einem zweiten Container, der eine ConfigMap mountet, und die ConfigMap als Artefakt:

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

Ein Artefakt liest die Workload unter .workload, statt ihre Werte zu wiederholen: Ein Container-Port erreicht es als Objekt, das seine Nummer unter port enthält, gleich in welcher Form die Workload ihn geschrieben hat. Die ConfigMap wird nach .context.rendered_name benannt, dem Namen, den der helm-Provider den Ressourcen der Komponente gibt, gefolgt von einem Suffix, das ein Local trägt; ein Local kann den gerenderten Namen nicht lesen, daher fügen das Volume und das Artefakt jeweils beide Teile zusammen, und der Name, den das Volume mountet, ist der Name, den das Artefakt schreibt.

Eine Quelle und Artefakte

Ein Recipe kann ein abgerufenes Chart rendern und eigene Dateien daneben hinzufügen. Hier wird core/datastore/mariadb aus dem Katalog durch das Chart eines Anbieters realisiert, und ein Artefakt fügt einen Prometheus-ServiceMonitor hinzu:

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

Das Chart kennzeichnet seine Ressourcen per Label mit dem Release-Namen, den der Build ihm gibt, daher wird der Selektor aus .context.rendered_name gebaut; ein aus .context.instance_id gebauter Selektor würde für eine Komponente, deren Name einen Unterstrich oder einen Großbuchstaben enthält, nichts treffen. Der Schlüssel eines Artefakts ist sein Ausgabedateiname, so verwendet, wie er geschrieben ist, und der Build bricht ab, wenn das Chart ebenfalls eine Datei dieses Namens rendert.

Eine Workload in einer eigenen Datei

workload: und ein Eintrag artifacts: können jeweils eine Datei importieren, statt den Text inline zu enthalten:

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

Die importierte Workload-Datei wird mit demselben Kontext als Template verarbeitet wie eine inline geschriebene. Eine Datei, die ein Eintrag artifacts: importiert, wird gepinnt, bevor ein Build sie liest: aggrega pin <recipe-dir>/recipe.yaml schreibt neben dem Recipe eine entity.lock, die den Digest der Datei festhält, und ein Build bricht unter Nennung dieses Befehls ab, solange der Lock keinen Pin für die Datei festhält oder die Datei nicht mehr zu ihm passt. Workload-Bibliotheksimport — ein gemeinsamer Workload-Body über $import baut ein Recipe, dessen Workload importiert wird.