Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Il blocco `assertions:`

Component, Feature, Recipe e FeatureRecipe portano un campo facoltativo spec.assertions: — una mappa di regole con nome che il compilatore valuta dopo la convalida dello schema ma prima del rendering. Ogni chiave è un identificatore di regola che compare nel messaggio di errore; ogni valore è un corpo di template Go. Un singolo corpo di template scritto direttamente sotto assertions: non ha la forma del campo e viene rifiutato quando l’entità viene letta, quindi ogni regola viene scritta sotto un nome proprio. Il blocco esprime regole tra campi che JSON Schema non può catturare in modo compatto: invarianti che coinvolgono più campi dove nessun singolo campo è «quello che viene convalidato». Questa pagina tratta la grammatica di authoring, la fase di valutazione, il contesto del template e la ripartizione delle responsabilità tra le asserzioni di Component / Feature (invarianti architetturali del contratto) e le asserzioni di Recipe / FeatureRecipe (invarianti di implementazione dello specifico provider).

Per i vincoli sul singolo campo (intervallo, pattern, enum, formato), usa le parole chiave native di JSON Schema all’interno di schema:. Per i predicati personalizzati sul singolo campo, usa il campo validate: della forma compatta. Per la forma condizionale, usa when:. Il campo assertions: li completa — è la sede delle vere regole tra campi.

Dove compare il campo

Le quattro entità che possono portare assertions::

  • Component — invarianti architetturali del contratto del Component.
  • Feature — invarianti architetturali del contratto della Feature.
  • Recipe — invarianti di implementazione del chart o del modulo sottostante della Recipe.
  • FeatureRecipe — invarianti di implementazione del meccanismo sottostante della FeatureRecipe.

Il campo è facoltativo su ciascuna. Le entità senza regole tra campi omettono del tutto il campo.

Quando vengono eseguite le asserzioni

Le fasi di valutazione delle asserzioni si collocano tra la convalida dello schema e il rendering nella pipeline di compilazione:

  1. Risoluzione: convalida e interpolazione dei parametri, poi convalida dello schema rispetto a schema: / usesSchema: / featuresSchema:.
  2. Costruzione della topologia e finalizzazione del grafo: il grafo viene assemblato.
  3. Analisi statica: il selettore di ogni socket uses: viene verificato rispetto alle etichette dei componenti raggiunti dalle sue connessioni.
  4. Asserzioni di Component / Feature valutate rispetto a ogni istanza.
  5. Binding della Recipe.
  6. Asserzioni di Recipe / FeatureRecipe valutate rispetto all’istanza legata.
  7. Rendering: template di mappatura valutati, output prodotto.

Le due fasi di asserzione vengono eseguite prima di qualsiasi rendering — nessun chart renderizzato, nessun file Compose generato. L’unica cosa che viene chiesta a un provider prima che vengano eseguite le asserzioni della Recipe è il nome che dà alle risorse di ciascun nodo legato, che il provides di una Recipe può leggere. Un’asserzione non riuscita arresta immediatamente la build con il messaggio di errore specifico dell’asserzione; i passaggi successivi non vengono eseguiti.

La separazione tra le due fasi riflette la ripartizione delle responsabilità: le regole a livello di Component si applicano indipendentemente da quale Recipe venga legata, quindi scattano prima del binding; le regole a livello di Recipe si applicano data una specifica scelta di Recipe, quindi scattano dopo il binding.

Il contesto di template

Per le assertions: di Component e Feature, il contesto di template espone lo stato risolto dell’istanza:

  • .values — il contenuto values dello sviluppatore.
  • .infra — il contenuto infra degli Ops (dall’Aggregate o dalla Release).
  • .uses — le connessioni uses: risolte, ciascuna già verificata rispetto al selettore del proprio socket, nella forma in cui l’autore le scrive: indicizzate per nome del socket e, sotto ogni socket, per l’alias di ogni connessione su di esso — il nome che l’autore ha dato alla connessione sotto il socket o, per una connessione scritta come voce di un elenco, la sua destinazione. La voce di ogni connessione descrive la connessione e non porta nulla di ciò che la sua destinazione ha pubblicato. target è l’id di istanza della destinazione risolta, alias ripete il nome con cui la voce è indicizzata, e origin_feature è presente quando la connessione è stata tracciata da un’associazione di Feature. Accanto a questi si trovano tre fatti, con i nomi con cui un template della Recipe li legge sulla voce .context.uses.<alias> della stessa connessione, dove template-context-contract.md descrive che cosa contiene ciascuno: labels — le etichette della destinazione, mai le etichette del componente su cui viene eseguita l’asserzione — values, i valori scritti sulla connessione, e features, le associazioni scritte sulla connessione, indicizzate per lo slot che ciascuna occupa. Ciascuno dei tre è presente su ogni connessione, vuoto dove la connessione non ne porta, e un’associazione sotto features ha la forma che .features dà a un’associazione più sotto. Così .uses.<socket>.<alias>.target legge la destinazione risolta di una connessione, .uses.<socket>.<alias>.labels le etichette di quella destinazione, un socket che contiene più connessioni contiene una voce per ciascuna, e un riferimento che attraversa questa mappa per raggiungere un valore pubblicato dalla destinazione arresta la build, perché la voce non porta alcun campo di questo tipo.
  • .features — le associazioni risolte, indicizzate per il nome di istanza che l’autore ha dato a ciascuna. Ogni voce porta type (l’URI di catalogo della Feature associata), resolved_version (la versione legata per questa build) e values (il contenuto di intento dello sviluppatore proprio dell’associazione). Un’associazione scritta su una delle connessioni del componente non è tra queste, esattamente come non è tra le .features di un template della Recipe: viene letta sotto la sua connessione, in .uses.<socket>.<alias>.features.<slot>, in questa stessa forma.
  • .metadata — l’istanza in corso di valutazione: il suo instance_id, il suo tipo component e la sua resolved_version, il suo boundary_path, e aggregate_name, aggregate_version e release_version della build.

Per le assertions: di Recipe e FeatureRecipe, il contesto aggiunge campi specifici della Recipe:

  • .provides — i valori provides: risolti del componente in corso di valutazione, già calcolati nel momento in cui viene eseguita l’asserzione. I valori pubblicati da una destinazione non si trovano su questa superficie; raggiungono invece un chiamante nel contesto di rendering.
  • .locals — i locals della Recipe.
  • .recipe.metadata — name e version della Recipe, e la sua capability.
  • .recipe.source — il puntatore al sorgente della Recipe.

L’accesso ai campi usa la sintassi standard dei template Go (.values.architecture, .uses.databases.primary.target); il costrutto che arresta la build è {{ fail "message" }} secondo il contratto Loud Guardrails — un’asserzione fallita produce un errore chiaro e specifico in fase di build che nomina l’invariante violato.

Questa superficie valuta con missingkey=error. Un riferimento a una chiave che il contesto non porta arresta la build — nominando l’entità, l’istanza, l’asserzione e la chiave assente — anziché essere renderizzato come nulla. Questo rigore è ciò che rende affidabile un’asserzione: un predicato il cui riferimento venisse renderizzato vuoto confronterebbe con nulla e passerebbe, così un singolo errore di battitura ritirerebbe silenziosamente la regola che l’asserzione è stata scritta per far rispettare. Significa anche che il riferimento nudo si risolve prima che possa essere eseguito qualsiasi fallback, quindi un campo facoltativo ha bisogno di una forma che tenga conto della presenza; errors/fatal-halts.md riporta la politica sulle chiavi mancanti di ciascuna superficie e le forme che funzionano con essa.

Leggere le connessioni su un socket. La voce di un socket ha una sola forma qualunque cosa contenga: una voce per connessione, sotto il suo alias. Un’asserzione legge una connessione tramite il suo alias, conta o percorre il socket per vedere ogni connessione su di esso, e verifica la chiave del socket stesso per chiedere se sia cablato o meno. Dato un componente la cui voce nell’Aggregate scrive

uses:
models:
local: { target: llama }
fast: { target: turbo }

queste asserzioni la leggono in ciascun modo:

assertions:
# The socket's presence: the socket key alone, however many connections it holds.
models-wired: |
{{- if not (hasKey .uses "models") -}}
{{- fail "wire at least one model to the models socket" -}}
{{- end -}}
# Every connection on the socket: a range visits each one.
every-model-distinct: |
{{- $seen := list -}}
{{- range $alias, $connection := (optional .uses "models" dict) -}}
{{- if has $connection.target $seen -}}
{{- fail (printf "connection %s points at %s, which another models connection already points at" $alias $connection.target) -}}
{{- end -}}
{{- $seen = append $seen $connection.target -}}
{{- end -}}
# One connection, by the alias it was written under; guarded, because the
# connection is optional.
fast-is-not-local: |
{{- with (optional .uses "models" dict) -}}
{{- if and (hasKey . "fast") (hasKey . "local") (eq .fast.target .local.target) -}}
{{- fail (printf "the fast and local connections both point at %s" .local.target) -}}
{{- end -}}
{{- end -}}

Un ciclo range visita le connessioni di un socket in ordine alfabetico dei loro alias — qui fast prima di local — non nell’ordine in cui l’Aggregate le ha scritte. Un socket che contiene una sola connessione si legge nello stesso modo: .uses.models.local.target legge llama che fast sia cablato accanto o meno, e .uses.models.target non indirizza alcuna connessione e arresta la build.

Ogni connessione che un componente possiede ha qui una voce propria, perché nessuna coppia di connessioni di uno stesso componente condivide un alias — su un socket o su due, qualunque documento o associazione abbia tracciato ciascuna. La build rifiuta una coppia di questo tipo, nominando entrambe le connessioni e dove ciascuna è stata scritta, prima che venga eseguita qualsiasi asserzione. Un elenco che nomina due volte la stessa destinazione è una coppia di questo tipo, poiché l’alias di una voce di elenco è la sua destinazione; lo è anche la connessione local propria di un componente accanto alla connessione local di un’associazione sullo stesso componente.

Leggere ciò che una connessione porta. Una regola su una connessione può leggere che cosa è la sua destinazione, che cosa lo sviluppatore ha scritto sulla connessione e che cosa vi è associato, così vale qualunque Recipe venga legata. Un Component il cui socket models dichiara un valore unauthenticated e uno slot credential può rifiutare una connessione verso una destinazione che il suo catalogo etichetta come servizio ospitato quando quella connessione non porta né una credenziale né l’opt-out:

assertions:
hosted-model-needs-a-credential: |
{{- range $alias, $connection := (optional .uses "models" dict) -}}
{{- $hosted := eq (optional $connection.labels "component.aggrega.ai/hosting" "") "managed" -}}
{{- $optedOut := optional $connection.values "unauthenticated" false -}}
{{- if and $hosted (not (hasKey $connection.features "credential")) (not $optedOut) -}}
{{- fail (printf "the models connection %s reaches a hosted model with no credential: attach one under credential, or set unauthenticated: true on the connection" $alias) -}}
{{- end -}}
{{- end -}}

L’etichetta viene letta da labels, che sono le etichette della destinazione — del modello — e mai quelle del componente stesso; l’opt-out viene letto dai values della connessione; e la credenziale è uno slot sotto le features della connessione. Ciascuno viene letto con optional o hasKey, perché una destinazione può non portare un’etichetta di questo tipo e una connessione un valore di questo tipo. Che cosa significhi l’etichetta è una convenzione del catalogo: la build porta la stringa e l’asserzione decide che cosa significa.

Il .uses di un’asserzione non è il .context.uses di un template della Recipe, e un riferimento scritto per l’uno non si trasferisce all’altro. Il contesto di rendering porta una proiezione più ricca degli stessi archi: indicizzata soltanto per alias, con il nome del socket come campo della voce, e con i valori pubblicati di ogni destinazione annidati sotto provides — così un template della Recipe legge .context.uses.<alias>.provides.<name> dove un’asserzione legge .uses.<socket>.<alias>.target. I fatti che entrambe le viste portano condividono i nomi ma non i percorsi: .context.uses.<alias>.labels e .uses.<socket>.<alias>.labels sono le etichette della stessa destinazione, e values e features leggono allo stesso modo la stessa connessione nell’una e nell’altra. Entrambe le fasi di asserzione valutano prima del rendering, ed è per questo che la vista di un arco da parte di un’asserzione non porta nulla di ciò che la sua destinazione ha pubblicato, e che un’associazione su di esso non porta alcun provides.

Per la forma più ampia del contesto di template e la semantica di disponibilità per campo, vedi template-context-contract.md.

Numeri su questa superficie

Un’asserzione legge un numero scritto dall’autore esattamente come fa un template di valore — vedi Numeri in un template di valore:

  • Confronti. I sei confronti leggono due numeri per valore, qualunque tipo porti ciascuno: lt .values.replicas 1.5 e eq .values.replicas 3.0 rispondono qui come su un template di valore, un 0.1 scritto dall’autore è eq a un 0.1 scritto nell’asserzione, e il confronto di un numero con un testo tra virgolette arresta la build con le stesse parole.
  • Vuoto. Un 0 scritto dall’autore è vuoto: falso per if e with, vero per empty, e sostituito da default. Una regola che chiede se l’autore abbia scritto un valore — 0 compreso — lo chiede con gli helper di presenza: per un 0 scritto dall’autore, hasKey .values "replicas" è vero e optional .values "replicas" 1 restituisce 0. Una regola che chiede se il valore sia zero confronta: eq .values.replicas 0. Presenza e vuoto mette le due domande una accanto all’altra.
  • Stampa. Un numero che un messaggio fail stampa si legge come apparirebbe nell’output di un template di valore: un numero intero come intero, così printf "%d" ne stampa le cifre, e qualsiasi altro numero nella sua forma decimale esatta più breve, così un 0.0000001 scritto dall’autore si legge 0.0000001.

Asserzioni di Component / Feature — invarianti architetturali

Queste esprimono regole che valgono indipendentemente da quale Recipe venga legata al Component. La regola è una proprietà del contratto, non dell’implementazione.

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: core/datastore/mariadb
version: 1.0.0
labels:
component.aggrega.ai/type: stateful-server
component.aggrega.ai/category: datastore
spec:
schema:
values:
architecture: { type: string, enum: [standalone, replication], default: standalone }
primary:
replicaCount: { type: integer, min: 1, max: 9, default: 1 }
secondary:
replicaCount: { type: integer, min: 0, max: 9, default: 0 }
assertions:
# Replication mode requires at least 2 secondary replicas.
replication-needs-two-secondaries: |
{{- if eq .values.architecture "replication" -}}
{{- if lt .values.secondary.replicaCount 2 -}}
{{- fail "architecture=replication requires secondary.replicaCount >= 2" -}}
{{- end -}}
{{- end -}}
# Total node count limit for safe replication coordination.
total-node-count-within-cap: |
{{- $total := add .values.primary.replicaCount .values.secondary.replicaCount -}}
{{- if gt $total 9 -}}
{{- fail (printf "total node count must not exceed 9; got %d" $total) -}}
{{- end -}}

Entrambe le regole esprimono proprietà del contratto MariaDB. Qualunque Recipe venga legata — un chart Bitnami, un’alternativa fatta a mano — le regole si applicano.

Il controllo degli spazi bianchi {{- ... -}} è importante: i template delle asserzioni non producono output, solo effetti collaterali tramite {{ fail }}. Il taglio degli spazi bianchi mantiene vuoto il corpo del template renderizzato in caso di successo.

Asserzioni di Recipe / FeatureRecipe — invarianti di implementazione

Queste esprimono regole che valgono per lo specifico chart o modulo da cui la Recipe trae il proprio sorgente. La regola è una proprietà dell’implementazione, non del contratto.

apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: bitnami/datastore/mariadb/k8s
version: 1.0.0
spec:
capability: helm
implements: core/datastore/mariadb:^1.0.0
source:
# Keys this provider defines for itself; a source the build fetches is written as { kind, url, version } instead.
chart: oci://registry-1.docker.io/bitnamicharts/mariadb
version: "20.0.0"
valuesMapping:
$import: BitnamiHelpers#/mappings/MariaDBBitnamiCore
assertions:
# Bitnami chart 20.x requires an explicit ServiceMonitor namespace when
# replication and metrics scraping are both enabled.
service-monitor-namespace-required: |
{{- if and (eq .values.architecture "replication") .values.metrics.serviceMonitor.enabled -}}
{{- if not .values.metrics.serviceMonitor.namespace -}}
{{- fail "Bitnami MariaDB 20.x requires metrics.serviceMonitor.namespace when architecture=replication and metrics.serviceMonitor.enabled=true" -}}
{{- end -}}
{{- end -}}
# ARM-node incompatibility.
arm-rejects-hard-anti-affinity: |
{{- if and (eq .values.primary.podAntiAffinityPreset "hard") (eq .infra.cpu_arch "arm64") -}}
{{- fail "Bitnami MariaDB 20.x is incompatible with ARM nodes when podAntiAffinityPreset=hard; use 'soft' or omit" -}}
{{- end -}}

Ogni regola è specifica dell’implementazione del chart Bitnami 20.x. Se viene legata una Recipe MariaDB diversa — un chart fatto a mano, un’implementazione alternativa — queste regole non si applicano. Le regole a livello di Component (replication-needs-two-secondaries, total-node-count-within-cap) si applicano comunque perché sono proprietà del contratto.

Perché le asserzioni di Component e di Recipe sono separate

I due ruoli sembrano simili (entrambi eseguono arresti {{ fail }} su regole tra campi), ma la ripartizione delle responsabilità è portante:

  • Le asserzioni di Component fanno parte del contratto. Quando lo sviluppatore scrive architecture: replication con secondary.replicaCount: 1, la build rifiuta indipendentemente da quale Recipe venga legata. Una futura Recipe alternativa non cambia le cose.
  • Le asserzioni di Recipe fanno parte dell’implementazione. Quando l’architetto sceglie il chart Bitnami 20.x come Recipe, il chart ha particolarità specifiche (il requisito di serviceMonitor.namespace, il bug dei nodi ARM). Queste non si applicano a un chart diverso.

Collocare entrambi i tipi di regola sul Component intreccerebbe il contratto con le sue implementazioni: il Component dovrebbe fare riferimento alla Recipe a cui è legato per sapere quali regole di implementazione far rispettare, rompendo la separazione Component-Recipe. Suddividere le regole nella loro collocazione naturale mantiene pulito il modello delle responsabilità. Il costo in fase di esecuzione della suddivisione è trascurabile; entrambe le fasi vengono eseguite prima del rendering e si arrestano con la stessa diagnostica Loud Guardrails, E0033, che nomina l’entità, l’istanza e la regola.

La convenzione dei messaggi fail

L’argomento di {{ fail "..." }} è l’errore in fase di build rivolto all’utente. Convenzioni:

  • Nomina il vincolo — «architecture=replication requires secondary.replicaCount >= 2» (architecture=replication richiede secondary.replicaCount >= 2).
  • Nomina il valore quando è pertinente — «total node count must not exceed 9; got 12» (il numero totale di nodi non deve superare 9; ottenuto 12).
  • Suggerisci la correzione quando possibile — «use ‘soft’ or omit the field» (usa ‘soft’ oppure ometti il campo).
  • Evita il gergo — chi legge è lo sviluppatore che ha scritto l’Aggregate, non l’architetto che ha scritto l’asserzione.

Per messaggi lunghi o che contengono valori, usa printf:

{{- fail (printf "field %s exceeds limit: got %d, max is %d" .field .value .max) -}}

Il compilatore presenta il messaggio nel formato di errore Loud Guardrails con il nome dell’entità, la posizione nel sorgente dell’asserzione e il messaggio di fallimento. La diagnostica è abbastanza specifica da permettere allo sviluppatore di individuare e correggere la causa principale.

Un valore che un autore ha dichiarato sensitive: true si legge <redacted> in quel messaggio ovunque il messaggio lo citi, quindi nominare nel messaggio il valore di un campo dichiarato è sicuro: la diagnostica nomina comunque la regola e il campo, e solo il valore viene trattenuto. Un’asserzione il cui esito dipende da ciò che contiene un tale valore — un confronto con un letterale, un test di prefisso — riporta che il suo testo di fallimento è trattenuto anziché il suo messaggio. vocabulary/compact-form-authoring.md «Che cosa dice un rifiuto su un valore dichiarato» contiene la regola completa.

Che cosa assertions: non sostituisce

assertions: è la sede delle regole tra campi. Non sostituisce:

  • I vincoli JSON Schema all’interno di schema: — le regole per singolo campo (intervallo, pattern, enum, formato, tipo) appartengono alle parole chiave native di JSON Schema.
  • Il campo validate: della forma compatta — predicati personalizzati per singolo campo con ambito su un solo campo. Usa validate: quando la regola si applica a un campo specifico; usa assertions: quando la regola coinvolge più campi e nessun singolo campo è «quello che viene convalidato».
  • Il campo when: della forma compatta — forma condizionale (se i vincoli di un sottoalbero si applicano). Usa when: per le variazioni di forma; usa assertions: quando la combinazione di valori non è valida in un modo che si esprime meglio come predicato in forma libera.
  • Controlli a runtime — assertions: viene eseguito solo in fase di compilazione. Tutto ciò che dipende dallo stato del cluster a runtime (IP attivi, contenuti del vault, stato dei pod a runtime) deve essere espresso come stringhe puntatore deterministiche (vedi il contratto di purezza AOT).

Esempi pratici

Minimo — singola regola architetturale

spec:
assertions:
replication-needs-two-secondaries: |
{{- if and (eq .values.architecture "replication") (lt .values.secondary.replicaCount 2) -}}
{{- fail "replication requires secondary.replicaCount >= 2" -}}
{{- end -}}

Di medie dimensioni — contratto di Component con più regole

spec:
assertions:
# Replication minimum.
replication-needs-two-secondaries: |
{{- if eq .values.architecture "replication" -}}
{{- if lt .values.secondary.replicaCount 2 -}}
{{- fail "architecture=replication requires secondary.replicaCount >= 2" -}}
{{- end -}}
{{- end -}}
# Total node limit.
total-node-count-within-cap: |
{{- $total := add .values.primary.replicaCount .values.secondary.replicaCount -}}
{{- if gt $total 9 -}}
{{- fail (printf "total node count exceeds 9: got %d (primary=%d, secondary=%d)"
$total .values.primary.replicaCount .values.secondary.replicaCount) -}}
{{- end -}}
# A ServiceMonitor scrapes the metrics exporter, so it needs one.
service-monitor-needs-metrics: |
{{- if and .values.metrics.serviceMonitor.enabled (not .values.metrics.enabled) -}}
{{- fail "metrics.serviceMonitor.enabled=true requires metrics.enabled=true" -}}
{{- end -}}

Produzione — Recipe con regole di implementazione

spec:
assertions:
# Bitnami 20.x: serviceMonitor namespace requirement.
service-monitor-namespace-required: |
{{- if and (eq .values.architecture "replication") .values.metrics.serviceMonitor.enabled -}}
{{- if not .values.metrics.serviceMonitor.namespace -}}
{{- fail "Bitnami MariaDB 20.x requires metrics.serviceMonitor.namespace when architecture=replication and metrics.serviceMonitor.enabled=true" -}}
{{- end -}}
{{- end -}}
# TLS certificate consistency.
tls-needs-both-certificate-files: |
{{- if .values.tls.enabled -}}
{{- if not (and .values.tls.certFilename .values.tls.certKeyFilename) -}}
{{- fail "tls.enabled=true requires both tls.certFilename and tls.certKeyFilename" -}}
{{- end -}}
{{- end -}}
# Replication-mode storage class consistency.
replication-needs-one-storage-class: |
{{- if eq .values.architecture "replication" -}}
{{- $primaryClass := .values.primary.persistence.storageClass -}}
{{- $secondaryClass := .values.secondary.persistence.storageClass -}}
{{- if and $primaryClass $secondaryClass (ne $primaryClass $secondaryClass) -}}
{{- fail "replication mode requires primary and secondary to use the same storageClass" -}}
{{- end -}}
{{- end -}}

Integrazione con gli strumenti

  • aggrega build valuta le asserzioni tra la convalida dello schema e il rendering; un’asserzione non riuscita arresta la build con il messaggio {{ fail }} dell’asserzione.
  • aggrega validate applica la stessa correttezza prima del rendering senza scrivere artefatti — per una Recipe il cui sorgente non viene recuperato esegue la vera pipeline di compilazione attorno a un Aggregate, un Manifest e una Release minimi sintetizzati, così un template di asserzione malformato o un’asserzione che fa riferimento a un campo sconosciuto emerge come errore di correttezza; le asserzioni di una Recipe il cui sorgente viene recuperato sono valutate da una build. Un’asserzione che lì chiama fail viene riportata come avviso con il suo messaggio, e il controllo passa: la Release sintetizzata contiene segnaposto e valori predefiniti anziché i valori che imposta una Release reale, quindi il verdetto sull’asserzione è lasciato a una build — vedi un’asserzione fallita è un avviso. (aggrega lint copre le convenzioni di pubblicazione, non la correttezza delle asserzioni.)
  • Gli IDE con supporto per i template Sprig evidenziano i riferimenti .values.X; la documentazione al passaggio del mouse rimanda alla definizione dello schema quando l’integrazione con l’IDE è configurata.