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:
aggrega scaffold --example module-boundary-routingPoi stampa i prossimi comandi da eseguire:
cd module-boundary-routingaggrega build --release release.yaml --auto-pullModuli: 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/ferretdbIl 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.mongoUn 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.netL’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/workerIl 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: backupsLe 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:.