Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Types d’entrée de la Recipe

Cette page explique une idée, les trois entrées à partir desquelles une Recipe effectue son rendu et la façon dont elles s’additionnent, et n’est pas un espace de travail exécutable. MariaDB + Adminer — un exemple exécutable à double cible réalise un composant avec une Recipe synthétisée, un chart récupéré et des artefacts à côté ; écrivez-le dans un dossier à vous avec :

Terminal window
aggrega scaffold --example mariadb-adminer

Elle affiche ensuite les prochaines commandes à exécuter :

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

Une Recipe a trois entrées et en utilise n’importe quelle combinaison :

  • un Workload (workload:), la description propre au build des conteneurs, ports, volumes et services, que le fournisseur synthétise en ressources de la cible — un Deployment et un Service sur Kubernetes, un service sur Docker Compose ;
  • une source (source:), un chart, un module ou un template dont le fournisseur effectue le rendu, alimentée par le valuesMapping de la Recipe ;
  • des artefacts (artifacts:), des fichiers que la Recipe écrit tels quels, après le templating, à côté de ce que produisent les deux autres.

La façon dont les trois se composent est exposée dans Composition des entrées de la Recipe ; la surface propre du Workload est entities/workload.md, et le contexte que lit chaque template — .values, .infra, .context, .locals, .features — est vocabulary/data-pillars.md.

Les Recipes ci-dessous implémentent un Component que l’espace de travail déclare pour lui-même, local/compute/api-server, avec un image et un port parmi ses values, replicas parmi son infra, et host, port et protocol parmi ce qu’il publie.

Un Workload seul

Sans source: ni artifacts:, le Workload pilote toute la sortie :

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

Pour un composant nommé api, le fournisseur helm écrit un Deployment et un Service ClusterIP. Les variables que livrent les connexions arrivent dans .context.inject.env et sont écrites dans le conteneur.

Un Workload et des artefacts

Les artefacts ajoutent des fichiers auxquels le Workload fait référence. Un Workload avec un second conteneur qui monte une ConfigMap, et la ConfigMap sous forme d’artefact :

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 artefact lit le Workload dans .workload au lieu de répéter ses valeurs : un port de conteneur lui parvient sous la forme d’un objet qui contient son numéro sous port, quelle que soit la forme sous laquelle le Workload l’a écrit. La ConfigMap est nommée d’après .context.rendered_name, le nom que le fournisseur helm donne aux ressources du composant, suivi d’un suffixe que porte un local ; un local ne peut pas lire le nom rendu, donc le volume et l’artefact joignent chacun les deux, et le nom que monte le volume est le nom qu’écrit l’artefact.

Une source et des artefacts

Une Recipe peut effectuer le rendu d’un chart récupéré et ajouter ses propres fichiers à côté. Ici, core/datastore/mariadb du catalogue est réalisé par le chart d’un éditeur, et un artefact ajoute un ServiceMonitor 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

Le chart étiquette ses ressources avec le nom de release que lui donne le build, donc le sélecteur est construit à partir de .context.rendered_name ; un sélecteur construit à partir de .context.instance_id ne correspondrait à rien pour un composant dont le nom contient un trait de soulignement ou une majuscule. La clé d’un artefact est le nom de son fichier de sortie, utilisé tel qu’écrit, et le build s’arrête si le chart rend aussi un fichier de ce nom.

Un Workload conservé dans un fichier à part

workload: et une entrée artifacts: peuvent chacun importer un fichier au lieu de contenir le texte en ligne :

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

Le fichier Workload importé est traité comme un template avec le même contexte qu’un Workload en ligne. Un fichier qu’importe une entrée artifacts: est épinglé avant qu’un build le lise : aggrega pin <recipe-dir>/recipe.yaml écrit un entity.lock à côté de la Recipe, qui enregistre l’empreinte du fichier, et un build s’arrête, en nommant cette commande, tant que le verrou n’enregistre aucun épinglage pour le fichier ou que le fichier ne lui correspond plus. Import d’une bibliothèque de Workload — un corps de Workload partagé via $import construit une Recipe dont le Workload est importé.