Personas
La superficie di scrittura di Aggrega è suddivisa tra quattro ruoli che collaborano. Ogni ruolo ha una competenza distinta, una cadenza di cambiamento distinta e un insieme distinto di tipi di entità che in genere scrive. Capire quale ruolo stai ricoprendo ti dice quale file aprire e quali pilastri compilare.
La suddivisione è un’indicazione, non una regola imposta dal compilatore. Il compilatore di base è matematicamente privo di opinioni: accetta qualsiasi modalità di scrittura che superi la validazione dello schema. Sei libero di unire i ruoli — un autore che lavora da solo li ricopre abitualmente tutti e quattro — o di oltrepassare un confine quando una situazione lo richiede. I ruoli esistono per mantenere basso il carico cognitivo e chiare le competenze, non per costruire una prigione. Per la trattazione architetturale di questa separazione, consulta Team Topologies e i quattro domini.
I quattro ruoli
Sviluppatore
intento applicativo
Aggregate
Architetto della piattaforma
il contratto del catalogo
Components
Features
Operations della piattaforma
ricette dell’infrastruttura
Recipes
FeatureRecipes
Plugins
di rendering per provider
Operatore della piattaforma
collegamenti per ambiente
Manifests
Releases
Chi scrive di solito quali file. La suddivisione è un’indicazione, non una regola che il compilatore impone: in un piccolo team o in un progetto individuale, una sola persona li scrive tutti.
Sviluppatore — intento applicativo
Lo sviluppatore scrive l’Aggregate: che cos’è l’applicazione e di che cosa ha bisogno, espresso come intento. Lo sviluppatore dice «mi serve un database di queste dimensioni e un servizio che lo usa», non «crea un’istanza AWS RDS in questa subnet». L’infrastruttura fisica è lasciata deliberatamente al catalogo e alle operations, così l’Aggregate resta agnostico rispetto alle capacità — lo stesso intento si compila per un laptop, un cloud o un cluster aziendale senza che il file dello sviluppatore cambi.
Ciò di cui è responsabile lo sviluppatore: i componenti che l’Aggregate dichiara, i values che fornisce, le Features il cui comportamento è intento applicativo (con i loro values), i parameters che espone per la variazione per ambiente e gli archi uses che collegano i componenti tra loro.
Architetto di piattaforma — il contratto del catalogo
L’architetto scrive Components e Features: i contratti riutilizzabili e versionati che gli sviluppatori consumano. Un Component dichiara i valori che uno sviluppatore può fornire (come JSON Schema), gli output che fornisce ai consumatori e i socket che espone per il cablaggio. Una Feature dichiara una capacità collegabile. L’architetto costruisce la «strada asfaltata» — il distributore automatico da cui gli sviluppatori ordinano — e garantisce che ciò che eroga abbia una forma corretta.
Ciò di cui è responsabile l’architetto: lo schema: che valida i valori dello sviluppatore, gli output provides, i socket usesSchema e le etichette che portano l’identità semantica. Gli architetti non scrivono l’infrastruttura fisica; ne definiscono l’interfaccia.
Operations di piattaforma — ricette dell’infrastruttura
Le operations scrivono Recipes, FeatureRecipes e Plugins di rendering dei provider: le traduzioni specifiche del provider che trasformano un contratto del catalogo in infrastruttura renderizzata. Una Recipe mappa i valori dichiarati di un Component su un provider concreto — Helm, Docker Compose, Terraform — senza modificare i valori rivolti allo sviluppatore che il Component dichiara. Una FeatureRecipe fa lo stesso per una Feature al momento del binding.
Ciò di cui sono responsabili le operations: i template che renderizzano l’output nativo del provider a partire dai values dello sviluppatore e dal dimensionamento infra dell’operatore, e i valori provides che una Recipe passa ai consumatori. Gli ingegneri delle operations riutilizzano il codice di infrastruttura esistente impacchettandolo come Recipes; non sono mai tenuti a imparare un linguaggio di policy specifico del catalogo.
Operatore di piattaforma — cablaggio del deployment
L’operatore scrive Manifests e Releases: il livello di instradamento e l’input di compilazione per ambiente. Un Manifest indica al compilatore quale Recipe realizza ciascun Component per un dato target, così lo stesso Aggregate può raggiungere implementazioni diverse nei vari ambienti. Una Release è l’unico input di compilazione — punta all’Aggregate e al Manifest, soddisfa i parametri esposti dallo sviluppatore, collega le Features i cui input sono operativi, dimensiona con infra quelle collegate dallo sviluppatore e cabla archi propri entro i socket dichiarati dall’architetto.
Ciò di cui è responsabile l’operatore: la mappa di instradamento del Manifest, il soddisfacimento dei parametri della Release, il dimensionamento infra che riceve ciascun component, i collegamenti delle Features i cui input sono operativi e l’infra per arco che una Release scrive su una connessione. L’operatore soddisfa i punti di variazione esposti dallo sviluppatore; la Release non può introdurre nuovi valori applicativi né nuove risorse di calcolo — questi provengono solo dall’Aggregate.
I ruoli sono cappelli, non persone
In una grande azienda questi quattro ruoli sono reparti distinti con competenze diverse e frequenze di cambiamento diverse — il catalogo evolve quando il team di piattaforma rilascia una nuova capacità, le Recipes evolvono quando cambia l’infrastruttura, le Releases cambiano a ogni deployment. In un piccolo team o in un progetto individuale, una sola persona indossa ogni cappello. Poiché Components e Recipes sono artefatti condivisibili e versionati, un autore può spesso restare puramente nel ruolo di sviluppatore e consumare un catalogo già pronto per tutto il resto.
Leggi poi Entità per ruolo per la mappa completa da tipo a ruolo, inclusi i tipi libreria e plugin che supportano tutti e quattro i ruoli.