provides, inject, uses
Il contratto di iniezione e la mappa pre-risolta
Poiché Aggrega è un compilatore statico a compilazione anticipata (AOT), durante la compilazione nessun dato fluisce all’indietro dall’infrastruttura in esecuzione. È meccanicamente impossibile per il compilatore recuperare attivamente una credenziale fisica (come un secret AWS) e passarla «indietro» all’ambiente del container dello Sviluppatore.
La piattaforma si basa invece sulla vera inversione del controllo. Quando uno sviluppatore scrive inject: { env: [{ in: ORACLE_PASSWORD, from: "password" }] }, non sta avviando un recupero di dati; sta dettando un contratto rigoroso all’infrastruttura.
- L’intento (Dominio 1): Lo Sviluppatore dichiara un’interfaccia astratta: «Mi serve un secret. Non so dove si trovi. Iniettalo semplicemente nel mio ambiente come
ORACLE_PASSWORD, mappato sulla chiavepassworddel catalogo.» - Il trasferimento del compilatore (al rendering): Il compilatore Go prende la voce
{ in: ORACLE_PASSWORD, from: "password" }e la consegna alla Recipe di Ops. Nessun secret fisico viene recuperato. - L’output del Plugin (Dominio 3): La pipeline Wasm della FeatureRecipe delle credenziali genera gli artefatti precisi e interdipendenti richiesti dall’infrastruttura di destinazione. Per esempio, in Kubernetes produce la CRD
ExternalSecret(che istruisce il cluster a recuperare i dati dal vault) E applica un JSONPatch al Pod di destinazione per mappare il Secret K8s locale risultante proprio sulla variabile d’ambiente"ORACLE_PASSWORD"richiesta dallo sviluppatore. - La realtà a runtime: A runtime, un operator nel cluster esegue semplicemente questi artefatti generati—recuperando la credenziale e montandola fisicamente nel container—disaccoppiando completamente la meccanica fisica della sicurezza dal compilatore AOT.
Per portare questa realtà fisica all’applicazione senza violare la separazione delle responsabilità, Aggrega utilizza l’Injection Contract. Tuttavia, questo contratto distingue rigorosamente tra il codice applicativo personalizzato e l’infrastruttura commerciale pronta all’uso (COTS):
- White-Box (codice personalizzato): Il componente è un worker generico (ad es. un agente Python personalizzato). Il compilatore Go e la Recipe di Ops non hanno idea di quali variabili si aspetti lo script personalizzato dello sviluppatore. Perciò lo Sviluppatore detta la consegna tramite il blocco
inject:ovunque il codice legga nomi che la sua Recipe non consegna per impostazione predefinita — sia per le dipendenze tra componenti (tramiteuses[].injectconfrom:che fa riferimento aiprovidesdel target) sia per i valori propri del componente (tramiteinjecta livello di componente con letteralivalue:ofrom:che fa riferimento ai propriprovides). Quali meccanismi sono consentiti è dichiarato per superficie, e le due dichiarazioni sono separate: i valori propri del componente sono governati dalla allowlistspec.inject(ad es.inject: ["env", "file"]), mentre un arcouses:è governato dalla allowlist del socket attraverso cui è collegato,spec.usesSchema.<socket>.inject. Dettare un meccanismo che la allowlist competente non nomina arresta la build su entrambe le superfici. - Black-Box (calcolo pacchettizzato): Il componente è un sistema chiuso (ad es. Redis, un API Gateway gestito). La Recipe di Ops sa già esattamente come il sistema consuma i propri dati. Perciò l’entità di catalogo del Component omette la allowlist, il che vieta del tutto la dettatura anziché restringerla — omettere
spec.injectvieta il self-inject a livello di componente, e un socket dichiarato senza una allowlistinject:vieta qualsiasi bloccoinject:su un arco collegato attraverso di esso. Lo Sviluppatore fornisce semplicemente il target della dipendenza tramiteuses, e la piattaforma gestisce il cablaggio interno in modo nativo tramite ilvaluesMappingdella Recipe.
La regola dell’indirizzamento deterministico (fisica della rete interna) La pipe .context.uses di Aggrega inietta dinamicamente stringhe di target nei container in fase di compilazione. Poiché il compilatore Go principale è del tutto agnostico rispetto alla rete fisica, ciò che vale come stringa di indirizzo valida si basa interamente su un contratto sociale mantenuto da Platform Ops, non su una funzione del compilatore — il compilatore convoglia qualunque stringa puntatore deterministica la Recipe di Ops abbia prodotto nel contesto del template a valle, senza interpretarla.
La regola: la Recipe di Ops deve esportare un puntatore di indirizzo deterministico e stabile. Il provider non calcola gli IP. Invece, la Recipe di Ops del target dovrebbe formulare una stringa prevedibile ed esporla tramite il suo contratto provides: (ad es. pubblicando provides.internal_host: "http://agent-b.namespace.svc.cluster.local" in Kubernetes, oppure una stringa di interpolazione come "${module.db.endpoint}" in Terraform, dove il modulo dichiara un output corrispondente per il valore).
Affidarsi al compilatore per recuperare IP dinamici post-provisioning viola direttamente il modello di esecuzione AOT. Poiché il compilatore valuta la topologia prima che il cloud effettui il provisioning di qualsiasi calcolo effettivo, non può fisicamente recuperare dati che non esistono ancora. Se un servizio richiede un IP casuale generato solo dopo l’avvio del calcolo, il compilatore non può fisicamente recuperarlo. L’unico compito del compilatore è convogliare la stringa puntatore deterministica fornita dalla Recipe di Ops, alla lettera, nelle variabili d’ambiente del container chiamante, lasciando la risoluzione finale al DNS del cluster o al gestore dello stato IaC attivo.
Imporre nativamente l’indirizzamento deterministico risolve le dipendenze cicliche (ad es. l’Agente A delega all’Agente B, e l’Agente B delega di nuovo all’Agente A). Poiché l’URL stabile o il puntatore IaC è calcolabile come stringa prima che uno dei due container si avvii effettivamente, il compilatore collega in modo sicuro i due agenti senza introdurre race condition temporali.
(Nota: questa regola si applica anche all’ingress esterno. Se un’architettura espone un API Gateway pubblico e richiede che quell’URL venga iniettato di nuovo in un container interno, il compilatore Go non può recuperare l’URL casuale generato dal cloud (ad es. xyz123.execute-api.aws.com) perché non esiste in fase di compilazione. Ops deve scrivere la propria Recipe in modo da mappare un dominio personalizzato deterministico (ad es. api.enterprise.com) oppure esportare la stringa di interpolazione IaC nativa, garantendo che il compilatore AOT abbia un riferimento noto da iniettare in sicurezza).
La meccanica di implementazione (il catalogo come contratto API) Per implementarlo senza accoppiare strettamente gli Sviluppatori a Ops, Aggrega usa il catalogo della piattaforma (Dominio 2) come contratto API rigoroso, avvalendosi di tre livelli distinti di validazione:
- Lo schema della Feature delle credenziali (etichettato
feature.aggrega.ai/kind: secret): Valida SOLO la query al vault (path,key). È del tutto agnostico rispetto a come il container consuma i dati. - Lo schema
Component(allowlistspec.inject): Impone la regola Black-Box/White-Box tramite il campospec.inject. Sespec.injectè presente (ad es.inject: ["env", "file"]), lo sviluppatore può usare il self-inject a livello di componente con quei meccanismi di consegna. Sespec.injectè omesso, il compilatore vieta strutturalmente il self-inject — i componenti Black-Box si affidano interamente alvaluesMappingdella Recipe per il cablaggio interno. La build lo impone quando risolve l’Aggregate, rifiutando il bloccoinject:del componente e nominando il meccanismo, separatamente dalla validazione del contenuto per pilastro sottoschema:. - La mappa
featuresSchema: Definita nel catalogo del Component, dichiara esplicitamente gli slot di credenziali che lo Sviluppatore deve (o può) usare. Ogni voce specificarequired(predefinitofalse), la allowlistinject([]= blackbox,[env, file]= trasparente) edescription. Poiché queste chiavi sono stabili e garantite per contratto, l’ingegnere Ops può farvi affidamento direttamente per dettare in modo affidabile target deterministici nel proprio template Go (ad es.existingSecret: "{{ .context.rendered_name }}-{{ .locals.secret_target_admin_password }}"sul targethelm), esportando esplicitamente il suffisso del nome tramite.locals— un local non può leggere.context.rendered_name— così la FeatureRecipe delle credenziali a valle unisce le stesse due parti e soddisfa il requisito senza violare l’ordine di esecuzione AOT. Vedientities/component.mdper il design completo difeaturesSchema.
La regola di posizionamento rigoroso: Il meccanismo inject: è disponibile in tre posizioni nell’Aggregate dello Sviluppatore:
- Self-inject a livello di Component: Come fratello diretto di
values:su un’istanza di componente. Inietta i valori letterali propri del componente o le sue chiaviprovidesnella pipe di consegna. Consentito solo se il catalogo del Component dichiaraspec.injectcon i meccanismi corrispondenti. - Cross-inject a livello di uses: All’interno delle definizioni esplicite dei target nel blocco
uses:. Inietta le chiaviprovidesdi un target di dipendenza nella pipe di consegna. - Inject a livello di Feature/secret: Come fratello di
values:quando si associano funzionalità e secret. Inietta le chiaviprovidesrisolte proprie dell’associazione — la credenziale risolta per un secret, o i valori forniti da una funzionalità — nella pipe di consegna.
Tutte e tre le forme popolano la stessa pipe .context.inject. La Recipe legge un’unica pipe unificata, indipendentemente da quante origini vi abbiano contribuito.
Lo schema di inject definisce enum standard (env, file, arg) per gli strumenti, ma lascia aperto additionalProperties, quindi è possibile indicare un meccanismo personalizzato (ad es. ssm_param per AWS Systems Manager Parameter Store). Un nome è riservato: all è la vista unificata di tutti i meccanismi che una Recipe legge in .context.inject.all, quindi un blocco inject che chiama un meccanismo all ferma la build all’involucro del documento, segnalandolo.
Sintassi delle voci di inject: In un blocco inject, ogni meccanismo di consegna — env, file, arg o uno personalizzato — è una lista di voci, e ogni posizione usa la stessa forma di voce. È la parola chiave che una voce porta, non la posizione in cui si trova, a dire che cosa sia la sua stringa, quindi una voce si legge allo stesso modo ovunque compaia. Un meccanismo scritto come mappa anziché come lista, o una voce che porta entrambe le parole chiave, arresta la build all’involucro del documento dell’Aggregate, indicando il percorso nell’Aggregate in cui la forma è errata.
Parole chiave delle voci (from: e value:): Ogni voce usa la parola chiave in per l’identificatore locale — un nome di variabile d’ambiente, un percorso di file, un flag di argomento — più esattamente uno tra from: (riferimento a una chiave di provides) e value: (stringa letterale). Un from: si risolve rispetto ai provides del nodo che la sua posizione indica: quelli propri del componente in component.inject, quelli del target in uses[target].inject e quelli propri dell’associazione in features[<name>].inject:
| Parola chiave | Significato | Consentito in component.inject | Consentito in uses[].inject | Consentito in features[<name>].inject |
|---|---|---|---|---|
from: | Risolve rispetto a provides | ✅ provides del nodo stesso | ✅ provides del nodo target | ✅ provides propri dell’allegato |
value: | Stringa letterale (supporta i template Go) | ✅ | ❌ (value: non è valido in uses[].inject; per il self-inject usa inject a livello di componente) | ❌ (value: ferma la build nell’inject di un allegato; usa inject a livello di componente per il self-inject) |
Esempi:
# Component-level self-inject (White-Box custom code)components: my-worker: type: core/python-worker:1.0.0 values: app_token: "xyz" inject: env: - in: MY_TOKEN value: "xyz" # Literal value - in: LOG_LEVEL value: "debug" # Literal value - in: CALLBACK_HOST from: "host" # From own provides (already evaluated) - in: APP_VERSION value: '{{"{{"}} .values.app_token }}' # Go template expanding own values uses: databases: my_db: target: postgres-db inject: env: - in: DB_HOST from: "host" # Provides key from target - in: DB_PORT from: "port" # Provides key from target - in: DB_URL from: "dsn" # From target's providesIl template nel value: di APP_VERSION si apre con {{"{{"}} anziché con {{: l’intero testo dell’Aggregate viene letto una volta come template, per l’interpolazione dei parametri, prima che venga eseguita la risoluzione del self-inject, e in quel momento .values non esiste, quindi l’escape rimette {{ perché la risoluzione del self-inject lo valuti. Vedi Testo che contiene le proprie doppie graffe.
Nota specifica del Provider (compose). Quando gli archi uses: si risolvono tra nodi destinati a compose, il provider compose deriva da quegli archi le voci depends_on. Quelle voci usano sempre la semantica service_started, indipendentemente dal blocco health: di qualsiasi target; condizionarle alla salute del target non è implementato. Vedi providers/compose.md per le regole di inferenza complete.
La regola di collisione delle chiavi di inject: Uno sviluppatore che richiede la stessa chiave di consegna (ad es. lo stesso nome di variabile d’ambiente) da due origini diverse è un errore fatale, non un merge. Il compilatore rileva la collisione e arresta la build:
| Origine A | Origine B | Risultato |
|---|---|---|
component.inject | uses[].inject | ❌ arresto fatale — chiave di consegna duplicata |
uses[target_A].inject | uses[target_B].inject | ❌ arresto fatale — chiave di consegna duplicata |
component.inject | features[<name>].inject | ❌ arresto fatale — chiave di consegna duplicata |
uses[].inject | features[<name>].inject | ❌ arresto fatale — chiave di consegna duplicata |
features[A].inject | features[B].inject | ❌ arresto fatale — chiave di consegna duplicata |
component.inject (stessa chiave due volte) | — | ❌ arresto fatale — chiave di consegna duplicata |
injectMapping della FeatureRecipe di features[A] | injectMapping della FeatureRecipe di features[B] | ❌ arresto fatale — chiave di consegna duplicata tra due associazioni |
features[A].inject | injectMapping della FeatureRecipe di features[B] | ❌ arresto fatale — chiave di consegna duplicata tra due associazioni |
component.inject o uses[].inject | injectMapping della FeatureRecipe | ✅ Lecito — intercettazione per design: il valore della mappatura sostituisce quella voce |
La tabella vale allo stesso modo per ogni Feature associata, ovunque sia stata associata — sul componente, a un sottosistema o a un confine della Release, tramite l’espansione di un’annotazione, o su una connessione. L’injectMapping di una FeatureRecipe esegue il rendering dopo che ogni blocco inject: ha consegnato, quindi è sempre la più tarda di due rivendicazioni: può riscrivere ciò che il componente o una delle sue connessioni ha consegnato, e può riscrivere ciò che ha consegnato il blocco inject: della propria associazione, ma una chiave che un’altra Feature associata ha già consegnato arresta la build, indicandole entrambe.
Una Feature associata a un confine della Release, la cui FeatureRecipe esegue il rendering una sola volta per il confine (executionScope: boundary), raggiunge i componenti che il confine contiene per la stessa via: il suo injectMapping viene eseguito una volta per ciascuno di essi, nel contesto di quel componente, ed è soggetto alle righe sopra come qualsiasi altra mappatura. Il bridge di compose che riscrive la variabile host di un consumatore per raggiungere il suo target attraverso il suo gateway è una di queste mappature, quindi un’altra Feature associata che ha consegnato la stessa variabile arresta la build, indicandole entrambe.
Per evitare il boilerplate di template Go nelle Recipes, il compilatore fornisce entrambi:
.context.uses: La mappa arricchita degli archi topologici (per la logica complessa, i riferimenti ai secret e il tracciamento dell’origine)..context.inject: Un dizionario pre-risolto e appiattito in cui il compilatore ha già risolto tutte le origini di inject (letterali di self-inject, riferimenti a provides di self-inject e riferimenti a provides tra componenti) in valori stringa finali, applicando poi le intercettazioniinjectMappingdi FeatureRecipe.
Il contesto di iniezione a doppio stato (sicurezza rispetto ai null vs. purezza dell’intento) Quando genera configurazioni per i Modificatori (la FeatureRecipe legata a qualsiasi associazione, di credenziali o d’altro tipo), il compilatore deve bilanciare la sicurezza rispetto ai puntatori nulli per i template Go, l’instradamento dinamico della rete e la preservazione di un grafo agnostico rispetto alle capacità. Per ottenere ciò, il compilatore fornisce al template un contesto a doppio stato:
.inject_raw(l’intento immutabile): Rappresenta il bloccoinject:proprio del componente esattamente come lo sviluppatore l’ha scritto nel Dominio 1. È immutabile. Se lo sviluppatore ha omesso il blocco, si valuta comenull. Ops lo usa specificamente per i controlli logici (ad es.{{ if not .inject_raw }}per applicare comportamenti di fallback). Poiché è immutabile, protegge i template di Ops dai falsi positivi se le funzionalità di instradamento intercettano e modificano la pipe di consegna fisica..context.inject(la pipe pre-idratata e intercettata): Una struct parallela, generata dal compilatore, che rappresenta la realtà fisica della consegna. Parte come mappa pre-idratata (ad es. associandoAPI_HOSTalla stringa di base del target"backend-instance"). Fondamentalmente, questa pipe è progettata per essere intercettata e sottoposta a deep merge dalle Features (ad es. l’instradamento di rete) che usano il bloccoinjectMapping. Nel momento in cui la Recipe di base esegue il rendering, questa pipe contiene le stringhe completamente formattate e fisicamente corrette (ad es. un nome di rete completo e corretto come"backend-instance.backend-zone.svc.cluster.local"). Il suo contenuto è strutturato comeenv,file,arg(più eventuali meccanismi di consegna personalizzati consentiti dalle allowlist inject del Component), con un dizionario.allpre-unito che combina tutti i meccanismi per una comoda serializzazione dell’intera pipe..context.self_inject(Quale valore proprio consegna ciascun nome): viene letto dallo stesso bloccoinject:a livello di componente di.inject_raw, nella forma in cui.context.uses.<alias>.injectfornisce i nomi di una connessione: per ciascun meccanismo, ogni nome scritto dallo sviluppatore corrisponde alla chiave propria del componente che la sua voce consegna —provides.<key>per una vocefrom:,values.<key>per un templatevalue:che legge esattamente uno dei valori propri del componente e nient’altro, e una stringa vuota per qualsiasi altro caso (un letterale, due valori, una lettura di qualcosa di diverso dai valori). Consente a una Recipe che esegue l’immagine propria dello sviluppatore di trattare come predefiniti i propri nomi di variabile — consegnando un valore proprio sotto il suo nome predefinito solo quando nessuna voce corrisponde già avalues.<key>, così uno sviluppatore che rinomina un valore mantiene tutti gli altri predefiniti. Questa è la convenzione del catalogo della libreria standard, non una regola del compilatore; un catalogo aziendale può consegnare i valori propri dei suoi componenti come preferisce.
Ops usa la struct .context.inject esclusivamente per la serializzazione sicura (ad es. {{ toJson .context.inject.all }}) e la generazione dell’instradamento, garantendo che l’infrastruttura fisica riceva le coordinate completamente risolte mentre l’intento originale dello sviluppatore resta perfettamente intatto in .inject_raw.
Esempio YAML dello sviluppatore (mappa granulare):
uses: databases: my-postgres-cluster: target: db-main inject: ssm_param: # Agnostic injection paradigm (AWS Systems Manager) - in: MY_DB_HOST # Local identifier from: "host" # Target provides keyIl compilatore lo risolve in fase di compilazione (mappandolo su stringhe statiche o nomi DNS interni) e passa i due oggetti alla Recipe:
"context": { "uses": { ... raw graph ... }, "inject": { "all": { "MY_DB_HOST": "db-main.internal" }, "ssm_param": { "MY_DB_HOST": "db-main.internal" } }}Configurazione con ambito di connessione (values e infra). Oltre a consegnare i provides di un target tramite inject, un arco può portare una propria configurazione — impostazioni per connessione che la Recipe consumatrice legge dalla pipe arricchita della topologia:
.context.uses.<alias>.values— scritto dallo sviluppatore, dichiarato nella voceusesestesa dell’Aggregate, validato rispetto alvalueSchemadel socket..context.uses.<alias>.infra— scritto dall’operatore, dichiarato nella Release, validato rispetto all’infraSchemadel socket.
Il socket (usesSchema[<socket>]) è il contratto dell’Architetto su quali connessioni sono possibili e quale configurazione possono portare; values e infra suddividono quella configurazione per dominio di authoring, rispecchiando la suddivisione values/infra sui componenti. Un arco ha quindi due autori: lo sviluppatore collega la topologia e la regola con values nell’Aggregate, mentre l’operatore imposta infra per connessione nella Release, all’interno dei socket che l’Architetto ha dichiarato. La Release può anche collegare un arco in un socket dichiarato ma non associato verso un componente esistente; non può reindirizzare un arco dichiarato dallo sviluppatore — vedi entities/release.md §«Per-edge connection configuration (Configurazione della connessione per arco)».
La configurazione per arco ha l’ambito del consumatore: compare solo nel contesto del nodo che ha scritto l’arco (l’origine della connessione), mai nel contesto del target. L’output renderizzato di un target è quindi invariante rispetto ai consumatori che vi si connettono. Una Feature associata al target è l’unico punto in cui le connessioni sono visibili: la sua FeatureRecipe legge quali componenti usano il target in .context.used_by — per ciascuno l’identità, il socket, i provides pubblicati, il namespace e il confine in cui è collocato e, per una FeatureRecipe che dichiara di leggerli, i fatti di rendering riportati dai suoi provider — mai i values o l’infra propri della connessione. Una Feature associata al consumatore legge, allo stesso modo, ciò che ha riportato il rendering di ciascuno dei suoi target, nella voce di quella connessione in .context.uses.<alias>.render_facts, dove la sua FeatureRecipe dichiara di leggerli.
Associazioni della connessione (features). Una connessione può anche portare associazioni proprie — ad esempio una credenziale che il consumatore presenta al componente raggiunto da questa connessione — sotto features: nella sua voce, indicizzate da uno slot che il socket dichiara nel suo featuresSchema. Gli stessi due autori se le suddividono: lo sviluppatore associa sulla voce di connessione dell’Aggregate con type e values, e l’operatore dimensiona quell’associazione con infra, oppure ne associa una propria con type e infra, sulla voce della Release. Un’associazione su una connessione non porta un proprio blocco inject, ed è per questo che è assente dalla regola di posizionamento sopra: non è uno dei punti in cui uno sviluppatore detta la consegna.
Ciascuna diventa un’associazione del componente consumatore denominata <alias>.<slot>, quindi ha l’ambito del consumatore esattamente come la configurazione per arco: la sua FeatureRecipe esegue il rendering dal lato del consumatore, e l’output del target non cambia con essa. È tenuta fuori dai .features della Recipe consumatrice, che contiene solo le associazioni dichiarate dal blocco proprio del componente; la Recipe la legge invece sotto la sua connessione, in .context.uses.<alias>.features.<slot>. Una connessione tracciata da un’associazione di Feature non porta associazioni. Vedi entities/aggregate.md §«A connection’s own attachments (Le associazioni proprie di una connessione)» e entities/component.md §«Topology Sockets (Socket di topologia)».
A. Variabili d’ambiente (env) e risoluzione dinamica della destinazione Il meccanismo di consegna standard per le applicazioni cloud-native moderne. Per gli archi topologici espliciti (ad es. un agente che comunica con un database), Aggrega usa .context.uses per iniettare la mappatura delle variabili d’ambiente.
- Caso d’uso: Ricevere nomi DNS interni deterministici, stringhe di interpolazione Infrastructure-as-Code (ad es.
${module.db.endpoint}) o puntatori Vault statici. Il compilatore collega questi riferimenti statici in modalità AOT, così l’infrastruttura di runtime o il controller GitOps possono risolvere i valori effettivi.
B. Montaggi di file (file) Molti framework di IA aziendali si aspettano che un config.json strutturato o un certificato .pem esista in un percorso specifico sul disco, anziché basarsi sulle variabili d’ambiente.
-
Caso d’uso: Iniettare configurazioni JSON complesse o soddisfare SDK legacy che leggono dal disco.
-
Intento dello sviluppatore:
features:openai_key:type: core/aws-secrets-managervalues:path: /prod/ai/openaikey: "api_token"inject:file:- in: "/etc/secrets/openai.json" # Local pathfrom: "api_token" # The attachment's provides key -
Realtà di Ops: La Recipe di Ops genera dinamicamente i
Volume,VolumeMountedExternalSecretdi Kubernetes necessari per prelevare in modo sicuro i dati del vault e montarli in/etc/secrets/openai.json.
C. Argomenti della riga di comando (arg) I binari precompilati (come i nodi worker in Rust o Go) spesso ignorano del tutto le variabili d’ambiente e si aspettano che i valori vengano passati come flag di runtime nel loro comando di esecuzione.
-
Caso d’uso: Aggiungere realtà fisiche al comando di avvio del container.
-
Intento dello sviluppatore:
features:public-ingress:type: core/external-ingressinject:arg:- in: "--callback-url=" # Local flagfrom: "hostname" # The attachment's provides key -
Realtà di Ops: L’hostname è il nome che l’ambiente dà al componente, quindi l’operatore lo scrive,
api.enterprise.com, nell’infradi questa associazione sulla voce della Release per il componente. Il plugin Wasm della Feature riceve l’URL pubblico risolto tramite l’Injection Contract ed emette un JSONPatch per aggiungere dinamicamente elementi all’arrayargsdi Kubernetes:["/app/binary", "--callback-url=https://api.enterprise.com"], aggirando completamente la Recipe di base del Component.