Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Composizione

Questa pagina spiega un’idea, costruire un’applicazione a partire da parti più grandi di un singolo componente, e non è un workspace eseguibile. Instradamento dei moduli nei confini — collocare interi sottomoduli nei confini la mostra in un workspace che costruisci tu; scrivilo in una cartella tua con:

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

Poi stampa i prossimi comandi da eseguire:

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

Moduli: un Aggregate importato da un altro

Un Aggregate può importare un altro Aggregate come modulo sotto aggregates:. Il modulo compone i propri componenti e collega i propri archi, quindi nessuno dei suoi elementi interni compare nell’Aggregate che lo importa. L’esempio importa due moduli dal catalogo della libreria standard, da aggregate.yaml:

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

Il blocco exportedComponents di un modulo è la sua interfaccia pubblica: i componenti a cui qualcosa all’esterno del modulo può connettersi, ciascuno con il nome con cui è esportato. core/ferretdb esporta il suo componente proxy come mongo, quindi un componente dell’Aggregate che importa lo raggiunge con il percorso puntato documents.mongo:

uses:
database:
main:
target: documents.mongo

Un modulo può dichiarare parametri propri, che l’Aggregate che importa soddisfa nel parameters: dell’import.

Collocare un modulo

La Release colloca un intero modulo in un confine con una voce aggregates: indicizzata dal nome del modulo, e ogni componente che il modulo contiene va con esso. Può anche configurare i componenti del modulo, ciascuno con il nome che ha all’interno del modulo. Da release.yaml, senza i commenti:

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

Le annotazioni proprie di un modulo raggiungono i suoi componenti esattamente come quelle di un Aggregate raggiungono i suoi, quindi un modulo può collocare i propri componenti in un namespace che dichiara. L’Aggregate che importa non dichiara nulla che raggiunga l’interno del modulo; la Release sì, e il suo valore prevale sulla stessa chiave.

Un servizio che il build non predispone

Un server che esiste già è comunque un nodo del grafo: partecipa alle connessioni, alla policy e a ciò che ricevono i suoi consumatori, e per esso non viene predisposto nulla. Il suo Manifest associa una Recipe che non predispone nulla, e la Release fornisce l’indirizzo. In Un contratto, tre realizzazioni, il Manifest manifest-external.yaml associa core/datastore/postgres a helm/postgres-external, che emette solo un ExternalName Service, e la Release fornisce l’indirizzo, da release-external.yaml:

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

L’indirizzo è una stringa puntatore: il build la fa passare senza risolverla, e qualunque cosa risponda a quel nome quando l’applicazione è in esecuzione è ciò che l’applicazione raggiunge. L’Aggregate è lo stesso file per tutte e tre le Releases dell’esempio.

Sottosistemi: raggruppare all’interno di un Aggregate

Un sottosistema raggruppa componenti all’interno di un Aggregate. Le annotazioni dichiarate su di esso raggiungono ogni componente che contiene, e una Feature agganciata a esso è agganciata a ciascuno di essi:

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

Il build appiattisce l’albero dei sottosistemi: invoice-api e payment-worker portano ciascuno l’aggancio metrics ed entrambe le annotazioni, che una Recipe legge come {{ index .context.annotations.aggregate "team.aggrega.ai/owner" }}. aggrega.ai/namespace è un’annotazione del provider, quindi colloca anche entrambi i componenti nel namespace billing. La Release configura l’infra dell’aggancio sotto la voce di ciascun componente, con il nome che il sottosistema gli ha dato, e un namespace impostato dalla Release sovrascrive quello del sottosistema per i componenti che copre.

Un aggancio che si connette a qualcosa di proprio

Un aggancio può avere un proprio blocco uses:, tracciando un arco dall’aggancio anziché dal componente su cui si trova. In Un datastore con backup su ogni target, l’operatore aggancia core/backup al database e connette l’aggancio al bucket in cui finiscono i backup, da release-helm-velero.yaml:

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

Le connessioni proprie del database restano invariate: l’arco verso backups appartiene all’aggancio, viene registrato come tracciato da esso ed è verificato dalla policy come qualsiasi altro arco. Una Feature operativa e una Feature di credenziali si agganciano allo stesso modo, e ciascuna delle due può avere un blocco uses:.