Cicli di vita Day-2
Cicli di vita Day-2 ed esecuzione temporale
Un compilatore Ahead-of-Time (AOT) agnostico rispetto alle capacità crea intrinsecamente un divario tra l’intento dichiarativo (Day-1) e la realtà operativa (Day-2). Il cloud non è perfettamente deterministico, il deployment richiede una sequenzializzazione temporale e gli sviluppatori hanno bisogno di trigger imperativi per le attività di manutenzione.
Aggrega colma strutturalmente questi divari tramite polyfill architetturali specifici e un instradamento nativo GitOps, così che le configurazioni generate soddisfino queste esigenze operative senza compromettere la purezza del compilatore centrale.
1. Il modello di esecuzione DAG (sequenzializzazione temporale)
Il problema: il deployment dell’infrastruttura è un grafo aciclico diretto (DAG) del tempo. Un task di migrazione del database deve completarsi prima che il server web si avvii. Tuttavia, i compilatori AOT generano cartelle piatte di YAML statico o di Terraform. Se consegni queste cartelle piatte a un controller GitOps (come ArgoCD), questo applica tutto simultaneamente, facendo entrare il server web in un crash loop mentre attende il database.
La soluzione: syncWave per confine nella Release L’Aggregate dello sviluppatore resta intatto. Poiché la sequenzializzazione è una realtà operativa fisica, è gestita rigorosamente nel Dominio 4 (la Release). Ogni confine nella Release porta un campo facoltativo syncWave: <integer>, che consente all’operatore di piattaforma di definire esplicitamente l’ordine di rollout a livello di confine.
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: sequenced-release version: 1.0.0 environment: productionspec: aggregate: my-app manifest: prod-manifest boundaries: infra: syncWave: 0 components: core-vpc: {} postgres-db: {} migrations: syncWave: 1 components: db-migration-task: {} apps: syncWave: 2 components: web-server: {} support-agent: {}Semantica del valore dell’ondata:
- L’ondata è un intero con segno; il valore predefinito è
0. I valori negativi vengono eseguiti prima di tutto il resto (CRD, namespace, RBAC); i valori più alti vengono eseguiti dopo quelli più bassi. Gli operatori impostano i valori in base alla propria topologia di deployment. - Ogni istanza di componente contenuta direttamente in un confine eredita il valore dell’ondata del confine nel proprio nodo IR. Non esiste alcuna sovrascrittura per singolo componente a livello di authoring — l’ordinamento per risorsa interno al provider all’interno di un singolo confine è competenza del provider.
- I confini annidati non ereditano implicitamente. Un confine annidato che non dichiara
syncWaveassume il valore predefinito0indipendentemente dalla dichiarazione del confine esterno. Gli operatori che vogliono «tuttoouterè nell’ondata 1, compreso il suo sotto-confineinner» dichiaranosyncWave: 1su entrambi.
L’effetto del compilatore: Il compilatore propaga il valore di wave di ciascun boundary ai manifesti renderizzati in quel boundary. I Providers emettono primitive di sequenziamento native:
- Per Kubernetes (ArgoCD/Flux): il provider helm emette
argocd.argoproj.io/sync-wave: "<N>"come voce dimetadata.annotationssu ogni manifest renderizzato, e una risorsa che il chart contrassegna come hook di Helm riceve inoltrehelm.sh/hook-weight: "<N>"per l’ordinamento nativo degli hook di Helm. Il provider helm-chart emette l’annotazione solo sui file di template che una Recipe aggiunge a un chart tramiteartifacts:; copia invariati i template propri del chart, quindi questi non portano alcuna wave. - Per Compose: il provider compose esprime l’ordinamento come
depends_ontra i servizi del file in cui un confine viene renderizzato, subordinato allo stato di salute del target dove il target dichiara unhealthchecke al suo avvio dove non lo dichiara.depends_onnomina un servizio all’interno di un solo file, quindi l’ordinamento tra due file compose non è esprimibile; gli operatori mettono in sequenza progetti compose separati al livello dell’invocazione didocker compose up. - Per CloudFormation: il provider cloudformation esprime l’ordinamento come
DependsOntra le risorse del template di stack in cui viene assemblato un gruppo di dispatch: ogni risorsa nomina le risorse dell’ondata popolata immediatamente precedente e il target concatena le restanti. L’attributo regola l’ordine di eliminazione, al contrario, oltre all’ordine di creazione; non esprime alcuna condizione di prontezza, perché un template non ha la nozione di una risorsa utilizzabile.DependsOnnomina una risorsa all’interno di un solo template, quindi l’ordinamento tra due stack non è esprimibile; gli operatori mettono in sequenza stack separati al livello del deployment. - Per Terraform: il provider terraform esprime l’ordinamento come
depends_ontra i blocchimoduledella configurazione radice in cui un boundary viene assemblato, con ogni modulo che indica i moduli della wave popolata immediatamente precedente e Terraform che concatena il resto. Ordina le azioni che Terraform esegue e non esprime alcuna condizione di prontezza, perché una configurazione non ha la nozione di una risorsa in grado di servire.depends_onindica un modulo all’interno di una configurazione, quindi l’ordinamento tra due configurazioni radice non è esprimibile; metterle in sequenza è compito dell’operatore.
La chiave interna di Aggrega aggrega.ai/sync-wave: "<N>" è distribuita insieme all’annotazione di ArgoCD per finalità di osservabilità e di provenienza — come annotazione sull’output helm e sui file di template che una Recipe aggiunge a un chart helm-chart, come etichetta di servizio su compose, come riga del commento di provenienza in ogni modulo terraform e sotto Metadata."aggrega.ai/provenance" di ogni risorsa cloudformation — mentre è l’annotazione di ArgoCD ciò che consumano i controller GitOps.
Unità di authoring delle ondate e unità distribuibile
Il confine è l’unità di authoring delle ondate. L’unità distribuibile è il percorso di assemblaggio — l’output su disco prodotto dal compilatore, su cui una pipeline CI/CD opera l’orchestrazione. Per impostazione predefinita, un confine corrisponde a un percorso di assemblaggio: i componenti di ogni confine vengono emessi in boundaries/<boundary-name>/<provider>/, e helm install / docker compose up viene eseguito su quel percorso.
Gli operatori possono far collassare questa corrispondenza 1:1. I confini possono dichiarare campi di template di percorso directory: (e subDirectory:) che, quando sono condivisi tra più confini, instradano i componenti di quei confini in un unico output assemblato nel percorso condiviso. Due confini che dichiarano directory: "deploy/cluster" producono un unico output assemblato contenente i componenti di entrambi — l’unità distribuibile diventa il percorso di assemblaggio, non l’identità del confine.
I manifest con ondate miste all’interno di un unico output assemblato sono normali e supportati. Quando il confine A dichiara syncWave: 1 e il confine B dichiara syncWave: 2, ed entrambi condividono directory: "deploy/cluster", l’unità distribuibile risultante contiene i componenti di entrambi i confini; ogni manifest porta l’annotazione dell’ondata del proprio confine di origine. Gli strumenti di runtime leggono le annotazioni per risorsa e ordinano all’interno dell’unità di deployment assemblata — il contesto di sync per Application di ArgoCD elabora i manifest dell’ondata 1, attende che siano Healthy, poi elabora l’ondata 2; l’ordinamento degli hook di Helm legge helm.sh/hook-weight per ogni risorsa hook. Questo è il pattern standard di ArgoCD: l’emissione per risorsa è esattamente l’input che si aspettano i consumatori degli altri strumenti.
La sequenzializzazione tra Application (quando un operatore esegue più Application di ArgoCD su output assemblati separati) è configurazione CI a livello di operatore — Aggrega produce gli artefatti; l’operatore collega le proprie Application di ArgoCD attorno a essi tramite app-of-apps o Progressive Sync. Il pattern di annotazione per risorsa di Aggrega è la forma di input standard che ogni consumatore degli altri strumenti si aspetta.
2. Il polyfill di indirizzamento dinamico
Il problema: il cloud non è deterministico al momento della creazione. Risorse come le istanze AWS RDS o i bucket S3 generano hash casuali negli URL solo dopo essere state fisicamente provisionate. Poiché il compilatore AOT genera la configurazione prima che il cloud provisioni qualsiasi cosa, è fisicamente impossibile per il compilatore iniettare l’URL letterale del database nella variabile d’ambiente di un container.
La soluzione: puntatori deterministici tramite le Features di credenziale Aggrega risolve il problema sfruttando le Features di credenziale esistenti, spostando la definizione di «deterministico» da un indirizzo IP letterale a un puntatore deterministico. La configurazione generata non passa l’URL; passa il percorso di un Cloud Vault in cui l’URL esisterà.
- Esempio 1: la generazione dell’output (Terraform RDS) La Recipe Ops del database crea l’istanza AWS RDS. Fondamentalmente, la Recipe è scritta per emettere in modo nativo l’URL dinamico appena generato in AWS Systems Manager (SSM) Parameter Store, in un percorso dal nome deterministico (ad es.
/aggrega/prod/db-url). - Esempio 2: l’iniezione dell’input (app Kubernetes) Lo sviluppatore collega la Feature di credenziale
core/referenced-secretal worker, in uno slot che il suo Component dichiara, conoriginimpostato sulla stringa del puntatore deterministico ("/aggrega/prod/db-url"). Su un target Kubernetes il Manifest lega quel collegamento ahelm/k8s-external-secret, che renderizza unExternalSecretdi Kubernetes chiedendo all’operatore del secret store del cluster di recuperare quella voce in un Secret, e pubblica il nome del Secret e la sua chiave dati; la Recipe del worker li legge tramite gliattachments:del suo container e renderizza una variabile d’ambiente del Pod mappata suvalueFrom: secretKeyRef(vedi Come una credenziale raggiunge un container). Il compilatore convoglia la stringa del puntatore e non legge mai l’URL.
A runtime, Terraform effettua il provisioning del DB e salva l’URL nel vault. Il container si avvia, legge il Secret riconciliato dal vault e si connette. Il compilatore AOT ha generato le relazioni tramite stringhe di puntatore stabili senza mai avere bisogno dell’indirizzo IP letterale.
3. Azioni imperative (il passaggio di consegne eseguibile)
Il problema: lo stato dichiarativo è perfetto per il provisioning Day-1, ma gli sviluppatori devono eseguire azioni imperative: «Esegui subito un backup del DB.» Una pipeline GitOps strettamente dichiarativa non ha alcun meccanismo nativo per riattivare uno script statico.
La soluzione: task dormienti e il comando proprio del target Aggrega risolve questo problema preservando una rigorosa purezza AOT. Genera la configurazione per un task che viene distribuito senza avviarsi, e ogni esecuzione viene avviata sul target con il comando proprio del target.
- L’intento dello sviluppatore: lo sviluppatore dichiara lo script come
tasknell’Aggregatee collega una Feature che chiede che venga eseguito su richiesta (ad es.core/manual-trigger). Essere eseguito su richiesta fa parte di ciò che il task è, quindi è lo sviluppatore a collegarla; una Feature i cui input sono tutti operativi viene invece collegata dalle operations, nella Release. - La forma dormiente: La Recipe propria del task su ciascun target legge l’associazione e renderizza il task in una forma che si distribuisce senza avviare un’esecuzione. Su Kubernetes il task è un
CronJobmantenuto consuspend: true, su una pianificazione che indica una data che non arriva mai, al posto delJobche verrebbe eseguito non appena distribuito. Su Docker Compose il servizio del task, che Compose non riavvia una volta terminato, porta il profilomanual, cosìdocker compose uplo lascia fermo. Su Amazon ECS, tramite Terraform o CloudFormation, la definizione del task viene distribuita da sola, senza alcuna pianificazione che la avvii. La FeatureRecipe che il Manifest lega per l’associazione non aggiunge alcun file proprio su nessun target: la modifica è nell’output proprio del task. - Il passaggio di consegne: Il compilatore non raggiunge alcun cluster e non chiama alcuna API cloud, e la build non avvia alcuna esecuzione e non scrive alcuno script. Ogni esecuzione viene avviata dall’operatore, con il comando proprio del target:
kubectl create job <run-name> --from=cronjob/<cronjob>su Kubernetes,docker compose run --rm <service>su Docker Compose eaws ecs run-tasksu Amazon ECS, a cui si passano il cluster, la definizione del task e la configurazione di rete che la Release imposta sottoinfra.overridesdel task. La generazione della configurazione e l’esecuzione a runtime restano separate.
(Nota: su Kubernetes e Amazon ECS un task che ha una pianificazione viene eseguito secondo essa, che l’associazione ci sia o meno, e lo stesso comando avvia un’esecuzione aggiuntiva tra quelle pianificate; su Docker Compose, che non ha uno scheduler, la Recipe del task rifiuta una pianificazione. L’esempio svolto task-run-on-demand compila un unico Aggregate per Kubernetes, Docker Compose, Terraform e CloudFormation, e mostra per ciascuno l’output renderizzato e il comando che avvia un’esecuzione.)
4. Pre-analisi: l’hook del workspace (RBAC e quote della piattaforma)
Il problema: alcune modifiche effettuano il provisioning di un’infrastruttura costosa o critica per la produzione — ad esempio un grande cluster GPU — e non devono confluire nella pipeline GitOps senza revisione. Quali contributori possano promuovere quali modifiche in quali ambienti è una decisione di policy organizzativa; il compilatore non deve codificarla in modo rigido.
La soluzione: un compilatore AOT puro non può interrogare Active Directory né recuperare credenziali cloud per capire chi sta eseguendo la build. Per impedire generazioni non autorizzate prima ancora che la CI/CD venga eseguita, l’architettura si basa su un’iniezione esplicita del contesto.
Quando aggrega build viene invocato da un runner CI/CD, la pipeline scrive il contesto di esecuzione in un file di configurazione che passa con --config, come with.settings dell’associazione di governance che lo giudica (ad es. approval: standard). Il file elenca le sue associazioni sotto governance_append, così si aggiungono ai plugin di governance che la configurazione del workspace stesso associa anziché esserne sostituite. Una policy al ruolo ir-verdict legge quelle impostazioni come input.settings. Riceve il grafo assemblato e non la Release, quindi l’ambiente della Release le arriva come etichetta: una policy al ruolo label-transform legge input.compilation_context.environment ed etichetta con esso ogni nodo. Il verdetto confronta i due e interrompe la build quando non concordano — qui, una build di produzione le cui impostazioni non portano approval: platform-approved:
# ci-governance.yaml — written by the CI/CD runner, passed as `aggrega build --config ci-governance.yaml`plugins: governance_append: - uri: governance/rego:<version> role: label-transform with: sources: - policies/environment.rego - uri: governance/rego:<version> role: ir-verdict with: sources: - policies/approval.rego settings: approval: standard# policies/environment.rego — evaluated by the governance label-transform role, during topology constructionpackage acme.context
import rego.v1
labels contains {"node": id, "key": "acme.com/environment", "value": input.compilation_context.environment} if { some id, _ in input.graph.nodes}# policies/approval.rego — evaluated by the governance ir-verdict role over the assembled graphpackage acme.approval
import rego.v1
approved if input.settings.approval == "platform-approved"
deny contains msg if { not approved some node in input.graph.spec.nodes node.labels["acme.com/environment"] == "production" msg := "a production build needs the approval platform-approved in the pipeline's governance settings."}Anche un’esecuzione le cui impostazioni non portano alcuna approvazione viene rifiutata, perché la regola chiede se l’approvazione è presente anziché se ne è presente una diversa. Questo isola l’RBAC dalla logica nativa del compilatore, garantendo che il compilatore agisca puramente come valutatore deterministico dei dati forniti.
5. FinOps shift-left (stima dei costi tramite policy)
Il problema: configurazioni errate accidentali (ad es. richiedere workers: 500) possono aggirare le salvaguardie finanziarie e innescare grandi sforamenti dei costi cloud.
La soluzione (policy Wasm aziendali): poiché il grafo IR contiene la topologia completa e la Release contiene la mappatura fisica (.infra), le aziende possono valutare il costo esatto di ciò che una Release distribuisce prima della generazione senza bisogno di una funzionalità del compilatore codificata in modo rigido. Le aziende scrivono semplicemente un plugin WebAssembly FinOps personalizzato e lo collegano al socket di governance in un ruolo di verdetto. Questo plugin personalizzato può leggere i payload .infra, calcolare il costo mensile stimato e interrompere la build se il costo calcolato supera i limiti di budget definiti internamente dall’azienda.
6. Il ciclo di vita dell’importazione «brownfield»
Il problema: le aziende hanno già in esecuzione la maggior parte della propria infrastruttura. Sebbene Aggrega sia progettato per collegare una build a infrastrutture non gestite tramite un workload di riferimento (networking pass-through; vedi workload di riferimento), spostare un database Oracle esistente nello stato Terraform generato da Aggrega fa sì che, in genere, gli orchestratori tentino di ricreare il database, distruggendo i dati esistenti.
La soluzione (pianificata): È prevista una Feature core/resource-adoption per gestire il ciclo di vita dell’importazione.
Quando uno sviluppatore modella il database esistente nel proprio Aggregate e collega la funzionalità resource-adoption in una pipeline eseguita in sequenza, il plugin di rendering Wasm è progettato per valutare il payload della Recipe Ops di base. Invece di emettere le configurazioni di creazione standard, il plugin è progettato per emettere la sintassi di adozione esplicita della piattaforma di destinazione (ad es. restituendo un JSONPatch con blocchi Terraform import {} o policy di gestione Crossplane ObserveOnly). Ciò consente alle aziende di generare in sicurezza configurazioni che assorbono l’architettura legacy nel control plane GitOps senza downtime.
7. Best practice per le Ops e denominazione deterministica
Mentre il compilatore centrale si basa su ID di nodo interni e stabili (ad es. support-db) nel grafo IR piatto, i provider cloud fisici (come AWS, Azure e GCP) richiedono spesso stringhe globalmente univoche per l’infrastruttura fisica (ad es. nomi di bucket S3, nomi di ruoli IAM o domini di API Gateway).
Se un ingegnere Platform Ops codifica in modo rigido un nome fisico nel proprio template di base (ad es. bucket_name: "enterprise-data-bucket"), gli artefatti generati verranno applicati senza problemi la prima volta. Tuttavia, se uno sviluppatore distribuisce un secondo ambiente (ad es. staging rispetto a prod), il provider cloud rifiuterà le risorse del secondo ambiente a runtime a causa di una collisione di nomi.
La regola dell’output deterministico (sicurezza GitOps): poiché i controller GitOps (ArgoCD, Flux) eseguono il rilevamento delle differenze a livello di byte sugli artefatti renderizzati, il compilatore garantisce che input identici producano output identici byte per byte. Le mappe che scorrono nel contesto del template (.context.inject.env, .values, .infra e il resto della vista di runtime) sono supportate da strutture a mappa ordinata che preservano l’ordine di inserimento dell’autore in tutto il livello dei dati, e il confine del template è l’unica eccezione: {{ range }} su quelle mappe itera in ordine alfabetico delle chiavi, come fanno i template Go, non nell’ordine dell’autore. Gli ingegneri Ops possono contare sul fatto che quell’ordine di iterazione sia deterministico tra esecuzioni dello stesso input; dove la sequenza ha un significato, la si scrive come lista anziché ricavarla da una mappa. La funzione Sprig keys, tuttavia, restituisce l’ordine di iterazione delle mappe Go (che non è deterministico per progettazione del linguaggio); i template che compongono una sequenza deterministica di chiavi dall’output di keys devono passarlo tramite pipe a sortAlpha (ad es. {{ keys .values | sortAlpha }}) per recuperare il determinismo.
La regola d’oro per le Recipes Ops (il pattern Helm): gli ingegneri Platform Ops non devono mai codificare in modo rigido i nomi fisici delle risorse cloud. Devono invece costruire nomi univoci in modo deterministico concatenando il contesto di deployment di Aggrega durante la fase di valutazione del template. Questa è una regola di riusabilità e di sicurezza contro le collisioni, non una regola di determinismo — i nomi codificati in modo rigido producono un output stabile ma entrano fatalmente in collisione quando la stessa Recipe renderizza più istanze di componente o quando lo stesso Aggregate viene distribuito su più Releases.
Il compilatore fornisce esattamente due variabili per garantire l’univocità globale:
{{ .metadata.release_name }}: il nome dellaReleaseche guida il deployment (ad es.prod-billing).{{ .context.instance_id }}: l’ID specifico del Component nell’Aggregatedello sviluppatore (ad es.receipt-storage).
Concatenandoli (ad es. {{ .metadata.release_name }}-{{ .context.instance_id }}), le Ops garantiscono che le configurazioni generate dai plugin Wasm usino nomi di risorsa univoci per ambiente e per componente, senza richiedere allo sviluppatore di gestire le convenzioni di denominazione fisica.