Der Block `assertions:`
Component, Feature, Recipe und FeatureRecipe tragen ein optionales Feld spec.assertions: — eine Map benannter Regeln, die der Compiler nach der Schemavalidierung, aber vor dem Rendering auswertet. Jeder Schlüssel ist ein Regelbezeichner, der in der Fehlermeldung erscheint; jeder Wert ist ein Go-Template-Body. Ein einzelner Template-Body, der direkt unter assertions: geschrieben wird, hat nicht die Form des Felds und wird beim Lesen der Entität abgelehnt, daher wird jede Regel unter einem eigenen Namen verfasst. Der Block drückt feldübergreifende Regeln aus, die JSON Schema nicht kompakt erfassen kann: Invarianten, die mehrere Felder betreffen, wobei kein einzelnes Feld „das zu validierende“ ist. Diese Seite behandelt die Authoring-Grammatik, die Auswertungsphase, den Template-Kontext und die Aufteilung der Verantwortung zwischen Component-/Feature-Assertions (architektonische Invarianten des Vertrags) und Recipe-/FeatureRecipe-Assertions (Implementierungsinvarianten des konkreten Providers).
Für Einschränkungen pro Feld (Bereich, Muster, Enum, Format) verwenden Sie die nativen Schlüsselwörter von JSON Schema innerhalb von schema:. Für benutzerdefinierte Prädikate pro Feld verwenden Sie das Feld validate: der Kompaktform. Für bedingte Formen verwenden Sie when:. Das Feld assertions: ergänzt diese — es ist der Ort für echte feldübergreifende Regeln.
Wo das Feld vorkommt
Die vier Entitäten, die assertions: tragen können:
- Component — architektonische Invarianten des Component-Vertrags.
- Feature — architektonische Invarianten des Feature-Vertrags.
- Recipe — Implementierungsinvarianten des zugrunde liegenden Charts oder Moduls des Recipe.
- FeatureRecipe — Implementierungsinvarianten des zugrunde liegenden Mechanismus des FeatureRecipe.
Das Feld ist bei jeder optional. Entitäten ohne feldübergreifende Regeln lassen das Feld ganz weg.
Wann Assertions ausgeführt werden
Die Phasen der Assertion-Auswertung liegen in der Kompilierungspipeline zwischen der Schemavalidierung und dem Rendering:
- Auflösung: Parametervalidierung und -interpolation, dann Schemavalidierung gegen
schema:/usesSchema:/featuresSchema:. - Topologieaufbau und Graphfinalisierung: Der Graph wird zusammengesetzt.
- Statische Analyse: Der Selektor jedes Sockets
uses:wird gegen die Labels der Komponenten geprüft, die seine Verbindungen erreichen. - Component-/Feature-Assertions, gegen jede Instanz ausgewertet.
- Recipe-Bindung.
- Recipe-/FeatureRecipe-Assertions, gegen die gebundene Instanz ausgewertet.
- Rendering: Mapping-Templates ausgewertet, Ausgabe erzeugt.
Die beiden Assertion-Phasen laufen vor jedem Rendering — keine Charts gerendert, keine Compose-Dateien erzeugt. Das Einzige, was ein Provider gefragt wird, bevor die Recipe-Assertions laufen, ist der Name, den er den Ressourcen jedes gebundenen Knotens gibt und den provides eines Recipe lesen kann. Eine fehlschlagende Assertion hält den Build sofort mit der spezifischen Fehlermeldung der Assertion an; nachfolgende Schritte werden nicht ausgeführt.
Die Trennung zwischen den beiden Phasen spiegelt die Aufteilung der Verantwortung wider: Regeln auf Component-Ebene gelten unabhängig davon, welches Recipe gebunden wird, daher greifen sie vor der Bindung; Regeln auf Recipe-Ebene gelten bei einer bestimmten Recipe-Wahl, daher greifen sie nach der Bindung.
Der Template-Kontext
Für assertions: von Component und Feature stellt der Template-Kontext den aufgelösten Instanzzustand bereit:
.values— der Inhaltvaluesdes Entwicklers..infra— der Inhaltinfravon Ops (aus dem Aggregate oder dem Release)..uses— die aufgelösten Verbindungenuses:, jede bereits gegen den Selektor ihres Sockets geprüft, in der Form, in der der Autor sie schreibt: nach Socket-Name geschlüsselt und unter jedem Socket nach dem Alias jeder Verbindung darauf — dem Namen, den der Autor der Verbindung unter dem Socket gegeben hat, oder, bei einer als Listeneintrag geschriebenen Verbindung, ihrem Ziel. Der Eintrag jeder Verbindung beschreibt die Verbindung und trägt nichts, was ihr Ziel veröffentlicht hat.targetist die Instanz-ID des aufgelösten Ziels,aliaswiederholt den Namen, unter dem der Eintrag geschlüsselt ist, undorigin_featureist vorhanden, wenn eine Feature-Anbindung die Verbindung gezogen hat. Daneben stehen drei Fakten unter den Namen, unter denen ein Recipe-Template sie im Eintrag.context.uses.<alias>derselben Verbindung liest, wo template-context-contract.md beschreibt, was jedes enthält:labels— die Labels des Ziels, niemals die Labels der Komponente, auf der die Assertion läuft —values, die auf der Verbindung geschriebenen Werte, undfeatures, die auf der Verbindung geschriebenen Anbindungen, geschlüsselt nach dem Slot, den jede füllt. Jedes der drei ist auf jeder Verbindung vorhanden, leer, wo die Verbindung keine trägt, und eine Anbindung unterfeatureshat die Form, die.featuresweiter unten einer Anbindung gibt. So liest.uses.<socket>.<alias>.targetdas aufgelöste Ziel einer Verbindung,.uses.<socket>.<alias>.labelsdie Labels dieses Ziels, ein Socket mit mehreren Verbindungen enthält für jede einen Eintrag, und eine Referenz, die durch diese Map nach einem vom Ziel veröffentlichten Wert greift, hält den Build an, weil der Eintrag kein solches Feld trägt..features— die aufgelösten Anbindungen, geschlüsselt nach dem Instanznamen, den der Autor jeder gegeben hat. Jeder Eintrag trägttype(die Katalog-URI des angebundenen Feature),resolved_version(die für diesen Build gebundene Version) undvalues(den eigenen Inhalt der Entwicklerabsicht der Anbindung). Eine Anbindung, die auf einer der Verbindungen der Komponente geschrieben ist, gehört nicht dazu, genau wie sie nicht zu den.featureseines Recipe-Templates gehört: Sie wird unter ihrer Verbindung gelesen, unter.uses.<socket>.<alias>.features.<slot>, in genau dieser Form..metadata— die ausgewertete Instanz: ihreinstance_id, ihr Typcomponentund ihreresolved_version, ihrboundary_pathsowieaggregate_name,aggregate_versionundrelease_versiondes Builds.
Für assertions: von Recipe und FeatureRecipe fügt der Kontext Recipe-spezifische Felder hinzu:
.provides— die aufgelösten Werteprovides:der ausgewerteten Komponente, die zum Zeitpunkt der Ausführung der Assertion bereits berechnet sind. Die veröffentlichten Werte eines Ziels sind nicht auf dieser Oberfläche; sie erreichen einen Aufrufer stattdessen im Render-Kontext..locals— die locals des Recipe..recipe.metadata—nameundversiondes Recipe sowie seinecapability..recipe.source— der Quellzeiger des Recipe.
Der Feldzugriff verwendet die Standardsyntax von Go-Templates (.values.architecture, .uses.databases.primary.target); das anhaltende Konstrukt ist {{ fail "message" }} gemäß dem Loud-Guardrails-Vertrag — eine fehlgeschlagene Assertion erzeugt einen klaren, spezifischen Fehler zur Build-Zeit, der die verletzte Invariante benennt.
Diese Oberfläche wertet mit missingkey=error aus. Eine Referenz auf einen Schlüssel, den der Kontext nicht trägt, hält den Build an — unter Nennung der Entität, der Instanz, der Assertion und des fehlenden Schlüssels —, statt als nichts gerendert zu werden. Diese Strenge macht eine Assertion vertrauenswürdig: Ein Prädikat, dessen Referenz leer gerendert würde, würde mit nichts vergleichen und bestehen, sodass ein einziger Tippfehler die Regel, zu deren Durchsetzung die Assertion geschrieben wurde, stillschweigend außer Kraft setzen würde. Es bedeutet auch, dass die bloße Referenz aufgelöst wird, bevor ein Fallback laufen kann, sodass ein optionales Feld eine Form braucht, die das Vorhandensein berücksichtigt; errors/fatal-halts.md enthält die Richtlinie für fehlende Schlüssel je Oberfläche und die Formen, die unter ihr funktionieren.
Die Verbindungen eines Sockets lesen. Der Eintrag eines Sockets hat eine einzige Form, was immer er enthält: einen Eintrag pro Verbindung, unter ihrem Alias. Eine Assertion liest eine Verbindung über ihren Alias, zählt oder durchläuft den Socket, um jede Verbindung darauf zu sehen, und prüft den eigenen Schlüssel des Sockets, um zu fragen, ob er überhaupt verdrahtet ist. Bei einer Komponente, deren Eintrag im Aggregate Folgendes schreibt
uses: models: local: { target: llama } fast: { target: turbo }lesen diese Assertions ihn auf jede Art:
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 -}}Eine Iteration mit range besucht die Verbindungen eines Sockets in alphabetischer Reihenfolge ihrer Aliase — hier fast vor local —, nicht in der Reihenfolge, in der das Aggregate sie geschrieben hat. Ein Socket mit einer einzigen Verbindung wird genauso gelesen: .uses.models.local.target liest llama, ob fast daneben verdrahtet ist oder nicht, und .uses.models.target adressiert keine Verbindung und hält den Build an.
Jede Verbindung, die eine Komponente hält, hat hier einen eigenen Eintrag, weil keine zwei Verbindungen einer Komponente einen Alias teilen — auf einem Socket oder auf zweien, gleich welches Dokument oder welche Anbindung jede gezogen hat. Der Build lehnt ein solches Paar ab und nennt dabei beide Verbindungen und wo jede geschrieben wurde, bevor irgendeine Assertion läuft. Eine Liste, die ein Ziel zweimal nennt, ist ein solches Paar, da der Alias eines Listeneintrags sein Ziel ist; ebenso die eigene Verbindung local einer Komponente neben der Verbindung local einer Anbindung auf derselben Komponente.
Lesen, was eine Verbindung trägt. Eine Regel über eine Verbindung kann lesen, was ihr Ziel ist, was der Entwickler auf die Verbindung geschrieben hat und was an sie angebunden ist, sodass sie gilt, welches Recipe auch immer gebunden wird. Eine Component, deren Socket models einen Wert unauthenticated und einen Slot credential deklariert, kann eine Verbindung zu einem Ziel ablehnen, das sein Katalog als gehosteten Dienst kennzeichnet, wenn diese Verbindung weder Anmeldedaten noch das Opt-out trägt:
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 -}}Das Label wird aus labels gelesen, die dem Ziel gehören — dem Modell — und niemals der Komponente selbst; das Opt-out wird aus den values der Verbindung gelesen; und die Anmeldedaten sind ein Slot unter den features der Verbindung. Jedes wird mit optional oder hasKey gelesen, weil ein Ziel kein solches Label und eine Verbindung keinen solchen Wert tragen kann. Was das Label bedeutet, ist die Konvention des Katalogs: Der Build trägt die Zeichenkette, und die Assertion entscheidet, was sie bedeutet.
Das .uses einer Assertion ist nicht das .context.uses eines Recipe-Templates, und eine für das eine geschriebene Referenz überträgt sich nicht auf das andere. Der Render-Kontext trägt eine reichhaltigere Projektion derselben Kanten: allein nach Alias geschlüsselt, mit dem Socket-Namen als Feld des Eintrags und mit den veröffentlichten Werten jedes Ziels verschachtelt unter provides — sodass ein Recipe-Template .context.uses.<alias>.provides.<name> liest, wo eine Assertion .uses.<socket>.<alias>.target liest. Die Fakten, die beide Sichten tragen, teilen ihre Namen, aber nicht ihre Pfade: .context.uses.<alias>.labels und .uses.<socket>.<alias>.labels sind die Labels desselben Ziels, und values und features lesen ebenso in beiden dieselbe Verbindung. Beide Assertion-Phasen werten vor dem Rendering aus, weshalb die Sicht einer Assertion auf eine Kante nichts trägt, was ihr Ziel veröffentlicht hat, und weshalb eine Anbindung darauf kein provides trägt.
Zur umfassenderen Form des Template-Kontexts und zur Semantik der Verfügbarkeit pro Feld siehe template-context-contract.md.
Zahlen auf dieser Oberfläche
Eine Assertion liest eine vom Autor geschriebene Zahl genau so wie ein Value-Template — siehe Zahlen in einem Value-Template:
- Vergleiche. Die sechs Vergleiche lesen zwei Zahlen nach ihrem Wert, gleich welche Art jede trägt:
lt .values.replicas 1.5undeq .values.replicas 3.0antworten hier wie in einem Value-Template, eine vom Autor geschriebene0.1isteqzu einer in der Assertion geschriebenen0.1, und der Vergleich einer Zahl mit Text in Anführungszeichen hält den Build mit denselben Worten an. - Leere. Eine vom Autor geschriebene
0ist leer: falsch fürifundwith, wahr füremptyund durchdefaultersetzt. Eine Regel, die fragt, ob der Autor einen Wert geschrieben hat — eine0eingeschlossen —, fragt mit den Helfern für das Vorhandensein: Für eine vom Autor geschriebene0isthasKey .values "replicas"wahr, undoptional .values "replicas" 1gibt0zurück. Eine Regel, die fragt, ob der Wert null ist, vergleicht:eq .values.replicas 0. Vorhandensein und Leere stellt die beiden Fragen nebeneinander. - Ausgabe. Eine Zahl, die eine Meldung von
failausgibt, liest sich so, wie sie in der Ausgabe eines Value-Templates stünde: eine ganze Zahl als ganze Zahl, sodassprintf "%d"ihre Ziffern ausgibt, und jede andere Zahl in ihrer kürzesten exakten Dezimalform, sodass eine vom Autor geschriebene0.0000001als0.0000001erscheint.
Component-/Feature-Assertions — architektonische Invarianten
Diese drücken Regeln aus, die gelten, gleich welches Recipe die Component bindet. Die Regel ist eine Eigenschaft des Vertrags, nicht der Implementierung.
apiVersion: aggrega.ai/v1beta1kind: Componentmetadata: name: core/datastore/mariadb version: 1.0.0 labels: component.aggrega.ai/type: stateful-server component.aggrega.ai/category: datastorespec: 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 -}}Beide Regeln drücken Eigenschaften des MariaDB-Vertrags aus. Welches Recipe auch immer bindet — ein Bitnami-Chart, eine selbst gebaute Alternative —, die Regeln gelten.
Die Whitespace-Steuerung {{- ... -}} ist wichtig: Assertion-Templates erzeugen keine Ausgabe, nur Seiteneffekte über {{ fail }}. Das Kürzen der Leerzeichen hält den gerenderten Template-Body im Erfolgsfall leer.
Recipe-/FeatureRecipe-Assertions — Implementierungsinvarianten
Diese drücken Regeln aus, die für das konkrete Chart oder Modul gelten, aus dem das Recipe seine Quelle bezieht. Die Regel ist eine Eigenschaft der Implementierung, nicht des Vertrags.
apiVersion: aggrega.ai/v1beta1kind: Recipemetadata: name: bitnami/datastore/mariadb/k8s version: 1.0.0spec: 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 -}}Jede Regel ist spezifisch für die Implementierung des Bitnami-Charts 20.x. Wenn ein anderes MariaDB-Recipe bindet — ein selbst gebautes Chart, eine alternative Implementierung —, gelten diese Regeln nicht. Die Regeln auf Component-Ebene (replication-needs-two-secondaries, total-node-count-within-cap) gelten weiterhin, weil sie Eigenschaften des Vertrags sind.
Warum Component- und Recipe-Assertions getrennt sind
Die beiden Rollen sehen ähnlich aus (beide halten bei feldübergreifenden Regeln mit {{ fail }} an), aber die Aufteilung der Verantwortung ist tragend:
- Component-Assertions sind Teil des Vertrags. Wenn der Entwickler
architecture: replicationmitsecondary.replicaCount: 1schreibt, lehnt der Build ab, gleich welches Recipe bindet. Ein künftiges alternatives Recipe ändert daran nichts. - Recipe-Assertions sind Teil der Implementierung. Wenn der Architekt das Bitnami-Chart 20.x als Recipe wählt, hat das Chart spezifische Eigenheiten (die Anforderung an
serviceMonitor.namespace, den Bug mit ARM-Knoten). Diese gelten für ein anderes Chart nicht.
Beide Regelarten auf der Component zusammenzulegen, würde den Vertrag mit seinen Implementierungen verflechten: Die Component müsste auf ihr gebundenes Recipe verweisen, um zu wissen, welche Implementierungsregeln durchzusetzen sind, was die Trennung zwischen Component und Recipe aufbrechen würde. Die Regeln an ihren natürlichen Ort aufzuteilen, hält das Verantwortungsmodell sauber. Die Laufzeitkosten der Aufteilung sind vernachlässigbar; beide Phasen laufen vor dem Rendering und halten mit derselben Loud-Guardrails-Diagnose E0033 an, die die Entität, die Instanz und die Regel nennt.
Die Konvention für Meldungen von fail
Das Argument von {{ fail "..." }} ist der benutzerseitige Fehler zur Build-Zeit. Konventionen:
- Die Einschränkung benennen — „architecture=replication requires secondary.replicaCount >= 2“ (architecture=replication erfordert secondary.replicaCount >= 2).
- Den Wert benennen, wenn relevant — „total node count must not exceed 9; got 12“ (die Gesamtzahl der Knoten darf 9 nicht überschreiten; erhalten: 12).
- Die Korrektur vorschlagen, wenn möglich — „use ‘soft’ or omit the field“ (verwenden Sie ‘soft’ oder lassen Sie das Feld weg).
- Fachjargon vermeiden — der Leser ist der Entwickler, der das Aggregate verfasst hat, nicht der Architekt, der die Assertion geschrieben hat.
Verwenden Sie für lange oder wertetragende Meldungen printf:
{{- fail (printf "field %s exceeds limit: got %d, max is %d" .field .value .max) -}}Der Compiler gibt die Meldung im Loud-Guardrails-Fehlerformat mit dem Entitätsnamen, der Quellposition der Assertion und der fehlschlagenden Meldung aus. Die Diagnose ist spezifisch genug, damit der Entwickler die Grundursache erkennen und beheben kann.
Ein Wert, den ein Autor als sensitive: true deklariert hat, erscheint in dieser Meldung als <redacted>, wo immer die Meldung ihn zitiert, sodass es sicher ist, den Wert eines deklarierten Felds in der Meldung zu nennen: Die Diagnose nennt weiterhin die Regel und das Feld, und nur der Wert wird zurückgehalten. Eine Assertion, deren Ergebnis davon abhängt, was ein solcher Wert enthält — ein Vergleich mit einem Literal, ein Präfixtest —, meldet statt ihrer Meldung, dass ihr Fehlertext zurückgehalten wird. vocabulary/compact-form-authoring.md „Was eine Ablehnung über einen deklarierten Wert aussagt“ enthält die vollständige Regel.
Was assertions: nicht ersetzt
assertions: ist der Ort für feldübergreifende Regeln. Es ersetzt nicht:
- JSON-Schema-Einschränkungen innerhalb von
schema:— Regeln pro Feld (Bereich, Muster, Enum, Format, Typ) gehören in die nativen Schlüsselwörter von JSON Schema. - Das Feld
validate:der Kompaktform — benutzerdefinierte Prädikate pro Feld mit Geltungsbereich auf ein einzelnes Feld. Verwenden Sievalidate:, wenn die Regel für ein bestimmtes Feld gilt; verwenden Sieassertions:, wenn die Regel mehrere Felder betrifft, wobei kein einzelnes Feld „das zu validierende“ ist. - Das Feld
when:der Kompaktform — bedingte Form (ob die Einschränkungen eines Teilbaums gelten). Verwenden Siewhen:für Formvariationen; verwenden Sieassertions:, wenn die Kombination von Werten auf eine Weise ungültig ist, die sich besser als frei formuliertes Prädikat ausdrücken lässt. - Laufzeitprüfungen —
assertions:läuft nur zur Kompilierzeit. Alles, was vom Laufzeitzustand des Clusters abhängt (Live-IPs, Vault-Inhalte, Pod-Status zur Laufzeit), muss als deterministische Zeiger-Zeichenketten ausgedrückt werden (siehe den AOT-Reinheitsvertrag).
Ausgearbeitete Beispiele
Minimal — einzelne architektonische Regel
spec: assertions: replication-needs-two-secondaries: | {{- if and (eq .values.architecture "replication") (lt .values.secondary.replicaCount 2) -}} {{- fail "replication requires secondary.replicaCount >= 2" -}} {{- end -}}Mittelgroß — Component-Vertrag mit mehreren Regeln
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 -}}Produktion — Recipe mit Implementierungsregeln
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 -}}Tool-Integration
aggrega buildwertet Assertions zwischen der Schemavalidierung und dem Rendering aus; eine fehlschlagende Assertion hält den Build mit der Meldung{{ fail }}der Assertion an.aggrega validatewendet dieselbe Korrektheit vor dem Rendering an, ohne Artefakte zu schreiben — für ein Recipe, dessen Quelle nicht abgerufen wird, betreibt es die echte Kompilierungspipeline um ein synthetisiertes minimales Aggregate, Manifest und Release, sodass ein fehlerhaftes Assertion-Template oder eine Assertion, die auf ein unbekanntes Feld verweist, als Korrektheitsfehler zutage tritt; die Assertions eines Recipe, dessen Quelle abgerufen wird, werden von einem Build ausgewertet. Eine Assertion dort, diefailaufruft, wird als Warnung mit ihrer Meldung gemeldet, und die Prüfung besteht: Das synthetisierte Release enthält Platzhalter und Standardwerte statt der Werte, die ein echtes Release setzt, sodass das Urteil über die Assertion einem Build überlassen bleibt — siehe eine fehlgeschlagene Assertion ist eine Warnung. (aggrega lintdeckt Veröffentlichungskonventionen ab, nicht die Korrektheit von Assertions.)- IDEs mit Unterstützung für Sprig-Templates heben Referenzen
.values.Xhervor; die Hover-Dokumentation verweist auf die Schemadefinition, wenn die IDE-Integration konfiguriert ist.