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

Importar um workflow do n8n

Este passo a passo importa um workflow exportado do n8n — um agente de IA que responde a mensagens de chat com um modelo de chat da OpenAI e uma memória — para um Aggregate, uma Release e um Manifest que, tal como estão escritos, compilam o n8n carregando o workflow para Docker Compose, depois os compila e executa o resultado. Cada arquivo e cada bloco de saída abaixo vem de uma execução real; o workflow e cada etapa do passo a passo estão no exemplo import-n8n, onde um script de verificação executa a importação novamente, compara o que ela escreve, o que ela imprime e os blocos que esta página cita com os arquivos mantidos ali, e valida e compila o que a importação escreveu.

Gerar o exemplo

Você pode executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute para você.

Escreva o exemplo em uma nova pasta com o nome dele:

Terminal window
aggrega scaffold --example import-n8n

Em seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova; o seguinte, abaixo, entra na pasta source da pasta nova, que contém o que esta página importa e é onde a importação é executada:

Terminal window
cd import-n8n

A pasta source do exemplo gerado aberta no Visual Studio Code, mostrando a exportação do workflow do n8n de um agente de suporte, aberta nos nós do gatilho de chat e do AI Agent.

O workflow

support-agent.json, escrito para este passo a passo no formato em que o n8n exporta um workflow, contém quatro nós: um gatilho de chat, um AI Agent com uma mensagem de sistema curta, um nó OpenAI Chat Model que seleciona gpt-4o-mini e um nó Simple Memory, unidos pelas conexões que o n8n lista pelo nome do nó de onde cada uma sai. O gatilho de chat é público, então uma mensagem de chat enviada à sua URL inicia o workflow, e o gatilho pede ao remetente um usuário e uma senha, que verifica em relação a uma credencial de autenticação básica que o n8n armazena:

"parameters": {
"public": true,
"authentication": "basicAuth",
"options": {}
},
[… omitted: the node's identifier, name, type, version, position and webhook identifier]
"credentials": {
"httpBasicAuth": {
"id": "Vx3mQ8rLb2Nk7Tz5",
"name": "Chat basic auth"
}
}

O nó do modelo seleciona sua credencial da mesma forma, por referência — a exportação carrega o identificador e o nome de cada credencial, nunca o usuário, a senha ou a chave:

"parameters": {
"model": {
"__rl": true,
"value": "gpt-4o-mini",
"mode": "list",
"cachedResultName": "gpt-4o-mini"
},
"options": {}
},
"id": "6f1d2c3a-7b4e-4a8f-9c21-0d3e5f6a7b03",
"name": "OpenAI Chat Model",
"type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
"typeVersion": 1.2,
"position": [120, 220],
"credentials": {
"openAiApi": {
"id": "Rb7nW2xQ9kT4mZ1c",
"name": "OpenAI account"
}
}

Ao lado do workflow, um .aggrega-config.yaml torna a pasta um workspace:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside support-agent.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 para o que nenhum workflow pode conter. Uma importação para Docker Compose não precisa de nenhuma: ela anexa a chave da OpenAI por uma referência de variável que o Docker Compose preenche a partir do seu shell. Uma importação para Kubernetes a anexa pelo nome de um Secret do Kubernetes, que só você pode nomear, então o arquivo nomeia esse Secret (veja 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.n8n.uses.model.openai-chat-model.features.credential.infra.origin: "openai-api-key"

O arquivo de respostas da importação descreve o arquivo por completo.

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, então a importação lê o catálogo da biblioteca padrão a partir do registro do qual obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação busca, verifica e guarda no cache de conteúdo do espaço de trabalho, e que o histórico que a importação escreve ao lado dos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indica suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa a partir delas em vez disso. Entre em source:

Terminal window
cd source

Executar a importação

Terminal window
aggrega import support-agent.json --target compose

Na saída padrão, ela lista o que gravou:

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

Na saída de erro padrão, com <workspace> representando a pasta em que você 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 n8n format, with drafted paths relative to <workspace>
warn: the value of credentials.httpBasicAuth.id of node When chat message received is carried as written in the flow the draft carries: its format marks the field as a credential, and setting empty_credentials to marked or all writes it empty
warn: the value of credentials.openAiApi.id of node OpenAI Chat Model is carried as written in the flow the draft carries: its format marks the field as a credential, and setting empty_credentials to marked or all writes it empty
warn: node OpenAI Chat Model reaches openai-chat-model, wired to the model socket of core/ai-agent/n8n as openai-chat-model, other than through that connection: an n8n @n8n/n8n-nodes-langchain.lmChatOpenAi node reaches the part at the address the stored credential it selects, or its own parameters, give; the platform delivers this connection as OPENAI_BASE_URL and OPENAI_API_KEY, but an n8n workflow reads a variable of the platform's environment only through an expression reading $env, which the platform refuses while values.allow_env_access_in_nodes is false, the value the draft leaves it at; setting it true lets every workflow, and every user who can edit one, read every variable of the platform's environment, the delivered credentials included
made no choice for When chat message received (@n8n/n8n-nodes-langchain.chatTrigger)
made no choice for AI Agent (@n8n/n8n-nodes-langchain.agent)
mapped OpenAI Chat Model (@n8n/n8n-nodes-langchain.lmChatOpenAi) to core/ai-model/openai as a reference, HIGH at 0.9143
made no choice for Simple Memory (@n8n/n8n-nodes-langchain.memoryBufferWindow)
warning: node "n8n" (provider "compose"): artifact "n8n-flow.compose-fragment.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 rascunhados aparecem ao lado da exportação do workflow, a saída do Aggrega lista como cada nó foi mapeado e os arquivos gravados, e uma notificação informa que a importação rascunhou 3 arquivos, reconhecidos como n8n.

  • A linha mapped diz que o nó OpenAI Chat Model se tornou o modelo OpenAI da biblioteca padrão, core/ai-model/openai, referenciado em vez de gerado como rascunho, já que correspondeu no nível alto, com 0.9143: um componente próprio, ligado ao socket model da plataforma.
  • As linhas made no choice dizem que o gatilho, o agente e a memória permanecem dentro do workflow, que o próprio n8n executa.
  • As duas primeiras linhas warn nomeiam os identificadores das credenciais armazenadas que o gatilho e o nó do modelo selecionam, que o n8n marca como credenciais. São referências, não segredos, e são transportadas tal como estão escritas.
  • A terceira linha warn é a que deve ser lida com atenção: o nó do modelo alcança a OpenAI com a credencial armazenada que seleciona, não pela conexão que o rascunho liga. A plataforma entrega a conexão ao ambiente do n8n, e o n8n recusa as leituras do ambiente feitas por um workflow enquanto o Aggregate deixa values.allow_env_access_in_nodes em false, como faz o rascunho. Defini-lo como true permite que todo workflow, e todos que podem editar um, leiam todas as variáveis da plataforma, incluindo a chave entregue. Portanto, a chave que o workflow usa é a que o n8n armazena, como mostra Execute.
  • As duas últimas linhas são o pull. Não restava nada a responder, então a importação baixou as dependências da Release rascunhada, como faz aggrega pull, e escreveu release.lock; o build abaixo não precisa de mais nada. A linha warning é uma que o build também imprime, e Validar e compilar a explica.

O arquivo de respostas nomeia um Secret que esta importação não pede: ela não deixa nada vazio para ele, então não aplica nenhuma resposta e deixa o arquivo como está.

O que a importação grava

O Aggregate, a Release e o Manifest se chamam imported/support-agent, a partir do nome próprio do workflow, Support agent, reduzido a support-agent — um workflow sem nome recebe o nome do seu arquivo — sob o namespace definido pela configuração target_namespace do importador, imported, a menos que você defina outro (Configurações).

aggregate.yaml — uma instância da plataforma n8n da biblioteca padrão, core/ai-agent/n8n, carregando o workflow tal como foi exportado, a maior parte dele omitida aqui, e o modelo ligado ao seu socket model:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support-agent
version: 0.1.0
description: Draft Aggregate imported from a source in the n8n format.
spec:
components:
n8n:
type: core/ai-agent/n8n
values:
workflow_id: 'sQ4vT8nKp2LmX7bR'
flow_definition: |
{
"id": "sQ4vT8nKp2LmX7bR",
"name": "Support agent",
[… omitted: the rest of the workflow, as exported]
}
uses:
model:
openai-chat-model:
target: openai-chat-model
# For the compose target, the lines below declare credential on openai-chat-model: 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.4125) by setting type: core/ai-model/azure-openai
openai-chat-model:
type: core/ai-model/openai
values:
model: |-
gpt-4o-mini

workflow_id é o identificador que a exportação dá ao workflow. O modelo é core/ai-model/openai, com o modelo que o nó seleciona, gpt-4o-mini; o comentário acima dele nomeia outro Component do catálogo com o qual o nó se parece, com sua pontuação. A chave da OpenAI que a plataforma apresenta ao modelo é declarada na conexão com a variável sob a qual ela chega no ambiente do n8n, OPENAI_API_KEY; a Release diz de onde ela vem.

release.yaml — a Release, que implanta o Aggregate com o Manifest:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support-agent
# 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 n8n format.
spec:
aggregate: imported/support-agent
manifest: imported/support-agent
components:
n8n:
infra:
# The image running core/ai-agent/n8n, 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.
image: "n8nio/n8n:1.110.1"
# 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: 5678
uses:
model:
openai-chat-model:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential n8n presents to openai-chat-model 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}"
openai-chat-model: {}
  • environment é development, um padrão que o comentário acima dele diz para trocar pelo ambiente em que a Release é implantada.
  • A imagem é o n8n 1.110.1, a versão que as Recipes do catálogo para o n8n executam.
  • published_port é 5678, a porta em que o n8n atende, então o editor responde em http://127.0.0.1:5678 na sua máquina. Como diz o comentário, qualquer processo nesta máquina pode alcançá-lo ali e nada mais pode; exclua a linha para manter o n8n apenas na rede da stack. Um published_port diferente de 5678 precisa de infra.external_base_url: http://127.0.0.1:<published_port> ao lado, ou o n8n informa os endereços do seu editor e dos webhooks em localhost:5678.
  • A chave é uma referência de variável, ${OPENAI_API_KEY}, que o Docker Compose preenche a partir do seu shell quando a stack inicia. O modelo OpenAI da biblioteca padrão é um serviço hospedado, e uma conexão com ele deve carregar uma credencial, então a Release anexa uma, mesmo que o workflow leia sua chave do armazenamento do n8n.

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

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

.aggrega-import.json é o registro 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 rascunhada aberta no editor após a validação, com a saída do Aggrega e uma notificação sem relatar nenhum problema.

O build da Release rascunhada: uma pasta dist aparece no Explorer, a saída do Aggrega lista o arquivo do Docker Compose gravado, e uma notificação informa que 1 arquivo foi gravado.

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 o build, com <workspace> representando a pasta que contém os rascunhos:

warning: node "n8n" (provider "compose"): artifact "n8n-flow.compose-fragment.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 arquivo Compose que carrega o workflow, uma entrada configs de nível superior, que não tem nenhum serviço onde colocar os rótulos do build. A linha notice é consultiva: a Feature de segredo aceita seu origin a partir de values do Aggregate ou de infra da Release, e o aviso informa que uma folha está declarada em ambos. Nenhuma delas altera o veredito.

dist/compose/docker-compose.yaml contém o n8n e um serviço que importa o workflow antes de o n8n iniciar:

services:
n8n:
image: n8nio/n8n:1.110.1
environment:
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_API_KEY: ${OPENAI_API_KEY}
N8N_BLOCK_ENV_ACCESS_IN_NODE: "true"
ports:
- 127.0.0.1:5678:5678
[… 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: n8n--data
target: /home/node/.n8n
networks:
- compose
depends_on:
n8n--import-flow:
condition: service_completed_successfully
[… omitted: the service's health check]
n8n--import-flow:
image: n8nio/n8n:1.110.1
command:
- import:workflow
- --input=/flows/workflow.json
entrypoint:
- n8n
[… omitted: the labels the build writes on every service]
volumes:
- type: volume
source: n8n--data
target: /home/node/.n8n
networks:
- compose
restart: "no"
configs:
- source: n8n-flow
target: /flows/workflow.json

O workflow chega ao n8n por meio de n8n import:workflow, executado no mesmo volume de dados toda vez que a stack inicia, antes do próprio n8n. N8N_BLOCK_ENV_ACCESS_IN_NODE é "true", o bloqueio do n8n à leitura do ambiente por um workflow, já que o Aggregate deixa allow_env_access_in_nodes em false. Assim, o nó OpenAI Chat Model lê sua chave do próprio armazenamento de credenciais do n8n, da mesma forma que o gatilho do chat lê seu usuário e sua senha, e a execução descrita abaixo armazena ambos. A Recipe do Compose para o n8n publica uma porta na sua máquina apenas onde a Release define published_port no infra do n8n, e então somente no endereço de loopback, 127.0.0.1; sem ele, o serviço só é acessível na rede da stack.

Com um assistente de IA

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

Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta do workspace ainda não contiver uma pasta `import-n8n`, chame a ferramenta `scaffold` uma vez com `example` definido como `import-n8n` e sem `dir`: ela grava o exemplo em uma nova pasta `import-n8n`, cuja pasta `source` contém o que esta página importa. Em seguida, chame a ferramenta `import` com `workspace_root` definido como `import-n8n/source`, `source` definido como `support-agent.json` e `target` definido como `compose`: ela lê as respostas de que precisa em `import-answers.yaml`, ao lado de `support-agent.json`, grava seus rascunhos em `import-n8n/source` e faz pull do que eles precisam. Em seguida, chame a ferramenta `validate` com `workspace_root` definido como `import-n8n/source` e `release` definido como `release.yaml`, e a ferramenta `build` com `workspace_root` definido como `import-n8n/source`, `release` definido como `release.yaml` e `write` definido como true. Diga-me quais arquivos o build gravou; eles ficam em `import-n8n/source/dist/`.

Abra no VS Code

Com a extensão do Aggrega para Visual Studio Code instalada, abra no VS Code a pasta import-n8n/source, onde a importação gravou seus rascunhos. A pasta contém uma única Release, o release.yaml rascunhado, então o editor a seleciona para você e verifica os rascunhos em relação a essa Release enquanto você os edita, marcando o que encontra no arquivo e no painel Problemas. Aggrega: Show topology graph, na Paleta de Comandos, desenha os componentes da Release e as conexõ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 visualização Aggrega na barra de atividades; Build grava seus arquivos no dist/ da pasta. Usar o Aggrega no Visual Studio Code cobre o restante.

Execução

O n8n lê do próprio armazenamento as duas credenciais que o workflow seleciona, por seus identificadores: a chave da OpenAI em Rb7nW2xQ9kT4mZ1c, e o usuário e a senha do chat em Vx3mQ8rLb2Nk7Tz5. A própria linha de comando do n8n as armazena, sob esses identificadores, a partir de um arquivo. Escreva-as em credentials.json, com seus próprios valores:

[
{"id": "Rb7nW2xQ9kT4mZ1c", "name": "OpenAI account", "type": "openAiApi", "data": {"apiKey": "your OpenAI key"}},
{"id": "Vx3mQ8rLb2Nk7Tz5", "name": "Chat basic auth", "type": "httpBasicAuth", "data": {"user": "a user of your own", "password": "a password of your own"}}
]

Defina a chave no seu shell, do modo como a Release em rascunho a lê, e inicie a stack:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
docker compose -p support-agent -f dist/compose/docker-compose.yaml up -d --wait

-p nomeia o projeto, como explica a etapa de execução de Como uma importação é executada. --wait retorna assim que o n8n se reporta saudável, depois que o serviço que importa o workflow foi executado e encerrado. Copie as credenciais para o contêiner do n8n, importe-as e remova a cópia:

Terminal window
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec -T n8n sh -c 'umask 077; cat > /tmp/credentials.json' < credentials.json
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec n8n n8n import:credentials --input=/tmp/credentials.json
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec n8n rm /tmp/credentials.json
[… omitted: n8n's notices about its settings file's permissions, error tracking and deprecated settings]
Successfully imported 2 credentials.

O n8n agora contém as duas credenciais, então exclua credentials.json:

Terminal window
rm credentials.json

Em seguida, ative o workflow e reinicie o n8n para que a ativação tenha efeito:

Terminal window
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec n8n n8n update:workflow --id=sQ4vT8nKp2LmX7bR --active=true
docker compose -p support-agent -f dist/compose/docker-compose.yaml restart n8n

Assim que docker compose -p support-agent -f dist/compose/docker-compose.yaml ps n8n mostrar o n8n (healthy) novamente, docker compose -p support-agent -f dist/compose/docker-compose.yaml logs n8n exibirá Activated workflow "Support agent" (ID: sQ4vT8nKp2LmX7bR).

Teste

Abra http://127.0.0.1:5678, o endereço que published_port publica: o editor do n8n pede uma conta de proprietário na primeira visita e depois mostra Support agent.

O gatilho do chat só aceita uma mensagem com o usuário e a senha armazenados acima; sem eles, responde HTTP/1.1 401 Unauthorized e Authorization is required!, e com uma senha errada, HTTP/1.1 403 Forbidden. Com os dois em CHAT_USER e CHAT_PASSWORD, o curl os lê da sua entrada padrão, de modo que não aparecem em nenhuma linha de comando:

Terminal window
printf 'user = "%s:%s"\n' "$CHAT_USER" "$CHAT_PASSWORD" | curl --config - -sS -i -X POST \
http://127.0.0.1:5678/webhook/a3c9e1f2-4b5d-4e6f-8a7b-9c0d1e2f3a04/chat -H 'Content-Type: application/json' \
-d '{"action": "sendMessage", "sessionId": "s1", "chatInput": "In one short sentence: what does a support plan cover?"}'
HTTP/1.1 500 Internal Server Error
[… omitted: the response's other headers]
{"message":"Error in workflow"}

A execução armazenou um valor provisório para a chave da OpenAI, então o workflow parou na chamada ao modelo. O n8n mantém a execução, que o editor lista entre as execuções do workflow, com a recusa da OpenAI: Incorrect API key provided: sk-place*****************-key. Com a sua chave, a resposta é HTTP/1.1 200 OK e a resposta do agente, como {"output": "…"}.

No Kubernetes, com o build descrito em No Kubernetes aplicado, o n8n mantém seus dados em um volume que dura tanto quanto seu pod, então um novo pod inicia sem o que você armazenou; em vez disso, armazene as credenciais e ative o workflow na instância em execução. Escreva credentials.json como faz Executar, importe-o por meio de kubectl exec, a partir da entrada padrão, no namespace em que você aplicou o build, e exclua-o depois:

Terminal window
kubectl exec -i -n <namespace> deploy/n8n -- n8n import:credentials --input=/dev/stdin < credentials.json
Defaulted container "main" out of: main, import-flow (init)
[… omitted: n8n's notices about its settings file's permissions, error tracking and deprecated settings]
Successfully imported 2 credentials.

Encaminhe uma porta local para o Service do n8n, n8n-default, e deixe o comando em execução:

Terminal window
kubectl port-forward -n <namespace> svc/n8n-default 5678:5678

Em outro terminal, configure a conta de proprietário pela API do n8n, que faz seu login e mantém a sessão em cookies.txt, e depois ative o workflow:

Terminal window
curl -sS -c cookies.txt -X POST http://127.0.0.1:5678/rest/owner/setup -H 'Content-Type: application/json' \
-d '{"email": "owner@example.com", "firstName": "Your", "lastName": "Name", "password": "a password of your own"}'
curl -sS -b cookies.txt -X PATCH http://127.0.0.1:5678/rest/workflows/sQ4vT8nKp2LmX7bR \
-H 'Content-Type: application/json' -d '{"active": true}'

A segunda resposta é o workflow, com "active":true. A mensagem de chat acima então o alcança no mesmo endereço, sem alterações; a execução obteve o mesmo {"message":"Error in workflow"} e a mesma recusa na execução do n8n.

Pare a stack com o comando abaixo. -v também remove o volume de dados do n8n e, com ele, as credenciais armazenadas e a ativação:

Terminal window
docker compose -p support-agent -f dist/compose/docker-compose.yaml down -v

No Kubernetes

O mesmo workflow é importado para o Kubernetes com o destino helm. Os rascunhos para o Docker Compose já estão em source, e a importação nunca sobrescreve um Aggregate ali, então gere estes em uma pasta própria com --output-dir e depois valide e faça o build a partir dela:

Terminal window
aggrega import support-agent.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 mapeia a plataforma para helm/n8n, o modelo para helm/openai e a chave para helm/k8s-existing-secret, que a lê de um Secret já existente no namespace. A Release anexa a chave como core/referenced-secret, nomeando esse Secret, openai-api-key, a partir do arquivo de respostas.

O build escreve manifestos simples do Kubernetes em dist/helm/ na raiz do workspace, source, que a partir de helm é ../dist/helm/. Crie o Secret no namespace em que você aplica, guardando a chave sob a chave de dados value, e depois aplique a pasta como explica a etapa de execução de Como uma importação é executada. O workflow continua lendo suas credenciais do armazenamento do próprio n8n, que Teste preenche no Kubernetes.