Importer un workflow n8n
Ce tutoriel pas à pas importe un workflow exporté depuis n8n — un agent d’IA qui répond aux messages de chat avec un modèle de chat OpenAI et une mémoire — dans un Aggregate, une Release et un Manifest qui, tels qu’ils sont écrits, construisent pour Docker Compose un n8n qui embarque le workflow, puis les construit et exécute le résultat. Chaque fichier et chaque bloc de sortie ci-dessous proviennent d’une exécution réelle ; le workflow et chaque étape du tutoriel se trouvent dans l’exemple import-n8n, où un script de vérification relance l’import, compare ce qu’il écrit, ce qu’il affiche et les blocs que cite cette page avec les fichiers qui y sont conservés, puis valide et construit ce que l’import a écrit.
Générer l’exemple
Vous pouvez exécuter cette importation avec les commandes de cette page, ou la faire exécuter par votre assistant IA.
Écrivez l’exemple dans un nouveau dossier qui porte son nom :
aggrega scaffold --example import-n8nElle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier ; la suivante, ci-dessous, vous place dans le dossier source du nouveau dossier, qui contient ce que cette page importe et où s’exécute l’import :
cd import-n8n
Le workflow
support-agent.json, écrit pour ce tutoriel sous la forme dans laquelle n8n exporte un workflow, contient quatre nœuds : un déclencheur de chat, un AI Agent avec un court message système, un nœud OpenAI Chat Model qui sélectionne gpt-4o-mini, et un nœud Simple Memory, reliés par les connexions que n8n liste par le nom du nœud dont chacune part. Le déclencheur de chat est public : un message de chat envoyé à son URL démarre donc le workflow, et le déclencheur demande à l’expéditeur un utilisateur et un mot de passe, qu’il vérifie auprès d’une information d’identification d’authentification basique que n8n stocke :
"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" } }Le nœud du modèle sélectionne son information d’identification de la même manière, par référence — l’export contient l’identifiant et le nom de chaque information d’identification, jamais l’utilisateur, le mot de passe ni la clé :
"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" } }À côté du workflow, un .aggrega-config.yaml fait du dossier un espace de travail :
# 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.aiet import-answers.yaml contient les réponses à ce qu’aucun workflow ne peut contenir. Un import pour Docker Compose n’en a besoin d’aucune : il attache la clé OpenAI par une référence de variable que Docker Compose renseigne depuis votre shell. Un import pour Kubernetes l’attache par le nom d’un Secret Kubernetes, que vous seul pouvez nommer, de sorte que le fichier nomme ce Secret (voir Sur 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"Le fichier de réponses de l’import décrit le fichier en détail.
L’import évalue chaque nœud par rapport aux Components du catalogue de l’espace de travail, et --target rédige un brouillon de Manifest à partir de ses Recipes. L’espace de travail n’indique aucun dossier de catalogue ; l’import lit donc le catalogue de la bibliothèque standard depuis le registre dont il récupère son importateur : un instantané signé du catalogue publié, que le premier import récupère, vérifie et conserve dans le cache de contenu de l’espace de travail, et que l’enregistrement écrit par l’import à côté de ses brouillons désigne par son condensé. Un espace de travail qui indique ses propres dossiers de catalogue — dans AGGREGA_CATALOG_DIRS, ou sous workspace.catalog_dirs — importe plutôt en s’appuyant sur ceux-ci. Placez-vous dans source :
cd sourceLancer l’importation
aggrega import support-agent.json --target composeSur la sortie standard, elle liste ce qu’elle a écrit :
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonSur la sortie d’erreur standard, où <workspace> désigne le dossier dans lequel vous l’avez lancée :
[… 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 emptywarn: 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 emptywarn: 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 includedmade 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.9143made 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 ligne
mappedindique que le nœud OpenAI Chat Model est devenu le modèle OpenAI de la bibliothèque standard,core/ai-model/openai, référencé plutôt que rédigé en brouillon, puisqu’il correspondait dans le niveau élevé, à 0.9143 : un composant à part entière, relié au socketmodelde la plateforme. - Les lignes
made no choiceindiquent que le déclencheur, l’agent et la mémoire restent à l’intérieur du workflow, que n8n exécute lui-même. - Les deux premières lignes
warnnomment les identifiants des informations d’identification stockées que sélectionnent le déclencheur et le nœud du modèle, et que n8n marque comme informations d’identification. Ce sont des références, pas des secrets, et elles sont reprises telles qu’elles sont écrites. - La troisième ligne
warnest celle à lire attentivement : le nœud du modèle atteint OpenAI avec l’information d’identification stockée qu’il sélectionne, et non par la connexion que relie le brouillon. La plateforme fournit la connexion à l’environnement de n8n, et n8n refuse à un workflow la lecture de son environnement tant que l’Aggregate laissevalues.allow_env_access_in_nodesàfalse, comme le fait le brouillon. Le passer àtruepermet à chaque workflow, et à quiconque peut en modifier un, de lire chaque variable de la plateforme, y compris la clé fournie. La clé qu’utilise le workflow est donc celle que stocke n8n, comme le montre L’exécuter. - Les deux dernières lignes sont le pull. Il ne restait rien à répondre, donc l’import a récupéré les dépendances de la Release rédigée, comme le fait
aggrega pull, et a écritrelease.lock; le build ci-dessous n’a besoin de rien de plus. La lignewarningest une ligne que le build affiche aussi, et Valider et construire l’explique.
Le fichier de réponses nomme un Secret que cet import ne demande pas : il ne laisse rien de vide pour lui, il n’applique donc aucune réponse et laisse le fichier tel quel.
Ce qu’elle écrit
L’Aggregate, la Release et le Manifest sont nommés imported/support-agent, d’après le nom propre du workflow, Support agent, réduit à support-agent — un workflow sans nom est nommé d’après son fichier —, sous le namespace que fixe le paramètre target_namespace de l’importeur, imported sauf si vous en fixez un autre (Paramètres).
aggregate.yaml — une instance de la plateforme n8n de la bibliothèque standard, core/ai-agent/n8n, portant le workflow tel qu’il a été exporté, en grande partie omis ici, et le modèle relié à son socket model :
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: 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-miniworkflow_id est l’identifiant que l’export donne au workflow. Le modèle est core/ai-model/openai, avec le modèle que sélectionne le nœud, gpt-4o-mini ; le commentaire au-dessus nomme un autre Component du catalogue auquel le nœud ressemble, avec son score. La clé OpenAI que la plateforme présente au modèle est déclarée sur la connexion avec la variable sous laquelle elle arrive dans l’environnement de n8n, OPENAI_API_KEY ; la Release indique d’où elle provient.
release.yaml — la Release, qui déploie l’Aggregate avec le Manifest :
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: 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: {}environmentvautdevelopment, une valeur par défaut que le commentaire au-dessus demande de remplacer par l’environnement dans lequel la Release est déployée.- L’image est n8n 1.110.1, la version qu’exécutent les Recipes du catalogue pour n8n.
published_portvaut 5678, le port sur lequel n8n sert ; l’éditeur répond donc surhttp://127.0.0.1:5678sur votre machine. Comme le dit son commentaire, tout processus de cette machine peut l’y atteindre, et rien d’autre ne le peut ; supprimez la ligne pour garder n8n sur le seul réseau de la pile. Unpublished_portautre que 5678 nécessiteinfra.external_base_url: http://127.0.0.1:<published_port>à côté, faute de quoi n8n annonce les adresses de son éditeur et de ses webhooks surlocalhost:5678.- La clé est une référence de variable,
${OPENAI_API_KEY}, que Docker Compose renseigne depuis votre shell au démarrage de la pile. Le modèle OpenAI de la bibliothèque standard est un service hébergé, et une connexion vers lui doit porter un identifiant ; la Release en attache donc un, même si le workflow lit sa clé dans le magasin de n8n.
manifest.yaml — les Recipes Compose de la plateforme et du modèle, et la réalisation qui écrit la référence de variable de la clé telle quelle dans le fichier Compose :
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/support-agent version: 0.1.0spec: 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 est l’enregistrement de ce que l’importation a écrit, que lit un aggrega import --sync ultérieur, et release.lock épingle chaque entité du catalogue vers laquelle la Release se résout, par version et digest.
Valider et compiler
aggrega validate --release release.yamlaggrega build --release release.yaml

La validation affiche :
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)et la compilation, où <workspace> désigne le dossier contenant les ébauches :
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>/distLa ligne warning concerne la partie du fichier Compose qui porte le workflow, une entrée configs de premier niveau, qui n’a aucun service sur lequel poser les étiquettes du build. La ligne notice est indicative : la Feature de secret accepte son origin depuis les values de l’Aggregate ou depuis l’infra de la Release, et l’avis signale qu’une feuille est déclarée dans les deux. Ni l’une ni l’autre ne change le verdict.
dist/compose/docker-compose.yaml contient n8n et un service qui importe le workflow avant le démarrage de n8n :
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.jsonLe workflow parvient à n8n via n8n import:workflow, exécuté sur le même volume de données à chaque démarrage de la pile, avant n8n lui-même. N8N_BLOCK_ENV_ACCESS_IN_NODE vaut "true", le blocage par n8n de la lecture de son environnement par un workflow, puisque l’Aggregate laisse allow_env_access_in_nodes à false. Le nœud OpenAI Chat Model lit donc sa clé depuis le propre magasin d’informations d’identification de n8n, comme le déclencheur de chat lit son utilisateur et son mot de passe, et l’exécution décrite plus bas enregistre les deux. La Recipe Compose de n8n ne publie un port sur votre machine que là où la Release définit published_port dans l’infra de n8n, et alors sur la seule adresse de loopback, 127.0.0.1 ; sans lui, le service n’est joignable que sur le réseau de la pile.
Avec un assistant IA
Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-y ce prompt.
Utilise uniquement les outils Aggrega et ne crée aucun dossier toi-même. Si le dossier de l’espace de travail ne contient pas encore de dossier `import-n8n`, appelle une fois l’outil `scaffold` avec `example` défini sur `import-n8n` et sans `dir` : il écrit l’exemple dans un nouveau dossier `import-n8n`, dont le dossier `source` contient ce que cette page importe. Appelle ensuite l’outil `import` avec `workspace_root` défini sur `import-n8n/source`, `source` défini sur `support-agent.json` et `target` défini sur `compose` : il lit les réponses dont il a besoin dans `import-answers.yaml` à côté de `support-agent.json`, écrit ses ébauches dans `import-n8n/source` et tire ce dont elles ont besoin. Appelle ensuite l’outil `validate` avec `workspace_root` défini sur `import-n8n/source` et `release` défini sur `release.yaml`, puis l’outil `build` avec `workspace_root` défini sur `import-n8n/source`, `release` défini sur `release.yaml` et `write` défini sur true. Dis-moi quels fichiers le build a écrits ; ils se trouvent sous `import-n8n/source/dist/`.L’ouvrir dans VS Code
Une fois l’extension Aggrega pour Visual Studio Code installée, ouvrez dans VS Code le dossier import-n8n/source, où l’importation a écrit ses ébauches. Le dossier contient une seule Release, le release.yaml ébauché ; l’éditeur la sélectionne donc pour vous et vérifie les ébauches par rapport à cette Release pendant que vous les modifiez, en signalant ce qu’il trouve dans le fichier et dans le panneau Problèmes. Aggrega: Show topology graph, dans la palette de commandes, dessine les composants de la Release et les connexions entre eux. Aggrega: Build, Aggrega: Preview build et Aggrega: Pull agissent sur la même Release, et chacune est aussi un bouton du panneau Commands de la vue Aggrega dans la barre d’activité ; Build écrit ses fichiers dans le dist/ du dossier. Utiliser Aggrega dans Visual Studio Code couvre le reste.
Exécution
n8n lit depuis son propre magasin les deux informations d’identification que le workflow sélectionne, par leurs identifiants : la clé OpenAI sous Rb7nW2xQ9kT4mZ1c, et l’utilisateur et le mot de passe du chat sous Vx3mQ8rLb2Nk7Tz5. La propre ligne de commande de n8n les enregistre, sous ces identifiants, à partir d’un fichier. Écrivez-les dans credentials.json, avec vos propres valeurs :
[ {"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"}}]Définissez la clé dans votre shell, telle que la Release rédigée en brouillon la lit, et démarrez la pile :
export OPENAI_API_KEY='your OpenAI key'docker compose -p support-agent -f dist/compose/docker-compose.yaml up -d --wait-p nomme le projet, comme l’explique l’étape d’exécution de Déroulement d’une importation. --wait rend la main dès que n8n se signale en bonne santé, une fois que le service qui importe le workflow s’est exécuté et s’est terminé. Copiez les informations d’identification dans le conteneur de n8n, importez-les, puis supprimez la copie :
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec -T n8n sh -c 'umask 077; cat > /tmp/credentials.json' < credentials.jsondocker compose -p support-agent -f dist/compose/docker-compose.yaml exec n8n n8n import:credentials --input=/tmp/credentials.jsondocker 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 détient désormais les deux informations d’identification ; supprimez donc credentials.json :
rm credentials.jsonActivez ensuite le workflow, et redémarrez n8n pour que l’activation prenne effet :
docker compose -p support-agent -f dist/compose/docker-compose.yaml exec n8n n8n update:workflow --id=sQ4vT8nKp2LmX7bR --active=truedocker compose -p support-agent -f dist/compose/docker-compose.yaml restart n8nUne fois que docker compose -p support-agent -f dist/compose/docker-compose.yaml ps n8n affiche de nouveau n8n (healthy), docker compose -p support-agent -f dist/compose/docker-compose.yaml logs n8n indique Activated workflow "Support agent" (ID: sQ4vT8nKp2LmX7bR).
Tester
Ouvrez http://127.0.0.1:5678, l’adresse que published_port publie : l’éditeur de n8n demande un compte propriétaire lors de la première visite, puis affiche Support agent.
Le déclencheur de chat n’accepte un message qu’avec l’utilisateur et le mot de passe enregistrés plus haut ; sans eux, il répond HTTP/1.1 401 Unauthorized et Authorization is required!, et avec un mot de passe erroné HTTP/1.1 403 Forbidden. Avec les deux dans CHAT_USER et CHAT_PASSWORD, curl les lit depuis son entrée standard, de sorte qu’ils n’apparaissent sur aucune ligne de commande :
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"}L’exécution a enregistré une valeur fictive pour la clé OpenAI ; le workflow s’est donc arrêté à son appel au modèle. n8n conserve l’exécution, que l’éditeur liste parmi les exécutions du workflow, avec le refus d’OpenAI : Incorrect API key provided: sk-place*****************-key. Avec votre clé, la réponse est HTTP/1.1 200 OK et la réponse de l’agent, sous la forme {"output": "…"}.
Sur Kubernetes, avec le build que décrit Sur Kubernetes appliqué, n8n conserve ses données dans un volume qui vit aussi longtemps que son pod ; un nouveau pod démarre donc sans ce que vous avez enregistré. Enregistrez plutôt les informations d’identification et activez le workflow sur l’instance en cours d’exécution. Écrivez credentials.json comme le fait Exécuter, importez-le via kubectl exec, depuis son entrée standard, dans l’espace de noms où vous avez appliqué le build, puis supprimez-le :
kubectl exec -i -n <namespace> deploy/n8n -- n8n import:credentials --input=/dev/stdin < credentials.jsonDefaulted 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.Redirigez un port local vers le Service de n8n, n8n-default, et laissez la commande s’exécuter :
kubectl port-forward -n <namespace> svc/n8n-default 5678:5678Depuis un autre terminal, configurez le compte propriétaire via l’API de n8n, qui vous connecte et conserve la session dans cookies.txt, puis activez le workflow :
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 seconde réponse est le workflow, avec "active":true. Le message de chat ci-dessus l’atteint alors à la même adresse, sans modification ; l’exécution a obtenu le même {"message":"Error in workflow"} et le même refus dans l’exécution n8n.
Arrêtez la pile avec la commande ci-dessous. -v supprime aussi le volume de données de n8n, et avec lui les informations d’identification enregistrées et l’activation :
docker compose -p support-agent -f dist/compose/docker-compose.yaml down -vSur Kubernetes
Le même workflow s’importe pour Kubernetes avec la cible helm. Les brouillons pour Docker Compose se trouvent déjà dans source, et l’import n’écrase jamais un Aggregate qui s’y trouve ; générez donc ceux-ci dans un dossier à part avec --output-dir, puis validez et construisez à partir de celui-ci :
aggrega import support-agent.json --target helm --output-dir helmcd helmaggrega validate --release release.yamlaggrega build --release release.yamlLes brouillons diffèrent là où la cible diffère. Le Manifest mappe la plateforme vers helm/n8n, le modèle vers helm/openai et la clé vers helm/k8s-existing-secret, qui la lit depuis un Secret déjà présent dans le namespace. La Release attache la clé en tant que core/referenced-secret, en nommant ce Secret, openai-api-key, d’après le fichier de réponses.
Le build écrit de simples manifestes Kubernetes sous dist/helm/ à la racine de l’espace de travail, source, ce qui, depuis helm, correspond à ../dist/helm/. Créez le Secret dans le namespace auquel vous appliquez, avec la clé sous la clé de données value, puis appliquez le dossier comme l’explique l’étape d’exécution de Déroulement d’un import. Le workflow lit toujours ses identifiants dans le magasin propre de n8n, que Le tester remplit sur Kubernetes.