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

Importer un flux Langflow

Ce guide pas à pas importe un flux exporté depuis Langflow — Basic Prompting, le projet de démarrage fourni avec Langflow 1.6.0 — dans un Aggregate, une Release et un Manifest qui, tels qu’ils sont écrits, construisent Langflow portant le flux pour Docker Compose, puis les construit et exécute le résultat. Chaque fichier et chaque bloc de sortie ci-dessous proviennent d’une exécution réelle ; le flux et chaque étape du guide se trouvent dans l’exemple import-langflow, où un script de vérification relance l’import, compare ce qu’il écrit, ce qu’il affiche et les blocs que cite cette page avec les fichiers qui y sont conservés, puis valide et construit ce que l’import a écrit.

Générer l’exemple

Vous pouvez exécuter cette importation avec les commandes de cette page, ou la faire exécuter par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example import-langflow

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier ; la suivante, ci-dessous, vous place dans le dossier source du nouveau dossier, où s’exécute l’import. Ce dossier contient le fichier du flux, basic-prompting.json, que cette page décrit plutôt que de le citer :

Terminal window
cd import-langflow

Le dossier source de l’exemple généré, ouvert dans Visual Studio Code, montrant l’export Langflow d’un flux de prompting de base.

Le flux

Basic Prompting enchaîne quatre nœuds : un Chat Input, un Prompt, un Language Model qui appelle gpt-4.1 d’OpenAI, et un Chat Output. Tel que Langflow le livre, c’est un seul fichier JSON, basic-prompting.json, d’environ 54 Ko, qui contient le code source de chaque composant en plus du flux. Son nœud Language Model lit sa clé dans la variable globale OPENAI_API_KEY, que Langflow lit dans son environnement lorsqu’aucune variable de ce nom n’est enregistrée.

À côté du flux, un .aggrega-config.yaml fait du dossier un espace de travail :

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside basic-prompting.json.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

et import-answers.yaml contient les réponses à ce qu’aucun flux ne peut contenir. Un import pour Docker Compose n’en requiert aucune : il rattache chaque secret par une référence de variable que Docker Compose renseigne depuis votre shell. Un import pour Kubernetes rattache chaque secret par le nom d’un Secret Kubernetes, que vous seul pouvez nommer, si bien que le fichier nomme les deux Secrets que cet import demande (voir Sur Kubernetes) :

# Values the import could not draft from the source, keyed by the drafted file and the key path inside
# it. Write each one beside its key; an import of the same source, and a sync, read them from here and
# ask nothing. A secret is never written here: its key asks where the secret comes from — a variable
# name, ${NAME}, or the name of a Kubernetes Secret.
release.yaml:
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.langflow.features.admin_password.infra.origin: "langflow-admin"
# The origin of the secret value, written by the operator in the Release. Read exactly as
# values.origin is. Write it here or in values.origin, never in both. A secret: name where it comes
# from, never the value.
spec.components.langflow.uses.model.languagemodelcomponent-kboja.features.credential.infra.origin: "openai-api-key"

Chaque réponse est le nom d’un Secret, jamais le secret lui-même, si bien que le fichier peut être conservé avec le flux. Le fichier de réponses d’import décrit le fichier en détail.

L’import évalue chaque nœud par rapport aux Components du catalogue de l’espace de travail, et --target rédige un brouillon de Manifest à partir de ses Recipes. L’espace de travail n’indique aucun dossier de catalogue ; l’import lit donc le catalogue de la bibliothèque standard depuis le registre dont il récupère son importateur : un instantané signé du catalogue publié, que le premier import récupère, vérifie et conserve dans le cache de contenu de l’espace de travail, et que l’enregistrement écrit par l’import à côté de ses brouillons désigne par son condensé. Un espace de travail qui indique ses propres dossiers de catalogue — dans AGGREGA_CATALOG_DIRS, ou sous workspace.catalog_dirs — importe plutôt en s’appuyant sur ceux-ci. Placez-vous dans source :

Terminal window
cd source

Lancer l’importation

Terminal window
aggrega import basic-prompting.json --target compose

Sur la sortie standard, elle liste ce qu’elle a écrit :

wrote aggregate.yaml
wrote release.yaml
wrote manifest.yaml
wrote .aggrega-import.json

Sur la sortie d’erreur standard, où <workspace> désigne le dossier dans lequel vous l’avez lancée :

[… omitted: a warning that the importer runs unverified, printed where its module is read from beside its Plugin entity in a catalog folder rather than fetched]
read as the langflow format, with drafted paths relative to <workspace>
warn: the flow is carried in values.flow_definition with the handles of all 3 of its edges written as Langflow's editor writes them — the same handles, their keys in order with no space between them — since the editor compares an edge's handles with the ones it writes for the nodes the edge joins, character for character, when it opens the flow, and drops every edge whose handles differ
warn: node LanguageModelComponent-kBOja reaches languagemodelcomponent-kboja through the model connection languagemodelcomponent-kboja of core/ai-agent/langflow: its field api_key names the variable OPENAI_API_KEY, which the platform delivers for this connection and Langflow reads as a global variable; no field of it gives its API's address, so the OpenAI client it runs takes OPENAI_BASE_URL, the address the platform delivers for this connection, from the environment
made no choice for ChatInput-SzjnT (ChatInput)
made no choice for Prompt-tOH5D (Prompt)
made no choice for ChatOutput-8ZWWB (ChatOutput)
mapped LanguageModelComponent-kBOja (LanguageModelComponent) to core/ai-model/openai as a reference, HIGH at 0.9
warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set.
Pull complete: <workspace>/release.lock (entities=8, source_artifacts=0, external_inputs=0)

L’import exécuté depuis l’éditeur : l’Aggregate, la Release et le Manifest rédigés apparaissent à côté de l’export du flux, la sortie Aggrega indique comment chaque composant du flux a été associé et liste les fichiers écrits, et une notification indique que l’import a rédigé 3 fichiers, reconnus comme langflow.

  • La ligne mapped indique ce que le nœud Language Model est devenu : le modèle OpenAI de la bibliothèque standard, core/ai-model/openai, référencé plutôt que rédigé, puisqu’il a correspondu dans le niveau élevé, avec un score de 0.9. C’est un composant à part entière, relié au socket model de la plateforme. Par défaut, le brouillon exécute le flux entier sur la plateforme qui exécute Langflow, et ne donne un composant propre qu’à un nœud qu’accueille un socket de cette plateforme — un modèle, un outil, un magasin vectoriel — lorsque le nœud est reconnu comme tel.
  • La première ligne warn indique que le flux est repris avec les handles de chaque arête écrits comme les écrit l’éditeur de Langflow. Langflow conserve ses projets de démarrage avec une espace après chaque deux-points et chaque virgule des handles d’une arête ; son éditeur, à l’ouverture d’un flux, supprime toute arête dont les handles ne sont pas écrits exactement comme il les écrit, puis enregistre le flux sans elle. Écrit ainsi, le flux s’ouvre avec ses trois connexions, et s’exécute avec elles.
  • La ligne warn qui nomme le nœud indique comment le flux atteint ce modèle. Le nœud lit sa clé dans la variable OPENAI_API_KEY, et son adresse dans OPENAI_BASE_URL, et la plateforme fournit les deux pour la connexion au modèle ; le flux ne nécessite donc aucune modification.
  • Les lignes made no choice nomment les nœuds qu’aucun socket de la plateforme n’accueille : ils restent à l’intérieur du flux, que Langflow exécute tel qu’il a été exporté.
  • Les deux dernières lignes sont le pull. Il ne restait rien à répondre, donc l’import a récupéré les dépendances de la Release rédigée, comme le fait aggrega pull, et a écrit release.lock ; le build ci-dessous n’a besoin de rien de plus. La ligne warning est une ligne que le build affiche aussi, et Valider et construire l’explique.

Le fichier de réponses nomme deux Secrets que cet import ne demande pas : il ne laisse rien de vide pour eux, il n’en applique donc aucun et laisse le fichier tel quel.

Ce qu’elle écrit

L’Aggregate, la Release et le Manifest sont nommés imported/basic-prompting, d’après le nom propre du flux, Basic Prompting, réduit à basic-prompting — un flux sans nom est nommé d’après son fichier —, sous le namespace que fixe le paramètre target_namespace de l’importeur, imported sauf si vous en fixez un autre (Paramètres).

aggregate.yaml — une instance de la plateforme Langflow de la bibliothèque standard, core/ai-agent/langflow, portant le flux tel qu’il a été exporté, à l’exception des handles de ses arêtes, écrits comme les écrit l’éditeur de Langflow, dont plus d’un millier de lignes sont omises ici, et le modèle qu’il atteint :

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/basic-prompting
version: 0.1.0
description: Draft Aggregate imported from a source in the langflow format.
spec:
components:
langflow:
type: core/ai-agent/langflow
features:
# For the compose target, the lines below declare admin_password on langflow: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
admin_password:
type: core/secret-value
values:
key: LANGFLOW_SUPERUSER_PASSWORD
values:
flow_id: '0dbee653-41ae-4e51-af2e-55757fb24be3'
flow_definition: |-
{
"data": {
"edges": [
[… omitted: the rest of the flow]
}
uses:
model:
languagemodelcomponent-kboja:
target: languagemodelcomponent-kboja
# For the compose target, the lines below declare credential on languagemodelcomponent-kboja: a secret the Release alone attaches arrives under the key value, so each is declared with a key of its own and no two arrive under one; the Release attaches its origin, naming this type or none.
features:
credential:
type: core/secret-value
values:
key: OPENAI_API_KEY
# swap to core/ai-model/azure-openai (score 0.4000) by setting type: core/ai-model/azure-openai
languagemodelcomponent-kboja:
type: core/ai-model/openai
values:
model: |-
gpt-4.1
  • Le modèle est core/ai-model/openai, avec le modèle que sélectionne le nœud du flux, gpt-4.1. Le commentaire au-dessus nomme un autre Component du catalogue auquel le nœud ressemble, avec son score, pour le lecteur qui préfère celui-là.
  • Les deux secrets — le mot de passe de l’administrateur que demande l’éditeur de Langflow, et la clé OpenAI que la plateforme présente au modèle — sont déclarés ici avec la variable sous laquelle chacun arrive dans l’environnement de Langflow, LANGFLOW_SUPERUSER_PASSWORD et OPENAI_API_KEY. Sur Docker Compose, un secret que la Release seule attacherait arriverait sous la clé value, et les deux entreraient en collision ; déclarés ici, chacun a sa propre clé. La Release indique d’où vient chacun.
  • flow_id est l’identifiant que l’export donne au flux.

release.yaml — la Release, qui déploie l’Aggregate avec le Manifest :

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/basic-prompting
# environment is a drafted default, since no source names the environment this Release deploys to; change it to name the one it deploys to.
environment: development
version: 0.1.0
description: Draft Release imported from a source in the langflow format.
spec:
aggregate: imported/basic-prompting
manifest: imported/basic-prompting
components:
langflow:
infra:
# The image running core/ai-agent/langflow, at the version this importer drafts, which the catalog's Recipes for it are known to run; the import does not raise or lower it to follow the source. The source states version "1.5.0" of the platform.
image: "langflowai/langflow:1.6.0"
# Published on this machine's loopback address, 127.0.0.1: reachable from this machine only, by any process running on it. Delete this line to keep the service internal.
published_port: 7860
features:
admin_password:
type: core/secret-value
infra:
# Attached by reference, never as a value: the administrator's password, read while values.require_authentication stays true, read from the variable LANGFLOW_ADMIN_PASSWORD, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${LANGFLOW_ADMIN_PASSWORD}"
uses:
model:
languagemodelcomponent-kboja:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential langflow presents to languagemodelcomponent-kboja on its model connection, read from the variable OPENAI_API_KEY, which a target substituting variable references, as Docker Compose does when the stack starts, reads from the environment, so no file carries the value.
origin: "${OPENAI_API_KEY}"
languagemodelcomponent-kboja: {}
  • environment vaut development, une valeur par défaut que le commentaire au-dessus demande de remplacer par l’environnement dans lequel la Release est déployée.
  • L’image est Langflow 1.6.0, la version qu’exécutent les Recipes du catalogue pour Langflow. Le flux a été testé pour la dernière fois sur Langflow 1.5.0, comme l’indique le commentaire ; l’import conserve la version qu’exécutent les Recipes plutôt que de suivre celle du flux.
  • published_port vaut 7860, le port sur lequel Langflow sert, si bien que l’éditeur répond à http://127.0.0.1:7860 sur votre machine. Comme l’indique son commentaire, tout processus de cette machine peut l’y atteindre et rien d’autre ne le peut ; supprimez la ligne pour garder Langflow sur le seul réseau de la stack.
  • Les deux secrets sont des références de variables, ${LANGFLOW_ADMIN_PASSWORD} et ${OPENAI_API_KEY}, que Docker Compose renseigne depuis votre shell au démarrage de la stack ; aucun fichier ne contient donc l’une ou l’autre valeur.

manifest.yaml — les Recipes Compose de la plateforme et du modèle, et la réalisation qui écrit telle quelle la référence de variable d’un secret dans le fichier Compose :

apiVersion: aggrega.ai/v1beta1
kind: Manifest
metadata:
name: imported/basic-prompting
version: 0.1.0
spec:
mappings:
components:
type:
core/ai-agent/langflow: compose/langflow
core/ai-model/openai: compose/openai
features:
type:
core/secret-value: compose/dotenv-secret

.aggrega-import.json est l’enregistrement de ce que l’importation a écrit, que lit un aggrega import --sync ultérieur, et release.lock épingle chaque entité du catalogue vers laquelle la Release se résout, par version et digest.

Valider et compiler

Terminal window
aggrega validate --release release.yaml
aggrega build --release release.yaml

La Release rédigée, ouverte dans l’éditeur après sa validation, la sortie Aggrega et une notification signalant toutes deux qu’aucun problème n’a été trouvé.

Le build de la Release rédigée : un dossier dist apparaît dans l’Explorateur, la sortie Aggrega liste le fichier Docker Compose écrit, et une notification indique qu’1 fichier a été écrit.

La validation affiche :

notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
release dependency validation passed: release.yaml (schema-pillar + dependency pillars)

et la compilation, où <workspace> désigne le dossier contenant les ébauches :

warning: node "langflow" (provider "compose"): artifact "langflow-flow/langflow-flow.yaml": skipped provenance label injection — the fragment declares no compose service. Compose carries build provenance as service labels, so a fragment contributing only top-level networks, volumes or configs carries none; the services this component emits elsewhere carry the full set.
notice: LINT: Feature "core/secret-value" at core/secret-value:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 1 file written to <workspace>/dist

La ligne warning concerne la partie du fichier Compose qui porte le flux, une entrée configs de premier niveau, qui n’a aucun service sur lequel apposer les étiquettes du build. La ligne notice est indicative : la Feature de secret accepte son origin depuis les values de l’Aggregate ou l’infra de la Release, et la notice signale qu’une feuille est déclarée dans les deux. Aucune des deux ne change le verdict.

dist/compose/docker-compose.yaml contient Langflow et un service qui s’exécute une fois avant lui :

services:
langflow:
image: langflowai/langflow:1.6.0
environment:
LANGFLOW_CONFIG_DIR: /app/langflow
LANGFLOW_SAVE_DB_IN_CONFIG_DIR: "true"
LANGFLOW_AUTO_LOGIN: "false"
LANGFLOW_SUPERUSER: admin
LANGFLOW_SUPERUSER_PASSWORD: ${LANGFLOW_ADMIN_PASSWORD}
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_API_KEY: ${OPENAI_API_KEY}
LANGFLOW_LOAD_FLOWS_PATH: /app/flows
ports:
- 127.0.0.1:7860:7860
[… omitted: the labels the build writes on every service, naming the Aggregate, the component, the environment and the compiler's version]
volumes:
- type: volume
source: langflow--data
target: /app/langflow
networks:
- compose
depends_on:
langflow--data-owner:
condition: service_completed_successfully
[… omitted: the service's health check]
configs:
- source: langflow-flow
target: /app/flows/flow.json
langflow--data-owner:
image: langflowai/langflow:1.6.0
entrypoint:
- chown
- "1000:0"
- /app/langflow
[… omitted: the labels the build writes on every service]
volumes:
- type: volume
source: langflow--data
target: /app/langflow
networks:
- compose
restart: "no"
user: "0"

Le flux atteint Langflow sous la forme de /app/flows/flow.json, depuis une entrée configs contenant le flux que porte l’Aggregate, et Langflow le charge depuis LANGFLOW_LOAD_FLOWS_PATH à chaque démarrage. La clé et le mot de passe sont des références de variables, remplies depuis votre shell au démarrage de la stack. La Recipe Compose de Langflow ne publie un port sur votre machine que là où la Release définit published_port dans l’infra de Langflow, et alors sur la seule adresse de loopback, 127.0.0.1 ; sans cela, le service n’est joignable que sur le réseau de la stack.

langflow--data-owner exécute l’image de Langflow en tant que root, attribue le volume de données à l’utilisateur 1000, groupe 0, l’identité sous laquelle s’exécute l’image de Langflow, puis se termine. Langflow démarre une fois ce service terminé : Docker crée le volume avec root pour propriétaire, et Langflow ne pourrait pas y écrire ses données autrement.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-y ce prompt.

Utilise uniquement les outils Aggrega, et ne crée aucun dossier toi-même. Si le dossier du Workspace ne contient pas encore de dossier `import-langflow`, appelle une fois l’outil `scaffold` avec `example` défini sur `import-langflow` et sans `dir` : il écrit l’exemple dans un nouveau dossier `import-langflow`, dont le dossier `source` contient ce que cette page importe. Appelle ensuite l’outil `import` avec `workspace_root` défini sur `import-langflow/source`, `source` défini sur `basic-prompting.json` et `target` défini sur `compose` : il lit les réponses dont il a besoin dans `import-answers.yaml` à côté de `basic-prompting.json`, écrit ses brouillons dans `import-langflow/source` et récupère ce dont ils ont besoin. Appelle ensuite l’outil `validate` avec `workspace_root` défini sur `import-langflow/source` et `release` défini sur `release.yaml`, et l’outil `build` avec `workspace_root` défini sur `import-langflow/source`, `release` défini sur `release.yaml` et `write` défini sur true. Dis-moi quels fichiers le build a écrits ; ils se trouvent sous `import-langflow/source/dist/`.

L’ouvrir dans VS Code

Avec l’extension Aggrega pour Visual Studio Code installée, ouvrez dans VS Code le dossier import-langflow/source, où l’import a écrit ses brouillons. Le dossier contient une seule Release, le release.yaml rédigé : l’éditeur la sélectionne donc pour vous, et vérifie les brouillons par rapport à cette Release pendant que vous les modifiez, en signalant ce qu’il trouve dans le fichier et dans le panneau Problèmes. Aggrega: Show topology graph, dans la palette de commandes, dessine les composants de la Release et les connexions entre eux. Aggrega: Build, Aggrega: Preview build et Aggrega: Pull agissent sur la même Release, et chacune est aussi un bouton du panneau Commands de la vue Aggrega dans la barre d’activité ; Build écrit ses fichiers dans le dist/ du dossier. Utiliser Aggrega dans Visual Studio Code couvre le reste.

Exécution

Définissez la clé et le mot de passe de l’administrateur dans votre shell, puis démarrez la stack :

Terminal window
export OPENAI_API_KEY='your OpenAI key'
export LANGFLOW_ADMIN_PASSWORD='a password of your own'
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml up -d --wait

-p nomme le projet, comme l’explique l’étape d’exécution de Déroulement d’une importation. --wait rend la main une fois que langflow--data-owner s’est achevé et que Langflow se signale en bonne santé.

Tester

Ouvrez http://127.0.0.1:7860, l’adresse que published_port publie, et connectez-vous en tant que admin avec le mot de passe que vous avez défini : Basic Prompting se trouve dans l’éditeur avec ses trois connexions.

Langflow n’exécute un flux via son API que pour une clé d’API, qu’un administrateur crée une fois connecté. Connectez-vous :

Terminal window
curl -sS -X POST http://127.0.0.1:7860/api/v1/login \
-d username=admin --data-urlencode "password=$LANGFLOW_ADMIN_PASSWORD"
{"access_token":"[… omitted: the access token]","refresh_token":"[… omitted: the refresh token]","token_type":"bearer"}

créez une clé avec le jeton d’accès :

Terminal window
curl -sS -X POST http://127.0.0.1:7860/api/v1/api_key/ \
-H 'Authorization: Bearer <access_token>' -H 'Content-Type: application/json' -d '{"name": "test-it"}'
{"name":"test-it","last_used_at":null,"total_uses":0,"is_active":true,"id":"[… omitted: the key's identifier]","api_key":"[… omitted: the key]","user_id":"[… omitted: the owner's identifier]"}

et exécutez le flux avec la clé :

Terminal window
curl -sS -X POST 'http://127.0.0.1:7860/api/v1/run/0dbee653-41ae-4e51-af2e-55757fb24be3?stream=false' \
-H 'x-api-key: <api_key>' -H 'Content-Type: application/json' \
-d '{"input_value": "In one short sentence: what is Docker Compose?", "input_type": "chat", "output_type": "chat"}'

L’exécution a utilisé un espace réservé pour la clé OpenAI, si bien que la réponse est le refus de la clé par OpenAI, ce qui montre que le flux s’est exécuté jusqu’à son appel au modèle :

{"detail":"{\"message\":\"Error running graph: Error building Component Language Model: \\n\\nError code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place*****************-key. You can find your API key at https://platform.openai.com/account/api-keys.', 'type': 'invalid_request_error', 'code': 'invalid_api_key', 'param': None}, 'status': 401}\",[… omitted: three empty fields, and a suggestion to update three of the flow's components]}"}

Avec votre clé, la réponse porte celle du modèle à outputs[0].outputs[0].results.message.text.

Sur Kubernetes, une fois appliqué le build que décrit Sur Kubernetes, redirigez un port local vers le Service de Langflow, langflow-default, dans le namespace auquel vous avez appliqué, et laissez la commande s’exécuter :

Terminal window
kubectl port-forward -n <namespace> svc/langflow-default 7860:7860

Depuis un autre terminal, les trois requêtes ci-dessus atteignent Langflow à la même adresse, sans modification ; l’exécution a obtenu le même refus de la clé fictive.

Arrêtez la stack avec la commande ci-dessous. -v supprime aussi le volume de données de Langflow, et avec lui le compte de l’administrateur, la clé d’API et l’historique des exécutions du flux :

Terminal window
docker compose -p basic-prompting -f dist/compose/docker-compose.yaml down -v

Sur Kubernetes

Le même flux s’importe pour Kubernetes avec la cible helm. Les brouillons pour Docker Compose se trouvent déjà dans source, et l’import n’écrase jamais un Aggregate qui s’y trouve : rédigez donc ceux-ci dans un dossier à part avec --output-dir, puis validez et lancez le build depuis celui-ci :

Terminal window
aggrega import basic-prompting.json --target helm --output-dir helm
cd helm
aggrega validate --release release.yaml
aggrega build --release release.yaml

Les brouillons diffèrent là où la cible diffère. Le Manifest associe la plateforme à helm/langflow, le modèle à helm/openai et chaque secret à helm/k8s-existing-secret, qui le lit depuis un Secret déjà présent dans le namespace. La Release attache les deux secrets en tant que core/referenced-secret, chacun nommant ce Secret, et ces noms sont ce que contient le fichier de réponses :

features:
admin_password:
type: core/referenced-secret
infra:
# Left for the Release, since the source cannot supply it: the name of a Kubernetes Secret already in the namespace holding, under the data key value, the administrator's password, read while values.require_authentication stays true.
origin: "langflow-admin"

Sans le fichier de réponses, l’import demande les deux noms dans un terminal et écrit vos réponses dans un nouveau fichier de réponses. Là où rien ne peut être demandé, il écrit ce fichier avec les deux clés et des réponses vides, puis se termine avec le statut 1 et cette ligne, où <workspace> désigne le dossier dans lequel vous l’avez exécuté :

2 values the drafts leave empty are still owed, listed in the answers file <workspace>/import-answers.yaml: write each beside its key there, then run the import again

Le build écrit de simples manifestes Kubernetes sous dist/helm/ à la racine de l’espace de travail, source, qui depuis helm est ../dist/helm/. Créez les deux Secrets dans le namespace auquel vous appliquez, chacun contenant sa valeur sous la clé de données value, puis appliquez le dossier comme l’explique l’étape d’exécution de Comment se déroule un import.