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

Composition

Cette page explique une idée, construire une application à partir de parties plus grandes qu’un composant, et n’est pas un espace de travail exécutable. Routage des modules vers les frontières — placer des sous-modules entiers dans des frontières la montre dans un espace de travail que vous construisez ; écrivez-le dans un dossier à vous avec :

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

Elle affiche ensuite les prochaines commandes à exécuter :

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

Modules : un Aggregate importé par un autre

Un Aggregate peut importer un autre Aggregate comme module sous aggregates:. Le module compose ses propres composants et câble ses propres arêtes, de sorte qu’aucun de ses éléments internes n’apparaît dans l’Aggregate qui l’importe. L’exemple importe deux modules du catalogue de la bibliothèque standard, depuis aggregate.yaml :

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

Le bloc exportedComponents d’un module est son interface publique : les composants auxquels quelque chose d’extérieur au module peut se connecter, chacun sous le nom sous lequel il est exporté. core/ferretdb exporte son composant proxy sous le nom mongo, de sorte qu’un composant de l’Aggregate importateur l’atteint par le chemin pointé documents.mongo :

uses:
database:
main:
target: documents.mongo

Un module peut déclarer ses propres paramètres, que l’Aggregate importateur renseigne dans le parameters: de l’import.

Placer un module

La Release place un module entier dans une frontière avec une entrée aggregates: indexée par le nom du module, et chaque composant que contient le module l’accompagne. Elle peut aussi configurer les composants du module, chacun par le nom qu’il porte à l’intérieur du module. Extrait de release.yaml, sans les commentaires :

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

Les annotations propres à un module atteignent ses propres composants exactement comme celles d’un Aggregate atteignent les siens, de sorte qu’un module peut placer ses composants dans un namespace qu’il déclare. L’Aggregate importateur ne déclare rien qui atteigne l’intérieur du module ; la Release, si, et sa valeur l’emporte sur la même clé.

Un service que le build ne provisionne pas

Un serveur qui existe déjà reste un nœud du graphe : il participe aux connexions, à la politique et à ce que reçoivent ses consommateurs, et rien n’est provisionné pour lui. Son Manifest lie une Recipe qui ne provisionne rien, et la Release fournit l’adresse. Dans Un contrat, trois réalisations, le Manifest manifest-external.yaml lie core/datastore/postgres à helm/postgres-external, qui n’émet qu’un Service ExternalName, et la Release fournit l’adresse, depuis release-external.yaml :

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

L’adresse est une chaîne pointeur : le build la transmet sans la résoudre, et ce qui répond à ce nom lorsque l’application s’exécute est ce que l’application atteint. L’Aggregate est le même fichier pour les trois Releases de l’exemple.

Sous-systèmes : regrouper à l’intérieur d’un Aggregate

Un sous-système regroupe des composants au sein d’un Aggregate. Les annotations déclarées sur lui atteignent chaque composant qu’il contient, et une Feature rattachée à lui est rattachée à chacun d’eux :

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

Le build aplatit l’arbre des sous-systèmes : invoice-api et payment-worker portent chacun le rattachement metrics et les deux annotations, qu’une Recipe lit sous la forme {{ index .context.annotations.aggregate "team.aggrega.ai/owner" }}. aggrega.ai/namespace est une annotation de fournisseur, elle place donc aussi les deux composants dans le namespace billing. La Release configure l’infra du rattachement sous l’entrée de chaque composant, par le nom que le sous-système lui a donné, et un namespace que définit la Release remplace celui du sous-système pour les composants qu’elle couvre.

Un rattachement qui se connecte à quelque chose qui lui est propre

Un rattachement peut porter son propre bloc uses:, traçant une arête depuis le rattachement plutôt que depuis le composant auquel il est rattaché. Dans Un datastore sauvegardé sur chaque cible, l’opérateur rattache core/backup à la base de données et connecte le rattachement au bucket où vont les sauvegardes, depuis release-helm-velero.yaml :

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

Les connexions propres à la base de données sont inchangées : l’arête vers backups appartient au rattachement, est enregistrée comme tracée par lui et est vérifiée par la politique comme toute autre arête. Une Feature opérationnelle et une Feature d’identifiants se rattachent de la même façon, et l’une comme l’autre peut porter un bloc uses:.