Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Importare un flusso di Langflow

Questa guida passo passo importa un flusso esportato da Langflow — Basic Prompting, il progetto iniziale fornito con Langflow 1.6.0 — in un Aggregate, una Release e un Manifest che, così come sono scritti, compilano Langflow con il flusso per Docker Compose, quindi li compila ed esegue il risultato. Ogni file e ogni blocco di output riportati di seguito provengono da un’esecuzione reale; il flusso e ogni fase della guida si trovano nell’esempio import-langflow, dove uno script di verifica esegue di nuovo l’importazione, confronta ciò che scrive, ciò che stampa e i blocchi citati in questa pagina con i file conservati lì, e convalida e compila ciò che l’importazione ha scritto.

Generare l’esempio

Puoi eseguire questa importazione con i comandi di questa pagina, oppure farla eseguire al tuo assistente AI.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

Terminal window
aggrega scaffold --example import-langflow

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella; quello successivo, qui sotto, ti porta nella cartella source della nuova cartella, dove viene eseguita l’importazione. Quella cartella contiene il file del flusso, basic-prompting.json, che questa pagina descrive anziché citare:

Terminal window
cd import-langflow

La cartella source dell’esempio generato aperta in Visual Studio Code, che mostra l’esportazione Langflow di un flusso di prompting di base.

Il flusso

Basic Prompting concatena quattro nodi: un Chat Input, un Prompt, un Language Model che chiama gpt-4.1 di OpenAI e un Chat Output. Così come Langflow lo distribuisce, è un unico file JSON, basic-prompting.json, di circa 54 KB, che contiene il codice sorgente di ogni componente oltre al flusso. Il suo nodo Language Model legge la propria chiave dalla variabile globale OPENAI_API_KEY, che Langflow legge dal proprio ambiente quando non è memorizzata alcuna variabile con quel nome.

Accanto al flusso, un .aggrega-config.yaml rende la cartella uno spazio di lavoro:

# 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

e import-answers.yaml contiene le risposte a ciò che nessun flusso può contenere. Un’importazione per Docker Compose non ne richiede nessuna: collega ogni segreto tramite un riferimento a variabile che Docker Compose riempie dalla tua shell. Un’importazione per Kubernetes collega ogni segreto tramite il nome di un Secret Kubernetes, che solo tu puoi indicare, quindi il file indica i due Secret richiesti da quell’importazione (vedi Su 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"

Ogni risposta è il nome di un Secret, mai il segreto stesso, quindi il file può essere conservato insieme al flusso. Il file delle risposte di importazione descrive il file per intero.

L’importazione valuta ogni nodo rispetto ai Components del catalogo dello spazio di lavoro, e --target abbozza un Manifest a partire dalle sue Recipes. Lo spazio di lavoro non indica alcuna cartella di catalogo, quindi l’importazione legge il catalogo della libreria standard dal registry da cui recupera il proprio importer: uno snapshot firmato del catalogo pubblicato, che la prima importazione recupera, verifica e conserva nella cache dei contenuti dello spazio di lavoro, e che il record scritto dall’importazione accanto alle sue bozze indica tramite il suo digest. Uno spazio di lavoro che indica le proprie cartelle di catalogo — in AGGREGA_CATALOG_DIRS, oppure sotto workspace.catalog_dirs — importa invece rispetto a quelle. Entra in source:

Terminal window
cd source

Eseguire l’importazione

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

Sullo standard output elenca ciò che ha scritto:

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

Sullo standard error, dove <workspace> sta per la cartella in cui l’hai eseguita:

[… 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’importazione eseguita dall’editor: l’Aggregate, la Release e il Manifest generati compaiono accanto all’esportazione del flusso, l’output di Aggrega elenca come è stato mappato ciascun componente del flusso e i file scritti, e una notifica dice che l’importazione ha generato 3 file, riconosciuti come langflow.

  • La riga mapped dice che cosa è diventato il nodo Language Model: il modello OpenAI della libreria standard, core/ai-model/openai, referenziato anziché abbozzato, poiché ha trovato corrispondenza nel livello alto, con un punteggio di 0.9. È un componente a sé, collegato al socket model della piattaforma. Per impostazione predefinita la bozza esegue l’intero flusso sulla piattaforma che esegue Langflow, e assegna un componente a sé solo a un nodo accolto da un socket di quella piattaforma — un modello, uno strumento, un archivio vettoriale — quando il nodo viene riconosciuto come tale.
  • La prima riga warn dice che il flusso è riportato con gli handle di ogni arco scritti come li scrive l’editor di Langflow. Langflow conserva i propri progetti iniziali con uno spazio dopo ogni due punti e ogni virgola degli handle di un arco; il suo editor, aprendo un flusso, scarta ogni arco i cui handle non sono scritti esattamente come li scrive lui, poi salva il flusso senza di esso. Scritto così, il flusso si apre con le sue tre connessioni e viene eseguito con esse.
  • La riga warn che nomina il nodo dice come il flusso raggiunge quel modello. Il nodo legge la propria chiave dalla variabile OPENAI_API_KEY, e il proprio indirizzo da OPENAI_BASE_URL, e la piattaforma fornisce entrambi per la connessione al modello, quindi il flusso non richiede modifiche.
  • Le righe made no choice nominano i nodi che nessun socket della piattaforma accoglie: restano all’interno del flusso, che Langflow esegue così come è stato esportato.
  • Le ultime due righe sono il pull. Non restava nulla a cui rispondere, quindi l’importazione ha scaricato le dipendenze della Release abbozzata, come fa aggrega pull, e ha scritto release.lock; la build qui sotto non richiede altro. La riga warning è una che stampa anche la build, e Convalidare e compilare la spiega.

Il file delle risposte nomina due Secret che questa importazione non richiede: per essi non lascia nulla di vuoto, quindi non ne applica nessuno e lascia il file così com’è.

Cosa scrive

L’Aggregate, la Release e il Manifest si chiamano imported/basic-prompting, dal nome proprio del flusso, Basic Prompting, ridotto a basic-prompting — un flusso senza nome prende il nome dal suo file — nel namespace definito dall’impostazione target_namespace dell’importatore, imported a meno che tu non ne imposti un altro (Impostazioni).

aggregate.yaml — un’istanza della piattaforma Langflow della libreria standard, core/ai-agent/langflow, che porta il flusso così come è stato esportato, salvo gli handle dei suoi archi, scritti come li scrive l’editor di Langflow, qui con più di mille righe omesse, e il modello che raggiunge:

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
  • Il modello è core/ai-model/openai, con il modello selezionato dal nodo del flusso, gpt-4.1. Il commento sopra di esso nomina un altro Component del catalogo a cui il nodo somiglia, con il relativo punteggio, per chi preferisce quello.
  • I due segreti — la password dell’amministratore richiesta dall’editor di Langflow e la chiave OpenAI che la piattaforma presenta al modello — sono dichiarati qui con la variabile sotto cui ciascuno arriva nell’ambiente di Langflow, LANGFLOW_SUPERUSER_PASSWORD e OPENAI_API_KEY. Su Docker Compose un segreto associato dalla sola Release arriverebbe sotto la chiave value, e i due entrerebbero in conflitto; dichiarati qui, ciascuno ha una chiave propria. La Release dice da dove proviene ciascuno.
  • flow_id è l’identificatore che l’esportazione assegna al flusso.

release.yaml — la Release, che distribuisce l’Aggregate con il 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 è development, un valore predefinito che il commento sopra di esso indica di cambiare con l’ambiente in cui la Release viene distribuita.
  • L’immagine è Langflow 1.6.0, la versione eseguita dalle Recipes del catalogo per Langflow. Il flusso è stato testato l’ultima volta su Langflow 1.5.0, come dice il commento; l’importazione mantiene la versione eseguita dalle Recipes anziché seguire quella del flusso.
  • published_port è 7860, la porta su cui Langflow risponde, quindi l’editor risponde su http://127.0.0.1:7860 sulla tua macchina. Come dice il suo commento, qualsiasi processo su questa macchina può raggiungerlo lì e nient’altro può farlo; elimina la riga per mantenere Langflow solo sulla rete dello stack.
  • I due segreti sono riferimenti a variabili, ${LANGFLOW_ADMIN_PASSWORD} e ${OPENAI_API_KEY}, che Docker Compose valorizza dalla tua shell all’avvio dello stack, quindi nessun file contiene l’uno o l’altro valore.

manifest.yaml — le Recipes Compose della piattaforma e del modello, e la realizzazione che scrive il riferimento a variabile di un segreto nel file Compose tale e quale:

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 è il registro di ciò che l’importazione ha scritto, che un successivo aggrega import --sync legge, e release.lock fissa ogni entità del catalogo a cui la Release si risolve, per versione e digest.

Convalidare e compilare

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

La Release generata aperta nell’editor dopo la validazione, con l’output di Aggrega e una notifica che segnalano entrambi che non sono stati trovati problemi.

La build della Release generata: una cartella dist compare in Esplora risorse, l’output di Aggrega elenca il file Docker Compose scritto, e una notifica dice che è stato scritto 1 file.

La convalida stampa:

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)

e la build, dove <workspace> sta per la cartella che contiene le bozze:

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 riga warning riguarda la parte del file Compose che porta il flusso, una voce configs di primo livello, che non ha alcun servizio su cui apporre le etichette della build. La riga notice è informativa: la Feature del segreto accetta il proprio origin dai values dell’Aggregate o dall’infra della Release, e la notifica segnala che una foglia è dichiarata in entrambi. Nessuna delle due cambia il verdetto.

dist/compose/docker-compose.yaml contiene Langflow e un servizio che viene eseguito una volta prima di esso:

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"

Il flusso raggiunge Langflow come /app/flows/flow.json, da una voce configs che contiene il flusso portato dall’Aggregate, e Langflow lo carica da LANGFLOW_LOAD_FLOWS_PATH a ogni avvio. La chiave e la password sono riferimenti a variabili, valorizzati dalla tua shell all’avvio dello stack. La Recipe Compose di Langflow pubblica una porta sulla tua macchina solo dove la Release imposta published_port nell’infra di Langflow, e in tal caso soltanto sull’indirizzo di loopback, 127.0.0.1; senza di essa, il servizio si raggiunge solo sulla rete dello stack.

langflow--data-owner esegue l’immagine di Langflow come root, assegna il volume dei dati all’utente 1000, gruppo 0, l’identità con cui viene eseguita l’immagine di Langflow, e termina. Langflow si avvia una volta che questo servizio è terminato: Docker crea il volume di proprietà di root, e altrimenti Langflow non potrebbe scrivervi i propri dati.

Con un assistente AI

Un assistente AI configurato con gli strumenti di Aggrega può fare lo stesso: incollaci questo prompt.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella del Workspace non contiene ancora una cartella `import-langflow`, chiama una volta lo strumento `scaffold` con `example` impostato a `import-langflow` e nessun `dir`: scrive l’esempio in una nuova cartella `import-langflow`, la cui cartella `source` contiene ciò che questa pagina importa. Poi chiama lo strumento `import` con `workspace_root` impostato a `import-langflow/source`, `source` impostato a `basic-prompting.json` e `target` impostato a `compose`: legge le risposte di cui ha bisogno da `import-answers.yaml` accanto a `basic-prompting.json`, scrive le sue bozze in `import-langflow/source` e scarica ciò di cui hanno bisogno. Poi chiama lo strumento `validate` con `workspace_root` impostato a `import-langflow/source` e `release` impostato a `release.yaml`, e lo strumento `build` con `workspace_root` impostato a `import-langflow/source`, `release` impostato a `release.yaml` e `write` impostato a true. Dimmi quali file ha scritto la build; si trovano in `import-langflow/source/dist/`.

Aprilo in VS Code

Con l’estensione Aggrega per Visual Studio Code installata, apri in VS Code la cartella import-langflow/source, dove l’importazione ha scritto le sue bozze. La cartella contiene una sola Release, il release.yaml generato, quindi l’editor la seleziona per te e controlla le bozze rispetto a quella Release mentre le modifichi, segnalando ciò che trova nel file e nel pannello Problemi. Aggrega: Show topology graph, nel riquadro comandi, disegna i componenti della Release e le connessioni tra di essi. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull agiscono sulla stessa Release, e ciascuno è anche un pulsante nel pannello Commands della vista Aggrega nella barra delle attività; Build scrive i propri file in dist/ della cartella. Usare Aggrega in Visual Studio Code copre il resto.

Esecuzione

Imposta la chiave e la password dell’amministratore nella tua shell, poi avvia lo 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 assegna il nome al progetto, come spiega il passaggio di esecuzione di Come si svolge un’importazione. --wait ritorna una volta che langflow--data-owner ha terminato e Langflow segnala di essere integro.

Eseguire il test

Apri http://127.0.0.1:7860, l’indirizzo che published_port pubblica, e accedi come admin con la password che hai impostato: Basic Prompting è nell’editor con le sue tre connessioni.

Langflow esegue un flusso tramite la propria API solo per una chiave API, che un amministratore crea dopo aver effettuato l’accesso. Accedi:

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

crea una chiave con il token di accesso:

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

ed esegui il flusso con la chiave:

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’esecuzione ha usato un segnaposto per la chiave OpenAI, quindi la risposta è il rifiuto della chiave da parte di OpenAI, che mostra che il flusso è stato eseguito fino alla sua chiamata al modello:

{"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]}"}

Con la tua chiave, la risposta riporta la risposta del modello in outputs[0].outputs[0].results.message.text.

Su Kubernetes, una volta applicata la build descritta in Su Kubernetes, inoltra una porta locale al Service di Langflow, langflow-default, nel namespace a cui hai applicato, e lascia il comando in esecuzione:

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

Da un altro terminale, le tre richieste precedenti raggiungono Langflow allo stesso indirizzo, invariate; l’esecuzione ha ottenuto lo stesso rifiuto della chiave segnaposto.

Arresta lo stack con il comando seguente. -v rimuove anche il volume dei dati di Langflow e, con esso, l’account dell’amministratore, la chiave API e la cronologia delle esecuzioni del flusso:

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

Su Kubernetes

Lo stesso flusso si importa per Kubernetes con il target helm. Le bozze per Docker Compose si trovano già in source, e l’importazione non sovrascrive mai un Aggregate lì presente, quindi genera queste in una cartella propria con --output-dir, poi valida ed esegui la build da lì:

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

Le bozze differiscono dove differisce il target. Il Manifest mappa la piattaforma su helm/langflow, il modello su helm/openai e ciascun secret su helm/k8s-existing-secret, che lo legge da un Secret già presente nel namespace. La Release collega i due secret come core/referenced-secret, ciascuno con il nome di quel Secret, e i nomi sono ciò che contiene il file delle risposte:

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"

Senza il file delle risposte, l’importazione chiede entrambi i nomi da un terminale e scrive le tue risposte in un nuovo file delle risposte. Dove non è possibile chiedere nulla, scrive quel file con entrambe le chiavi e risposte vuote, e termina con stato 1 e questa riga, in cui <workspace> indica la cartella in cui l’hai eseguita:

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

La build scrive semplici manifest Kubernetes in dist/helm/ nella radice del workspace, source, che da helm è ../dist/helm/. Crea i due Secret nel namespace a cui applichi, ciascuno con il proprio valore sotto la chiave di dati value, poi applica la cartella come spiega la fase di esecuzione di Come si esegue un’importazione.