Ir al contenido
AggregaAggrega
Seleccionar idioma: Español
Esta página se tradujo automáticamente. Lee el original en inglés.

Tipos de entrada de la Recipe

Esta página explica una idea, las tres entradas a partir de las que una Recipe renderiza y cómo se suman, y no es un espacio de trabajo ejecutable. MariaDB + Adminer — un ejemplo ejecutable con dos destinos realiza un componente con una Recipe sintetizada, un chart obtenido y artefactos junto a ellos; escríbelo en una carpeta propia con:

Terminal window
aggrega scaffold --example mariadb-adminer

Después imprime los comandos que hay que ejecutar a continuación:

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

Una Recipe tiene tres entradas y usa cualquier combinación de ellas:

  • un Workload (workload:), la descripción propia de la compilación de contenedores, puertos, volúmenes y servicios, que el proveedor sintetiza en los recursos del destino — un Deployment y un Service en Kubernetes, un servicio en Docker Compose;
  • un origen (source:), un chart, un módulo o una plantilla que el proveedor renderiza, alimentado por el valuesMapping de la Recipe;
  • artefactos (artifacts:), archivos que la Recipe escribe tal cual, después del procesamiento de plantillas, junto a lo que producen los otros dos.

Cómo se componen los tres se expone en Composición de las entradas de la Recipe; la superficie propia del Workload es entities/workload.md, y el contexto que lee cada plantilla — .values, .infra, .context, .locals, .features — es vocabulary/data-pillars.md.

Las Recipes siguientes implementan un Component que el espacio de trabajo declara para sí mismo, local/compute/api-server, con un image y un port entre sus values, replicas entre su infra, y host, port y protocol entre lo que publica.

Un Workload por sí solo

Sin source: ni artifacts:, el Workload determina toda la salida:

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 un componente llamado api, el proveedor helm escribe un Deployment y un Service ClusterIP. Las variables que entregan las conexiones llegan a .context.inject.env y se escriben en el contenedor.

Un Workload y artefactos

Los artefactos añaden archivos a los que hace referencia el Workload. Un Workload con un segundo contenedor que monta un ConfigMap, y el 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 }}"

Un artefacto lee el Workload en .workload en lugar de repetir sus valores: un puerto de contenedor le llega como un objeto que contiene su número bajo port, sea cual sea la forma en que lo escribió el Workload. El ConfigMap recibe el nombre de .context.rendered_name, el nombre que el proveedor helm da a los recursos del componente, seguido de un sufijo que lleva un local; un local no puede leer el nombre renderizado, así que el volumen y el artefacto unen cada uno las dos partes, y el nombre que monta el volumen es el nombre que escribe el artefacto.

Un origen y artefactos

Una Recipe puede renderizar un chart obtenido y añadir archivos propios junto a él. Aquí, core/datastore/mariadb del catálogo se realiza mediante el chart de un fabricante, y un artefacto añade un ServiceMonitor de 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

El chart etiqueta sus recursos con el nombre de release que le da la compilación, así que el selector se construye a partir de .context.rendered_name; uno construido a partir de .context.instance_id no coincidiría con nada para un componente cuyo nombre contenga un guion bajo o una mayúscula. La clave de un artefacto es el nombre de su archivo de salida, usado tal como está escrito, y la compilación se detiene si el chart también renderiza un archivo con ese nombre.

Un Workload en un archivo propio

workload: y una entrada artifacts: pueden importar cada uno un archivo en lugar de contener el texto en línea:

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

El archivo de Workload importado se procesa como plantilla con el mismo contexto que uno en línea. Un archivo que importa una entrada artifacts: se fija antes de que una compilación lo lea: aggrega pin <recipe-dir>/recipe.yaml escribe un entity.lock junto a la Recipe que registra el digest del archivo, y una compilación se detiene, nombrando ese comando, mientras el lock no registre ningún pin para el archivo o el archivo ya no coincida con él. Importación de una biblioteca de Workload — un cuerpo de Workload compartido mediante $import construye una Recipe cuyo Workload se importa.