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

provides, inject, uses

Le contrat d’injection et la map pré-résolue

Comme Aggrega est un compilateur statique à compilation anticipée (AOT), aucune donnée ne remonte de l’infrastructure en service pendant la compilation. Il est mécaniquement impossible pour le compilateur de récupérer activement un identifiant physique (comme un secret AWS) et de le « renvoyer » à l’environnement du conteneur du Développeur.

La plateforme s’appuie plutôt sur une véritable inversion de contrôle. Lorsqu’un développeur écrit inject: { env: [{ in: ORACLE_PASSWORD, from: "password" }] }, il ne lance pas une récupération de données ; il dicte un contrat strict à l’infrastructure.

  1. L’intention (Domaine 1) : Le Développeur déclare une interface abstraite : « J’ai besoin d’un secret. Je ne sais pas où il se trouve. Injectez-le simplement dans mon environnement sous le nom ORACLE_PASSWORD, associé à la clé password du catalogue. »
  2. Le transfert par le compilateur (au rendu) : Le compilateur Go prend l’entrée { in: ORACLE_PASSWORD, from: "password" } et la transmet à la Recipe d’Ops. Aucun secret physique n’est récupéré.
  3. La sortie du Plugin (Domaine 3) : Le pipeline Wasm de la FeatureRecipe d’identifiants génère les artefacts précis et imbriqués requis par l’infrastructure cible. Par exemple, dans Kubernetes, il produit la CRD ExternalSecret (qui indique au cluster de récupérer les données du vault) ET exécute un JSONPatch sur le Pod cible pour associer le Secret K8s local résultant précisément à la variable d’environnement "ORACLE_PASSWORD" demandée par le développeur.
  4. La réalité à l’exécution : À l’exécution, un opérateur dans le cluster exécute simplement ces artefacts générés—en récupérant l’identifiant et en le montant physiquement dans le conteneur—ce qui découple complètement la mécanique de sécurité physique du compilateur AOT.

Pour livrer cette réalité physique à l’application sans violer la séparation des préoccupations, Aggrega utilise l’Injection Contract. Ce contrat distingue toutefois strictement le code applicatif personnalisé de l’infrastructure commerciale prête à l’emploi (COTS) :

  • White-Box (code personnalisé) : Le composant est un worker générique (par ex. un agent Python personnalisé). Le compilateur Go et la Recipe d’Ops n’ont aucune idée des variables qu’attend le script personnalisé du développeur. C’est pourquoi le Développeur dicte la livraison via le bloc inject: partout où le code lit des noms que sa Recipe ne livre pas par défaut — à la fois pour les dépendances entre composants (via uses[].inject avec from: qui référence les provides de la cible) et pour les valeurs propres du composant (via inject au niveau du composant avec des littéraux value: ou from: qui référence ses propres provides). Les mécanismes autorisés sont déclarés par surface, et les deux déclarations sont distinctes : les valeurs propres du composant sont régies par la liste d’autorisation spec.inject (par ex. inject: ["env", "file"]), tandis qu’une arête uses: est régie par la liste d’autorisation du socket par lequel elle est câblée, spec.usesSchema.<socket>.inject. Dicter un mécanisme que la liste d’autorisation applicable ne nomme pas arrête le build sur l’une comme sur l’autre surface.
  • Black-Box (calcul packagé) : Le composant est un système fermé (par ex. Redis, une API Gateway managée). La Recipe d’Ops sait déjà exactement comment le système consomme ses données. C’est pourquoi l’entité de catalogue du Component omet la liste d’autorisation, ce qui interdit purement et simplement la dictée au lieu de la restreindre — omettre spec.inject interdit le self-inject au niveau du composant, et un socket déclaré sans liste d’autorisation inject: interdit tout bloc inject: sur une arête câblée par son intermédiaire. Le Développeur fournit simplement la cible de dépendance via uses, et la plateforme gère nativement le câblage interne via le valuesMapping de la Recipe.

La règle d’adressage déterministe (physique du réseau interne) Le pipe .context.uses d’Aggrega injecte dynamiquement des chaînes cibles dans les conteneurs au moment de la compilation. Comme le compilateur Go central est entièrement agnostique vis-à-vis du réseau physique, ce qui compte comme chaîne d’adresse valide repose entièrement sur un contrat social maintenu par Platform Ops, et non sur une fonction du compilateur — le compilateur achemine, sans l’interpréter, la chaîne de pointeur déterministe qu’a produite la Recipe d’Ops vers le contexte de template en aval.

La règle : la Recipe d’Ops doit exporter un pointeur d’adresse déterministe et stable. Le fournisseur ne calcule pas d’adresses IP. La Recipe d’Ops de la cible devrait plutôt formuler une chaîne prévisible et l’exposer via son contrat provides: (par ex. en publiant provides.internal_host: "http://agent-b.namespace.svc.cluster.local" dans Kubernetes, ou une chaîne d’interpolation comme "${module.db.endpoint}" dans Terraform, où le module déclare un output correspondant pour la valeur).

Compter sur le compilateur pour récupérer des IP dynamiques après le provisionnement viole directement le modèle d’exécution AOT. Comme le compilateur évalue la topologie avant que le cloud ne provisionne la moindre ressource de calcul réelle, il ne peut pas physiquement récupérer des données qui n’existent pas encore. Si un service a besoin d’une IP aléatoire générée seulement après le démarrage du calcul, le compilateur ne peut pas physiquement la récupérer. Le seul rôle du compilateur est d’acheminer telle quelle la chaîne de pointeur déterministe fournie par la Recipe d’Ops dans les variables d’environnement du conteneur appelant, en laissant la résolution finale au DNS du cluster ou au gestionnaire d’état IaC actif.

Imposer nativement un adressage déterministe résout les dépendances cycliques (par ex. l’agent A délègue à l’agent B, et l’agent B délègue en retour à l’agent A). Comme l’URL stable ou le pointeur IaC est calculable sous forme de chaîne avant que l’un ou l’autre conteneur ne démarre réellement, le compilateur câble les deux agents ensemble en toute sécurité sans introduire de conditions de concurrence temporelles.

(Remarque : cette règle s’applique aussi à l’ingress externe. Si une architecture expose une API Gateway publique et exige que cette URL soit réinjectée dans un conteneur interne, le compilateur Go ne peut pas récupérer l’URL aléatoire générée par le cloud (par ex. xyz123.execute-api.aws.com), car elle n’existe pas au moment de la compilation. Ops doit rédiger sa Recipe de façon soit à associer un domaine personnalisé déterministe (par ex. api.enterprise.com), soit à exporter la chaîne d’interpolation IaC native, afin que le compilateur AOT dispose d’une référence connue à injecter en toute sécurité).

La mécanique d’implémentation (le catalogue comme contrat d’API) Pour mettre cela en œuvre sans coupler étroitement les Développeurs à Ops, Aggrega utilise le catalogue de la plateforme (Domaine 2) comme contrat d’API strict, en s’appuyant sur trois couches de validation distinctes :

  1. Le schéma de la Feature d’identifiants (labellisé feature.aggrega.ai/kind: secret) : Valide UNIQUEMENT la requête au vault (path, key). Il est entièrement agnostique vis-à-vis de la manière dont le conteneur consomme les données.
  2. Le schéma Component (liste d’autorisation spec.inject) : Impose la règle Black-Box/White-Box via le champ spec.inject. Si spec.inject est présent (par ex. inject: ["env", "file"]), le développeur peut utiliser le self-inject au niveau du composant avec ces mécanismes de livraison. Si spec.inject est omis, le compilateur interdit structurellement le self-inject — les composants Black-Box s’appuient entièrement sur le valuesMapping de la Recipe pour le câblage interne. Le build l’impose lorsqu’il résout l’Aggregate, en refusant le bloc inject: du composant et en nommant le mécanisme, indépendamment de la validation du contenu par pilier sous schema:.
  3. La map featuresSchema : Définie dans le catalogue du Component, elle déclare explicitement les slots d’identifiants que le Développeur doit (ou peut) utiliser. Chaque entrée précise required (par défaut false), la liste d’autorisation inject ([] = blackbox, [env, file] = transparente) et description. Comme ces clés sont stables et garanties par contrat, l’ingénieur Ops peut s’y fier directement pour dicter de manière fiable des cibles déterministes dans son template Go (par ex. existingSecret: "{{ .context.rendered_name }}-{{ .locals.secret_target_admin_password }}" sur la cible helm), en exportant explicitement le suffixe du nom via .locals — un local ne peut pas lire .context.rendered_name — de sorte que la FeatureRecipe d’identifiants en aval assemble les deux mêmes parties et satisfait l’exigence sans violer l’ordre d’exécution AOT. Voir entities/component.md pour la conception complète de featuresSchema.

La règle d’emplacement stricte : Le mécanisme inject: est disponible à trois emplacements dans l’Aggregate du Développeur :

  1. Self-inject au niveau du Component : En tant que frère direct de values: sur une instance de composant. Injecte les valeurs littérales propres du composant ou ses propres clés provides dans le pipe de livraison. Autorisé uniquement si le catalogue du Component déclare spec.inject avec les mécanismes correspondants.
  2. Cross-inject au niveau de uses : Dans les définitions explicites de cibles au sein du bloc uses:. Injecte les clés provides d’une cible de dépendance dans le pipe de livraison.
  3. Inject au niveau Feature/secret : En tant que frère de values: lors du rattachement de fonctionnalités et de secrets. Injecte les clés provides résolues propres au rattachement — l’identifiant résolu pour un secret, ou les valeurs fournies par une fonctionnalité — dans le pipe de livraison.

Les trois formes alimentent le même pipe .context.inject. La Recipe lit un pipe unique et unifié, quel que soit le nombre de sources qui y ont contribué.

Le schéma de inject définit des énumérations standard (env, file, arg) pour l’outillage, mais laisse additionalProperties ouvert, de sorte qu’un mécanisme personnalisé peut être nommé (par ex. ssm_param pour AWS Systems Manager Parameter Store). Un nom est réservé : all est la vue fusionnée de tous les mécanismes qu’une Recipe lit dans .context.inject.all, de sorte qu’un bloc inject qui nomme un mécanisme all arrête le build au niveau de l’enveloppe du document, en l’indiquant.

Syntaxe des entrées d’inject : Sous un bloc inject, chaque mécanisme de livraison — env, file, arg ou un mécanisme personnalisé — est une liste d’entrées, et chaque emplacement utilise la même forme d’entrée. C’est le mot-clé que porte une entrée, et non l’emplacement où elle se trouve, qui indique ce qu’est sa chaîne, si bien qu’une entrée se lit de la même façon où qu’elle apparaisse. Un mécanisme écrit sous forme de map au lieu d’une liste, ou une entrée portant les deux mots-clés, arrête le build à l’enveloppe du document de l’Aggregate, en nommant le chemin dans l’Aggregate où la forme est incorrecte.

Mots-clés des entrées (from: et value:) : Chaque entrée utilise le mot-clé in pour l’identifiant local — un nom de variable d’environnement, un chemin de fichier, un flag d’argument — plus exactement un parmi from: (référence à une clé de provides) ou value: (chaîne littérale). Un from: se résout par rapport aux provides du nœud que son emplacement nomme : ceux du composant lui-même dans component.inject, ceux de la cible dans uses[target].inject et ceux du rattachement lui-même dans features[<name>].inject :

Mot-cléSignificationAutorisé dans component.injectAutorisé dans uses[].injectAutorisé dans features[<name>].inject
from:Se résout par rapport à provides✅ provides du nœud lui-même✅ provides du nœud cible✅ provides propres au rattachement
value:Chaîne littérale (prend en charge les templates Go)✅❌ (value: n’est pas valide dans uses[].inject ; utilisez inject au niveau du composant pour le self-inject)❌ (value: arrête le build dans l’inject d’un rattachement ; utilisez inject au niveau du composant pour le self-inject)

Exemples :

# Component-level self-inject (White-Box custom code)
components:
my-worker:
type: core/python-worker:1.0.0
values:
app_token: "xyz"
inject:
env:
- in: MY_TOKEN
value: "xyz" # Literal value
- in: LOG_LEVEL
value: "debug" # Literal value
- in: CALLBACK_HOST
from: "host" # From own provides (already evaluated)
- in: APP_VERSION
value: '{{"{{"}} .values.app_token }}' # Go template expanding own values
uses:
databases:
my_db:
target: postgres-db
inject:
env:
- in: DB_HOST
from: "host" # Provides key from target
- in: DB_PORT
from: "port" # Provides key from target
- in: DB_URL
from: "dsn" # From target's provides

Le template du value: d’APP_VERSION commence par {{"{{"}} plutôt que par {{ : tout le texte de l’Aggregate est lu une fois comme template, pour l’interpolation des paramètres, avant que la résolution du self-inject ne s’exécute, et .values n’existe pas à ce stade, si bien que l’échappement remet {{ en place pour que la résolution du self-inject l’évalue. Voir Texte qui contient ses propres doubles accolades.

Note spécifique au Provider (compose). Lorsque des arêtes uses: se résolvent entre des nœuds ciblant compose, le fournisseur compose dérive des entrées depends_on de ces arêtes. Ces entrées utilisent toujours la sémantique service_started, quel que soit le bloc health: d’une cible ; les conditionner à la santé de la cible n’est pas implémenté. Voir providers/compose.md pour les règles d’inférence complètes.

La règle de collision des clés d’inject : Un développeur qui demande la même clé de livraison (par ex. le même nom de variable d’environnement) à deux sources différentes constitue une erreur fatale, pas une fusion. Le compilateur détecte la collision et arrête le build :

Source ASource BRésultat
component.injectuses[].inject❌ arrêt fatal — clé de livraison en double
uses[target_A].injectuses[target_B].inject❌ arrêt fatal — clé de livraison en double
component.injectfeatures[<name>].inject❌ arrêt fatal — clé de livraison en double
uses[].injectfeatures[<name>].inject❌ arrêt fatal — clé de livraison en double
features[A].injectfeatures[B].inject❌ arrêt fatal — clé de livraison en double
component.inject (même clé deux fois)—❌ arrêt fatal — clé de livraison en double
injectMapping de la FeatureRecipe de features[A]injectMapping de la FeatureRecipe de features[B]❌ arrêt fatal — clé de livraison en double entre deux rattachements
features[A].injectinjectMapping de la FeatureRecipe de features[B]❌ arrêt fatal — clé de livraison en double entre deux rattachements
component.inject ou uses[].injectinjectMapping de la FeatureRecipe✅ Légal — interception voulue par conception : la valeur du mapping remplace cette entrée

Le tableau s’applique de la même façon à chaque Feature rattachée, où qu’elle ait été rattachée — sur le composant, à un sous-système ou à une frontière de la Release, par l’expansion d’une annotation, ou sur une connexion. L’injectMapping d’une FeatureRecipe est rendu après que chaque bloc inject: a livré, de sorte qu’il est toujours la plus tardive de deux revendications : il peut réécrire ce que le composant ou l’une de ses connexions a livré, et il peut réécrire ce que le bloc inject: de son propre rattachement a livré, mais une clé qu’une autre Feature rattachée a déjà livrée arrête le build, en nommant les deux.

Une Feature rattachée à une frontière de la Release dont la FeatureRecipe est rendue une seule fois pour la frontière (executionScope: boundary) atteint les composants que contient la frontière par la même voie : son injectMapping s’exécute une fois pour chacun d’eux, dans le contexte de ce composant, et il est soumis aux lignes ci-dessus comme tout autre mapping. Le pont compose qui réécrit la variable d’hôte d’un consommateur pour qu’il atteigne sa cible via sa passerelle est l’un de ces mappings, de sorte qu’une autre Feature rattachée qui a livré la même variable arrête le build, en nommant les deux.

Pour éviter le code répétitif de template Go dans les Recipes, le compilateur fournit les deux :

  • .context.uses : La map enrichie des arêtes topologiques (pour la logique complexe, les références de secrets et le suivi de l’origine).
  • .context.inject : Un dictionnaire pré-résolu et aplati dans lequel le compilateur a déjà résolu toutes les sources d’inject (littéraux de self-inject, références à provides de self-inject et références à provides entre composants) en valeurs de chaîne finales, puis appliqué les interceptions injectMapping de FeatureRecipe.

Le contexte d’injection à double état (sûreté vis-à-vis du null vs pureté de l’intention) Lorsqu’il génère des configurations pour les Modificateurs (la FeatureRecipe liée à n’importe quel rattachement, d’identifiants ou autre), le compilateur doit concilier la sûreté vis-à-vis des pointeurs nuls pour les templates Go, le routage réseau dynamique et la préservation d’un graphe agnostique vis-à-vis des capacités. Pour y parvenir, le compilateur fournit au template un contexte à double état :

  • .inject_raw (l’intention immuable) : Représente le bloc inject: propre au composant exactement tel que le développeur l’a rédigé dans le domaine 1. Il est immuable. Si le développeur a omis le bloc, il s’évalue à null. Ops l’utilise spécifiquement pour des vérifications logiques (par ex. {{ if not .inject_raw }} pour appliquer des comportements de repli). Comme il est immuable, il protège les templates d’Ops contre les faux positifs si des fonctionnalités de routage interceptent et modifient le pipe de livraison physique.
  • .context.inject (le pipe pré-hydraté et intercepté) : Une struct parallèle, générée par le compilateur, qui représente la réalité physique de la livraison. Elle commence comme une map pré-hydratée (par ex. qui associe API_HOST à la chaîne de base de la cible "backend-instance"). Point essentiel, ce pipe est conçu pour être intercepté et fusionné en profondeur par les Features (par ex. le routage réseau) au moyen du bloc injectMapping. Au moment où la Recipe de base est rendue, ce pipe contient les chaînes entièrement formatées et physiquement correctes (par ex. un nom réseau complet et correct comme "backend-instance.backend-zone.svc.cluster.local"). Son contenu est structuré en env, file, arg (plus tout mécanisme de livraison personnalisé autorisé par les listes d’autorisation inject du Component), avec un dictionnaire .all pré-fusionné qui combine tous les mécanismes pour une sérialisation pratique de l’ensemble du pipe.
  • .context.self_inject (Quelle valeur propre chaque nom livre) : Lu depuis le même bloc inject: au niveau du composant que .inject_raw, sous la forme dans laquelle .context.uses.<alias>.inject donne les noms d’une connexion : pour chaque mécanisme, chaque nom écrit par le développeur correspond à la clé propre du composant que livre son entrée — provides.<key> pour une entrée from:, values.<key> pour un template value: qui lit exactement l’une des valeurs propres du composant et rien d’autre, et une chaîne vide pour tout autre cas (un littéral, deux valeurs, une lecture de quoi que ce soit d’autre que les valeurs). Cela permet à une Recipe qui exécute l’image propre du développeur de traiter ses propres noms de variables comme des valeurs par défaut — en livrant une valeur propre sous son nom par défaut uniquement lorsqu’aucune entrée ne correspond déjà à values.<key>, de sorte qu’un développeur qui renomme une valeur conserve toutes les autres valeurs par défaut. Il s’agit de la convention du catalogue de la bibliothèque standard, et non d’une règle du compilateur ; un catalogue d’entreprise peut livrer les valeurs propres de ses composants comme il l’entend.

Ops utilise la struct .context.inject exclusivement pour la sérialisation sûre (par ex. {{ toJson .context.inject.all }}) et la génération du routage, ce qui garantit que l’infrastructure physique reçoit les coordonnées entièrement résolues tandis que l’intention originale du développeur reste parfaitement intacte dans .inject_raw.

Exemple YAML du développeur (map granulaire) :

uses:
databases:
my-postgres-cluster:
target: db-main
inject:
ssm_param: # Agnostic injection paradigm (AWS Systems Manager)
- in: MY_DB_HOST # Local identifier
from: "host" # Target provides key

Le compilateur résout cela à la compilation (en l’associant à des chaînes statiques ou à des noms DNS internes) et transmet les deux objets à la Recipe :

"context": {
"uses": { ... raw graph ... },
"inject": {
"all": { "MY_DB_HOST": "db-main.internal" },
"ssm_param": { "MY_DB_HOST": "db-main.internal" }
}
}

Configuration à portée de connexion (values et infra). Au-delà de la livraison des provides d’une cible via inject, une arête peut porter sa propre configuration — des paramètres par connexion que la Recipe consommatrice lit dans le pipe de topologie enrichi :

  • .context.uses.<alias>.values — rédigé par le développeur, déclaré dans l’entrée uses détaillée de l’Aggregate, validé par rapport au valueSchema du socket.
  • .context.uses.<alias>.infra — rédigé par l’opérateur, déclaré dans la Release, validé par rapport à l’infraSchema du socket.

Le socket (usesSchema[<socket>]) est le contrat de l’Architecte qui détermine quelles connexions sont possibles et quelle configuration elles peuvent porter ; values et infra répartissent cette configuration par domaine de rédaction, à l’image de la répartition values/infra sur les composants. Une arête a donc deux auteurs : le développeur câble la topologie et l’ajuste avec values dans l’Aggregate, tandis que l’opérateur définit infra par connexion dans la Release, au sein des sockets que l’Architecte a déclarés. La Release peut aussi câbler une arête dans un socket déclaré mais non lié vers un composant existant ; elle ne peut pas recibler une arête déclarée par le développeur — voir entities/release.md §« Per-edge connection configuration (Configuration de connexion par arête) ».

La configuration par arête est à portée du consommateur : elle n’apparaît que dans le contexte du nœud qui a rédigé l’arête (la source de la connexion), jamais dans le contexte de la cible. La sortie rendue propre à une cible est donc invariante vis-à-vis des consommateurs qui s’y connectent. Une Feature rattachée à la cible est le seul endroit où les connexions sont visibles : sa FeatureRecipe lit quels composants utilisent la cible dans .context.used_by — pour chacun son identité, son socket, ses provides publiés, le namespace et la frontière dans lesquels il est placé et, pour une FeatureRecipe qui déclare les lire, les faits de rendu que ses fournisseurs ont signalés — jamais les values ni l’infra propres de la connexion. Une Feature rattachée au consommateur lit, de la même façon, ce que les rendus de chacune de ses cibles ont signalé, sur l’entrée de cette connexion dans .context.uses.<alias>.render_facts, là où sa FeatureRecipe déclare les lire.

Rattachements de connexion (features). Une connexion peut aussi porter ses propres rattachements — par exemple un identifiant que le consommateur présente au composant que cette connexion atteint — sous features: dans son entrée, indexés par un slot que le socket déclare dans son featuresSchema. Les deux mêmes auteurs se les répartissent : le développeur rattache sur l’entrée de connexion de l’Aggregate avec type et values, et l’opérateur dimensionne ce rattachement avec infra, ou en rattache un qui lui est propre avec type et infra, sur l’entrée de la Release. Un rattachement sur une connexion ne porte aucun bloc inject propre, ce qui explique son absence de la règle d’emplacement ci-dessus : ce n’est pas l’un des endroits où un développeur dicte la livraison.

Chacun devient un rattachement du composant consommateur nommé <alias>.<slot>, et il est donc à portée du consommateur exactement comme la configuration par arête : sa FeatureRecipe est rendue du côté du consommateur, et la sortie de la cible n’en est pas modifiée. Il est tenu hors des .features de la Recipe consommatrice, qui ne contient que les rattachements que déclare le bloc propre du composant ; la Recipe le lit plutôt sous sa connexion, dans .context.uses.<alias>.features.<slot>. Une connexion qu’établit un rattachement de Feature ne porte aucun rattachement. Voir entities/aggregate.md §« A connection’s own attachments (Les rattachements propres d’une connexion) » et entities/component.md §« Topology Sockets (Sockets de topologie) ».

A. Variables d’environnement (env) et résolution dynamique de la destination Le mécanisme de livraison standard des applications cloud-native modernes. Pour les arêtes topologiques explicites (par ex. un agent qui communique avec une base de données), Aggrega utilise .context.uses pour injecter le mappage des variables d’environnement.

  • Cas d’usage : Recevoir des noms DNS internes déterministes, des chaînes d’interpolation Infrastructure-as-Code (par ex. ${module.db.endpoint}) ou des pointeurs Vault statiques. Le compilateur câble ces références statiques en AOT afin que l’infrastructure d’exécution ou le contrôleur GitOps puisse résoudre les valeurs réelles.

B. Montages de fichiers (file) De nombreux frameworks d’IA d’entreprise s’attendent à ce qu’un config.json structuré ou un certificat .pem existe à un chemin précis sur le disque, plutôt que de s’appuyer sur des variables d’environnement.

  • Cas d’usage : Injecter des configurations JSON complexes ou satisfaire des SDK hérités qui lisent depuis le disque.

  • Intention du développeur :

    features:
    openai_key:
    type: core/aws-secrets-manager
    values:
    path: /prod/ai/openai
    key: "api_token"
    inject:
    file:
    - in: "/etc/secrets/openai.json" # Local path
    from: "api_token" # The attachment's provides key
  • Réalité côté Ops : La Recipe d’Ops génère dynamiquement les Volume, VolumeMount et ExternalSecret Kubernetes nécessaires pour récupérer de façon sécurisée les données du coffre et les monter dans /etc/secrets/openai.json.

C. Arguments de ligne de commande (arg) Les binaires précompilés (comme les nœuds workers en Rust ou en Go) contournent souvent entièrement les variables d’environnement et s’attendent à ce que les valeurs soient passées comme flags d’exécution dans leur commande de lancement.

  • Cas d’usage : Ajouter des réalités physiques à la commande de démarrage du conteneur.

  • Intention du développeur :

    features:
    public-ingress:
    type: core/external-ingress
    inject:
    arg:
    - in: "--callback-url=" # Local flag
    from: "hostname" # The attachment's provides key
  • Réalité côté Ops : Le nom d’hôte est le nom que l’environnement donne au composant, donc l’opérateur l’écrit, api.enterprise.com, dans l’infra de ce rattachement sur l’entrée de la Release pour le composant. Le plugin Wasm de la Feature reçoit l’URL publique résolue via l’Injection Contract et émet un JSONPatch pour compléter dynamiquement le tableau args de Kubernetes : ["/app/binary", "--callback-url=https://api.enterprise.com"], en contournant complètement la Recipe de base du Component.