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

Composition de la sortie

Un seul build Aggrega produit des fichiers de sortie dans des répertoires par frontière sous dist/ au moyen de six mécanismes distincts — rendu à partir de sources, synthèse de charge de travail, génération de ressources de FeatureRecipe, patchs du pipeline de plugins de FeatureRecipe, composition au niveau de la Release et émission directe d’artefacts. Les mécanismes s’exécutent dans un ordre défini ; les sorties entrent en collision de manière déterministe lorsque deux mécanismes produisent un fichier portant le même nom dans le même répertoire de frontière ; le build s’arrête avant l’émission, en nommant chaque contributeur, lorsqu’une collision est détectée, sous la catégorie que nomme la règle de collision.

Cette page documente les six mécanismes en un seul endroit et nomme l’ordre de rendu entre eux. Les références par chapitre et par entité couvrent leurs propres surfaces ; les règles de détection des collisions entre les six se trouvent ici.

Les six mécanismes producteurs de sortie

Chaque mécanisme se situe sur une surface de rédaction spécifique de Recipe / FeatureRecipe et produit des fichiers selon des conventions de nommage spécifiques. Les mécanismes s’accumulent par nœud — une seule instance de composant peut activer plusieurs mécanismes à la fois (une Recipe de base avec source + un fichier compagnon synthétisé par le Workload + un CRD ExternalSecret émis par une FeatureRecipe + un patch du pipeline de plugins appliqué au Deployment synthétisé).

1 — Rendu à partir de sources de la Recipe (source: + valuesMapping:)

Surface de rédaction. La Recipe déclare source: <path> plus valuesMapping: (le champ accepte un template Go en ligne, un $import: de fichier ou un $import: de bibliothèque vers une entrée d’une MappingLibrary — voir entities/recipe.md « The valuesMapping field — three authoring modes (Le champ valuesMapping — trois modes de rédaction) »). La source pointe vers un chart Helm sur disque, un fichier YAML docker-compose ou un autre artefact natif du fournisseur.

Position dans le pipeline. Rendu de base, après la résolution des locals et des provides de la Recipe.

Forme de la sortie. Spécifique au Provider :

  • fournisseur helm — des fichiers YAML Kubernetes plats, nommés d’après l’identité du composant puis d’après la ressource elle-même : <component-id>-<kind>[-<namespace>]-<name>.yaml, un document ne portant aucun kind ou aucun nom étant nommé d’après le chemin de son template à la place. Le nom vient de la ressource plutôt que du template, de sorte que deux templates situés dans des sous-répertoires différents qui partagent un nom de fichier restent deux fichiers. Le SDK Helm effectue le rendu du chart avec les valeurs fusionnées ; Aggrega injecte des labels et des annotations de provenance après le rendu.
  • fournisseur helm-chart — des fichiers de sous-chart copiés sous charts/<instance_id>/, tels quels à l’exception du name propre au chart, que l’umbrella définit sur l’identité encodée de l’instance afin que deux composants embarquant des charts qui déclarent un même nom restent distinguables (voir providers/helm-chart.md) ; un Chart.yaml + values.yaml umbrella par frontière émis à côté.
  • fournisseur compose — des fichiers intermédiaires <nodeID>.compose-fragment.yaml qui alimentent la composition au niveau de la Release (mécanisme 5).

2 — Synthèse de Workload de la Recipe (workload:)

Surface de rédaction. La Recipe déclare workload: portant un document Workload. Le champ accepte un contenu en ligne (block scalar) ou $import: (chemin de fichier).

Position dans le pipeline. Rendu de base, après la résolution du valuesMapping de la Recipe (le corps du Workload est lui-même une chaîne avec template Go évaluée avec le contexte de template complet).

Forme de la sortie. Spécifique au Provider :

  • fournisseur helm — un objet contrôleur choisi par le form du Workload (Deployment pour stateless, StatefulSet pour stateful, DaemonSet pour daemon, Job pour task, CronJob pour scheduled) + un Service par service + un PVC par volume persistent. Deux formes de nommage, et elles ne sont pas identiques : l’objet contrôleur est nommé d’après le nom de release du nœud et son kind — <release name>-deployment.yaml, <release name>-statefulset.yaml, <release name>-daemonset.yaml, <release name>-job.yaml, <release name>-cronjob.yaml — tandis qu’un fichier par ressource est nommé d’après la ressource qu’il porte, avec le kind en dernier : <release name>-<svcName>-service.yaml et <release name>-<volName>-pvc.yaml, parce que chacun est nommé à partir du propre metadata.name de cette ressource. Le nom de release est l’identité du nœud écrite dans l’alphabet qu’admet un nom Kubernetes, de sorte qu’il est égal à l’ID du nœud partout où celui-ci ne contient ni trait de soulignement ni majuscule : le nœud my_api écrit my-zuapi-deployment.yaml (voir entities/workload.md « Synthesized-name convention (Convention des noms synthétisés) »). Un Workload dont la seule exposition est un nom externe émet <release name>-service.yaml à la place, faute de clé de service à porter.
  • fournisseur compose — des fichiers intermédiaires <nodeID>.compose-fragment.yaml qui alimentent la composition au niveau de la Release.
  • fournisseur helm-chart — non pris en charge ; le rôle de helm-chart se limite à la composition de charts en mode avec source. Une Recipe ciblant helm-chart avec workload: est rejetée au moment du rendu (le fournisseur helm-chart ne déclare aucune capacité de synthèse).

3 — Génération de ressources de la FeatureRecipe (mode avec source pour les FeatureRecipes)

Surface de rédaction. La FeatureRecipe déclare source: plus valuesMapping: (ou équivalent), selon le même schéma que le rendu à partir de sources de la Recipe, mais pour les rattachements de Feature plutôt que pour les Components principaux.

Position dans le pipeline. Rendu de base, à côté du rendu de la Recipe de base pour le Component parent. Chaque rattachement de Feature exécute sa propre passe de rendu de la FeatureRecipe.

Forme de la sortie. Décidée par le fournisseur du Component parent, parce que la sortie du rattachement rejoint le groupe d’assemblage de ce Component plutôt qu’un groupe à elle — et elle découle de la façon dont ce fournisseur combine le groupe, puisque c’est cela qui dit s’il existe ou non un endroit où placer un rattachement. Trois formes, une par manière de combiner :

  • Un fournisseur qui donne à chaque contributeur une position à lui — un chart contenant un chart par contributeur, une configuration racine contenant un module par contributeur — donne aussi à un rattachement une position à lui, à côté du composant auquel il est rattaché plutôt qu’à l’intérieur. Les deux coordonnées composent l’unique segment de répertoire de cette position, <component-id>--<feature-instance-id>, de sorte qu’un composant api portant un rattachement aux se trouve en api--aux à côté de api, sous le répertoire que ce fournisseur désigne pour ses contributeurs, quel qu’il soit. À côté plutôt qu’à l’intérieur, parce que la cible d’un tel fournisseur découvre ses contributeurs aux positions qu’il leur a données : un répertoire situé un niveau sous l’une de ces positions est un contenu appartenant à ce contributeur plutôt qu’un contributeur à part entière, de sorte que rien ne l’adresse et que rien ne le lit. Un rattachement déclaré sur la frontière n’a aucun composant hôte à nommer, de sorte que son segment est son seul nom d’instance. Chaque coordonnée est encodée avant que les deux soient jointes, de sorte qu’une coordonnée qui contient elle-même la séquence de jointure ne peut pas être prise pour la jointure.
  • Un fournisseur qui écrit chaque document directement dans le répertoire de frontière n’a pas un tel endroit, parce que c’est exactement ce qu’il déclare de sa cible : seuls les fichiers situés directement dans un répertoire sont lus. Les deux mêmes coordonnées quittent donc les segments de répertoire pour passer dans le nom de fichier, et les fichiers du rattachement se placent à côté de ceux du composant sous la forme <component-id>--<feature-instance-id>--<file>. Les deux coordonnées sont encodées, parce qu’un nom de fichier n’a aucun séparateur sur lequel se rabattre, et elles sont jointes au nom propre du fichier à une limite de deux caractères qu’aucune coordonnée encodée ne peut contenir — c’est ce qui maintient deux rattachements émettant un même nom de fichier dans deux fichiers distincts.
  • Un fournisseur qui intègre les contributeurs de son groupe dans un seul document y intègre aussi la sortie du rattachement, chaque ressource portant l’identité propre du rattachement afin que l’on puisse lire ce qui vient d’où. Lorsqu’un tel fournisseur porte un rattachement dont le rendu a été effectué pour une cible différente, ce contenu ne peut pas être intégré à un document auquel il n’appartient pas ; il est donc écrit à côté du document assemblé — sous la forme à préfixe de nom de fichier décrite ci-dessus, pour la même raison.

Formes courantes :

  • Un CRD ExternalSecret / VaultSecret généré par le Fetcher d’une FeatureRecipe d’identifiants.
  • Un CRD ServiceMonitor / PrometheusRule généré par une Feature d’observabilité.
  • Un CRD HTTPRoute / Gateway généré par une Feature de routage.

4 — Pipeline de plugins de la FeatureRecipe (patchs RFC 6902 + émission de ressources)

Surface de rédaction. La FeatureRecipe déclare pipeline: — un tableau d’étapes de plugins Wasm (principe du Plugin en deux parties : Fetcher + Injector pour les Features d’identifiants ; pipelines de plugins arbitraires pour les Features hors identifiants).

Position dans le pipeline. Le pipeline de plugins, après l’achèvement du rendu de base et du rendu à partir de sources de la FeatureRecipe.

Forme de la sortie. Spécifique au Plugin. Une étape renvoie deux classes de sortie :

  • Patchs RFC 6902 que le moteur d’application applique aux documents ciblés dans l’ensemble rendu (p. ex. ajout d’un conteneur sidecar, montage d’un volume de secret, réécriture d’une variable d’environnement sur le Deployment synthétisé).
  • Effets de bord — des ressources nouvelles complètes émises à côté du patch via le side_effects d’une étape (typiquement le CRD vault-fetch du Fetcher auquel l’Injector fait ensuite référence).

Statut actuel : disponible selon État du langage → Phases du pipeline de compilation. Chaque étape déclarée s’exécute pendant aggrega build : l’hôte invoque le plugin Wasm de l’étape sur l’ensemble rendu, applique les patchs renvoyés et émet les effets de bord de l’étape. Voir plugins/plugin-contract.md pour la surface du contrat des plugins.

5 — Composition au niveau de la Release (assemblage de la frontière par fournisseur)

Surface de rédaction. Pilotée par la forme de la Release — aucune rédaction par Recipe. Une capacité qui assemble une frontière le fait une seule fois, après que chaque nœud de cette frontière a été rendu : la capacité compose rassemble tous les fragments par nœud dans un seul docker-compose.yaml par frontière, et la capacité helm-chart rassemble les copies de sous-charts par nœud dans un seul chart umbrella par frontière.

Position dans le pipeline. Après le rendu de base, une fois que la sortie par Recipe de chaque nœud s’est accumulée pour la frontière.

Forme de la sortie. Par fournisseur :

  • fournisseur compose — un seul docker-compose.yaml à la racine de la frontière, agrégeant les services, volumes et réseaux de chaque nœud contributeur. Les fichiers intermédiaires <nodeID>.compose-fragment.yaml (mécanismes 1 + 2) sont fusionnés dans la sortie unique ; les fragments n’apparaissent pas dans le répertoire final de la frontière.
  • fournisseur helm-chart — un Chart.yaml + values.yaml umbrella à la racine de la frontière, plus des répertoires de sous-charts par nœud sous charts/<instance_id>/.

6 — Émission directe d’artefacts de la Recipe (artifacts:)

Surface de rédaction. La Recipe déclare artifacts: comme une map d’entrées nommées ; chaque entrée est soit un contenu en ligne (une chaîne avec template portant le corps du fichier), soit une référence $import: vers un chemin de fichier de template — émission directe de fichiers sans passer par un fournisseur.

Position dans le pipeline. Évaluation des artefacts, au sein du rendu de base.

Forme de la sortie. Un fichier par entrée d’artefact, nommé d’après la clé de l’entrée dans la map artifacts:. L’auteur de la Recipe dicte directement le nom de fichier et le contenu.

Statut actuel : disponible selon État du langage → Types d’entrée de Recipe. Chaque entrée est évaluée avec le contexte de template complet après la synthèse de charge de travail et la résolution de la source, et le fichier résultant est émis sous la clé de l’entrée. Ce qu’une cible fait d’un artefact émis dépend de la capacité : un fournisseur qui accepte un artefact autonome l’émet comme son propre fichier, tandis qu’un fournisseur qui n’accepte les artefacts qu’accompagnés d’un autre type d’entrée intègre l’entrée dans ce qu’il assemble — de sorte qu’un corps qui n’a pas la forme attendue par cet assembleur provoque un arrêt sous la catégorie TRANSLATION_ERROR au lieu d’être émis tel quel. Consultez la grille par capacité dans architecture/16-recipe-input-composition.md avant de rédiger un artefact pour une capacité.

Ordre de rendu

Les six mécanismes s’exécutent dans un ordre défini afin que les mécanismes en aval puissent lire les sorties des mécanismes en amont. L’ordre :

  1. Évaluation des provides — par nœud, le bloc locals: de la Recipe est résolu en premier, dans l’ordre de l’auteur, chaque entrée lisant les entrées situées au-dessus d’elle ; les templates provides: du nœud sont ensuite évalués, dans n’importe quel ordre entre eux (autonomes : .context.instance_id, .context.rendered_name là où le fournisseur du nœud en signale un, .values, .infra, les .locals résolus, du texte statique). L’ordre locals-avant-provides est ce qui permet à une entrée provides: de lire un local et de recevoir une valeur résolue.
  2. Publication des locals et résolution de la source — ces locals sont publiés sur .locals, et le template d’URI source: de la Recipe est évalué par rapport à eux (ce qui résout le pointeur de source s’il est un template). La surface de la source partage le contexte des locals, elle lit donc .locals et non .provides.
  3. Mapping d’injection — les blocs injectMapping: de la FeatureRecipe sont évalués (le pipe d’injection est intercepté avant le rendu de la Recipe).
  4. Mapping des valeurs — le valuesMapping: de la Recipe est évalué (le mode avec source + le mode sans source produisent des dictionnaires de valeurs).
  5. Synthèse de Workload — synthèse de Workload de la Recipe (le mécanisme 2 émet des manifestes pour le mode synthétisé).
  6. Évaluation des artefacts — évaluation de artifacts: de la Recipe (mécanisme 6).
  7. Rendu du Provider — le fournisseur effectue le rendu (mécanisme 1 — le mode avec source produit des manifestes plats ; le mode sans source produit des manifestes génératifs).
  8. Rendu de Feature — rendu de la FeatureRecipe pour chaque rattachement de Feature sur le nœud (mécanismes 3 + 4 — la génération de ressources s’exécute ici ; le pipeline de plugins s’exécute plus tard, à l’étape 9).
  9. Le pipeline de plugins — mutation après le rendu : les étapes de plugins pipeline: de la FeatureRecipe appliquent des patchs RFC 6902 et émettent des ressources supplémentaires (mécanisme 4).
  10. Composition au niveau de la Release — l’assemblage de la frontière de la capacité rassemble les fragments par nœud dans des sorties par frontière (mécanisme 5).

L’ordre compte parce que les mécanismes en aval peuvent lire les sorties des mécanismes en amont — par exemple, une étape du pipeline de plugins peut appliquer un patch à un Deployment rendu par le fournisseur, et un compositeur au niveau de la Release peut fusionner des fragments émis par le rendu du fournisseur, par le rendu des fonctionnalités et par le pipeline de plugins.

Ensemble de règles de détection des collisions

Lorsque deux mécanismes produisent un fichier portant le même nom dans le même répertoire de frontière, le build s’arrête, en nommant chaque contributeur, sous la catégorie que nomme chaque règle ci-dessous. L’ensemble de règles :

Règle de forme de la Recipe : collision des clés d’entrée de artifacts:

Une Recipe déclare deux entrées sous artifacts: avec la même clé (la clé dicte le nom du fichier émis, que le corps de l’entrée soit rédigé en ligne ou chargé via $import:). Détecté au chargement de la Recipe selon errors/fatal-halts.md « artifacts: entry keys must be unique (Les clés des entrées d’artefacts doivent être uniques) ».

Règle de forme de la Recipe : collision à l’émission entre types d’entrée

Les trois types d’entrée d’une Recipe — avec source, synthétisé et artefacts — émettent chacun des fichiers dans le même répertoire de frontière. Si une sortie rendue à partir de la source, synthétisée à partir de la charge de travail ou émise comme artefact produit un fichier dont le nom a aussi été produit par un autre type d’entrée, le build s’arrête à l’émission. Détecté au moment de l’émission selon errors/fatal-halts.md « Emission-time filename collision across input kinds (Collision de noms de fichiers à l’émission entre types d’entrée) ».

Collision de noms de services Compose (niveau Release)

Lorsque deux nœuds différents (dans n’importe quelle combinaison de frontières) apportent des services de même nom à la sortie compose fusionnée, le fournisseur compose s’arrête pendant qu’il compose la frontière, sous la catégorie TRANSLATION_ERROR, en nommant chaque tuple (boundary, node, serviceName) contributeur. Détecté lors de la composition au niveau de la Release selon la section sur la sortie au niveau de la Release de providers/compose.md.

Un service est refusé sur le seul nom, sans comparer ce que les deux nœuds ont déclaré. Un service compose est un seul conteneur en cours d’exécution, de sorte que deux nœuds qui en voulaient chacun un n’en obtiennent qu’un à eux deux, et l’intention d’un contributeur est perdue, aussi identiques que soient les deux définitions.

Conflit de noms de volumes et de configs Compose (niveau Release)

Lorsque deux nœuds différents apportent une entrée volumes: ou configs: de premier niveau de même nom à la sortie compose fusionnée, et que les deux déclarations diffèrent, le fournisseur compose s’arrête sous la catégorie TRANSLATION_ERROR, en nommant l’entrée et chaque tuple (boundary, node) contributeur. Détecté lors de la composition au niveau de la Release selon la section sur la sortie au niveau de la Release de providers/compose.md.

Contrairement à la règle sur les services ci-dessus, celle-ci compare les déclarations, et un nom partagé est légitime là où les contributeurs sont d’accord. Un volume ou une config nommés constituent un seul objet, de sorte que deux nœuds qui le déclarent de façon identique ont tous deux demandé exactement l’entrée avec laquelle le document fusionné se retrouve, et rien n’est perdu. Deux nœuds qui le déclarent différemment sont en désaccord sur cet objet unique, et conserver l’une ou l’autre des déclarations écarterait l’autre d’un build qui réussirait autrement. Deux déclarations sont considérées comme concordantes lorsqu’elles décrivent la même entrée dans le fichier assemblé, de sorte qu’un corps écrit comme un mapping vide et un corps entièrement omis concordent.

Alias et répertoire des sous-charts helm-chart

Un sous-chart helm-chart se trouve sous charts/<instance_id>/ et ses valeurs sont délimitées sous son alias, qui est l’ID d’instance encodé pour la position d’alias. Deux instances ne peuvent aboutir au même alias que si leurs ID d’instance sont la même chaîne, parce que l’encodage écrit en toutes lettres les caractères qu’un alias n’accepte pas au lieu de les remplacer — de sorte qu’un alias identifie exactement un sous-chart, et que les valeurs écrites sous lui n’atteignent que ce sous-chart. Les ID d’instance sont à leur tour uniques par frontière en vertu des règles d’aplatissement de l’Aggregate, de sorte que le répertoire ne peut pas non plus entrer en collision. Les deux moitiés sont structurelles : aucune ne repose sur une vérification.

Collision de noms de ressources rendues par Helm

Au sein d’une frontière, deux nœuds dont le rendu aboutit au même nom de ressource Kubernetes produisent deux fichiers YAML avec des champs metadata.name qui se chevauchent. Les noms de fichiers diffèrent, parce que chacun est préfixé par sa propre base de nommage, tandis que le metadata.name qu’ils contiennent peut tout de même coïncider — le build vérifie donc les noms que portent les ressources rendues, et deux contributeurs dérivant un même nom pour un même kind dans un même namespace l’arrêtent sous la catégorie TRANSLATION_ERROR avant que quoi que ce soit ne soit écrit, en nommant le nom et chaque composant, et chaque rattachement, qui l’a dérivé (voir errors/fatal-halts.md).

Le cas le plus large est fermé par construction plutôt que vérifié. Un chart avec source qui nomme ses ressources d’après le nom de release ne peut plus produire cela entre deux composants, parce que deux bases de nommage qui diffèrent si peu que ce soit aboutissent à deux noms de release — voir providers/helm.md « How the release name is derived (Comment le nom de release est dérivé) ». Deux cas subsistent, et c’est la vérification ci-dessus qui les signale. L’un est un chart qui écrit littéralement un nom de ressource dans ses templates, et aucune dérivation ne peut distinguer un tel nom d’un autre littéral. L’autre est celui de deux rattachements de Feature sur un seul composant qui livrent chacun un chart écrit par leur auteur : tous deux sont rendus avec le nom de release de ce composant, par conception, de sorte que deux charts nommant une ressource d’après .Release.Name s’y rencontrent — donnez des noms distincts aux ressources des deux charts, ou rattachez-les à des composants différents.

Chaque nom synthétisé commence par l’identité propre du nœud — celui de l’objet contrôleur, et chaque nom par ressource via la convention synthétisée des noms de Service <release name>-<svcName> (selon entities/workload.md « Synthesized-name convention (Convention des noms synthétisés) ») — ce qui rend les collisions entre nœuds structurellement impossibles par construction. Les auteurs dont le build s’arrête sur un nom de Deployment / Service devraient d’abord vérifier si deux Recipes différentes émettent des ressources de même nom par des chemins de rendu différents (p. ex. le templates/deployment.yaml d’un chart avec source entrant en collision avec le metadata.name d’un Deployment synthétisé à partir de la charge de travail).

Modèles d’interaction entre mécanismes

Workload synthétisé + patch du pipeline de plugins

Le modèle canonique : le mécanisme 2 (synthèse de charge de travail) émet un Deployment de base ; le mécanisme 4 (le plugin Injector) applique un patch RFC 6902 qui monte un volume de secret dans le Deployment. Les deux mécanismes se composent — le Deployment est la même ressource K8s, le patch superposant des références ConfigMap / Secret à la base synthétisée.

C’est le modèle dominant pour l’injection d’identifiants dans les charges de travail synthétisées. Le Fetcher (mécanisme 3, génération de ressources) émet un CRD ExternalSecret que le cluster récupère à l’exécution ; l’Injector (mécanisme 4, un patch du pipeline de plugins) modifie le Deployment pour monter le Secret K8s qui en résulte.

Avec source + synthèse de Workload sur des frontières différentes

Un même Aggregate peut avoir un composant lié à une Recipe helm avec source (mécanisme 1) sur la frontière A et un composant frère lié à une Recipe helm synthétisant un Workload (mécanisme 2) sur la frontière B. Le répertoire de chaque frontière porte la forme de sortie appropriée ; le nommage des fichiers entre frontières n’entre pas en collision, car les répertoires dist/ par frontière sont isolés les uns des autres.

Fusion Compose au niveau de la Release par répertoire de sortie

L’assemblage de la capacité compose rassemble les fragments par nœud de chaque frontière dont le répertoire s’évalue en un même chemin dans un seul docker-compose.yaml à ce chemin ; deux frontières ciblant compose dans une même Release écrivent deux fichiers lorsque leurs répertoires diffèrent, et un seul fichier fusionné lorsqu’elles partagent un répertoire.

Les collisions de noms de services sont donc détectées par fichier, lors de sa fusion au niveau de la Release, selon la règle ci-dessus. Deux frontières ciblant compose dans des répertoires différents qui déclarent chacune un service nommé api n’entrent pas en collision : le fichier de chaque frontière porte le sien. Deux frontières qui partagent un répertoire écrivent un seul fichier, et le build s’arrête en nommant les deux contributeurs.

Références croisées

  • entities/recipe.md — surface de rédaction de la Recipe (les mécanismes 1 + 2 + 6 émettent à partir du contenu de la Recipe).
  • entities/featurerecipe.md — surface de rédaction de la FeatureRecipe (les mécanismes 3 + 4 émettent à partir du contenu de la FeatureRecipe).
  • providers/helm.md — formes de sortie par mécanisme et conventions de nommage du fournisseur helm.
  • providers/helm-chart.md — composition umbrella + sous-charts du fournisseur helm-chart (mécanisme 5).
  • providers/compose.md — fragmentation par nœud + composition au niveau de la Release du fournisseur compose (mécanisme 5).
  • errors/fatal-halts.md — les règles de forme de la Recipe sur l’unicité des clés d’entrée de artifacts: et sur la collision de noms de fichiers entre types d’entrée.
  • templates/expansion-matrix.md — moment d’évaluation par site de template tout au long de l’ordre de rendu.
  • plugins/plugin-contract.md — la surface du contrat du pipeline de plugins (mécanisme 4).
  • 10-status.md — état de disponibilité actuel du mécanisme 6 (artifacts:) et de l’exécution du pipeline de plugins du mécanisme 4.
  • architecture/10-compilation-pipeline.md — le pipeline de compilation complet, y compris l’ordre des étapes de rendu.
  • architecture/16-recipe-input-composition.md — les trois types d’entrée de la Recipe (le cadrage en amont des mécanismes 1 + 2 + 6).