Ir al contenido
AggregaAggrega
Seleccionar idioma: Español
Esta página se tradujo automáticamente. Lee el original en inglés.

Importar un flujo de Langflow

Esta guía paso a paso importa un flujo exportado de Langflow — Basic Prompting, el proyecto inicial que incluye Langflow 1.6.0 — en un Aggregate, una Release y un Manifest que, tal como están escritos, compilan Langflow con el flujo para Docker Compose, y luego los compila y ejecuta el resultado. Cada archivo y cada bloque de salida que aparecen a continuación proceden de una ejecución real; el flujo y cada etapa de la guía están en el ejemplo import-langflow, donde un script de comprobación vuelve a ejecutar la importación, compara lo que escribe, lo que imprime y los bloques que cita esta página con los archivos que se conservan allí, y valida y compila lo que escribió la importación.

Generar el ejemplo

Puedes ejecutar esta importación con los comandos de esta página o pedir a tu asistente de IA que la ejecute por ti.

Escribe el ejemplo en una carpeta nueva con su nombre:

Terminal window
aggrega scaffold --example import-langflow

Después imprime los comandos que hay que ejecutar a continuación. El primero entra en la carpeta nueva; el siguiente, más abajo, entra en la carpeta source de la carpeta nueva, donde se ejecuta la importación. Esa carpeta contiene el archivo del flujo, basic-prompting.json, que esta página describe en lugar de citar:

Terminal window
cd import-langflow

La carpeta source del ejemplo generado abierta en Visual Studio Code, que muestra la exportación de Langflow de un flujo de prompting básico.

El flujo

Basic Prompting encadena cuatro nodos: un Chat Input, un Prompt, un Language Model que llama a gpt-4.1 de OpenAI y un Chat Output. Tal como lo distribuye Langflow, es un único archivo JSON, basic-prompting.json, de unos 54 KB, que contiene el código fuente de cada componente además del flujo. Su nodo Language Model lee su clave de la variable global OPENAI_API_KEY, que Langflow lee de su entorno cuando no hay almacenada ninguna variable con ese nombre.

Junto al flujo, un .aggrega-config.yaml convierte la carpeta en un espacio de trabajo:

# 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

y import-answers.yaml contiene las respuestas a lo que ningún flujo puede contener. Una importación para Docker Compose no necesita ninguna: vincula cada secreto mediante una referencia de variable que Docker Compose rellena desde tu shell. Una importación para Kubernetes vincula cada secreto mediante el nombre de un Secret de Kubernetes, que solo tú puedes nombrar, así que el archivo nombra los dos Secrets que pide esa importación (consulta En 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"

Cada respuesta es el nombre de un Secret, nunca el secreto en sí, así que el archivo puede guardarse junto con el flujo. El archivo de respuestas de importación describe el archivo por completo.

La importación evalúa cada nodo frente a los Components del catálogo del espacio de trabajo, y --target genera un borrador de Manifest a partir de sus Recipes. El espacio de trabajo no indica ninguna carpeta de catálogo, así que la importación lee el catálogo de la biblioteca estándar desde el registro del que obtiene su importador: una instantánea firmada del catálogo publicado, que la primera importación obtiene, verifica y guarda en la caché de contenido del espacio de trabajo, y que el historial que la importación escribe junto a sus borradores nombra por su resumen criptográfico. Un espacio de trabajo que indica sus propias carpetas de catálogo — en AGGREGA_CATALOG_DIRS, o bajo workspace.catalog_dirs — importa en cambio a partir de ellas. Entra en source:

Terminal window
cd source

Ejecutar la importación

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

En la salida estándar enumera lo que escribió:

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

En la salida de error estándar, donde <workspace> representa la carpeta en la que la ejecutaste:

[… 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)

La importación ejecutada desde el editor: el Aggregate, la Release y el Manifest generados aparecen junto a la exportación del flujo, la salida de Aggrega indica cómo se asignó cada componente del flujo y los archivos escritos, y una notificación dice que la importación generó 3 archivos, reconocidos como langflow.

  • La línea mapped indica en qué se convirtió el nodo Language Model: el modelo OpenAI de la biblioteca estándar, core/ai-model/openai, referenciado en lugar de generado como borrador, ya que coincidió en el nivel alto, con una puntuación de 0.9. Es un componente propio, conectado al socket model de la plataforma. Por defecto, el borrador ejecuta el flujo completo en la plataforma que ejecuta Langflow, y solo da un componente propio a un nodo que acoge un socket de esa plataforma — un modelo, una herramienta, un almacén vectorial — cuando el nodo se reconoce como tal.
  • La primera línea warn indica que el flujo se incluye con los handles de cada arista escritos como los escribe el editor de Langflow. Langflow guarda sus proyectos de inicio con un espacio después de cada dos puntos y cada coma de los handles de una arista; su editor, al abrir un flujo, descarta toda arista cuyos handles no estén escritos exactamente como él los escribe, y luego guarda el flujo sin ella. Escrito así, el flujo se abre con sus tres conexiones y se ejecuta con ellas.
  • La línea warn que nombra el nodo indica cómo llega el flujo a ese modelo. El nodo lee su clave de la variable OPENAI_API_KEY, y su dirección de OPENAI_BASE_URL, y la plataforma entrega ambas para la conexión del modelo, así que el flujo no necesita ninguna edición.
  • Las líneas made no choice nombran los nodos que ningún socket de la plataforma acoge: permanecen dentro del flujo, que Langflow ejecuta tal como se exportó.
  • Las dos últimas líneas son el pull. No quedaba nada por responder, así que la importación descargó las dependencias de la Release generada, como hace aggrega pull, y escribió release.lock; la compilación de abajo no necesita nada más. La línea warning es una que también imprime la compilación, y Validar y compilar la explica.

El archivo de respuestas nombra dos Secrets que esta importación no pide: no deja nada vacío para ellos, así que no aplica ninguno y deja el archivo como está.

Lo que escribe

El Aggregate, la Release y el Manifest se llaman imported/basic-prompting, por el nombre propio del flujo, Basic Prompting, reducido a basic-prompting — un flujo sin nombre recibe el nombre de su archivo — bajo el namespace que fija el ajuste target_namespace del importador, imported salvo que fijes otro (Ajustes).

aggregate.yaml — una instancia de la plataforma Langflow de la biblioteca estándar, core/ai-agent/langflow, que lleva el flujo tal como se exportó, salvo los handles de sus aristas, escritos como los escribe el editor de Langflow, del que aquí se omiten más de mil líneas, y el modelo al que llega:

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
  • El modelo es core/ai-model/openai, con el modelo que selecciona el nodo del flujo, gpt-4.1. El comentario que tiene encima nombra otro Component del catálogo al que se parece el nodo, con su puntuación, para quien prefiera ese.
  • Los dos secretos — la contraseña del administrador que pide el editor de Langflow y la clave de OpenAI que la plataforma presenta al modelo — se declaran aquí con la variable bajo la que cada uno llega al entorno de Langflow, LANGFLOW_SUPERUSER_PASSWORD y OPENAI_API_KEY. En Docker Compose, un secreto que adjuntara solo la Release llegaría bajo la clave value, y los dos colisionarían; declarados aquí, cada uno tiene una clave propia. La Release indica de dónde viene cada uno.
  • flow_id es el identificador que la exportación da al flujo.

release.yaml — la Release, que despliega el Aggregate con el 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 es development, un valor predeterminado que el comentario de encima indica cambiar por el entorno en el que se despliega la Release.
  • La imagen es Langflow 1.6.0, la versión que ejecutan las Recipes del catálogo para Langflow. El flujo se probó por última vez en Langflow 1.5.0, como dice el comentario; la importación mantiene la versión que ejecutan las Recipes en lugar de seguir la del flujo.
  • published_port es 7860, el puerto en el que sirve Langflow, así que el editor responde en http://127.0.0.1:7860 en tu máquina. Como dice su comentario, cualquier proceso de esta máquina puede alcanzarlo ahí y nada más puede hacerlo; elimina la línea para mantener Langflow solo en la red del stack.
  • Los dos secretos son referencias a variables, ${LANGFLOW_ADMIN_PASSWORD} y ${OPENAI_API_KEY}, que Docker Compose completa desde tu shell cuando se inicia el stack, así que ningún archivo contiene ninguno de los dos valores.

manifest.yaml — las Recipes de Compose de la plataforma y del modelo, y la realización que escribe tal cual la referencia a variable de un secreto en el archivo 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 es el registro de lo que escribió la importación, que lee un aggrega import --sync posterior, y release.lock fija cada entidad del catálogo a la que se resuelve la Release, por versión y digest.

Validar y compilar

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

La Release generada abierta en el editor tras validarla, con la salida de Aggrega y una notificación que informan de que no se encontraron problemas.

La compilación de la Release generada: aparece una carpeta dist en el Explorador, la salida de Aggrega muestra el archivo de Docker Compose escrito, y una notificación dice que se escribió 1 archivo.

La validación imprime:

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)

y la compilación, donde <workspace> representa la carpeta que contiene los borradores:

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 línea warning trata de la parte del archivo Compose que lleva el flujo, una entrada configs de nivel superior, que no tiene ningún servicio en el que poner las etiquetas de la compilación. La línea notice es informativa: la Feature de secreto acepta su origin de los values del Aggregate o de la infra de la Release, y el aviso informa de que una hoja está declarada en ambos. Ninguna de las dos cambia el veredicto.

dist/compose/docker-compose.yaml contiene Langflow y un servicio que se ejecuta una vez antes que él:

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"

El flujo llega a Langflow como /app/flows/flow.json, desde una entrada configs que contiene el flujo que lleva el Aggregate, y Langflow lo carga desde LANGFLOW_LOAD_FLOWS_PATH en cada arranque. La clave y la contraseña son referencias de variables, que se rellenan desde tu shell cuando arranca el stack. La Recipe de Compose de Langflow publica un puerto en tu máquina solo donde la Release define published_port en el infra de Langflow, y entonces solo en la dirección de loopback, 127.0.0.1; sin él, el servicio solo es accesible en la red del stack.

langflow--data-owner ejecuta la imagen de Langflow como root, asigna el volumen de datos al usuario 1000, grupo 0, la identidad con la que se ejecuta la imagen de Langflow, y termina. Langflow se inicia una vez que este servicio ha finalizado: Docker crea el volumen con root como propietario, y de lo contrario Langflow no podría escribir allí sus datos.

Con un asistente de IA

Un asistente de IA configurado con las herramientas de Aggrega puede hacer lo mismo: pega en él este prompt.

Usa solo las herramientas de Aggrega y no crees ninguna carpeta por tu cuenta. Si la carpeta del Workspace todavía no contiene una carpeta `import-langflow`, llama una vez a la herramienta `scaffold` con `example` establecido en `import-langflow` y sin `dir`: escribe el ejemplo en una nueva carpeta `import-langflow`, cuya carpeta `source` contiene lo que importa esta página. Después llama a la herramienta `import` con `workspace_root` establecido en `import-langflow/source`, `source` establecido en `basic-prompting.json` y `target` establecido en `compose`: lee las respuestas que necesita de `import-answers.yaml` junto a `basic-prompting.json`, escribe sus borradores en `import-langflow/source` y descarga lo que necesitan. Después llama a la herramienta `validate` con `workspace_root` establecido en `import-langflow/source` y `release` establecido en `release.yaml`, y a la herramienta `build` con `workspace_root` establecido en `import-langflow/source`, `release` establecido en `release.yaml` y `write` establecido en true. Dime qué archivos escribió la compilación; están en `import-langflow/source/dist/`.

Ábrelo en VS Code

Con la extensión de Aggrega para Visual Studio Code instalada, abre en VS Code la carpeta import-langflow/source, donde la importación escribió sus borradores. La carpeta contiene una sola Release, el release.yaml generado, así que el editor la selecciona por ti y comprueba los borradores con esa Release mientras los editas, marcando lo que encuentra en el archivo y en el panel Problemas. Aggrega: Show topology graph, en la paleta de comandos, dibuja los componentes de la Release y las conexiones entre ellos. Aggrega: Build, Aggrega: Preview build y Aggrega: Pull actúan sobre la misma Release, y cada uno es también un botón del panel Commands de la vista Aggrega en la barra de actividades; Build escribe sus archivos en el dist/ de la carpeta. Usar Aggrega en Visual Studio Code cubre el resto.

Ejecución

Define la clave y la contraseña del administrador en tu shell y luego inicia el 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 da nombre al proyecto, como explica el paso de ejecución de Cómo se ejecuta una importación. --wait regresa una vez que langflow--data-owner ha finalizado y Langflow informa de que está en buen estado.

Probarlo

Abre http://127.0.0.1:7860, la dirección que publica published_port, e inicia sesión como admin con la contraseña que definiste: Basic Prompting está en el editor con sus tres conexiones.

Langflow ejecuta un flujo a través de su API solo para una clave de API, que un administrador crea una vez que ha iniciado sesión. Inicia sesión:

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 clave con el token de acceso:

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

y ejecuta el flujo con la clave:

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

La ejecución usó un marcador de posición para la clave de OpenAI, así que la respuesta es el rechazo de la clave por parte de OpenAI, lo que muestra que el flujo se ejecutó hasta su llamada al modelo:

{"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 tu clave, la respuesta lleva la respuesta del modelo en outputs[0].outputs[0].results.message.text.

En Kubernetes, con la compilación que describe En Kubernetes ya aplicada, reenvía un puerto local al Service de Langflow, langflow-default, en el namespace al que aplicaste, y deja el comando en ejecución:

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

Desde otra terminal, las tres solicitudes anteriores llegan a Langflow en la misma dirección, sin cambios; la ejecución obtuvo el mismo rechazo de la clave de marcador de posición.

Detén el stack con el comando siguiente. -v también elimina el volumen de datos de Langflow y, con él, la cuenta del administrador, la clave de API y el historial de ejecuciones del flujo:

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

En Kubernetes

El mismo flujo se importa para Kubernetes con el destino helm. Los borradores para Docker Compose ya están en source, y la importación nunca sobrescribe un Aggregate que esté ahí, así que genera estos en una carpeta propia con --output-dir, y luego valida y compila desde ella:

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

Los borradores difieren donde difiere el destino. El Manifest asigna la plataforma a helm/langflow, el modelo a helm/openai y cada secreto a helm/k8s-existing-secret, que lo lee de un Secret que ya existe en el namespace. La Release adjunta los dos secretos como core/referenced-secret, cada uno con el nombre de ese Secret, y los nombres son lo que contiene el archivo de respuestas:

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"

Sin el archivo de respuestas, la importación pide ambos nombres en un terminal y escribe tus respuestas en un nuevo archivo de respuestas. Donde no se puede preguntar nada, escribe ese archivo con ambas claves y respuestas vacías, y termina con el estado 1 y esta línea, donde <workspace> representa la carpeta en la que la ejecutaste:

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 compilación escribe manifiestos simples de Kubernetes en dist/helm/ en la raíz del espacio de trabajo, source, que desde helm es ../dist/helm/. Crea los dos Secrets en el namespace al que aplicas, cada uno con su valor bajo la clave de datos value, y luego aplica la carpeta como explica el paso de ejecución de Cómo se ejecuta una importación.