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

Importar un workflow de n8n

Este recorrido guiado importa un workflow exportado desde n8n — un agente de IA que responde mensajes de chat con un modelo de chat de OpenAI y una memoria — en un Aggregate, una Release y un Manifest que, tal como están escritos, compilan para Docker Compose n8n con el workflow incluido; después los compila y ejecuta el resultado. Cada archivo y cada bloque de salida que aparecen a continuación provienen de una ejecución real; el workflow y cada etapa del recorrido están en el ejemplo import-n8n, 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 la importación escribió.

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-n8n

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, que contiene lo que esta página importa y es donde se ejecuta la importación:

Terminal window
cd import-n8n

La carpeta source del ejemplo generado abierta en Visual Studio Code, que muestra la exportación del workflow de n8n de un agente de soporte, abierta en sus nodos de disparador de chat y AI Agent.

El workflow

support-agent.json, escrito para este recorrido con la forma en que n8n exporta un workflow, contiene cuatro nodos: un disparador de chat, un AI Agent con un breve mensaje de sistema, un nodo OpenAI Chat Model que selecciona gpt-4o-mini y un nodo Simple Memory, unidos por las conexiones que n8n enumera por el nombre del nodo del que sale cada una. El disparador de chat es público, así que un mensaje de chat enviado a su URL inicia el workflow, y el disparador pide al remitente un usuario y una contraseña, que comprueba con una credencial de autenticación básica que n8n almacena:

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

El nodo del modelo selecciona su credencial de la misma forma, por referencia — la exportación contiene el identificador y el nombre de cada credencial, nunca el usuario, la contraseña ni la clave:

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

Junto al workflow, 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 support-agent.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 workflow puede contener. Una importación para Docker Compose no necesita ninguna: adjunta la clave de OpenAI mediante una referencia a variable que Docker Compose rellena desde tu shell. Una importación para Kubernetes la adjunta mediante el nombre de un Secret de Kubernetes, que solo tú puedes nombrar, así que el archivo nombra ese Secret (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.n8n.uses.model.openai-chat-model.features.credential.infra.origin: "openai-api-key"

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 support-agent.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 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)

La importación ejecutada desde el editor: el Aggregate, la Release y el Manifest en borrador aparecen junto a la exportación del workflow, la salida de Aggrega enumera cómo se asignó cada nodo y los archivos escritos, y una notificación indica que la importación generó 3 archivos en borrador, reconocidos como n8n.

  • La línea mapped indica que el nodo OpenAI Chat Model pasó a ser 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 0.9143: un componente propio, enlazado al socket model de la plataforma.
  • Las líneas made no choice indican que el disparador, el agente y la memoria permanecen dentro del workflow, que n8n ejecuta por sí mismo.
  • Las dos primeras líneas warn nombran los identificadores de las credenciales almacenadas que seleccionan el disparador y el nodo del modelo, que n8n marca como credenciales. Son referencias, no secretos, y se conservan tal como están escritas.
  • La tercera línea warn es la que hay que leer con atención: el nodo del modelo llega a OpenAI con la credencial almacenada que selecciona, no a través de la conexión que enlaza el borrador. La plataforma entrega la conexión al entorno de n8n, y n8n rechaza las lecturas de su entorno por parte de un workflow mientras el Aggregate deje values.allow_env_access_in_nodes en false, como hace el borrador. Ponerlo en true permite a cada workflow, y a cualquiera que pueda editar uno, leer cada variable de la plataforma, incluida la clave entregada. Así que la clave que usa el workflow es la que almacena n8n, como muestra Ejecútalo.
  • 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 un Secret que esta importación no pide: no deja nada vacío para él, así que no aplica ninguna respuesta y deja el archivo tal como está.

Lo que escribe

El Aggregate, la Release y el Manifest se llaman imported/support-agent, por el nombre propio del flujo de trabajo, Support agent, reducido a support-agent — un flujo de trabajo 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 n8n de la biblioteca estándar, core/ai-agent/n8n, que lleva el workflow tal como se exportó, en gran parte omitido aquí, y el modelo enlazado a su 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 es el identificador que la exportación da al workflow. El modelo es core/ai-model/openai, con el modelo que selecciona el nodo, gpt-4o-mini; el comentario sobre él nombra otro Component del catálogo al que se parece el nodo, con su puntuación. La clave de OpenAI que la plataforma presenta al modelo se declara en la conexión con la variable con la que llega al entorno de n8n, OPENAI_API_KEY; la Release indica de dónde procede.

release.yaml — la Release, que despliega el Aggregate con el 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 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 n8n 1.110.1, la versión que ejecutan las Recipes del catálogo para n8n.
  • published_port es 5678, el puerto en el que sirve n8n, así que el editor responde en http://127.0.0.1:5678 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 n8n solo en la red del stack. Un published_port distinto de 5678 necesita infra.external_base_url: http://127.0.0.1:<published_port> a su lado, o n8n informa de las direcciones de su editor y de sus webhooks en localhost:5678.
  • La clave es una referencia de variable, ${OPENAI_API_KEY}, que Docker Compose rellena desde tu shell cuando se inicia el stack. El modelo OpenAI de la biblioteca estándar es un servicio alojado, y una conexión hacia él debe llevar una credencial, así que la Release adjunta una aunque el workflow lea su clave del almacén de n8n.

manifest.yaml — las Recipes de Compose de la plataforma y del modelo, y la realización que escribe la referencia de variable de la clave en el archivo de Compose tal cual:

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 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 en borrador abierta en el editor tras validarla, con la salida de Aggrega y una notificación que no informan de ningún problema.

El build de la Release en borrador: aparece una carpeta dist en el Explorador, la salida de Aggrega enumera el archivo de Docker Compose escrito, y una notificación indica 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 "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

La línea warning trata de la parte del archivo Compose que lleva el workflow, 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 secretos 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 n8n y un servicio que importa el workflow antes de que n8n se inicie:

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

El workflow llega a n8n mediante n8n import:workflow, ejecutado sobre el mismo volumen de datos cada vez que se inicia el stack, antes que el propio n8n. N8N_BLOCK_ENV_ACCESS_IN_NODE es "true", el bloqueo de n8n a que un workflow lea su entorno, ya que el Aggregate deja allow_env_access_in_nodes en false. Así que el nodo OpenAI Chat Model lee su clave del propio almacén de credenciales de n8n, igual que el disparador del chat lee su usuario y su contraseña, y la ejecución que se describe más abajo almacena ambos. La Recipe de Compose de n8n publica un puerto en tu máquina solo donde la Release establece published_port en el infra de n8n, y en ese caso solo en la dirección de loopback, 127.0.0.1; sin él, el servicio solo es accesible en la red del stack.

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 tú mismo. Si la carpeta del espacio de trabajo aún no contiene una carpeta `import-n8n`, llama una vez a la herramienta `scaffold` con `example` establecido en `import-n8n` y sin `dir`: escribe el ejemplo en una nueva carpeta `import-n8n`, cuya carpeta `source` contiene lo que importa esta página. Después llama a la herramienta `import` con `workspace_root` establecido en `import-n8n/source`, `source` establecido en `support-agent.json` y `target` establecido en `compose`: lee las respuestas que necesita de `import-answers.yaml`, junto a `support-agent.json`, escribe sus borradores en `import-n8n/source` y extrae lo que necesitan. Después llama a la herramienta `validate` con `workspace_root` establecido en `import-n8n/source` y `release` establecido en `release.yaml`, y a la herramienta `build` con `workspace_root` establecido en `import-n8n/source`, `release` establecido en `release.yaml` y `write` establecido en true. Dime qué archivos escribió el build; están bajo `import-n8n/source/dist/`.

Ábrelo en VS Code

Con la extensión de Aggrega para Visual Studio Code instalada, abre en VS Code la carpeta import-n8n/source, donde la importación escribió sus borradores. La carpeta contiene una sola Release, el release.yaml en borrador, así que el editor la selecciona por ti y comprueba los borradores con respecto a 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 actividad; Build escribe sus archivos en el dist/ de la carpeta. Usar Aggrega en Visual Studio Code cubre el resto.

Ejecución

n8n lee de su propio almacén las dos credenciales que selecciona el workflow, por sus identificadores: la clave de OpenAI bajo Rb7nW2xQ9kT4mZ1c, y el usuario y la contraseña del chat bajo Vx3mQ8rLb2Nk7Tz5. La propia línea de comandos de n8n las almacena, bajo esos identificadores, a partir de un archivo. Escríbelas en credentials.json, con tus propios 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"}}
]

Define la clave en tu shell, tal como la lee la Release generada como borrador, e inicia el 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 da nombre al proyecto, como explica el paso de ejecución de Cómo se ejecuta una importación. --wait regresa en cuanto n8n informa de que está en buen estado, después de que el servicio que importa el workflow se haya ejecutado y haya terminado. Copia las credenciales en el contenedor de n8n, impórtalas y elimina la copia:

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.

n8n ya contiene ambas credenciales, así que elimina credentials.json:

Terminal window
rm credentials.json

Después activa el workflow y reinicia n8n para que la activación surta efecto:

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

Una vez que docker compose -p support-agent -f dist/compose/docker-compose.yaml ps n8n vuelva a mostrar n8n (healthy), docker compose -p support-agent -f dist/compose/docker-compose.yaml logs n8n muestra Activated workflow "Support agent" (ID: sQ4vT8nKp2LmX7bR).

Probarlo

Abre http://127.0.0.1:5678, la dirección que publica published_port: el editor de n8n pide una cuenta de propietario en la primera visita y después muestra Support agent.

El disparador del chat solo acepta un mensaje con el usuario y la contraseña almacenados más arriba; sin ellos responde HTTP/1.1 401 Unauthorized y Authorization is required!, y con una contraseña incorrecta HTTP/1.1 403 Forbidden. Con ambos en CHAT_USER y CHAT_PASSWORD, curl los lee de su entrada estándar, de modo que no aparecen en ninguna línea de comandos:

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

La ejecución almacenó un valor de marcador para la clave de OpenAI, así que el workflow se detuvo en su llamada al modelo. n8n conserva la ejecución, que el editor enumera entre las ejecuciones del workflow, con el rechazo de OpenAI: Incorrect API key provided: sk-place*****************-key. Con tu clave, la respuesta es HTTP/1.1 200 OK y la respuesta del agente, como {"output": "…"}.

En Kubernetes, con aplicado el build que describe En Kubernetes, n8n guarda sus datos en un volumen que dura tanto como su pod, así que un pod nuevo se inicia sin lo que almacenaste; almacena en su lugar las credenciales y activa el workflow en la instancia en ejecución. Escribe credentials.json como hace Ejecutarlo, impórtalo mediante kubectl exec, desde su entrada estándar, en el espacio de nombres donde aplicaste el build, y elimínalo después:

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.

Reenvía un puerto local al Service de n8n, n8n-default, y deja el comando en ejecución:

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

Desde otra terminal, configura la cuenta de propietario mediante la API de n8n, que inicia tu sesión y la guarda en cookies.txt, y después activa el 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}'

La segunda respuesta es el workflow, con "active":true. El mensaje de chat anterior lo alcanza entonces en la misma dirección, sin cambios; la ejecución obtuvo el mismo {"message":"Error in workflow"} y el mismo rechazo en la ejecución de n8n.

Detén el stack con el comando de abajo. -v también elimina el volumen de datos de n8n y, con él, las credenciales almacenadas y la activación:

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

En Kubernetes

El mismo workflow 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 allí, así que genera estos en una carpeta propia con --output-dir y luego valida y compila desde ella:

Terminal window
aggrega import support-agent.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 mapea la plataforma a helm/n8n, el modelo a helm/openai y la clave a helm/k8s-existing-secret, que la lee de un Secret que ya existe en el namespace. La Release adjunta la clave como core/referenced-secret, nombrando ese Secret, openai-api-key, a partir del archivo de respuestas.

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 el Secret en el namespace al que aplicas, con la clave 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. El workflow sigue leyendo sus credenciales del almacén propio de n8n, que Pruébalo rellena en Kubernetes.