Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

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 :

Terminal window
aggrega scaffold --example import-n8n

Elle 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 :

Terminal window
cd import-n8n

Le dossier source de l’exemple généré ouvert dans Visual Studio Code, montrant l’export du workflow n8n d’un agent de support, ouvert sur ses nœuds de déclencheur de chat et d’AI Agent.

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.ai

et 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 :

Terminal window
cd source

Lancer l’importation

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

Sur la sortie standard, elle liste ce qu’elle a écrit :

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

Sur 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 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)

L’importation lancée depuis l’éditeur : l’Aggregate, la Release et le Manifest ébauchés apparaissent à côté de l’export du workflow, la sortie Aggrega liste comment chaque nœud a été mis en correspondance et les fichiers écrits, et une notification indique que l’importation a ébauché 3 fichiers, reconnus comme n8n.

  • La ligne mapped indique 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 socket model de la plateforme.
  • Les lignes made no choice indiquent 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 warn nomment 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 warn est 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 laisse values.allow_env_access_in_nodes à false, comme le fait le brouillon. Le passer à true permet à 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 écrit release.lock ; le build ci-dessous n’a besoin de rien de plus. La ligne warning est 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/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 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/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 vaut development, 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_port vaut 5678, le port sur lequel n8n sert ; l’éditeur répond donc sur http://127.0.0.1:5678 sur 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. Un published_port autre que 5678 nécessite infra.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 sur localhost: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/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 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

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

La Release ébauchée ouverte dans l’éditeur après sa validation, la sortie Aggrega et une notification ne signalant toutes deux aucun problème.

Le build de la Release ébauchée : un dossier dist apparaît dans l’explorateur, la sortie Aggrega liste le fichier Docker Compose écrit, et une notification indique que 1 fichier a été écrit.

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>/dist

La 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.json

Le 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 :

Terminal window
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 :

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 détient désormais les deux informations d’identification ; supprimez donc credentials.json :

Terminal window
rm credentials.json

Activez ensuite le workflow, et redémarrez n8n pour que l’activation prenne effet :

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

Une 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 :

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

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 :

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.

Redirigez un port local vers le Service de n8n, n8n-default, et laissez la commande s’exécuter :

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

Depuis 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 :

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

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

Sur 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 :

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

Les 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.