Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Portugal)
Esta página foi traduzida automaticamente. Ler o original em inglês.

Importar um fluxo do Langflow

Este guia importa um fluxo exportado do Langflow — Basic Prompting, o projeto inicial incluído no Langflow 1.6.0 — para um Aggregate, uma Release e um Manifest que, tal como estão escritos, compilam o Langflow com o fluxo para Docker Compose, e depois compila-os e executa o resultado. Cada ficheiro e cada bloco de saída abaixo provêm de uma execução real; o fluxo e cada etapa do guia estão no exemplo import-langflow, onde um script de verificação volta a executar a importação, compara o que ela escreve, o que ela imprime e os blocos que esta página cita com os ficheiros aí guardados, e valida e compila o que a importação escreveu.

Gerar o exemplo

É possível executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute.

Escreva o exemplo numa nova pasta com o nome dele:

Terminal window
aggrega scaffold --example import-langflow

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta; o seguinte, abaixo, entra na pasta source da nova pasta, onde a importação é executada. Essa pasta contém o ficheiro do fluxo, basic-prompting.json, que esta página descreve em vez de citar:

Terminal window
cd import-langflow

A pasta source do exemplo gerado aberta no Visual Studio Code, mostrando a exportação do Langflow de um fluxo de prompting básico.

O fluxo

O Basic Prompting encadeia quatro nós: um Chat Input, um Prompt, um Language Model que chama o gpt-4.1 da OpenAI e um Chat Output. Tal como o Langflow o distribui, é um único ficheiro JSON, basic-prompting.json, de cerca de 54 KB, que transporta o código-fonte de cada componente, além do fluxo. O seu nó Language Model lê a chave da variável global OPENAI_API_KEY, que o Langflow lê do seu ambiente quando não está armazenada nenhuma variável com esse nome.

Ao lado do fluxo, um .aggrega-config.yaml faz da pasta um espaço de trabalho:

# 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 contém as respostas ao que nenhum fluxo pode conter. Uma importação para Docker Compose não precisa de nenhuma delas: associa cada segredo através de uma referência de variável que o Docker Compose preenche a partir da shell do utilizador. Uma importação para Kubernetes associa cada segredo através do nome de um Secret do Kubernetes, que só o utilizador pode indicar, pelo que o ficheiro indica os dois Secrets que essa importação pede (ver No 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 resposta é o nome de um Secret, nunca o segredo em si, pelo que o ficheiro pode ser guardado com o fluxo. O ficheiro de respostas da importação descreve o ficheiro na íntegra.

A importação compara cada nó com os Components do catálogo do espaço de trabalho, e --target rascunha um Manifest a partir das Recipes desse catálogo. O espaço de trabalho não indica nenhuma pasta de catálogo, pelo que a importação lê o catálogo da biblioteca padrão a partir do registry de onde obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação obtém, verifica e guarda na cache de conteúdo do espaço de trabalho, e que o registo que a importação escreve junto aos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indique as suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa antes com base nessas pastas. Entre em source:

Terminal window
cd source

Executar a importação

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

Na saída padrão, lista o que escreveu:

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

Na saída de erro padrão, com <workspace> a representar a pasta em que a executou:

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

A importação executada a partir do editor: o Aggregate, a Release e o Manifest gerados aparecem ao lado da exportação do fluxo, a saída do Aggrega lista como cada componente do fluxo foi mapeado e os ficheiros escritos, e uma notificação indica que a importação gerou 3 ficheiros, reconhecidos como langflow.

  • A linha mapped indica em que se tornou o nó Language Model: o modelo OpenAI da biblioteca-padrão, core/ai-model/openai, referenciado em vez de rascunhado, uma vez que correspondeu no nível alto, com pontuação 0.9. É um componente próprio, ligado ao socket model da plataforma. Por predefinição, o rascunho executa o fluxo inteiro na plataforma que executa o Langflow, e só dá um componente próprio a um nó que um socket dessa plataforma recebe — um modelo, uma ferramenta, um armazenamento vetorial — quando o nó é reconhecido como tal.
  • A primeira linha warn indica que o fluxo é transportado com os handles de cada aresta escritos como o editor do Langflow os escreve. O Langflow guarda os seus projetos iniciais com um espaço após cada dois-pontos e cada vírgula dos handles de uma aresta; o seu editor, ao abrir um fluxo, descarta todas as arestas cujos handles não estejam escritos exatamente como ele os escreve e depois guarda o fluxo sem elas. Escrito assim, o fluxo abre com as suas três ligações e é executado com elas.
  • A linha warn que indica o nó indica como o fluxo chega a esse modelo. O nó lê a sua chave da variável OPENAI_API_KEY, e o seu endereço de OPENAI_BASE_URL, e a plataforma entrega ambos para a ligação ao modelo, pelo que o fluxo não precisa de nenhuma edição.
  • As linhas made no choice indicam os nós que nenhum socket da plataforma recebe: permanecem dentro do fluxo, que o Langflow executa tal como foi exportado.
  • As duas últimas linhas são o pull. Não restava nada por responder, pelo que a importação obteve as dependências da Release rascunhada, como faz aggrega pull, e escreveu release.lock; a compilação abaixo não precisa de mais nada. A linha warning é uma que a compilação também imprime, e Validar e compilar explica-a.

O ficheiro de respostas nomeia dois Secrets que esta importação não pede: não deixa nada vazio para eles, pelo que não aplica nenhum e deixa o ficheiro como está.

O que a importação escreve

O Aggregate, a Release e o Manifest chamam-se imported/basic-prompting, a partir do nome próprio do fluxo, Basic Prompting, reduzido a basic-prompting — um fluxo sem nome recebe o nome do seu ficheiro — no namespace que a definição target_namespace do importador estabelece, imported, salvo se definir outro (Definições).

aggregate.yaml — uma instância da plataforma Langflow da biblioteca-padrão, core/ai-agent/langflow, com o fluxo tal como foi exportado, exceto os handles das suas arestas, escritos como o editor do Langflow os escreve, do qual mais de mil linhas são omitidas aqui, e o modelo que este alcança:

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
  • O modelo é core/ai-model/openai, com o modelo que o nó do fluxo seleciona, gpt-4.1. O comentário acima dele nomeia outro Component do catálogo com o qual o nó se assemelha, com a respetiva pontuação, para quem preferir esse.
  • Os dois segredos — a palavra-passe do administrador que o editor do Langflow pede e a chave da OpenAI que a plataforma apresenta ao modelo — são declarados aqui com a variável sob a qual cada um chega ao ambiente do Langflow, LANGFLOW_SUPERUSER_PASSWORD e OPENAI_API_KEY. No Docker Compose, um segredo anexado só pela Release chegaria sob a chave value, e os dois colidiriam; declarados aqui, cada um tem uma chave própria. A Release indica de onde vem cada um.
  • flow_id é o identificador que a exportação atribui ao fluxo.

release.yaml — a Release, que implementa o Aggregate com o 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, uma predefinição que o comentário acima indica que se deve alterar para o ambiente em que a Release é implementada.
  • A imagem é Langflow 1.6.0, a versão que as Recipes do catálogo para Langflow executam. O fluxo foi testado pela última vez no Langflow 1.5.0, como indica o comentário; a importação mantém a versão que as Recipes executam em vez de seguir a do fluxo.
  • published_port é 7860, a porta em que o Langflow serve, pelo que o editor responde em http://127.0.0.1:7860 na sua máquina. Como diz o comentário, qualquer processo nesta máquina pode alcançá-lo aí e mais nada pode; apague a linha para manter o Langflow apenas na rede da stack.
  • Os dois segredos são referências de variáveis, ${LANGFLOW_ADMIN_PASSWORD} e ${OPENAI_API_KEY}, que o Docker Compose preenche a partir da sua shell quando a stack arranca, pelo que nenhum ficheiro contém qualquer um dos valores.

manifest.yaml — as Recipes de Compose da plataforma e do modelo, e a realização que escreve a referência de variável de um segredo no ficheiro Compose tal como está escrita:

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 é o registo do que a importação escreveu, que um aggrega import --sync posterior lê, e release.lock fixa cada entidade do catálogo para a qual a Release se resolve, por versão e digest.

Validar e compilar

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

A Release gerada aberta no editor após a validação, com a saída do Aggrega e uma notificação a indicarem ambas que não foram encontrados problemas.

A compilação da Release gerada: uma pasta dist aparece no Explorador, a saída do Aggrega lista o ficheiro do Docker Compose escrito, e uma notificação indica que foi escrito 1 ficheiro.

A validação 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)

e a compilação, com <workspace> a representar a pasta que contém os rascunhos:

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

A linha warning diz respeito à parte do ficheiro Compose que transporta o fluxo, uma entrada configs de nível superior, que não tem nenhum serviço onde colocar as etiquetas da compilação. A linha notice é informativa: a Feature de segredo aceita o seu origin dos values do Aggregate ou do infra da Release, e o aviso indica que uma folha está declarada em ambos. Nenhuma das duas altera o veredicto.

dist/compose/docker-compose.yaml contém o Langflow e um serviço que é executado uma vez antes dele:

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"

O fluxo chega ao Langflow como /app/flows/flow.json, a partir de uma entrada configs que contém o fluxo que o Aggregate transporta, e o Langflow carrega-o de LANGFLOW_LOAD_FLOWS_PATH em cada arranque. A chave e a palavra-passe são referências de variável, preenchidas a partir da sua shell quando a stack arranca. A Recipe do Compose do Langflow só publica uma porta na sua máquina onde a Release define published_port no infra do Langflow, e nesse caso apenas no endereço de loopback, 127.0.0.1; sem isso, o serviço só é alcançado na rede da stack.

langflow--data-owner executa a imagem do Langflow como root, entrega o volume de dados ao utilizador 1000, grupo 0, a identidade com que a imagem do Langflow é executada, e termina. O Langflow arranca assim que este serviço termina: o Docker cria o volume pertencente ao root, e de outro modo o Langflow não conseguiria escrever lá os seus dados.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole nele este prompt.

Usa apenas as ferramentas do Aggrega e não cries nenhuma pasta por tua conta. Se a pasta do Workspace ainda não contiver uma pasta `import-langflow`, chama uma vez a ferramenta `scaffold` com `example` definido como `import-langflow` e sem `dir`: ela escreve o exemplo numa nova pasta `import-langflow`, cuja pasta `source` contém o que esta página importa. Em seguida, chama a ferramenta `import` com `workspace_root` definido como `import-langflow/source`, `source` definido como `basic-prompting.json` e `target` definido como `compose`: ela lê as respostas de que precisa em `import-answers.yaml` ao lado de `basic-prompting.json`, escreve os seus rascunhos em `import-langflow/source` e obtém aquilo de que precisam. Em seguida, chama a ferramenta `validate` com `workspace_root` definido como `import-langflow/source` e `release` definido como `release.yaml`, e a ferramenta `build` com `workspace_root` definido como `import-langflow/source`, `release` definido como `release.yaml` e `write` definido como true. Diz-me que ficheiros a compilação escreveu; estão em `import-langflow/source/dist/`.

Abrir no VS Code

Com a extensão do Aggrega para Visual Studio Code instalada, abra no VS Code a pasta import-langflow/source, onde a importação escreveu os seus rascunhos. A pasta contém uma única Release, o release.yaml gerado, pelo que o editor a seleciona automaticamente e verifica os rascunhos em relação a essa Release à medida que são editados, assinalando o que encontra no ficheiro e no painel Problemas. Aggrega: Show topology graph, na Paleta de Comandos, desenha os componentes da Release e as ligações entre eles. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull atuam sobre a mesma Release, e cada um é também um botão no painel Commands da vista Aggrega na barra de atividades; Build escreve os seus ficheiros no dist/ da pasta. Utilizar o Aggrega no Visual Studio Code cobre o resto.

Execução

Defina a chave e a palavra-passe do administrador na sua shell e, em seguida, inicie a 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 dá nome ao projeto, como explica o passo de execução de Como decorre uma importação. --wait regressa assim que langflow--data-owner tiver terminado e o Langflow indicar que está em bom estado.

Testar

Abra http://127.0.0.1:7860, o endereço que published_port publica, e inicie sessão como admin com a palavra-passe que definiu: o Basic Prompting está no editor com as suas três ligações.

O Langflow só executa um fluxo através da sua API para uma chave de API, que um administrador cria depois de iniciar sessão. Inicie sessão:

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

crie uma chave com o token de acesso:

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

e execute o fluxo com a chave:

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

A execução usou um marcador de posição para a chave da OpenAI, pelo que a resposta é a recusa da chave pela OpenAI, o que mostra que o fluxo foi executado até à sua chamada ao 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]}"}

Com a sua chave, a resposta contém a resposta do modelo em outputs[0].outputs[0].results.message.text.

No Kubernetes, com a compilação descrita em No Kubernetes aplicada, reencaminhe uma porta local para o Service do Langflow, langflow-default, no namespace ao qual aplicou, e deixe o comando em execução:

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

A partir de outro terminal, os três pedidos acima chegam ao Langflow no mesmo endereço, sem alterações; a execução obteve a mesma recusa da chave de marcador de posição.

Pare a stack com o comando abaixo. -v remove também o volume de dados do Langflow e, com ele, a conta do administrador, a chave de API e o histórico de execuções do fluxo:

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

No Kubernetes

O mesmo fluxo importa-se para Kubernetes com o destino helm. Os rascunhos para Docker Compose já estão em source, e a importação nunca substitui um Aggregate que aí esteja, pelo que deve gerar estes numa pasta própria com --output-dir e depois validar e compilar a partir dela:

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

Os rascunhos diferem onde o destino difere. O Manifest associa a plataforma a helm/langflow, o modelo a helm/openai e cada segredo a helm/k8s-existing-secret, que o lê a partir de um Secret já existente no namespace. A Release anexa os dois segredos como core/referenced-secret, cada um com o nome desse Secret, e os nomes são o que o ficheiro de respostas contém:

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"

Sem o ficheiro de respostas, a importação pede os dois nomes num terminal e escreve as respostas num novo ficheiro de respostas. Onde nada pode ser perguntado, escreve esse ficheiro com as duas chaves e respostas vazias, e termina com o estado 1 e esta linha, em que <workspace> representa a pasta onde foi executada:

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

A compilação escreve manifestos simples do Kubernetes em dist/helm/ na raiz do espaço de trabalho, source, que a partir de helm é ../dist/helm/. Crie os dois Secrets no namespace ao qual se aplica, cada um com o respetivo valor na chave de dados value, e depois aplique a pasta como explica o passo de execução de Como decorre uma importação.