Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Contrat du contexte de template

Cette page documente la vue d’exécution que le compilateur injecte dans les templates Go de Recipe et de FeatureRecipe : la forme du contexte de template, la disponibilité par champ tout au long du pipeline de compilation, et le contrat canonique dont les auteurs avancés ont besoin lorsqu’ils écrivent des templates qui consomment un état inter-composants. La disponibilité par site de template (quels champs sont présents à quel site d’évaluation) se trouve dans expansion-matrix.md ; cette page documente la forme des champs et leur sémantique.

Vue d’ensemble

Le compilateur assemble un contexte de template par nœud pendant le rendu et l’injecte dans chaque template Go que le moteur de rendu évalue pour ce nœud. Le contexte n’existe qu’en mémoire — il n’est jamais persisté sur disque et ne traverse jamais l’ABI Wasm en tant que charge utile unique. Chaque site de template reçoit une vue du même objet de contexte ; certains champs sont renseignés tardivement (.workload arrive à la synthèse du workload ; .source à la résolution de la source ; .steps est renseigné par l’exécution de pipeline: à mesure que chaque étape se termine, voir État du langage → Phases du pipeline de compilation).

Le schéma de la forme d’exécution est template-context-v1beta1.schema.json (livré avec la distribution des schémas d’Aggrega).

Champs de premier niveau

Les champs de premier niveau se trouvent à la racine du contexte de template — on y accède par .field depuis l’intérieur d’un template.

  • .values (map). Charge utile cognitive rédigée par le développeur, issue de l’Aggregate. Les valeurs par composant parviennent jusqu’à la Recipe rendue dans ce champ. Validé par le schema: du catalogue (la déclaration JSON Schema 2020-12 du Component ou de la Feature) lors de la résolution. Lorsque le zéro / vide / faux écrit pour un champ est sémantiquement distinct de l’absence du champ, utilisez optional (voir sprig-functions.md) plutôt que default.
  • .infra (map). Dimensionnement physique rédigé par les Ops, issu de la Release. Validé par le schema: du catalogue (la déclaration JSON Schema 2020-12 du Component ou de la Feature) lors de la résolution. La même recommandation optional-vs-default que pour .values s’applique — préférez optional lorsqu’un zéro ou un faux écrit par l’auteur est une intention légitime (scale-to-zero, pas de nouvelle tentative, feature flag désactivé).
  • .locals (map à valeurs de chaîne). État privé de la Recipe — des noms déclarés dans le bloc locals: de la Recipe, résolus dans le préambule des locals et publiés sur ce pilier lors de la résolution de la source. Les entrées se résolvent dans l’ordre de l’auteur et une entrée peut lire une entrée sœur définie au-dessus d’elle, de sorte que l’ordre est déterminant partout où une entrée en lit une autre. Accessible uniquement dans les templates propres de la Recipe ; jamais exposé aux appelants.
  • .provides (map à valeurs de chaîne). Les chaînes de sortie publiques de la Recipe — le contrat par rapport auquel les blocs inject: des appelants résolvent les références from:. Renseigné lors de l’évaluation des provides.
  • .features (map de rattachements). Itère les Features rattachées à ce Component (niveau Aggregate + niveau sous-système + niveau Release + piloté par les annotations du Manifest, selon le modèle en oignon à 5 niveaux), avec pour clé le nom d’instance que l’auteur a donné au rattachement. Chaque entrée porte les mêmes champs — voir la forme du rattachement ci-dessous. Un rattachement écrit sur l’une des connexions du Component n’en fait pas partie : il se lit sous cette connexion, dans .context.uses.<alias>.features.<slot>, de sorte qu’un template qui parcourt .features ne rencontre que les rattachements propres du Component.
  • .metadata (struct). Identité de la Release pour un nommage déterministe : release_name, release_version, environment, aggregate_name. Renseigné pour chaque rendu ; les valeurs proviennent du bloc metadata: de la Release.
  • .source. Le source: de la Recipe, résolu par l’évaluation du template de résolution de la source. nil pour les Recipes sans source ; nil avant l’exécution de la résolution de la source. Sur les templates d’une FeatureRecipe, c’est le propre source: de cette FeatureRecipe, jamais celui du composant hôte — voir Surface de la FeatureRecipe d’un rattachement.
  • .workload. L’objet Workload analysé, renseigné une fois que le document workload: rendu a été décodé et a passé la validation qui le conditionne : le schéma du Workload, le featuresSchema du Component pour chaque rattachement que ses conteneurs déclarent, et la résolvabilité de ce que chaque rattachement référence. nil pour les Recipes non synthétisées ; nil avant l’exécution de la synthèse du workload.
  • .steps (map des sorties d’étapes). Renseigné par l’exécution de pipeline: à mesure que les plugins Wasm s’exécutent, exposant les sorties renvoyées par une étape terminée aux étapes suivantes via .steps.<id>.outputs. Une étape lit les sorties d’une étape précédente depuis son propre template with ; les outputs d’une étape ne deviennent visibles qu’aux étapes déclarées après elle. Vide lorsque le nœud ne déclare aucun pipeline, et avant que la première étape du nœud se termine.

Un champ de premier niveau qui ne contient rien pour ce nœud — .workload sur une Recipe qui n’en synthétise aucun, .source sur une Recipe sans source, .features sur un Component sans rattachements — se lit comme vide dans un template de valeur, exactement comme une clé non définie sous .values : {{ .workload }} ne rend rien, un default appliqué dessus fournit sa valeur de repli, et un if ou un with appliqué dessus prend sa branche fausse. Un range dessus n’itère sur rien. Une lecture en dessous — {{ .workload.containers }} — s’arrête quand même, parce qu’il n’y a rien dans quoi descendre. Et un template qui à la fois affiche un tel champ là où il s’exécute toujours — en dehors de tout if, with et range — et le parcourt s’arrête en nommant le champ, comme pour tout chemin qui ne contient rien et qui est lu des deux manières, parce qu’aucune valeur unique ne s’affiche comme rien et n’itère comme rien : voir A template reads and iterates a path that holds nothing (Un template lit et itère un chemin qui ne contient rien).

La forme du rattachement

.features.<name> et .features.<slot> ont la même forme — un rattachement, lu d’une seule façon :

  • .type (chaîne). L’URI de catalogue de la Feature rattachée.
  • .resolved_version (chaîne). La version de la Feature rattachée après la résolution du Manifest — la version réellement liée pour ce build, plutôt qu’une version épinglée répétée côté consommateur. Reflète .context.uses.<alias>.resolved_version. Vide lorsque le type du rattachement ne se résout en aucune entité de catalogue.
  • .labels (map à valeurs de chaîne). Les labels de catalogue de la Feature rattachée, transmis tels quels dans l’ordre où la Feature les déclare — rien n’est filtré, renommé ni dépouillé de son préfixe, de sorte qu’un template lit exactement ce que l’auteur de la Feature a écrit. Reflète .context.uses.<alias>.labels. Absent lorsque la Feature ne déclare aucun label, et lorsque le type du rattachement ne se résout en aucune entité de catalogue.
  • .values (map). Le pilier propre de l’intention du développeur du rattachement, rédigé sur la déclaration du rattachement dans l’Aggregate. Distinct du .values de premier niveau du composant hôte.
  • .infra (map). Le pilier propre du dimensionnement opérationnel du rattachement, rédigé sur la déclaration du rattachement dans la Release. Distinct du .infra de premier niveau du composant hôte.
  • .provides (map à valeurs de chaîne). Le contrat public résolu de la FeatureRecipe liée à ce rattachement — le nom de la ressource émise, sa clé de données, une identité cloud et toute clé supplémentaire que la FeatureRecipe publie. Se lit sous la forme .features.<name>.provides.<key>, à l’image de .context.uses.<alias>.provides : le consommateur lit ce que le producteur a publié au lieu de le redériver. Un rattachement dont la FeatureRecipe liée ne publie rien ne porte aucune clé provides, plutôt qu’une map vide ; vérifiez donc sa présence avant d’adresser une clé individuelle.

.provides est ce qui rend un rattachement consommable plutôt que simplement présent. Une Feature qui déclare un contrat schema.provides voit ce contrat appliqué à la FeatureRecipe qui la réalise — la FeatureRecipe doit publier chaque clé déclarée — et le consommateur en lit le résultat ici. Ainsi, une Feature d’identité qui émet un ServiceAccount et publie son nom permet à la Recipe consommatrice de s’y lier :

workload: |
serviceAccount: "{{ .features.identity.provides.name }}"

Le nom émis est énoncé une seule fois, par le producteur, puis consommé — jamais répété côté consommateur, où les deux pourraient diverger. L’exemple workload-identity-binding en fait le rendu de bout en bout.

.labels est ce qui permet à un template de s’adapter à ce qu’est un rattachement sans faire correspondre son nom ni analyser son URI. Le compilateur n’en lit aucun — il transporte les chaînes, et l’auteur du template décide de ce qu’elles signifient.

Une Feature qui ne déclare aucun label ne porte aucun .labels, plutôt qu’une map vide ; vérifiez donc sa présence avant d’adresser un label individuel — accéder via une clé absente arrête le build. Lisez un label que la Feature pourrait ne pas déclarer via optional, car index s’arrête en nommant la clé lorsque la map ne la contient pas :

{{ if .features.db.labels }}
{{ if eq (optional .features.db.labels "feature.aggrega.ai/kind" "") "secret" }}...{{ end }}
{{ end }}

Comme les labels arrivent tels quels, le namespace propre à l’auteur d’un catalogue atteint le template inchangé, et une Recipe lit la même clé que celle que la Feature déclare.

Le bloc .context

.context est le contexte d’exécution assemblé par le compilateur pour un nœud unique — les données d’identité, de topologie et du pipe de livraison que le moteur de rendu fait passer par chaque site de template. Ses champs :

  • .context.instance_id (chaîne). L’identité du nœud en tant que nom — la valeur que le build lui-même utilise pour nommer et étiqueter ce qu’il émet, de sorte qu’un template qui en compose un nom de ressource ou une adresse interne au cluster prédit le nom que le build produit réellement. C’est le nom que vous avez écrit pour un nœud que votre propre Aggregate déclare. Pour un nœud qu’apporte un Aggregate importé, c’est l’identité aplatie avec le séparateur de module écrit en toutes lettres (data-layer.main-db devient data-layer-zdmain-db), car un point n’est pas un caractère qu’un nom de ressource peut contenir et, dans une adresse de cluster, il sépare un service de son namespace. La forme pointée est celle que vos documents et les diagnostics du build utilisent pour adresser ce nœud ; voir Conventions de nommage.
  • .context.rendered_name (chaîne). Le nom que le fournisseur du nœud donne aux ressources qu’il rend pour le nœud — à partir de la source que vous avez fournie, comme le nom de release que lit un chart, et à partir d’un workload qu’il synthétise lorsqu’il nomme les ressources de ce workload d’après un nom qui lui est propre, comme le fait helm avec le même nom de release. Présent uniquement là où ce fournisseur en dérive un. Sur les templates d’un rattachement de Feature, c’est le nom du composant hôte, de même que .context.instance_id y est l’identité de l’hôte ; voir Nommer une ressource rendue.
  • .context.labels (map à valeurs de chaîne). Les labels rédigés dans le catalogue, plus les éventuels ajouts de label-transform effectués lors de la construction de la topologie.
  • .context.annotations (trois compartiments, voir ci-dessous). Annotations en cascade, regroupées par origine.
  • .context.inject (map de mécanismes, voir ci-dessous). Le pipe de livraison pré-hydraté et intercepté — la surface standard que les templates de Recipe lisent pour les valeurs inter-composants.
  • .context.uses (map de connexions, voir ci-dessous). La projection JOIN sur les arêtes topologiques sortantes.
  • .context.self_inject (map de mécanismes, voir ci-dessous). Pour chaque nom que le développeur a écrit dans le propre bloc inject: du composant, la clé provides propre que cette entrée livre, ou l’unique valeur propre que lit son template.
  • .context.used_by (liste, voir ci-dessous). Les composants dont les entrées uses pointent vers celui-ci. Lu par une FeatureRecipe rattachée au composant, sur les templates qui produisent les ressources propres du rattachement ; vide partout ailleurs.
  • .context.render_facts (map de listes, voir ci-dessous). Ce que le fournisseur du composant a signalé sur la sortie qu’il a rendue, indexé par nom de fait. Lu par une FeatureRecipe rattachée au composant, sur chacun de ses templates qui s’exécute après le rendu du composant ; absent partout ailleurs.

.context.annotations — trois compartiments

Les annotations se propagent en cascade dans trois compartiments indexés par origine :

  • .context.annotations.release — annotations de la frontière de la Release (Domaine 4). Utilisées pour régir les réalités physiques ; les moteurs de rendu les acheminent vers les champs infra: lorsque c’est approprié. Les annotations bien connues aggrega.ai/* se trouvent dans ce compartiment.
  • .context.annotations.catalog — annotations de métadonnées du Component issues du Domaine 2. Traits intrinsèques immuables rédigés par l’Architect ; consommés principalement par les plugins de politique Wasm.
  • .context.annotations.aggregate — annotations de sous-système de l’Aggregate issues du Domaine 1. Métadonnées cognitives ; les moteurs de rendu les acheminent vers les payloads values: lorsque c’est approprié.

Chaque compartiment est une map plate de chaîne à chaîne. Selon les règles de séparation de l’architecture, les compartiments sont destinés à des usages distincts ; le moteur n’impose pas la séparation, c’est donc la discipline de rédaction qui maintient les compartiments alignés sur leur sémantique prévue. Voir chapitre 6 §2 Flux 5 pour la conception des annotations en cascade.

.context.inject — le pipe de livraison

Le pipe est la map de livraison pré-résolue du compilateur. Au moment où un template de Recipe s’exécute lors du rendu de base, chaque source d’inject (littéraux self-inject rédigés par le développeur, références from: self-inject résolues par rapport aux propres provides, références uses[].inject inter-composants résolues par rapport aux provides de la cible, interceptions injectMapping de FeatureRecipe) a été résolue en une valeur chaîne finale et fusionnée dans cette map.

Champs :

  • .context.inject.env — map à valeurs de chaîne de nom de variable d’environnement → valeur résolue.
  • .context.inject.file — map à valeurs de chaîne de chemin de fichier → valeur résolue.
  • .context.inject.arg — map à valeurs de chaîne de flag d’argument → valeur résolue.
  • .context.inject.all — map à valeurs de chaîne combinant les mécanismes env/file/arg/personnalisés en un seul dictionnaire plat ; utile pour sérialiser le pipe entier ({{ toJson .context.inject.all }}).

Un mécanisme n’est dans le pipe que lorsque quelque chose livre par son intermédiaire. Un template qui en lit un par lequel rien ne livre — .context.inject.file sans livraison de fichier — le lit comme vide, comme un template de valeur lit toute clé absente, et un range sur celui-ci ne rend rien ; cette lecture fournit la valeur vide pour l’ensemble du template, de sorte qu’un {{ toJson .context.inject }} dans le même template affiche "file": "". hasKey .context.inject "file" indique si quelque chose livre par son intermédiaire.

  • Mécanismes personnalisés (p. ex. ssm_param) — lisibles sous leur propre nom de champ, .context.inject.<mechanism>.<key>, exactement comme les trois mécanismes de base. Les valeurs d’un mécanisme personnalisé atteignent le pipe depuis le self-inject au niveau du composant, depuis une arête uses[].inject, depuis le mapping inject: d’un rattachement de Feature et depuis la sortie injectMapping d’une FeatureRecipe. Pour le self-inject au niveau du composant, l’allowlist spec.inject du Component doit nommer le mécanisme, et un mécanisme que l’allowlist ne nomme pas arrête le build. Les entrées d’un mécanisme personnalisé apparaissent aussi dans .context.inject.all aux côtés des trois mécanismes de base. Un mécanisme personnalisé peut porter n’importe quel nom sauf all : ce nom est la vue fusionnée elle-même, de sorte qu’un mécanisme portant ce nom ne pourrait jamais être lu seul. Un bloc inject nommant un mécanisme all, et une allowlist de Component ou de Feature (spec.inject, l’inject d’un socket) qui le liste, arrêtent le build au chargement du document, et le refus explique que ce nom appartient à cette vue fusionnée. Les noms sont sensibles à la casse, donc ALL est un mécanisme personnalisé ordinaire.

Le pipe est l’état postérieur à l’interception — les blocs injectMapping de FeatureRecipe ont déjà fusionné en profondeur leurs remplacements sur ce pipe pendant le mapping d’inject, au moment où les templates de Recipe le lisent. Un mapping peut remplacer une clé livrée par le propre bloc inject: du composant, par l’un des blocs inject: de ses connexions ou par le bloc inject: de son propre rattachement ; une clé que deux Features rattachées livrent toutes deux, via leurs blocs inject: ou leurs mappings, arrête le build au lieu d’atteindre ce pipe avec l’une des deux valeurs. Une Feature rattachée à une frontière de la Release atteint le composant de la même façon, via l’injectMapping de sa FeatureRecipe, qui s’exécute dans le propre contexte du composant quel que soit l’executionScope de la FeatureRecipe — la réécriture, par le bridge compose, de la variable d’hôte d’un consommateur est l’un de ces mappings, soumis à la même règle.

.context.self_inject — quelle valeur propre livre chacun des noms du développeur

Lorsqu’un Component déclare spec.inject, le développeur peut écrire un bloc inject: sur le composant lui-même et choisir les noms sous lesquels les valeurs et les provides propres du composant sont livrés. .context.inject contient ce en quoi ces entrées se sont résolues et .inject_raw les contient telles qu’elles ont été écrites ; .context.self_inject indique, pour chacune, la clé provides propre du composant qu’elle livre ou l’unique valeur propre que lit son template. Il a la forme qu’a le .context.uses.<alias>.inject d’une connexion — le mécanisme, puis le nom du développeur, puis une clé —, la clé nommant l’un des provides ou l’une des valeurs propres du composant :

  • provides.<key> — une entrée écrite avec from: <key>, qui livre l’un des provides propres du composant.
  • values.<key> — une entrée dont le template value: lit exactement l’une des valeurs propres du composant et rien d’autre, <key> étant la clé de premier niveau de cette valeur. Le texte ou les fonctions autour de la lecture n’ont pas d’importance, pas plus que la profondeur à laquelle le template lit dans la valeur : '{{ .values.role }}', 'role={{ .values.role | upper }}' et '{{ with .values.role }}{{ . }}{{ end }}' correspondent tous à values.role, et '{{ .values.config.port }}', '{{ index .values.config "port" }}' et '{{ (default dict .values.config).port }}' correspondent tous à values.config.
  • une chaîne vide — toute autre entrée : un littéral, un template qui lit deux valeurs, un template qui lit autre chose que les valeurs (.infra, .metadata, .context), et un template dont le texte n’attribue pas la lecture des valeurs à une seule clé de premier niveau — les valeurs passées à une fonction par leur racine (index .values "role"), les valeurs lues en entier (toJson .values, ou un champ lu à l’intérieur de {{ with .values }} ou via une variable liée à .values), ou le contexte entier transmis (toJson .).
# The developer's block on the component, in the Aggregate
inject:
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_inject
env:
SERVICE_HOST: provides.host
AGENT_ROLE: values.role
MODE: ""
ROLE_AND_GOAL: ""
ssm_param:
/app/goal: values.goal

Dans l’Aggregate, chaque template value: commence par {{"{{"}} plutôt que par {{, car le texte entier de l’Aggregate est lu une fois comme template, pour l’interpolation des paramètres, avant que les templates propres du bloc ne soient évalués ; les templates cités dans la liste ci-dessus sont présentés tels qu’ils se lisent après cet échappement. Voir Texte qui contient ses propres doubles accolades.

C’est ce qui permet à une Recipe qui exécute l’image propre du développeur de traiter ses propres noms de variables pour les valeurs propres du composant comme des valeurs par défaut — la convention du catalogue de la bibliothèque standard, qu’un catalogue d’entreprise peut choisir autrement. Avant de livrer une valeur propre sous un nom qui lui est propre, une telle Recipe vérifie si le bloc du développeur livre déjà cette valeur, et ignore sa valeur par défaut si c’est le cas — ainsi, un développeur qui renomme une valeur conserve toutes les autres valeurs par défaut :

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 est présent à chaque rendu et vide là où le développeur n’a écrit aucun bloc. Un mécanisme n’apparaît que lorsque le bloc le nomme ; protégez donc la lecture d’un mécanisme que le bloc pourrait ne pas nommer, comme le fait le with ci-dessus. Un template rencontre les noms triés, quelle que soit la manière dont il les lit, comme il rencontre toute map. La map est lue à partir du texte écrit par le développeur ; rien de ce qu’elle contient n’est une valeur résolue, et le compilateur n’attribue aucune signification aux noms ni aux clés.

.context.uses — projection JOIN

.context.uses est la vue enrichie, par le compilateur, de chaque arête topologique sortante du nœud courant. Chaque entrée de la map est indexée par l’alias de socket local (p. ex. databases.primary devient .context.uses.primary lorsque l’Aggregate a rédigé uses: { databases: { primary: { target: ... } } }) et porte une projection JOIN de l’état résolu de la cible, plus le contrat de livraison côté appelant :

  • .target (chaîne) — ID d’instance du nœud cible.
  • .socket (chaîne) — nom du socket côté appelant (la clé usesSchema).
  • .provides (map à valeurs de chaîne) — les clés provides: résolues de la cible (les chaînes de sortie publiques que la Recipe cible a exportées lors de l’évaluation des provides).
  • .inject (map de mécanisme → map de clé → valeur) — directives d’inject côté appelant pour cette arête (le bloc inject: sur la déclaration uses[].inject). Les clés de mécanisme sont env/file/arg/personnalisées ; les entrées de map par mécanisme sont des références clé locale → clé provides de la cible.
  • .labels (map à valeurs de chaîne) — les labels de la cible, jamais ceux du composant consommateur : l’ensemble que porte le propre .context.labels de la cible, ses labels rédigés dans le catalogue plus les éventuels ajouts de label-transform effectués lors de la construction de la topologie.
  • .annotations (trois compartiments) — les compartiments d’annotations release/catalog/aggregate de la cible.
  • .component (chaîne) — URI du type de Component de la cible.
  • .resolved_version (chaîne) — version du Component de la cible après la résolution du Manifest.
  • .boundary_path (chaîne) — chemin de la frontière de la Release de la cible, défini que la cible se trouve dans la frontière de l’appelant ou dans une autre.
  • .origin_feature (chaîne) — défini lorsque l’arête a été synthétisée par un rattachement de Feature (p. ex. une Feature sidecar qui apporte une arête uses vers une Feature d’identifiants).
  • .values (map) — configuration développeur résolue par arête pour cette connexion, rédigée sur l’entrée uses de l’Aggregate. Présent uniquement lorsque l’arête porte des valeurs par arête.
  • .infra (map) — configuration opérateur résolue par arête pour cette connexion, rédigée sur l’entrée uses de la Release. Présent uniquement lorsque l’arête porte de l’infra par arête.
  • .origin_release (booléen) — true lorsque c’est la Release qui a câblé cette connexion plutôt que l’Aggregate qui l’a déclarée ; absent pour une connexion que l’Aggregate déclare.
  • .features (map de rattachements) — les rattachements écrits sur cette connexion, indexés par le nom de slot que le socket déclare ; voir ci-dessous. Présent uniquement lorsque la connexion en porte un.
  • .render_facts (map de listes) — ce que les rendus de la cible ont signalé sur la sortie qu’ils ont émise, indexé par nom de fait, sous la même forme que le .render_facts d’un appelant sur .context.used_by : chaque fait est une liste, d’abord les appels du propre fournisseur de la cible, puis chacune de ses Features dans l’ordre de leur rendu, les listes qu’un nom reçoit de chacun étant jointes en une seule. Présent uniquement pour une FeatureRecipe qui définit readsTargetRenderFacts: true — ses rattachements sont rendus une fois que chaque composant a été rendu, de sorte que le rendu de chaque cible est complet — et alors sur chaque connexion, vide pour une cible dont les fournisseurs ne signalent rien. Lu uniquement dans les valuesMapping:, workload: et artifacts: de cette FeatureRecipe ; absent des propres templates de Recipe du composant, d’un injectMapping:, des with: et when: d’une étape pipeline:, et de toute FeatureRecipe qui ne définit pas la clé — un template de l’une d’elles qui le lit arrête le build avant que quoi que ce soit ne soit rendu.

Les deux maps de configuration par arête ont une portée consommateur : elles arrivent uniquement dans le contexte de rendu du nœud consommateur, jamais dans celui de la cible.

Une valeur fournie se lit à .provides.<name> — les noms fournis sont imbriqués sous .provides au lieu de se trouver directement sur l’arête, de sorte que .context.uses.<alias>.<name> n’adresse aucun champ et ne donne rien.

Sur une connexion dont les deux extrémités sont rendues dans des sorties différentes, .provides contient des substituts plutôt que les valeurs. Là où le fournisseur câble une telle connexion avec une référence qui lui est propre une fois les deux sorties assemblées — une stack CloudFormation lisant la valeur d’une autre stack, par exemple —, chaque valeur que porte .context.uses.<alias>.provides est un espace réservé que le fournisseur remplace ensuite, par une référence inter-stacks ou par la valeur elle-même, comme le décrit sa propre page. Une telle valeur doit être copiée, pas comparée — la même règle que suit la valeur qu’une telle connexion livre sur le pipe d’inject, qui est un espace réservé du même type. Écrivez-la entière, à l’intérieur d’une chaîne plus longue, ou via une fonction qui la laisse telle quelle, comme quote. Un template qui compare une valeur qu’il lit sur .provides, effectue un branchement sur elle, la mesure ou la modifie déciderait d’après l’espace réservé ; le build s’arrête donc à la place, en nommant le template et chaque valeur qu’il a lue ; faites plutôt le branchement sur une valeur propre au composant consommateur. L’arrêt couvre chaque template qui lit les .provides de la connexion, y compris l’injectMapping: d’une FeatureRecipe rattachée, ainsi qu’une FeatureRecipe de portée frontière qui lit les mêmes connexions sous .boundary. Une connexion dont les deux extrémités sont rendues dans une seule sortie porte ses valeurs telles quelles.

Un alias nomme une connexion, donc la map contient une entrée pour chaque connexion qu’établit le composant. La map est indexée par alias seul, quel que soit le socket dans lequel une connexion est câblée, et deux connexions d’un même composant ne partagent jamais un alias — ni sur un socket ni sur deux, quel que soit le document ou le rattachement qui a tracé chacune. Le build refuse une telle paire, en nommant les deux connexions et l’endroit où chacune a été écrite, avant que quoi que ce soit ne soit rendu. Une liste qui nomme deux fois une même cible est une telle paire, puisque l’alias d’une entrée de liste est sa cible ; il en va de même d’une connexion local sur un socket models à côté d’une connexion local sur un socket databases.

Les templates de Recipe consomment cette projection pour consulter l’état côté cible sans parcourir le graphe IR. Les templates injectMapping de FeatureRecipe l’utilisent pour accéder aux annotations de la cible afin de prendre des décisions de routage entre frontières (le pattern de résolveur DNS K8s documenté dans entities/featurerecipe.md est l’exemple canonique détaillé).

Un template qui itère sur .context.uses voit les connexions dans l’ordre des clés — triées par alias — et non dans l’ordre où l’Aggregate les a écrites. Chaque map qu’un template itère est parcourue ainsi, y compris .features et les .features d’une connexion, de sorte qu’un template ne retrouve jamais l’ordre rédigé en itérant sur une map ; là où l’ordre porte un sens, la surface de rédaction le modélise sous forme de liste. Dans tous les cas, la sortie rendue est identique octet pour octet d’un build à l’autre pour une même entrée.

Les rattachements d’une connexion — .context.uses.<alias>.features

Un rattachement écrit sur une connexion — sous features: dans l’entrée uses d’un composant dans l’Aggregate, ou dans l’entrée de la Release pour cette connexion — remplit un slot que le socket déclare. C’est un rattachement du composant consommateur pour tout ce que le build en fait : le Manifest lie sa réalisation, sa FeatureRecipe est rendue du côté du consommateur, son contrat provides est appliqué. Un template le lit sous la connexion sur laquelle il a été écrit :

{{- 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 }}
  • Indexé par slot. .context.uses.<alias>.features.<slot> nomme le slot que le socket de la connexion déclare — credential ci-dessus —, de sorte qu’un consommateur qui atteint plusieurs cibles lit l’identifiant propre à chaque cible sous l’alias de cette cible. Une connexion qui ne porte aucun rattachement n’a pas de .features, c’est pourquoi la lecture est protégée.
  • La forme du rattachement. Chaque entrée porte exactement ce que .features.<name> porte pour l’un des rattachements propres du composant — .type, .resolved_version, .labels, .values, .infra et les .provides résolus de la FeatureRecipe qui lui est liée — ; voir la forme du rattachement. Les provides lus ici sont ceux par rapport auxquels la propre FeatureRecipe du rattachement est rendue, de sorte que le nom auquel un consommateur fait référence et le nom de la ressource qu’émet cette FeatureRecipe sont une seule et même valeur évaluée.
  • Jamais dans .features. Les propres .features du composant ne contiennent que les rattachements écrits sur son propre bloc. Une Recipe qui itère sur .features et choisit des rattachements par type — {{ range $name, $f := (default dict .features) }}{{ if eq $f.type "core/referenced-secret" }}… — ne rencontre donc jamais l’identifiant d’une connexion, même s’il relève de la même Feature : un template atteint le rattachement d’une connexion par sa connexion, jamais par .features. Il en va de même sur chaque surface qui montre les rattachements d’un composant, y compris le contexte assertions.

Les composants qui utilisent celui-ci — .context.used_by

.context.uses regarde vers l’extérieur, vers les connexions qu’établit un composant. .context.used_by regarde vers l’intérieur, vers les composants dont les entrées uses pointent vers celui-ci. Une FeatureRecipe rattachée au composant le lit, et c’est là qu’a sa place une ressource qui décrit ou restreint ces connexions — une network policy n’admettant que les composants déclarés comme appelants de celui-ci, par exemple :

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 }}

Chaque entrée porte :

  • .component_id (chaîne) — l’ID d’instance du composant qui se connecte sous sa forme aplatie (frontend, data-layer.etl), la valeur qu’un template de chemin subDirectory: lit comme .component_id.
  • .socket (chaîne) — le socket que la connexion remplit sur le composant qui se connecte (sa clé usesSchema).
  • .provides (map à valeurs de chaîne) — ce que publie le composant qui se connecte, restreint aux clés que déclare son Component : les mêmes valeurs qu’un consommateur de ce composant lit à .context.uses.<alias>.provides. Une clé que la Recipe du composant publie sans que son Component la déclare n’en fait pas partie.
  • .source_namespace (chaîne) — le namespace dans lequel est placé le composant qui se connecte : l’annotation aggrega.ai/namespace qui s’applique à lui, propagée en cascade le long de ses frontières, sa propre entrée dans la Release prenant le pas. Un composant dont l’entrée de Release définit le namespace, ou l’efface avec null, porte son propre réglage plutôt que celui de sa frontière, de sorte que la valeur nomme le namespace dans lequel les propres ressources du composant sont rendues. Absent lorsqu’aucun namespace ne s’applique au composant ; lisez-le via with ou if, comme le fait l’exemple, plutôt que de l’afficher tel quel.
  • .source_boundary_path (chaîne) — le chemin de la frontière de la Release qui contient le composant qui se connecte, les frontières imbriquées étant jointes par / (edge, edge/inner).
  • .render_facts (map de listes) — ce que les rendus du composant qui se connecte ont signalé sur la sortie qu’ils ont émise, indexé par nom de fait, sous la même forme que .context.render_facts. Chaque fait est une liste, de sorte qu’un template itère toujours dessus, même lorsqu’elle contient une seule entrée. Ses entrées peuvent provenir du propre rendu du composant qui se connecte et des rendus des Features qui lui sont rattachées : les listes qu’un nom reçoit de chacun sont jointes en une seule, d’abord les appels du propre fournisseur du composant, puis chacune de ses Features dans l’ordre de leur rendu. Présent uniquement pour une FeatureRecipe qui définit readsCallerRenderFacts: true — ses rattachements sont rendus une fois que chaque composant a été rendu, de sorte que le rendu de chaque appelant est complet — et alors sur chaque entrée, vide pour un appelant dont les fournisseurs ne signalent rien. Une FeatureRecipe qui ne définit pas la clé ne voit aucun .render_facts sur aucune entrée, et un template de celle-ci qui les lit arrête le build avant que quoi que ce soit ne soit rendu.

Les deux valeurs de placement sont celles qu’une FeatureRecipe de portée frontière lit comme source_namespace et source_boundary_path sur l’entrée de la même connexion dans ses listes d’arêtes .boundary : les deux vues lisent de la même façon où un composant est placé, de sorte qu’elles ne divergent jamais à ce sujet. Une arête de ces listes porte aussi le chemin d’assemblage de chaque extrémité — source_assembly_path et target_assembly_path, le répertoire sous le répertoire de sortie du build dans lequel le fournisseur de l’extrémité l’assemble —, que ne porte pas une entrée de .context.used_by.

Une FeatureRecipe qui définit readsCallerRenderFacts: true lit les faits de chaque appelant de la même façon qu’elle lit ceux de l’hôte. Pour un fournisseur documentant un fait nommé ports dont les entrées portent chacune un port :

artifacts:
callers.yaml: |
callers:
{{- range .context.used_by }}
- component: {{ .component_id }}
ports:
{{- range .render_facts.ports }}
- {{ .port }}
{{- end }}
{{- end }}

Un appelant dont le fournisseur ne signale aucun ports rend un ports: vide au lieu d’échouer, car un nom que personne n’a signalé se lit comme rien.

Comment la liste se comporte :

  • Dans l’ordre d’écriture. Les entrées suivent l’ordre dans lequel les composants qui se connectent sont écrits, puis l’ordre des propres entrées uses de chacun. Un composant qui se connecte deux fois apparaît deux fois, une fois par connexion. Comme il s’agit d’une liste et non d’une map, un range rencontre les appelants dans cet ordre — rien n’est trié.
  • Uniquement là où le rattachement rend ses propres ressources. Les valuesMapping:, workload: et artifacts: de la FeatureRecipe la lisent. Elle est vide dans les propres templates de Recipe du composant, dans un injectMapping: et dans les with: et when: d’une étape pipeline:, car ce que produit chacun d’eux peut aboutir dans la propre sortie rendue du composant : un injectMapping: écrit le pipe de livraison du composant, et une étape de pipeline peut réécrire les documents du composant. C’est ce qui maintient identique la propre sortie d’un composant, quel que soit celui qui l’utilise — câbler un appelant de plus à un composant modifie la sortie d’une Feature qui lui est rattachée et qui lit ses appelants, et rien de ce que le composant rend lui-même.
  • Rien sur la connexion elle-même. Une entrée ne porte ni values ni infra par connexion, ni aucun des rattachements de la connexion ; ceux-ci restent avec le composant consommateur, sous son .context.uses.<alias>.
  • Vide lorsque rien n’utilise le composant. Un range sur celle-ci ne rend alors rien.
  • Transmis, jamais interprété. L’identité, le socket, les valeurs publiées et le placement sont des chaînes que le compilateur fait transiter, et les faits de rendu sont ce que les fournisseurs de chaque appelant ont signalé, indexés par nom. Il ne déduit rien d’un nom, ne récupère rien et ne décide rien quant aux appelants qu’une ressource doit admettre ; c’est le template qui décide.

Ce qu’un fournisseur a signalé sur un rendu — .context.render_facts

Le fournisseur d’un composant peut signaler des faits sur la sortie qu’il a rendue — des propriétés des documents qu’il a écrits que seule sa propre connaissance de son format peut voir. Les faits qu’un fournisseur signale, sous quels noms et avec quel contenu dans chaque entrée, relèvent du contrat documenté propre à ce fournisseur ; voir Signaler des faits sur ce qu’un guest a émis pour le côté du fournisseur. Le fournisseur helm, par exemple, signale les labels des templates de pod qu’il a émis, les sélecteurs de ses contrôleurs et de ses Services, et les ports de ses conteneurs — voir ses faits de rendu. Une FeatureRecipe rattachée au composant lit ce que le fournisseur du composant a signalé à .context.render_facts, indexé par nom de fait. Pour un fournisseur documentant un fait nommé ports dont les entrées portent chacune un name et un port :

artifacts:
ports.yaml: |
ports:
{{- range .context.render_facts.ports }}
- name: {{ .name }}
port: {{ .port }}
{{- end }}
  • Chaque fait est une liste. Un fournisseur signale chaque fait sous forme de liste, même lorsqu’elle contient une seule entrée, de sorte qu’un template itère toujours dessus — il n’y a pas de valeur unique à lire isolément.
  • Une liste par nom, jointe sur l’ensemble du rendu du composant. Le rendu d’un composant peut nécessiter plus d’un appel de son fournisseur — un rendu de chart et un placement d’artifacts, par exemple — et chaque appel signale pour lui-même. Les listes qu’un nom reçoit de ces appels sont jointes en une seule, dans l’ordre d’exécution des appels. Ce qu’ont rendu les Features rattachées au composant n’en fait pas partie ici : une Feature ne lit que le propre rendu du composant à .context.render_facts, quoi qu’aient émis les autres Features du composant.
  • Sur chaque template d’une FeatureRecipe rattachée. Ses valuesMapping:, workload: et artifacts: le lisent, de même que les with: et when: de ses étapes pipeline: — les faits proviennent du propre rendu du composant, de sorte que les lire ne fait dépendre rien de qui se connecte au composant. Il est absent des propres templates de Recipe du composant et d’un injectMapping:, qui s’exécutent avant que le composant ait été rendu.
  • Vide plutôt que manquant. Là où le fournisseur du composant ne signale rien, .context.render_facts est une map vide, et un nom que personne n’a signalé se lit comme rien, de sorte qu’un range sur celle-ci ne rend rien au lieu d’échouer.
  • Ordre. Une liste conserve ses entrées dans l’ordre dans lequel le fournisseur les a signalées. Une entrée objet est une map indexée comme toutes les autres du contexte, de sorte qu’un template qui en parcourt une rencontre ses clés dans l’ordre des clés.
  • Transmis, jamais interprété. Le compilateur vérifie seulement que la valeur de chaque fait est une liste. Il ne lit rien de ce que signifie un nom ou une entrée ; c’est le template qui décide quoi en faire.

Le .uses d’une assertion — indexé par socket, puis par alias

Un template assertions: lit les mêmes connexions à travers une vue plus étroite qui lui est propre : .uses à la racine plutôt que sous .context, et sans rien de ce que la cible d’une connexion a publié, car les deux phases d’assertion sont évaluées avant le rendu. Il reflète la forme de rédaction uses: <socket>: <alias>: { target: … } — indexé par socket, et sous chaque socket par l’alias de chaque connexion qui s’y trouve, une connexion écrite comme entrée de liste prenant sa cible comme alias. L’entrée de chaque connexion porte target, alias et, pour une connexion qu’a tracée un rattachement de Feature, origin_feature, ainsi que trois des faits que porte .context.uses, sous les mêmes noms et avec les mêmes valeurs : .labels, les labels de la cible ; .values, les valeurs écrites sur la connexion ; et .features, les rattachements écrits sur celle-ci, indexés par slot. Chacun des trois est présent sur chaque entrée, vide là où la connexion n’en porte aucun. Un rattachement sous .features ne porte que son type, sa resolved_version et ses values — la forme sous laquelle une assertion lit chaque rattachement, y compris ceux propres à un composant, puisque la FeatureRecipe d’un rattachement n’a pas encore résolu ses provides lorsqu’une assertion s’exécute.

Un socket contenant une connexion et un socket en contenant plusieurs ont la même forme, de sorte qu’une assertion lit l’un ou l’autre de la même façon. Pour un composant dont l’entrée d’Aggregate écrit 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" demande si le socket est câblé, len compte ses connexions, un range sur celui-ci visite chacune dans l’ordre alphabétique de leurs alias, et .uses.models.local.target lit une connexion. .uses.models.target n’adresse aucune connexion et s’arrête sous le missingkey=error de la surface des assertions. Chaque connexion a sa propre entrée, pour la même raison que la map du contexte de rendu : deux connexions d’un même composant ne partagent jamais un alias, car le build le refuse avant qu’une assertion ne s’exécute. Le contexte d’assertion complet est documenté dans assertions-block.md.

Le contexte de template porte ces champs en forme d’inject, chacun avec sa propre sémantique. Les auteurs de Recipe et de FeatureRecipe devraient savoir quelle surface lire.

SurfaceTypeRenseigné lorsqueUsage
.context.injectmap de mécanismes (toujours présente)Chaque renduLe pipe de livraison standard pré-hydraté — lisez-le dans les templates valuesMapping:/workload:/artifacts: et sur tout site de template de FeatureRecipe.
.inject (premier niveau)map de mécanismes (pouvant être nulle)Rendu de la FeatureRecipe d’un rattachement, lorsque le rattachement rédige un bloc inject:Les entrées inject: propres au rattachement, sous chaque mécanisme que son bloc nomme — env, file, arg ou un mécanisme personnalisé comme vault_ref —, chaque nom local étant associé à la clé que nomme son from:. Cette clé est soit une clé que la FeatureRecipe publie dans ses provides:, que le compilateur livre aussi dans le .context.inject du composant, soit une clé qu’une FeatureRecipe lisant .inject consomme elle-même : une entrée nommant une clé que la FeatureRecipe ne publie pas arrête le build, sauf si un template que la FeatureRecipe évalue par rapport à ce contexte — son valuesMapping:, workload:, artifacts:, omits: ou le with: ou le when: d’une étape de pipeline — lit .inject par un chemin que le template nomme : .inject, .inject.env, {{ with .inject }} et similaires, et non par une transmission du contexte entier comme toJson .. Son injectMapping: ne compte pas, car il est évalué par rapport au contexte du composant, où .inject est absent. Le bloc d’un rattachement ne porte aucun littéral : une entrée value: y arrête le build, et un littéral dont le composant a besoin s’écrit dans le propre bloc inject: du composant. Un mécanisme personnalisé se lit dans .inject.<mechanism> exactement comme .inject.env, et ses entrées apparaissent dans .inject.all aux côtés des trois mécanismes de base. Une lecture pointée d’un mécanisme que le rattachement n’écrit pas s’arrête sur une clé inconnue, même à l’intérieur d’un if ou d’un with, où .context.inject.<mechanism> se lit comme vide ; lisez un mécanisme que le rattachement pourrait ne pas écrire via {{ with .inject }}{{ if hasKey . "<mechanism>" }}{{ index . "<mechanism>" "<key>" }}{{ end }}{{ end }}, qui se construit que le rattachement écrive ou non le mécanisme ou un bloc inject: quelconque. Absent des templates d’une Recipe de base et d’un rattachement qui n’écrit aucun bloc inject:.
.inject_raw (premier niveau)map de mécanismes (pouvant être nulle)Défini lorsque le développeur a rédigé un bloc inject: sur le composant parentL’intention non modifiée du développeur, avant toute interception par inject-mapping. Chaque mécanisme que nomme le bloc — env, file, arg ou un mécanisme personnalisé tel que ssm_param — se trouve sous son propre nom et contient les entrées exactement telles qu’elles sont écrites (in avec from ou value), dans l’ordre d’écriture : .inject_raw.ssm_param lit un mécanisme personnalisé comme .inject_raw.env lit le mécanisme de base. À utiliser pour des vérifications logiques du type « le développeur a-t-il initialement demandé cette clé de livraison ? » ; insensible à la réécriture par l’injectMapping d’une FeatureRecipe. nil si le développeur a omis le bloc inject:.
.context.self_injectmap de mécanismes (toujours présente)Chaque rendu ; vide là où le développeur n’a écrit aucun bloc inject: sur le composantChaque nom du propre bloc inject: du composant, associé à la clé propre que son entrée livre — provides.<key>, values.<key> ou vide. À utiliser pour ignorer un nom par défaut pour une valeur propre que le développeur livre déjà ; voir ci-dessus.

Les auteurs qui ont besoin de la livraison résolue après interception devraient lire .context.inject. Les auteurs qui ont besoin de l’intention d’origine immuable (p. ex. pour détecter une interception ou pour émettre un comportement de repli lorsque le développeur a omis un bloc inject) devraient lire .inject_raw. Les auteurs qui ont besoin de savoir lesquelles des valeurs propres du composant le développeur a déjà nommées devraient lire .context.self_inject.

Surface de la FeatureRecipe d’un rattachement

Lorsque le moteur de rendu évalue les templates de la FeatureRecipe d’un rattachement, un champ de premier niveau supplémentaire est défini :

  • .attachment_name (chaîne) — le nom d’instance du rattachement : le slot qu’il remplit dans le featuresSchema de l’entité propriétaire, ou le nom libre que l’auteur lui a donné. Les locals:, provides:, injectMapping:, valuesMapping: et artifacts: d’une FeatureRecipe le lisent pour dériver un identifiant de ressource déterministe — {{ .context.rendered_name }}-{{ .attachment_name | replace "_" "-" }} là où le fournisseur de l’hôte signale un nom rendu, comme le fait helm, et {{ .context.instance_id }}-{{ .attachment_name }} là où il n’en signale aucun — et pour nommer le rattachement en cours de traitement.

Les propres templates d’une Recipe de base ne résolvent pas un rattachement, de sorte que le champ ne fait pas partie de leur contexte : un template provides:, locals: ou source: d’une Recipe qui y fait référence s’arrête en nommant la référence au lieu de rendre une valeur vide. Une FeatureRecipe avec executionScope: boundary est rendue une fois pour la frontière plutôt qu’une fois par composant, de sorte que le champ n’est pas non plus disponible pour les templates qui s’exécutent pour la frontière ; son injectMapping: s’exécute pour chaque composant qu’atteint le rattachement et le lit à cet endroit.

Sur les templates qui produisent les propres ressources du rattachement — ses valuesMapping:, workload: et artifacts: —, le contexte du rattachement liste aussi les composants qui utilisent son hôte, à .context.used_by, et, là où sa FeatureRecipe définit readsTargetRenderFacts: true, porte ce qu’a rendu chaque composant auquel son hôte est câblé, à .context.uses.<alias>.render_facts. Ces templates et ses étapes pipeline: lisent aussi ce que le fournisseur de son hôte a signalé sur le rendu de l’hôte, à .context.render_facts. Une FeatureRecipe de portée frontière rend ses ressources pour aucun composant hôte et sans .context ; elle lit à la place chaque connexion entrant dans sa frontière sous .boundary.internal_uses_edges et .boundary.incoming_cross_boundary_uses_edges. Son injectMapping: est le seul template qu’elle écrit qui s’exécute dans le contexte d’un composant — celui de chaque composant qu’atteint le rattachement, .context.* compris —, et une référence à .boundary à cet endroit arrête le build.

Le champ est la seule voie vers le nom d’instance du rattachement. .context.instance_id est le composant hôte pour lequel le rattachement est en cours de résolution — il désigne l’hôte sur chaque surface de template qu’évalue le compilateur, y compris les propres locals: d’une FeatureRecipe —, de sorte que les deux noms ne sont pas interchangeables, et aucun ne remplace l’autre.

.source appartient au rattachement. Le template source: d’une FeatureRecipe est évalué avant son valuesMapping:, comme celui d’une Recipe l’est avant le sien, et ce qu’il a produit est ce que contient .source sur les templates qui produisent les ressources du rattachement — son valuesMapping:, omits:, workload: et artifacts: — et sur ses étapes pipeline:. Ce n’est jamais la source du composant hôte : une FeatureRecipe qui ne déclare aucun source:, ou dont le template ne produit rien, n’y lit rien, même sur un hôte dont la Recipe en déclare un. Une FeatureRecipe de portée frontière lit sa propre source sur les mêmes templates. La seule exception est l’injectMapping:, qui s’exécute avant l’évaluation de la source du rattachement et lit .source comme le fait la propre Recipe du composant hôte.

.context.rendered_name est lui aussi celui du composant hôte : sur chaque template d’un rattachement par composant, il porte le nom que le propre fournisseur de l’hôte signale pour l’hôte — la valeur que lit la propre Recipe de l’hôte —, de sorte qu’un rattachement nomme une ressource d’après son hôte avec {{ .context.rendered_name }}-{{ .attachment_name }} et obtient un nom que la plateforme accepte même là où l’identité de l’hôte contient un trait de soulignement ou une majuscule. Il est présent partout où le fournisseur de l’hôte signale un nom et absent là où il n’en signale aucun, et le lire sur un tel hôte arrête le build depuis tout template que la FeatureRecipe écrit en ligne autre que son injectMapping: ; voir Nommer une ressource rendue.

Disponibilité par site de template

La disponibilité des champs varie selon le site de template. Les templates provides: de Recipe s’exécutent lors de l’évaluation des provides avec un contexte autonome (pas de .context.inject/.context.uses) ; le valuesMapping: de Recipe s’exécute lors du rendu de base avec le contexte de template complet ; l’injectMapping: de FeatureRecipe s’exécute lors du mapping d’inject avec le contexte de template complet, y compris le pipe d’inject en cours d’interception. Le tableau complet de disponibilité site par site se trouve dans expansion-matrix.md ; cette page documente les formes de champ vers lesquelles pointe la colonne « références disponibles » de la matrice.

Références croisées