Contratto del contesto dei template
Questa pagina documenta la vista di runtime che il compilatore inietta nei template Go di Recipe e FeatureRecipe: la forma del contesto di template, la disponibilità per campo lungo la pipeline di compilazione e il contratto canonico di cui gli autori avanzati hanno bisogno quando scrivono template che consumano stato tra componenti. La disponibilità per sito di template (quali campi sono presenti in quale sito di valutazione) si trova in expansion-matrix.md; questa pagina documenta le forme dei campi e la loro semantica.
Panoramica
Il compilatore assembla un contesto di template per nodo durante il rendering e lo inietta in ogni template Go che il renderer valuta per quel nodo. Il contesto esiste solo in memoria — non viene mai persistito su disco e non attraversa mai l’ABI Wasm come singolo payload. Ogni sito di template riceve una vista dello stesso oggetto di contesto; alcuni campi vengono popolati tardi (.workload arriva alla sintesi del workload; .source alla risoluzione della sorgente; .steps viene popolato dall’esecuzione di pipeline: man mano che ogni passo si completa, vedi Stato del linguaggio → Fasi della pipeline di compilazione).
Lo schema per la forma di runtime è template-context-v1beta1.schema.json (distribuito con la distribuzione degli schemi di Aggrega).
Campi di primo livello
I campi di primo livello si trovano alla radice del contesto di template — vi si accede come .field dall’interno di un template.
.values(mappa). Payload cognitivo scritto dallo sviluppatore proveniente dall’Aggregate. I valori per componente fluiscono fino alla Recipe renderizzata in questo campo. Validato dalloschema:del catalogo (la dichiarazione JSON Schema 2020-12 del Component o della Feature) alla risoluzione. Quando lo zero / vuoto / falso scritto per un campo è semanticamente distinto dall’assenza del campo, usaoptional(vedisprig-functions.md) anzichédefault..infra(mappa). Dimensionamento fisico scritto da Ops proveniente dalla Release. Validato dalloschema:del catalogo (la dichiarazione JSON Schema 2020-12 del Component o della Feature) alla risoluzione. Vale la stessa indicazioneoptional-vs-defaultdata per.values— preferiscioptionalquando uno zero o un falso scritti dall’autore sono un’intenzione legittima (scale-to-zero, nessun retry, feature flag disattivato)..locals(mappa con valori stringa). Stato privato della Recipe — nomi dichiarati nel bloccolocals:della Recipe, risolti nel preambolo dei locals e pubblicati su questo pilastro alla risoluzione della sorgente. Le voci si risolvono nell’ordine dell’autore e una voce può leggere una voce sorella definita sopra di essa, quindi l’ordine è determinante ovunque una voce ne legga un’altra. Accessibile solo all’interno dei template della Recipe stessa; mai esposto ai chiamanti..provides(mappa con valori stringa). Le stringhe di output pubbliche della Recipe — il contratto rispetto a cui i blocchiinject:dei chiamanti risolvono i riferimentifrom:. Popolato alla valutazione dei provides..features(mappa di associazioni). Itera le Features associate a questo Component (a livello di Aggregate + a livello di sottosistema + a livello di Release + guidate dalle annotazioni del Manifest, secondo il modello a cipolla a 5 livelli), con chiave il nome di istanza che l’autore ha dato all’associazione. Ogni voce porta gli stessi campi — vedi la forma dell’associazione più sotto. Un’associazione scritta su una delle connessioni del Component non è tra queste: viene letta sotto quella connessione, in.context.uses.<alias>.features.<slot>, quindi un template che itera.featuresincontra solo le associazioni proprie del Component..metadata(struct). Identità della Release per una denominazione deterministica:release_name,release_version,environment,aggregate_name. Popolato per ogni rendering; i valori provengono dal bloccometadata:della Release..source. Ilsource:della Recipe, risolto dalla valutazione del template di risoluzione della sorgente.nilper le Recipes senza sorgente;nilprima che venga eseguita la risoluzione della sorgente. Sui template di una FeatureRecipe è ilsource:proprio di quella FeatureRecipe, mai quello del componente host — vedi Superficie della FeatureRecipe di un’associazione..workload. L’oggetto Workload analizzato, popolato una volta che il documentoworkload:renderizzato è stato decodificato e ha superato la validazione che lo vincola: lo schema del Workload, ilfeaturesSchemadel Component per ogni associazione che i suoi container dichiarano, e la risolvibilità di ciò a cui ogni associazione fa riferimento.nilper le Recipes non sintetizzate;nilprima che venga eseguita la sintesi del workload..steps(mappa degli output dei passi). Popolato dall’esecuzione dipipeline:man mano che i plugin Wasm vengono eseguiti, ed espone gli output restituiti da un passo completato ai passi successivi tramite.steps.<id>.outputs. Un passo legge gli output di un passo precedente dal proprio templatewith; glioutputsdi un passo diventano visibili solo ai passi dichiarati dopo di esso. Vuoto quando il nodo non dichiara alcuna pipeline, e prima che il primo passo del nodo si completi.
Un campo di primo livello che non contiene nulla per questo nodo — .workload su una Recipe che non ne sintetizza alcuno, .source su una Recipe senza sorgente, .features su un Component senza associazioni — si legge come vuoto in un template di valore, esattamente come una chiave non impostata sotto .values: {{ .workload }} non renderizza nulla, un default applicato su di esso fornisce il suo fallback, e un if o un with su di esso prende il ramo falso. Un range su di esso non itera nulla. Una lettura al di sotto di esso — {{ .workload.containers }} — si arresta comunque, perché non c’è nulla in cui scendere. E un template che sia stampa un tale campo dove viene sempre eseguito — fuori da ogni if, with e range — sia lo itera si arresta nominando il campo, come fa per qualsiasi percorso che non contiene nulla letto in entrambi i modi, perché nessun singolo valore si stampa come nulla e itera come nulla: vedi A template reads and iterates a path that holds nothing (Un template legge e itera un percorso che non contiene nulla).
La forma dell’associazione
.features.<name> e .features.<slot> hanno la stessa forma — un’associazione, letta in un unico modo:
.type(stringa). L’URI di catalogo della Feature associata..resolved_version(stringa). La versione della Feature associata dopo la risoluzione del Manifest — la versione effettivamente legata a questa build, anziché un pin ripetuto sul lato che consuma. Rispecchia.context.uses.<alias>.resolved_version. Vuoto quando iltypedell’associazione non si risolve in alcuna entità di catalogo..labels(mappa con valori stringa). Le etichette di catalogo della Feature associata, trasportate alla lettera nell’ordine in cui la Feature le dichiara — nulla viene filtrato, rinominato o privato del prefisso, quindi un template legge esattamente ciò che l’autore della Feature ha scritto. Rispecchia.context.uses.<alias>.labels. Assente quando la Feature non dichiara etichette e quando iltypedell’associazione non si risolve in alcuna entità di catalogo..values(mappa). Il pilastro dell’intento dello sviluppatore proprio dell’associazione, scritto nella dichiarazione dell’associazione nell’Aggregate. Distinto dal.valuesdi primo livello del componente host..infra(mappa). Il pilastro del dimensionamento operativo proprio dell’associazione, scritto nella dichiarazione dell’associazione nella Release. Distinto dall’.infradi primo livello del componente host..provides(mappa con valori stringa). Il contratto pubblico risolto della FeatureRecipe assegnata a questa associazione — il nome della risorsa emessa, la sua chiave di dati, un’identità cloud ed eventuali chiavi aggiuntive che la FeatureRecipe pubblica. Si legge come.features.<name>.provides.<key>, rispecchiando.context.uses.<alias>.provides: il consumatore legge ciò che il produttore ha pubblicato invece di ricavarlo di nuovo. Un’associazione la cui FeatureRecipe assegnata non pubblica nulla non porta alcuna chiaveprovides, anziché una mappa vuota, quindi verifica prima di indirizzare una singola chiave.
.provides è ciò che rende un’associazione consumabile anziché semplicemente presente. Una Feature che dichiara un contratto schema.provides vede quel contratto applicato alla FeatureRecipe che la realizza — la FeatureRecipe deve pubblicare ogni chiave dichiarata — e il consumatore ne legge il risultato qui. Così una Feature di identità che emette un ServiceAccount e ne pubblica il nome consente alla Recipe consumatrice di collegarsi a esso:
workload: | serviceAccount: "{{ .features.identity.provides.name }}"Il nome emesso viene dichiarato una sola volta, dal produttore, e consumato — mai ripetuto sul lato che consuma, dove i due potrebbero divergere. L’esempio workload-identity-binding ne esegue il rendering da un capo all’altro.
.labels è ciò che consente a un template di adattarsi a che cosa è un’associazione senza confrontarne il nome né analizzarne l’URI. Il compilatore non ne legge nessuna — trasporta le stringhe, e l’autore del template decide che cosa significano.
Una Feature che non dichiara etichette non porta alcun .labels, anziché una mappa vuota, quindi verifica prima di indirizzare una singola etichetta — accedere attraverso una chiave che non c’è arresta la build. Leggi un’etichetta che la Feature potrebbe non dichiarare tramite optional, perché index si arresta indicando la chiave quando la mappa non la contiene:
{{ if .features.db.labels }}{{ if eq (optional .features.db.labels "feature.aggrega.ai/kind" "") "secret" }}...{{ end }}{{ end }}Poiché le etichette arrivano alla lettera, il namespace proprio dell’autore di un catalogo raggiunge il template invariato, e una Recipe legge la stessa chiave che la Feature dichiara.
Il blocco .context
.context è il contesto di esecuzione assemblato dal compilatore per un singolo nodo — i dati di identità, di topologia e della pipe di consegna che il renderer fa passare attraverso ogni punto di template. I suoi campi:
.context.instance_id(stringa). L’identità del nodo come nome — il valore che la build stessa usa per nominare ed etichettare ciò che emette, così un template che ne compone un nome di risorsa o un indirizzo interno al cluster prevede il nome che la build produce davvero. È il nome che hai scritto per un nodo dichiarato dal tuo Aggregate. Per un nodo apportato da un Aggregate importato è l’identità appiattita con il separatore di modulo scritto per esteso (data-layer.main-dbdiventadata-layer-zdmain-db), perché un punto non è un carattere che un nome di risorsa possa contenere e, in un indirizzo del cluster, separa un servizio dal suo namespace. La forma con il punto è quella che i tuoi documenti e la diagnostica della build usano per indirizzare quel nodo; vedi Convenzioni di denominazione..context.rendered_name(stringa). Il nome che il provider del nodo dà alle risorse che renderizza per il nodo — dal sorgente che hai fornito, come il nome della release letto da un chart, e da un workload che sintetizza, laddove dà alle risorse di quel workload un nome proprio, come fahelmcon lo stesso nome della release. Presente solo dove quel provider ne ricava uno. Nei template di un’associazione di Feature è il nome del componente host, come lì.context.instance_idè l’identità dell’host; vedi Assegnare un nome a una risorsa renderizzata..context.labels(mappa con valori stringa). Etichette scritte nel catalogo più eventuali aggiunte dilabel-transformfatte durante la costruzione della topologia..context.annotations(tre contenitori, vedi sotto). Annotazioni propagate a cascata, raggruppate per origine..context.inject(mappa di meccanismi, vedi sotto). La pipe di consegna pre-idratata e intercettata — la superficie standard che i template della Recipe leggono per i valori tra componenti..context.uses(mappa di connessioni, vedi sotto). La proiezione JOIN sugli archi topologici in uscita..context.self_inject(mappa di meccanismi, vedi sotto). Per ogni nome che lo sviluppatore ha scritto nel bloccoinject:del componente stesso, la chiave provides propria che quella voce consegna oppure l’unico valore proprio che il suo template legge..context.used_by(lista, vedi sotto). I componenti le cui vociusespuntano a questo. Letto da una FeatureRecipe associata al componente, nei template che producono le risorse proprie dell’associazione; vuoto ovunque altrove..context.render_facts(mappa di liste, vedi sotto). Ciò che il provider del componente ha riportato sull’output che ha renderizzato, indicizzato per nome del fatto. Letto da una FeatureRecipe associata al componente, in ognuno dei suoi template che viene eseguito dopo il rendering del componente; assente ovunque altrove.
.context.annotations — tre contenitori
Le annotazioni si propagano a cascata in tre contenitori indicizzati per origine:
.context.annotations.release— annotazioni del confine della Release (Dominio 4). Usate per governare le realtà fisiche; i renderer le instradano nei campiinfra:dove opportuno. Le annotazioni noteaggrega.ai/*risiedono in questo contenitore..context.annotations.catalog— annotazioni dei metadati del Component dal Dominio 2. Tratti intrinseci immutabili scritti dall’Architect; consumati principalmente dai plugin di policy Wasm..context.annotations.aggregate— annotazioni di sottosistema dell’Aggregate dal Dominio 1. Metadati cognitivi; i renderer le instradano nei payloadvalues:dove opportuno.
Ogni contenitore è una mappa piatta da stringa a stringa. Secondo le regole di separazione dell’architettura, i contenitori sono destinati a usi distinti; il motore non impone la separazione, quindi è la disciplina di authoring a mantenere i contenitori allineati con la semantica a cui sono destinati. Vedi capitolo 6 §2 Flusso 5 per il design delle annotazioni a cascata.
.context.inject — la pipe di consegna
La pipe è la mappa di consegna pre-risolta del compilatore. Nel momento in cui un template della Recipe viene eseguito nel rendering di base, ogni sorgente di inject (letterali self-inject scritti dallo sviluppatore, riferimenti from: self-inject risolti rispetto ai propri provides, riferimenti uses[].inject tra componenti risolti rispetto ai provides del target, intercettazioni injectMapping delle FeatureRecipe) è stata risolta in un valore stringa finale e unita in questa mappa.
Campi:
.context.inject.env— mappa con valori stringa da nome di variabile d’ambiente → valore risolto..context.inject.file— mappa con valori stringa da percorso di file → valore risolto..context.inject.arg— mappa con valori stringa da flag di argomento → valore risolto..context.inject.all— mappa con valori stringa che combina i meccanismienv/file/arg/personalizzati in un unico dizionario piatto; utile per serializzare l’intera pipe ({{ toJson .context.inject.all }}).
Un meccanismo è nella pipe solo quando qualcosa consegna attraverso di esso. Un template che ne legge uno attraverso cui nulla consegna — .context.inject.file senza alcuna consegna di file — lo legge come vuoto, come un template di valore legge qualsiasi chiave assente, e un range su di esso non renderizza nulla; quella lettura fornisce il valore vuoto per l’intero template, quindi un {{ toJson .context.inject }} nello stesso template mostra "file": "". hasKey .context.inject "file" indica se qualcosa consegna attraverso di esso.
- Meccanismi personalizzati (ad es.,
ssm_param) — leggibili sotto il proprio nome di campo,.context.inject.<mechanism>.<key>, esattamente come i tre di base. I valori di un meccanismo personalizzato raggiungono la pipe dal self-inject a livello di componente, da un arcouses[].inject, dalla mappaturainject:di un’associazione di Feature e dall’outputinjectMappingdi una FeatureRecipe. Per il self-inject a livello di componente, l’allowlistspec.injectdel Component deve nominare il meccanismo, e un meccanismo che l’allowlist non nomina arresta la build. Le voci di un meccanismo personalizzato compaiono anche in.context.inject.allaccanto ai tre di base. Un meccanismo personalizzato può avere qualsiasi nome tranneall: quel nome è la vista unita stessa, quindi un meccanismo con quel nome non potrebbe mai essere letto da solo. Un blocco inject che nomina un meccanismoall, e un’allowlist di un Component o di una Feature (spec.inject, l’injectdi un socket) che lo elenca, arrestano la build al caricamento del documento, e il rifiuto spiega che il nome appartiene a questa vista unita. I nomi distinguono tra maiuscole e minuscole, quindiALLè un normale meccanismo personalizzato.
La pipe è lo stato successivo all’intercettazione — i blocchi injectMapping delle FeatureRecipe hanno già unito in profondità le loro sostituzioni su questa pipe durante la mappatura degli inject, nel momento in cui i template della Recipe la leggono. Una mappatura può sostituire una chiave consegnata dal blocco inject: del componente stesso, da uno dei blocchi inject: delle sue connessioni o dal blocco inject: della sua stessa associazione; una chiave che due Features associate consegnano entrambe, attraverso i loro blocchi inject: o le loro mappature, arresta la build invece di raggiungere questa pipe con uno dei due valori. Una Feature associata a un confine della Release raggiunge il componente allo stesso modo, attraverso l’injectMapping della sua FeatureRecipe, che viene eseguito nel contesto del componente stesso qualunque sia l’executionScope della FeatureRecipe — la riscrittura, da parte del bridge di compose, della variabile host di un consumatore è una di queste mappature, soggetta alla stessa regola.
.context.self_inject — quale valore proprio consegna ciascuno dei nomi dello sviluppatore
Dove un Component dichiara spec.inject, lo sviluppatore può scrivere un blocco inject: sul componente stesso e scegliere i nomi sotto cui vengono consegnati i valori e i provides propri del componente. .context.inject contiene ciò in cui quelle voci si sono risolte e .inject_raw le contiene così come sono state scritte; .context.self_inject indica, per ciascuna, la chiave provides propria del componente che essa consegna oppure l’unico valore proprio che il suo template legge. Ha la forma che ha il .context.uses.<alias>.inject di una connessione — meccanismo, poi il nome dello sviluppatore, poi una chiave — con la chiave che nomina uno dei provides o dei valori propri del componente:
provides.<key>— una voce scritta confrom: <key>, che consegna uno dei provides propri del componente.values.<key>— una voce il cui templatevalue:legge esattamente uno dei valori propri del componente e nient’altro, essendo<key>la chiave di primo livello di quel valore. Il testo o le funzioni attorno alla lettura non contano, e nemmeno quanto in profondità il template legge nel valore:'{{ .values.role }}','role={{ .values.role | upper }}'e'{{ with .values.role }}{{ . }}{{ end }}'corrispondono tutti avalues.role, e'{{ .values.config.port }}','{{ index .values.config "port" }}'e'{{ (default dict .values.config).port }}'corrispondono tutti avalues.config.- una stringa vuota — ogni altra voce: un letterale, un template che legge due valori, un template che legge qualcosa oltre ai valori (
.infra,.metadata,.context), e un template la cui lettura dei valori il testo non attribuisce a un’unica chiave di primo livello — i valori passati a una funzione dalla loro radice (index .values "role"), i valori letti per intero (toJson .values, oppure un campo letto dentro{{ with .values }}o tramite una variabile legata a.values), oppure l’intero contesto passato oltre (toJson .).
# The developer's block on the component, in the Aggregateinject: env: - { in: SERVICE_HOST, from: host } - { in: AGENT_ROLE, value: '{{"{{"}} .values.role }}' } - { in: MODE, value: batch } - { in: ROLE_AND_GOAL, value: '{{"{{"}} .values.role }}-{{"{{"}} .values.goal }}' } ssm_param: - { in: /app/goal, value: '{{"{{"}} .values.goal }}' }
# What the Recipe reads at .context.self_injectenv: SERVICE_HOST: provides.host AGENT_ROLE: values.role MODE: "" ROLE_AND_GOAL: ""ssm_param: /app/goal: values.goalNell’Aggregate, ogni template value: si apre con {{"{{"}} anziché con {{, perché l’intero testo dell’Aggregate viene letto una volta come template, per l’interpolazione dei parametri, prima che vengano valutati i template del blocco stesso; i template citati nell’elenco sopra sono mostrati come si leggono dopo quell’escape. Vedi Testo che contiene le proprie doppie graffe.
È questo che permette a una Recipe che esegue l’immagine dello sviluppatore stesso di trattare come predefiniti i propri nomi di variabile per i valori propri del componente — la convenzione del catalogo della libreria standard, che un catalogo aziendale può scegliere diversamente. Prima di consegnare un valore proprio sotto un nome di sua scelta, una tale Recipe verifica se il blocco dello sviluppatore consegna già quel valore, e in tal caso salta il proprio predefinito — così uno sviluppatore che rinomina un valore mantiene tutti gli altri predefiniti:
workload: | containers: main: variables: {{- range $name, $value := .context.inject.env }} {{ $name }}: {{ $value | quote }} {{- end }} {{- $named := dict }} {{- with .context.self_inject.env }}{{ range $name, $key := . }}{{ $_ := set $named $key true }}{{ end }}{{ end }} {{- if not (hasKey $named "values.role") }} APP_ROLE: {{ .values.role | quote }} {{- end }}.context.self_inject è presente in ogni rendering ed è vuoto dove lo sviluppatore non ha scritto alcun blocco. Un meccanismo compare solo quando il blocco lo nomina, quindi proteggi la lettura di un meccanismo che il blocco potrebbe non nominare, come fa il with qui sopra. Un template incontra i nomi ordinati comunque li legga, come incontra ogni mappa. La mappa è letta dal testo scritto dallo sviluppatore; nulla in essa è un valore risolto, e il compilatore non attribuisce alcun significato ai nomi né alle chiavi.
.context.uses — proiezione JOIN
.context.uses è la vista arricchita del compilatore su ogni arco topologico in uscita dal nodo corrente. Ogni voce della mappa è indicizzata per alias locale del socket (ad es., databases.primary diventa .context.uses.primary quando l’Aggregate ha scritto uses: { databases: { primary: { target: ... } } }) e porta una proiezione JOIN dello stato risolto del target più il contratto di consegna lato chiamante:
.target(stringa) — ID di istanza del nodo target..socket(stringa) — nome del socket lato chiamante (la chiaveusesSchema)..provides(mappa con valori stringa) — le chiaviprovides:risolte del target (le stringhe di output pubbliche che la Recipe target ha esportato durante la valutazione dei provides)..inject(mappa da meccanismo → mappa da chiave → valore) — direttive inject lato chiamante per questo arco (il bloccoinject:nella dichiarazioneuses[].inject). Le chiavi dei meccanismi sonoenv/file/arg/personalizzate; le voci della mappa per meccanismo sono riferimenti chiave locale → chiave provides del target..labels(mappa con valori stringa) — le etichette del target, mai quelle del componente che consuma: l’insieme che porta il.context.labelsdel target stesso, le sue etichette scritte nel catalogo più eventuali aggiunte dilabel-transformfatte durante la costruzione della topologia..annotations(tre contenitori) — i contenitori di annotazionirelease/catalog/aggregatedel target..component(stringa) — URI del tipo di Component del target..resolved_version(stringa) — versione del Component del target dopo la risoluzione del Manifest..boundary_path(stringa) — percorso del confine della Release del target, impostato sia che il target risieda nel confine del chiamante sia in un altro..origin_feature(stringa) — impostato quando l’arco è stato sintetizzato da un’associazione di Feature (ad es., una Feature sidecar che contribuisce con un arcousesverso una Feature di credenziali)..values(mappa) — configurazione dello sviluppatore per arco, risolta, per questa connessione, scritta nella voceusesdell’Aggregate. Presente solo quando l’arco porta valori per arco..infra(mappa) — configurazione dell’operatore per arco, risolta, per questa connessione, scritta nella voceusesdella Release. Presente solo quando l’arco porta infra per arco..origin_release(booleano) —truequando è stata la Release a collegare questa connessione anziché l’Aggregate a dichiararla; assente per una connessione che l’Aggregate dichiara..features(mappa di associazioni) — le associazioni scritte su questa connessione, indicizzate per il nome dello slot che il socket dichiara; vedi sotto. Presente solo quando la connessione ne porta una..render_facts(mappa di liste) — ciò che i render del target hanno riportato sull’output che hanno emesso, indicizzato per nome del fatto, nella stessa forma del.render_factsdi un chiamante su.context.used_by: ogni fatto una lista, prima le chiamate del provider del target stesso e poi ciascuna delle sue Features nell’ordine in cui hanno eseguito il rendering, le liste che un nome riceve da ciascuno unite in una. Presente solo per una FeatureRecipe che impostareadsTargetRenderFacts: true— le sue associazioni vengono renderizzate una volta che ogni componente è stato renderizzato, quindi il render di ogni target è completo — e in tal caso su ogni connessione, vuoto per un target i cui provider non riportano nulla. Letto solo invaluesMapping:,workload:eartifacts:di quella FeatureRecipe; assente dai template della Recipe del componente stesso, da uninjectMapping:, dawith:ewhen:di un passopipeline:e da ogni FeatureRecipe che non imposta la chiave — un template di una di queste che lo legge arresta la build prima che venga renderizzato qualsiasi cosa.
Entrambe le mappe di configurazione per arco hanno ambito consumatore: finiscono solo nel contesto di rendering del nodo che consuma, mai in quello del target.
Un valore fornito si legge in .provides.<name> — i nomi forniti sono annidati sotto .provides anziché stare direttamente sull’arco, quindi .context.uses.<alias>.<name> non indirizza alcun campo e non restituisce nulla.
Su una connessione i cui due capi vengono renderizzati in output diversi, .provides contiene dei sostituti anziché i valori. Dove il provider collega una tale connessione con un proprio riferimento una volta assemblati entrambi gli output — uno stack CloudFormation che legge un valore di un altro stack, per esempio — ogni valore che .context.uses.<alias>.provides porta è un segnaposto che il provider sostituisce in seguito, con un riferimento tra stack o con il valore stesso, come descrive la sua pagina. Un tale valore va copiato, non confrontato — la stessa regola che segue il valore che una tale connessione consegna sulla pipe di inject, che è un segnaposto dello stesso tipo. Scrivilo per intero, all’interno di una stringa più ampia o tramite una funzione che lo lascia com’è, come quote. Un template che confronta un valore letto da .provides, ne fa la condizione di una diramazione, lo misura o lo modifica deciderebbe in base al segnaposto, quindi la build si arresta, indicando il template e ogni valore che ha letto; fai dipendere la diramazione da un valore proprio del componente che consuma. L’arresto copre ogni template che legge i .provides della connessione, incluso l’injectMapping: di una FeatureRecipe associata, e una FeatureRecipe con ambito di confine che legge le stesse connessioni sotto .boundary. Una connessione i cui due capi vengono renderizzati in un unico output porta i suoi valori così come sono.
Un alias nomina una connessione, quindi la mappa contiene una voce per ogni connessione che il componente stabilisce. La mappa è indicizzata solo per alias, qualunque sia il socket in cui una connessione è collegata, e due connessioni di uno stesso componente non condividono mai un alias — né su un socket né su due, qualunque documento o associazione abbia tracciato ciascuna. La build rifiuta una tale coppia, indicando entrambe le connessioni e dove ciascuna è stata scritta, prima che venga renderizzato qualsiasi cosa. Una lista che nomina due volte uno stesso target è una tale coppia, poiché l’alias di una voce di lista è il suo target; lo è anche una connessione local su un socket models accanto a una connessione local su un socket databases.
I template della Recipe consumano questa proiezione per cercare lo stato lato target senza percorrere il grafo IR. I template injectMapping delle FeatureRecipe la usano per accedere alle annotazioni del target per decisioni di instradamento tra confini (il pattern del resolver DNS K8s documentato in entities/featurerecipe.md è l’esempio canonico svolto).
Un template che itera .context.uses vede le connessioni in ordine di chiave — ordinate per alias — non nell’ordine in cui l’Aggregate le ha scritte. Ogni mappa su cui un template itera viene visitata in questo modo, inclusi .features e i .features di una connessione, quindi un template non recupera mai l’ordine di scrittura iterando una mappa; dove l’ordine ha un significato, la superficie di authoring lo modella come lista. In ogni caso l’output renderizzato è identico byte per byte tra build dello stesso input.
Le associazioni di una connessione — .context.uses.<alias>.features
Un’associazione scritta su una connessione — sotto features: nella voce uses di un componente nell’Aggregate, oppure nella voce della Release per quella connessione — riempie uno slot che il socket dichiara. È un’associazione del componente che consuma per tutto ciò che la build ne fa: il Manifest ne lega la realizzazione, la sua FeatureRecipe viene renderizzata sul lato del consumatore, il suo contratto provides viene applicato. Un template la legge sotto la connessione su cui è stata scritta:
{{- range $alias, $edge := .context.uses }}- name: {{ $alias }} api_base: {{ $edge.provides.endpoint }} {{- with $edge.features }}{{ with .credential }} api_key_secret: {{ .provides.name }} api_key_key: {{ .provides.key }} {{- end }}{{ end }}{{- end }}- Indicizzate per slot.
.context.uses.<alias>.features.<slot>nomina lo slot che il socket della connessione dichiara —credentialqui sopra — così un consumatore che raggiunge più target legge la credenziale propria di ciascun target sotto l’alias di quel target. Una connessione che non porta alcuna associazione non ha.features, ed è per questo che la lettura è protetta. - La forma dell’associazione. Ogni voce porta esattamente ciò che
.features.<name>porta per una delle associazioni proprie del componente —.type,.resolved_version,.labels,.values,.infrae i.providesrisolti della FeatureRecipe assegnata a essa — vedi la forma dell’associazione. I provides letti qui sono quelli rispetto a cui viene renderizzata la FeatureRecipe propria dell’associazione, quindi il nome a cui un consumatore fa riferimento e il nome della risorsa che quella FeatureRecipe emette sono un unico valore valutato. - Mai in
.features. I.featurespropri del componente contengono solo le associazioni scritte nel suo stesso blocco. Una Recipe che itera.featurese sceglie le associazioni per tipo —{{ range $name, $f := (default dict .features) }}{{ if eq $f.type "core/referenced-secret" }}…— quindi non incontra mai la credenziale di una connessione, nemmeno una della stessa Feature: un template raggiunge l’associazione di una connessione attraverso la sua connessione, mai attraverso.features. Lo stesso vale su ogni superficie che mostra le associazioni di un componente, incluso il contestoassertions.
I componenti che usano questo — .context.used_by
.context.uses guarda verso l’esterno, alle connessioni che un componente stabilisce. .context.used_by guarda verso l’interno, ai componenti le cui voci uses puntano a questo. Una FeatureRecipe associata al componente lo legge, ed è lì che va collocata una risorsa che descrive o limita quelle connessioni — una network policy che ammette solo i componenti dichiarati come chiamanti di questo, per esempio:
artifacts: callers.yaml: | apiVersion: v1 kind: ConfigMap metadata: name: {{ .context.rendered_name }}-{{ .attachment_name }} data: callers: | {{- range .context.used_by }} - component: {{ .component_id }} socket: {{ .socket }} selector: {{ .provides.selector }} {{- with .source_namespace }} namespace: {{ . }} {{- end }} {{- end }}Ogni voce porta:
.component_id(stringa) — l’ID di istanza del componente che si connette nella sua forma appiattita (frontend,data-layer.etl), il valore che un template di percorsosubDirectory:legge come.component_id..socket(stringa) — il socket che la connessione riempie sul componente che si connette (la sua chiaveusesSchema)..provides(mappa con valori stringa) — ciò che il componente che si connette pubblica, ristretto alle chiavi che il suo Component dichiara: gli stessi valori che un consumatore di quel componente legge in.context.uses.<alias>.provides. Una chiave che la Recipe del componente pubblica senza che il suo Component la dichiari non è tra questi..source_namespace(stringa) — il namespace in cui è collocato il componente che si connette: l’annotazioneaggrega.ai/namespaceche si applica a esso, propagata a cascata lungo i suoi confini, con la precedenza alla sua voce nella Release. Un componente la cui voce nella Release imposta il namespace, o lo azzera connull, porta la propria impostazione anziché quella del suo confine, quindi il valore nomina il namespace in cui vengono renderizzate le risorse proprie del componente. Assente quando nessun namespace si applica al componente; leggilo tramitewithoif, come fa l’esempio, anziché stamparlo così com’è..source_boundary_path(stringa) — il percorso del confine della Release che contiene il componente che si connette, con i confini annidati uniti da/(edge,edge/inner)..render_facts(mappa di liste) — ciò che i render del componente che si connette hanno riportato sull’output che hanno emesso, indicizzato per nome del fatto, nella stessa forma di.context.render_facts. Ogni fatto è una lista, quindi un template itera sempre su di esso, anche quando contiene una sola voce. Le sue voci possono provenire dal render proprio del componente che si connette e dai render delle Features associate a esso: le liste che un nome riceve da ciascuno sono unite in una, prima le chiamate del provider del componente stesso, poi ciascuna delle sue Features nell’ordine in cui hanno eseguito il rendering. Presente solo per una FeatureRecipe che impostareadsCallerRenderFacts: true— le sue associazioni vengono renderizzate una volta che ogni componente è stato renderizzato, quindi il render di ogni chiamante è completo — e in tal caso su ogni voce, vuoto per un chiamante i cui provider non riportano nulla. Una FeatureRecipe che non imposta la chiave non vede alcun.render_factssu nessuna voce, e un suo template che li legge arresta la build prima che venga renderizzato qualsiasi cosa.
I due valori di collocazione sono quelli che una FeatureRecipe con ambito di confine legge come source_namespace e source_boundary_path nella voce della stessa connessione nelle sue liste di archi .boundary: entrambe le viste leggono allo stesso modo dove è collocato un componente, quindi non sono mai in disaccordo su questo. Un arco in quelle liste porta anche il percorso di assemblaggio di ciascun estremo — source_assembly_path e target_assembly_path, la directory sotto la directory di output della build in cui il provider dell’estremo lo assembla — che una voce di .context.used_by non porta.
Una FeatureRecipe che imposta readsCallerRenderFacts: true legge i fatti di ogni chiamante nello stesso modo in cui legge quelli dell’host. Per un provider che documenta un fatto chiamato ports le cui voci portano ciascuna un port:
artifacts: callers.yaml: | callers: {{- range .context.used_by }} - component: {{ .component_id }} ports: {{- range .render_facts.ports }} - {{ .port }} {{- end }} {{- end }}Un chiamante il cui provider non riporta alcun ports renderizza un ports: vuoto anziché fallire, perché un nome che nessuno ha riportato si legge come nulla.
Come si comporta la lista:
- Nell’ordine di scrittura. Le voci seguono l’ordine in cui sono scritti i componenti che si connettono, poi l’ordine delle voci
usesproprie di ciascuno. Un componente che si connette due volte compare due volte, una per connessione. Poiché è una lista e non una mappa, unrangeincontra i chiamanti in quell’ordine — nulla viene ordinato. - Solo dove l’associazione renderizza le proprie risorse.
valuesMapping:,workload:eartifacts:della FeatureRecipe la leggono. È vuota nei template della Recipe del componente stesso, in uninjectMapping:e inwith:ewhen:di un passopipeline:, perché ciò che ciascuno di questi produce può finire nell’output renderizzato del componente stesso: uninjectMapping:scrive la pipe di consegna del componente, e un passo della pipeline può riscrivere i documenti del componente. È ciò che mantiene invariato l’output proprio di un componente chiunque lo usi — collegare un chiamante in più a un componente cambia l’output di una Feature a esso associata che legge i suoi chiamanti, e nulla di ciò che il componente stesso renderizza. - Nulla sulla connessione stessa. Una voce non porta
valuesoinfraper connessione né alcuna delle associazioni della connessione; questi restano al componente che consuma, sotto il suo.context.uses.<alias>. - Vuota quando nulla usa il componente. Un
rangesu di essa allora non renderizza nulla. - Convogliato, mai interpretato. L’identità, il socket, i valori pubblicati e la collocazione sono stringhe che il compilatore lascia passare, e i fatti di rendering sono ciò che i provider di ciascun chiamante hanno riportato, indicizzati per nome. Non deduce nulla da un nome, non recupera nulla e non decide nulla su quali chiamanti una risorsa debba ammettere; decide il template.
Ciò che un provider ha riportato su un render — .context.render_facts
Il provider di un componente può riportare fatti sull’output che ha renderizzato — proprietà dei documenti che ha scritto che solo la sua conoscenza del proprio formato può vedere. Quali fatti un provider riporta, con quali nomi e con che cosa in ciascuna voce, è il contratto documentato proprio di quel provider; vedi Riportare fatti su ciò che un guest ha emesso per il lato del provider. Il provider helm, per esempio, riporta le etichette dei template di pod che ha emesso, i selettori dei suoi controller e Services e le porte dei suoi container — vedi i suoi fatti di rendering. Una FeatureRecipe associata al componente legge ciò che il provider del componente ha riportato in .context.render_facts, indicizzato per nome del fatto. Per un provider che documenta un fatto chiamato ports le cui voci portano ciascuna un name e un port:
artifacts: ports.yaml: | ports: {{- range .context.render_facts.ports }} - name: {{ .name }} port: {{ .port }} {{- end }}- Ogni fatto è una lista. Un provider riporta ogni fatto come lista, anche quando contiene una sola voce, quindi un template itera sempre su di esso — non c’è un singolo valore da leggere da solo.
- Una lista per nome, unita lungo il render del componente. Il rendering di un componente può richiedere più di una chiamata del suo provider — un render di chart e un posizionamento di artifacts, per esempio — e ciascuna chiamata riporta per sé. Le liste che un nome riceve da quelle chiamate sono unite in una, nell’ordine in cui le chiamate sono state eseguite. Ciò che le Features associate al componente hanno renderizzato non è tra queste qui: una Feature legge solo il render proprio del componente in
.context.render_facts, qualunque cosa abbiano emesso le altre Features del componente. - Su ogni template di una FeatureRecipe associata. I suoi
valuesMapping:,workload:eartifacts:lo leggono, e così fannowith:ewhen:dei suoi passipipeline:— i fatti provengono dal render proprio del componente, quindi leggerli non fa dipendere nulla da chi si connette al componente. È assente dai template della Recipe del componente stesso e da uninjectMapping:, che vengono eseguiti prima che il componente sia stato renderizzato. - Vuoto anziché mancante. Dove il provider del componente non riporta nulla,
.context.render_factsè una mappa vuota, e un nome che nessuno ha riportato si legge come nulla, quindi unrangesu di essa non renderizza nulla anziché fallire. - Ordine. Una lista mantiene le sue voci nell’ordine in cui il provider le ha riportate. Una voce oggetto è una mappa con chiavi come ogni altra nel contesto, quindi un template che ne itera una incontra le sue chiavi in ordine di chiave.
- Convogliato, mai interpretato. Il compilatore verifica solo che il valore di ogni fatto sia una lista. Non legge nulla di ciò che un nome o una voce significa; il template decide che cosa farne.
Il .uses di un’asserzione — indicizzato per socket, poi per alias
Un template assertions: legge le stesse connessioni attraverso una propria vista più ristretta: .uses alla radice anziché sotto .context, e senza nulla di ciò che il target di una connessione ha pubblicato, perché entrambe le fasi delle asserzioni vengono valutate prima del rendering. Rispecchia la forma di authoring uses: <socket>: <alias>: { target: … } — indicizzato per socket, e sotto ogni socket per l’alias di ogni connessione su di esso, dove una connessione scritta come voce di lista prende il proprio target come alias. La voce di ogni connessione porta target, alias e, per una connessione tracciata da un’associazione di Feature, origin_feature, oltre a tre dei fatti che .context.uses porta, con gli stessi nomi e gli stessi valori: .labels, le etichette del target; .values, i valori scritti sulla connessione; e .features, le associazioni scritte su di essa, indicizzate per slot. Ciascuno dei tre è presente su ogni voce, vuoto dove la connessione non ne porta. Un’associazione sotto .features porta solo il suo type, resolved_version e values — la forma in cui un’asserzione legge ogni associazione, incluse quelle proprie di un componente, poiché la FeatureRecipe di un’associazione non ha ancora risolto i suoi provides quando viene eseguita un’asserzione.
Un socket che contiene una connessione e un socket che ne contiene diverse hanno la stessa forma, quindi un’asserzione legge l’uno o l’altro allo stesso modo. Per un componente la cui voce nell’Aggregate scrive uses: { models: { local: { target: llama }, fast: { target: turbo } } }:
assertions: two-models-wired: | {{- if lt (len (optional .uses "models" dict)) 2 -}} {{- fail "wire two models to the models socket" -}} {{- end -}} local-is-llama: | {{- if and (hasKey .uses "models") (hasKey .uses.models "local") (ne .uses.models.local.target "llama") -}} {{- fail (printf "the local connection must point at llama; it points at %s" .uses.models.local.target) -}} {{- end -}}hasKey .uses "models" chiede se il socket è collegato, len ne conta le connessioni, un range su di esso visita ciascuna in ordine alfabetico dei loro alias, e .uses.models.local.target legge una connessione. .uses.models.target non indirizza alcuna connessione, e si arresta sotto il missingkey=error della superficie delle asserzioni. Ogni connessione ha una voce propria, per la stessa ragione della mappa del contesto di rendering: due connessioni di uno stesso componente non condividono mai un alias, perché la build lo rifiuta prima che venga eseguita qualsiasi asserzione. Il contesto completo delle asserzioni è documentato in assertions-block.md.
Le superfici legate a inject
Il contesto di template porta questi campi a forma di inject, ciascuno con la propria semantica. Gli autori di Recipe e FeatureRecipe dovrebbero sapere quale superficie leggere.
| Superficie | Tipo | Popolato quando | Uso |
|---|---|---|---|
.context.inject | mappa di meccanismi (sempre presente) | Ogni render | La pipe di consegna standard pre-idratata — leggila nei template valuesMapping:/workload:/artifacts: e in qualsiasi punto di template di una FeatureRecipe. |
.inject (di primo livello) | mappa di meccanismi (annullabile) | Rendering della FeatureRecipe di un’associazione, dove l’associazione scrive un blocco inject: | Le voci inject: proprie dell’associazione, sotto ciascun meccanismo che il suo blocco nomina — env, file, arg o uno personalizzato come vault_ref — con ogni nome locale associato alla chiave nominata dal suo from:. Quella chiave è una che la FeatureRecipe pubblica nei suoi provides:, che il compilatore consegna anche nel .context.inject del componente, oppure una chiave che una FeatureRecipe che legge .inject consuma essa stessa: una voce che nomina una chiave che la FeatureRecipe non pubblica arresta la build, a meno che un template che la FeatureRecipe valuta rispetto a questo contesto — il suo valuesMapping:, workload:, artifacts:, omits: o il with: o il when: di un passo della pipeline — legga .inject tramite un percorso che il template nomina: .inject, .inject.env, {{ with .inject }} e simili, non un passaggio dell’intero contesto come toJson .. Il suo injectMapping: non conta, perché viene valutato rispetto al contesto del componente, dove .inject è assente. Il blocco di un’associazione non contiene letterali: una voce value: lì arresta la build, e un letterale di cui il componente ha bisogno si scrive nel blocco inject: del componente stesso. Un meccanismo personalizzato si legge in .inject.<mechanism> esattamente come .inject.env, e le sue voci compaiono in .inject.all accanto ai tre di base. Una lettura puntata di un meccanismo che l’associazione non scrive provoca un arresto come chiave sconosciuta, anche dentro un if o un with, dove .context.inject.<mechanism> risulta vuoto; leggi un meccanismo che l’associazione potrebbe non scrivere tramite {{ with .inject }}{{ if hasKey . "<mechanism>" }}{{ index . "<mechanism>" "<key>" }}{{ end }}{{ end }}, che supera la build indipendentemente dal fatto che l’associazione scriva il meccanismo o un qualsiasi blocco inject:. Assente dai template di una Recipe di base e da un’associazione che non scrive alcun blocco inject:. |
.inject_raw (di primo livello) | mappa di meccanismi (annullabile) | Impostato quando lo sviluppatore ha scritto un blocco inject: sul componente padre | L’intento dello sviluppatore non modificato, prima di qualsiasi intercettazione di inject-mapping. Ogni meccanismo che il blocco nomina — env, file, arg o uno personalizzato come ssm_param — si trova sotto il proprio nome e contiene le voci esattamente come sono scritte (in con from o value), nell’ordine in cui sono scritte: .inject_raw.ssm_param legge un meccanismo personalizzato nello stesso modo in cui .inject_raw.env legge quello di base. Da usare per verifiche logiche del tipo «lo sviluppatore ha originariamente richiesto questa chiave di consegna?»; immune alla riscrittura da parte dell’injectMapping di una FeatureRecipe. nil se lo sviluppatore ha omesso il blocco inject:. |
.context.self_inject | mappa di meccanismi (sempre presente) | Ogni rendering; vuoto dove lo sviluppatore non ha scritto alcun blocco inject: sul componente | Ogni nome nel blocco inject: del componente stesso, mappato alla chiave propria che la sua voce consegna — provides.<key>, values.<key> o vuoto. Da usare per saltare un nome predefinito per un valore proprio che lo sviluppatore consegna già; vedi sopra. |
Gli autori che hanno bisogno della consegna risolta dopo l’intercettazione dovrebbero leggere .context.inject. Gli autori che hanno bisogno dell’intento originale immutabile (ad es., per rilevare un’intercettazione o per emettere un comportamento di fallback quando lo sviluppatore ha omesso un blocco inject) dovrebbero leggere .inject_raw. Gli autori che hanno bisogno di sapere quali valori propri del componente lo sviluppatore ha già nominato dovrebbero leggere .context.self_inject.
Superficie della FeatureRecipe di un’associazione
Quando il renderer valuta i template della FeatureRecipe di un’associazione, viene impostato un campo aggiuntivo di primo livello:
.attachment_name(stringa) — il nome di istanza dell’associazione: lo slot che riempie nelfeaturesSchemadell’entità proprietaria, oppure il nome libero che l’autore le ha dato.locals:,provides:,injectMapping:,valuesMapping:eartifacts:di una FeatureRecipe lo leggono per ricavare un identificatore di risorsa deterministico —{{ .context.rendered_name }}-{{ .attachment_name | replace "_" "-" }}dove il provider dell’host riporta un nome renderizzato, come fahelm, e{{ .context.instance_id }}-{{ .attachment_name }}dove non ne riporta alcuno — e per nominare l’associazione in fase di elaborazione.
I template propri di una Recipe di base non stanno risolvendo un’associazione, quindi il campo non fa parte del loro contesto: un template provides:, locals: o source: di una Recipe che vi fa riferimento si arresta indicando il riferimento anziché renderizzare un valore vuoto. Una FeatureRecipe con executionScope: boundary viene renderizzata una volta per il confine anziché una volta per componente, quindi il campo non è disponibile nemmeno per i template eseguiti per il confine; il suo injectMapping: viene eseguito per ogni componente che l’associazione raggiunge e lì lo legge.
Sui template che producono le risorse proprie dell’associazione — i suoi valuesMapping:, workload: e artifacts: — il contesto dell’associazione elenca anche i componenti che usano il suo host, in .context.used_by, e, dove la sua FeatureRecipe imposta readsTargetRenderFacts: true, porta ciò che ha renderizzato ciascun componente a cui il suo host è collegato, in .context.uses.<alias>.render_facts. Quei template e i suoi passi pipeline: leggono anche ciò che il provider del suo host ha riportato sul render dell’host, in .context.render_facts. Una FeatureRecipe con ambito di confine renderizza le proprie risorse per nessun componente host e senza .context; legge invece ogni connessione verso il suo confine sotto .boundary.internal_uses_edges e .boundary.incoming_cross_boundary_uses_edges. Il suo injectMapping: è l’unico template che scrive che viene eseguito nel contesto di un componente — quello di ogni componente che l’associazione raggiunge, .context.* incluso — e un riferimento a .boundary lì arresta la build.
Il campo è l’unica via per il nome di istanza dell’associazione. .context.instance_id è il componente host per cui l’associazione si sta risolvendo — denota l’host su ogni superficie di template che il compilatore valuta, inclusi i locals: propri di una FeatureRecipe — quindi i due nomi non sono intercambiabili, e nessuno dei due sostituisce l’altro.
.source è proprio dell’associazione. Il template source: di una FeatureRecipe viene valutato prima del suo valuesMapping:, come quello di una Recipe prima del proprio, e ciò che ha prodotto è ciò che .source contiene sui template che producono le risorse dell’associazione — il suo valuesMapping:, omits:, workload: e artifacts: — e sui suoi passi pipeline:. Non è mai la sorgente del componente host: una FeatureRecipe che non dichiara alcun source:, o il cui template non produce nulla, lì non legge nulla, anche su un host la cui Recipe ne dichiara uno. Una FeatureRecipe con ambito di boundary legge la propria sorgente sugli stessi template. L’unica eccezione è l’injectMapping:, che viene eseguito prima che la sorgente dell’associazione sia valutata e legge .source come fa la Recipe propria del componente host.
Anche .context.rendered_name è quello del componente host: su ogni template di un’associazione per componente porta il nome che il provider proprio dell’host riporta per l’host — il valore che legge la Recipe propria dell’host — così un’associazione nomina una risorsa in base al suo host con {{ .context.rendered_name }}-{{ .attachment_name }} e ottiene un nome che la piattaforma accetta anche dove l’identità dell’host contiene un trattino basso o una lettera maiuscola. È presente ovunque il provider dell’host riporti un nome e assente dove non ne riporta alcuno, e leggerlo su un host di questo tipo arresta la build da qualsiasi template che la FeatureRecipe scrive inline diverso dal suo injectMapping:; vedi Assegnare un nome a una risorsa renderizzata.
Disponibilità per punto di template
La disponibilità dei campi varia in base al punto di template. I template provides: della Recipe vengono eseguiti durante la valutazione dei provides con un contesto autosufficiente (niente .context.inject/.context.uses); valuesMapping: della Recipe viene eseguito nel rendering di base con il contesto di template completo; injectMapping: della FeatureRecipe viene eseguito durante la mappatura degli inject con il contesto di template completo, inclusa la pipe di inject che viene intercettata. La tabella completa della disponibilità punto per punto si trova in expansion-matrix.md; questa pagina documenta le forme dei campi a cui punta la colonna «riferimenti disponibili» della matrice.
Riferimenti incrociati
05-templates.md— panoramica sul templating.expansion-matrix.md— matrice di valutazione per punto di template.sprig-functions.md— helper Sprig integrati nel motore di template.../entities/recipe.md— superficie di authoring della Recipe.../entities/featurerecipe.md— superficie di authoring della FeatureRecipe (incluso l’esempio svolto del resolver DNS K8s per l’attraversamento di.context.uses).../vocabulary/topology-triad.md— specifica dell’Injection Contract (copre il contesto a doppio stato, le regole di collisione delle chiavi e gli esempi svolti).../10-status.md#compilation-pipeline-phases— stato di prontezza attuale delle superfici di inject-mapping, di rendering di base e di pipeline dei plugin.