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

Komposition

Diese Seite erklärt eine Idee, nämlich eine Anwendung aus Teilen aufzubauen, die größer als eine Komponente sind, und ist kein ausführbarer Workspace. Modul-Boundary-Routing — ganze Untermodule in Boundaries platzieren zeigt sie in einem Workspace, den Sie bauen; schreiben Sie ihn mit folgendem Befehl in einen eigenen Ordner:

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

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

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

Module: ein Aggregate, das von einem anderen importiert wird

Ein Aggregate kann ein anderes Aggregate als Modul unter aggregates: importieren. Das Modul setzt seine eigenen Komponenten zusammen und verdrahtet seine eigenen Kanten, sodass keines seiner Interna in dem Aggregate erscheint, das es importiert. Das Beispiel importiert zwei Module aus dem Standardbibliothekskatalog, aus aggregate.yaml:

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

Der Block exportedComponents eines Moduls ist seine öffentliche Schnittstelle: die Komponenten, mit denen sich etwas außerhalb des Moduls verbinden darf, jede unter dem Namen, unter dem sie exportiert wird. core/ferretdb exportiert seine Komponente proxy als mongo, sodass eine Komponente des importierenden Aggregate sie über den Punktpfad documents.mongo erreicht:

uses:
database:
main:
target: documents.mongo

Ein Modul kann eigene Parameter deklarieren, die das importierende Aggregate im parameters: des Imports erfüllt.

Ein Modul platzieren

Das Release platziert ein ganzes Modul in einer Boundary mit einem Eintrag aggregates:, dessen Schlüssel der Name des Moduls ist, und jede Komponente, die das Modul enthält, kommt mit. Es kann auch die Komponenten des Moduls konfigurieren, jede unter dem Namen, den sie innerhalb des Moduls hat. Aus release.yaml, ohne Kommentare:

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

Die eigenen Annotationen eines Moduls erreichen seine eigenen Komponenten genau so, wie die eines Aggregate dessen eigene erreichen, sodass ein Modul seine Komponenten in einem Namespace platzieren kann, den es deklariert. Das importierende Aggregate deklariert nichts, was in das Modul hineinreicht; das Release schon, und sein Wert gewinnt beim selben Schlüssel.

Ein Dienst, den der Build nicht bereitstellt

Ein bereits existierender Server ist trotzdem ein Knoten des Graphen: Er nimmt an Verbindungen, an Richtlinien und an dem teil, was seine Konsumenten erhalten, und für ihn wird nichts bereitgestellt. Sein Manifest bindet ein Recipe, das nichts bereitstellt, und das Release gibt die Adresse an. In Ein Vertrag, drei Realisierungen bindet das Manifest manifest-external.yaml core/datastore/postgres an helm/postgres-external, das nur einen ExternalName-Service ausgibt, und das Release liefert die Adresse, aus release-external.yaml:

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

Die Adresse ist ein Zeiger-String: Der Build reicht sie durch, ohne sie aufzulösen, und was auch immer zur Laufzeit der Anwendung unter diesem Namen antwortet, ist das, was die Anwendung erreicht. Das Aggregate ist für alle drei Releases des Beispiels dieselbe Datei.

Subsysteme: Gruppierung innerhalb eines Aggregate

Ein Subsystem gruppiert Komponenten innerhalb eines Aggregate. Daran deklarierte Annotationen erreichen jede Komponente, die es enthält, und ein daran angebundenes Feature wird an jede von ihnen angebunden:

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

Der Build flacht den Subsystembaum ab: invoice-api und payment-worker tragen jeweils die Anbindung metrics und beide Annotationen, die ein Recipe als {{ index .context.annotations.aggregate "team.aggrega.ai/owner" }} liest. aggrega.ai/namespace ist eine Provider-Annotation, daher platziert sie beide Komponenten außerdem im Namespace billing. Das Release konfiguriert das infra der Anbindung unter dem Eintrag jeder Komponente, unter dem Namen, den das Subsystem ihr gegeben hat, und ein Namespace, den das Release setzt, überschreibt den des Subsystems für die Komponenten, die es abdeckt.

Eine Anbindung, die sich mit etwas Eigenem verbindet

Eine Anbindung kann einen eigenen Block uses: tragen und so eine Kante von der Anbindung statt von der Komponente ziehen, an der sie sitzt. In Ein Datenspeicher, auf jedem Ziel gesichert bindet der Operator core/backup an die Datenbank an und verbindet die Anbindung mit dem Bucket, in den die Backups gehen, aus release-helm-velero.yaml:

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

Die eigenen Verbindungen der Datenbank bleiben unverändert: Die Kante zu backups gehört zur Anbindung, wird als von ihr gezogen festgehalten und wird wie jede andere Kante von Richtlinien geprüft. Ein operatives Feature und ein Credential-Feature werden auf dieselbe Weise angebunden, und jedes von beiden kann einen Block uses: tragen.