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

Composición

Esta página explica una idea, construir una aplicación a partir de partes más grandes que un componente, y no es un espacio de trabajo ejecutable. Enrutamiento de módulos a límites — colocar submódulos completos en límites la muestra en un espacio de trabajo que construyes; escríbelo en una carpeta propia con:

Terminal window
aggrega scaffold --example module-boundary-routing

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

Terminal window
cd module-boundary-routing
aggrega build --release release.yaml --auto-pull

Módulos: un Aggregate importado por otro

Un Aggregate puede importar otro Aggregate como módulo bajo aggregates:. El módulo compone sus propios componentes y conecta sus propias aristas, así que nada de su interior aparece en el Aggregate que lo importa. El ejemplo importa dos módulos del catálogo de la biblioteca estándar, de aggregate.yaml:

spec:
aggregates:
metrics:
type: core/thanos
documents:
type: core/ferretdb

El bloque exportedComponents de un módulo es su interfaz pública: los componentes a los que algo de fuera del módulo puede conectarse, cada uno con el nombre con el que se exporta. core/ferretdb exporta su componente proxy como mongo, así que un componente del Aggregate que importa lo alcanza con la ruta con puntos documents.mongo:

uses:
database:
main:
target: documents.mongo

Un módulo puede declarar parámetros propios, que el Aggregate que importa satisface en el parameters: de la importación.

Colocar un módulo

La Release coloca un módulo completo en un límite con una entrada aggregates: cuya clave es el nombre del módulo, y cada componente que contiene el módulo va con él. También puede configurar los componentes del módulo, cada uno por el nombre que tiene dentro del módulo. De release.yaml, sin los comentarios:

spec:
boundaries:
observability:
directory: observability
annotations:
aggrega.ai/namespace: observability
aggregates:
metrics:
components:
query:
infra:
compute:
cpu: 500m
memory: 1Gi
data:
directory: data
annotations:
aggrega.ai/namespace: data
aggregates:
documents: {}

Las anotaciones propias de un módulo llegan a sus propios componentes exactamente como las de un Aggregate llegan a los suyos, así que un módulo puede colocar sus componentes en un namespace que declara. El Aggregate que importa no declara nada que llegue al interior del módulo; la Release sí, y su valor prevalece en la misma clave.

Un servicio que la compilación no aprovisiona

Un servidor que ya existe sigue siendo un nodo del grafo: participa en las conexiones, en la política y en lo que reciben sus consumidores, y no se aprovisiona nada para él. Su Manifest vincula una Recipe que no aprovisiona nada, y la Release da la dirección. En Un contrato, tres realizaciones, el Manifest manifest-external.yaml vincula core/datastore/postgres a helm/postgres-external, que solo emite un Service ExternalName, y la Release proporciona la dirección, de release-external.yaml:

db:
infra:
overrides:
host: postgres.data.example.net

La dirección es una cadena puntero: la compilación la transmite sin resolverla, y lo que responda a ese nombre cuando la aplicación se ejecute es lo que alcanza la aplicación. El Aggregate es el mismo archivo para las tres Releases del ejemplo.

Subsistemas: agrupar dentro de un Aggregate

Un subsistema agrupa componentes dentro de un Aggregate. Las anotaciones declaradas en él llegan a cada componente que contiene, y una Feature acoplada a él se acopla a cada uno de ellos:

spec:
subsystems:
billing:
annotations:
team.aggrega.ai/owner: billing-squad
aggrega.ai/namespace: billing
features:
metrics:
type: core/prometheus-exporter
components:
invoice-api:
type: core/compute/server
payment-worker:
type: core/compute/worker

La compilación aplana el árbol de subsistemas: invoice-api y payment-worker llevan cada uno el acoplamiento metrics y ambas anotaciones, que una Recipe lee como {{ index .context.annotations.aggregate "team.aggrega.ai/owner" }}. aggrega.ai/namespace es una anotación del proveedor, así que también coloca ambos componentes en el namespace billing. La Release configura el infra del acoplamiento bajo la entrada de cada componente, por el nombre que le dio el subsistema, y un namespace que establece la Release anula el del subsistema para los componentes que cubre.

Un acoplamiento que se conecta a algo propio

Un acoplamiento puede llevar su propio bloque uses:, trazando una arista desde el acoplamiento en lugar de desde el componente sobre el que se sitúa. En Un almacén de datos con copia de seguridad en cada destino, el operador acopla core/backup a la base de datos y conecta el acoplamiento al bucket al que van las copias de seguridad, de release-helm-velero.yaml:

spec:
components:
db:
features:
backup:
type: core/backup
infra:
schedule: "30 2 * * *"
retention_days: 14
uses:
store:
bucket:
target: backups

Las conexiones propias de la base de datos no cambian: la arista hacia backups pertenece al acoplamiento, se registra como trazada por él y la política la comprueba como cualquier otra arista. Una Feature operativa y una Feature de credenciales se acoplan de la misma manera, y cualquiera de las dos puede llevar un bloque uses:.