Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Importare un workflow n8n

Questa procedura guidata importa un workflow esportato da n8n — un agente IA che risponde ai messaggi di chat con un modello di chat OpenAI e una memoria — in un Aggregate, una Release e un Manifest che, così come sono scritti, compilano per Docker Compose n8n con al suo interno il workflow, poi li compila ed esegue il risultato. Ogni file e ogni blocco di output riportati di seguito provengono da un’esecuzione reale; il workflow e ogni fase della procedura si trovano nell’esempio import-n8n, dove uno script di verifica esegue di nuovo l’importazione, confronta ciò che scrive, ciò che stampa e i blocchi citati in questa pagina con i file lì conservati, e convalida e compila ciò che l’importazione ha scritto.

Generare l’esempio

Puoi eseguire questa importazione con i comandi di questa pagina, oppure farla eseguire al tuo assistente AI.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

Terminal window
aggrega scaffold --example import-n8n

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella; quello successivo, qui sotto, ti porta nella cartella source della nuova cartella, che contiene ciò che questa pagina importa ed è dove viene eseguita l’importazione:

Terminal window
cd import-n8n

La cartella source dell’esempio generato aperta in Visual Studio Code, che mostra l’esportazione del workflow n8n di un agente di supporto, aperta sui nodi del trigger della chat e dell’AI Agent.

Il workflow

support-agent.json, scritto per questa procedura guidata nella forma in cui n8n esporta un workflow, contiene quattro nodi: un trigger di chat, un AI Agent con un breve messaggio di sistema, un nodo OpenAI Chat Model che seleziona gpt-4o-mini e un nodo Simple Memory, uniti dalle connessioni che n8n elenca per nome del nodo da cui ciascuna parte. Il trigger di chat è pubblico, quindi un messaggio di chat inviato al suo URL avvia il workflow, e il trigger chiede al mittente un utente e una password, che verifica rispetto a una credenziale di autenticazione di base che n8n memorizza:

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

Il nodo del modello seleziona la propria credenziale allo stesso modo, per riferimento — l’esportazione contiene l’identificatore e il nome di ogni credenziale, mai l’utente, la password o la chiave:

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

Accanto al workflow, un .aggrega-config.yaml rende la cartella un 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 contiene le risposte a ciò che nessun workflow può contenere. Un’importazione per Docker Compose non ne ha bisogno: associa la chiave OpenAI tramite un riferimento a variabile che Docker Compose valorizza dalla tua shell. Un’importazione per Kubernetes la associa tramite il nome di un Secret Kubernetes, che solo tu puoi indicare, quindi il file nomina quel Secret (vedi Su 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"

Il file delle risposte dell’importazione descrive il file in modo completo.

L’importazione valuta ogni nodo rispetto ai Components del catalogo dello spazio di lavoro, e --target abbozza un Manifest a partire dalle sue Recipes. Lo spazio di lavoro non indica alcuna cartella di catalogo, quindi l’importazione legge il catalogo della libreria standard dal registry da cui recupera il proprio importer: uno snapshot firmato del catalogo pubblicato, che la prima importazione recupera, verifica e conserva nella cache dei contenuti dello spazio di lavoro, e che il record scritto dall’importazione accanto alle sue bozze indica tramite il suo digest. Uno spazio di lavoro che indica le proprie cartelle di catalogo — in AGGREGA_CATALOG_DIRS, oppure sotto workspace.catalog_dirs — importa invece rispetto a quelle. Entra in source:

Terminal window
cd source

Eseguire l’importazione

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

Sullo standard output elenca ciò che ha scritto:

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

Sullo standard error, dove <workspace> sta per la cartella in cui l’hai eseguita:

[… 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’importazione eseguita dall’editor: l’Aggregate, la Release e il Manifest abbozzati compaiono accanto all’esportazione del workflow, l’output di Aggrega elenca come è stato mappato ogni nodo e i file scritti, e una notifica indica che l’importazione ha abbozzato 3 file, riconosciuti come n8n.

  • La riga mapped dice che il nodo OpenAI Chat Model è diventato il modello OpenAI della libreria standard, core/ai-model/openai, referenziato anziché abbozzato, poiché ha trovato corrispondenza nel livello alto, a 0.9143: un componente a sé stante, collegato al socket model della piattaforma.
  • Le righe made no choice dicono che il trigger, l’agente e la memoria restano all’interno del workflow, che n8n esegue da sé.
  • Le prime due righe warn nominano gli identificatori delle credenziali memorizzate che il trigger e il nodo del modello selezionano, che n8n contrassegna come credenziali. Sono riferimenti, non segreti, e vengono riportati così come sono scritti.
  • La terza riga warn è quella da leggere con attenzione: il nodo del modello raggiunge OpenAI con la credenziale memorizzata che seleziona, non tramite la connessione che la bozza collega. La piattaforma fornisce la connessione all’ambiente di n8n, e n8n rifiuta le letture del proprio ambiente da parte di un workflow finché l’Aggregate lascia values.allow_env_access_in_nodes a false, come fa la bozza. Impostarlo a true consente a ogni workflow, e a chiunque possa modificarne uno, di leggere ogni variabile della piattaforma, compresa la chiave fornita. Per questo la chiave usata dal workflow è quella che n8n memorizza, come mostra Eseguilo.
  • Le ultime due righe sono il pull. Non restava nulla a cui rispondere, quindi l’importazione ha scaricato le dipendenze della Release abbozzata, come fa aggrega pull, e ha scritto release.lock; la build qui sotto non richiede altro. La riga warning è una che stampa anche la build, e Convalidare e compilare la spiega.

Il file delle risposte nomina un Secret che questa importazione non richiede: non lascia nulla di vuoto per esso, quindi non applica alcuna risposta e lascia il file così com’è.

Cosa scrive

L’Aggregate, la Release e il Manifest si chiamano imported/support-agent, dal nome proprio del workflow, Support agent, ridotto a support-agent — un workflow senza nome prende il nome dal suo file — nel namespace definito dall’impostazione target_namespace dell’importatore, imported a meno che tu non ne imposti un altro (Impostazioni).

aggregate.yaml — un’istanza della piattaforma n8n della libreria standard, core/ai-agent/n8n, che contiene il workflow così come è stato esportato, in gran parte omesso qui, e il modello collegato al suo 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 è l’identificatore che l’esportazione assegna al workflow. Il modello è core/ai-model/openai, con il modello selezionato dal nodo, gpt-4o-mini; il commento sopra di esso nomina un altro Component del catalogo a cui il nodo somiglia, con il relativo punteggio. La chiave OpenAI che la piattaforma presenta al modello è dichiarata sulla connessione con la variabile con cui arriva nell’ambiente di n8n, OPENAI_API_KEY; la Release dice da dove proviene.

release.yaml — la Release, che distribuisce l’Aggregate con il 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, un valore predefinito che il commento sopra di esso indica di cambiare con l’ambiente in cui la Release viene distribuita.
  • L’immagine è n8n 1.110.1, la versione eseguita dalle Recipes del catalogo per n8n.
  • published_port è 5678, la porta su cui n8n serve, quindi l’editor risponde su http://127.0.0.1:5678 sulla tua macchina. Come dice il suo commento, qualsiasi processo su questa macchina può raggiungerlo lì e nient’altro può farlo; elimina la riga per tenere n8n solo sulla rete dello stack. Un published_port diverso da 5678 richiede accanto infra.external_base_url: http://127.0.0.1:<published_port>, altrimenti n8n riporta gli indirizzi del proprio editor e dei webhook su localhost:5678.
  • La chiave è un riferimento a variabile, ${OPENAI_API_KEY}, che Docker Compose valorizza dalla tua shell all’avvio dello stack. Il modello OpenAI della libreria standard è un servizio ospitato, e una connessione verso di esso deve portare una credenziale, quindi la Release ne allega una anche se il workflow legge la propria chiave dall’archivio di n8n.

manifest.yaml — le Recipes Compose della piattaforma e del modello, e la realizzazione che scrive il riferimento a variabile della chiave nel file Compose così com’è:

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 è il registro di ciò che l’importazione ha scritto, che un successivo aggrega import --sync legge, e release.lock fissa ogni entità del catalogo a cui la Release si risolve, per versione e digest.

Convalidare e compilare

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

La Release abbozzata aperta nell’editor dopo la validazione, con l’output di Aggrega e una notifica che non segnalano alcun problema.

La build della Release abbozzata: nell’Explorer compare una cartella dist, l’output di Aggrega elenca il file Docker Compose scritto, e una notifica indica che è stato scritto 1 file.

La convalida stampa:

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 la build, dove <workspace> sta per la cartella che contiene le bozze:

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 riga warning riguarda la parte del file Compose che contiene il workflow, una voce configs di primo livello, che non ha alcun servizio su cui apporre le etichette della build. La riga notice è informativa: la Feature per i segreti accetta il proprio origin dai values dell’Aggregate o dall’infra della Release, e l’avviso segnala che una foglia è dichiarata in entrambi. Nessuna delle due cambia il verdetto.

dist/compose/docker-compose.yaml contiene n8n e un servizio che importa il workflow prima che n8n si avvii:

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

Il workflow raggiunge n8n tramite n8n import:workflow, eseguito sullo stesso volume di dati ogni volta che lo stack si avvia, prima di n8n stesso. N8N_BLOCK_ENV_ACCESS_IN_NODE è "true", il blocco di n8n sulla lettura del proprio ambiente da parte di un workflow, poiché l’Aggregate lascia allow_env_access_in_nodes a false. Quindi il nodo OpenAI Chat Model legge la propria chiave dall’archivio di credenziali di n8n, così come il trigger della chat legge il proprio utente e la propria password, e l’esecuzione descritta più avanti li memorizza entrambi. La Recipe Compose di n8n pubblica una porta sulla tua macchina solo dove la Release imposta published_port nell’infra di n8n, e in quel caso solo sull’indirizzo di loopback, 127.0.0.1; senza di esso, il servizio è raggiungibile solo sulla rete dello stack.

Con un assistente AI

Un assistente AI configurato con gli strumenti di Aggrega può fare lo stesso: incollaci questo prompt.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella del workspace non contiene ancora una cartella `import-n8n`, chiama una volta lo strumento `scaffold` con `example` impostato su `import-n8n` e senza `dir`: scrive l’esempio in una nuova cartella `import-n8n`, la cui cartella `source` contiene ciò che questa pagina importa. Poi chiama lo strumento `import` con `workspace_root` impostato su `import-n8n/source`, `source` impostato su `support-agent.json` e `target` impostato su `compose`: legge le risposte di cui ha bisogno da `import-answers.yaml` accanto a `support-agent.json`, scrive le bozze in `import-n8n/source` ed esegue il pull di ciò di cui hanno bisogno. Poi chiama lo strumento `validate` con `workspace_root` impostato su `import-n8n/source` e `release` impostato su `release.yaml`, e lo strumento `build` con `workspace_root` impostato su `import-n8n/source`, `release` impostato su `release.yaml` e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano sotto `import-n8n/source/dist/`.

Aprilo in VS Code

Con l’estensione Aggrega per Visual Studio Code installata, apri in VS Code la cartella import-n8n/source, in cui l’importazione ha scritto le bozze. La cartella contiene una sola Release, il release.yaml abbozzato, quindi l’editor la seleziona per te e, mentre modifichi le bozze, le verifica rispetto a quella Release, segnalando ciò che trova nel file e nel pannello Problemi. Aggrega: Show topology graph, nel riquadro comandi, disegna i componenti della Release e le connessioni tra di essi. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull agiscono sulla stessa Release, e ciascuno è anche un pulsante nel pannello Commands della vista Aggrega nella barra delle attività; Build scrive i suoi file in dist/ all’interno della cartella. Usare Aggrega in Visual Studio Code descrive il resto.

Esecuzione

n8n legge dal proprio archivio entrambe le credenziali selezionate dal workflow, tramite i loro identificatori: la chiave OpenAI sotto Rb7nW2xQ9kT4mZ1c, e l’utente e la password della chat sotto Vx3mQ8rLb2Nk7Tz5. La riga di comando di n8n le memorizza, sotto quegli identificatori, a partire da un file. Scrivile in credentials.json, con i tuoi valori:

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

Imposta la chiave nella tua shell, così come la legge la Release abbozzata, e avvia lo 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 assegna il nome al progetto, come spiega il passaggio di esecuzione di Come si svolge un’importazione. --wait ritorna non appena n8n risulta integro, dopo che il servizio che importa il workflow è stato eseguito ed è terminato. Copia le credenziali nel container di n8n, importale e rimuovi 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.

Ora n8n contiene entrambe le credenziali, quindi elimina credentials.json:

Terminal window
rm credentials.json

Poi attiva il workflow e riavvia n8n affinché l’attivazione abbia effetto:

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

Quando docker compose -p support-agent -f dist/compose/docker-compose.yaml ps n8n mostra di nuovo n8n (healthy), docker compose -p support-agent -f dist/compose/docker-compose.yaml logs n8n riporta Activated workflow "Support agent" (ID: sQ4vT8nKp2LmX7bR).

Eseguire il test

Apri http://127.0.0.1:5678, l’indirizzo che published_port pubblica: l’editor di n8n chiede un account proprietario alla prima visita, poi mostra Support agent.

Il trigger della chat accetta un messaggio solo con l’utente e la password memorizzati sopra; senza di essi risponde HTTP/1.1 401 Unauthorized e Authorization is required!, e con una password errata HTTP/1.1 403 Forbidden. Con i due in CHAT_USER e CHAT_PASSWORD, curl li legge dal proprio standard input, così non compaiono in nessuna riga di 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"}

L’esecuzione ha memorizzato un segnaposto per la chiave OpenAI, quindi il workflow si è fermato alla chiamata al modello. n8n conserva l’esecuzione, che l’editor elenca tra le esecuzioni del workflow, con il rifiuto di OpenAI: Incorrect API key provided: sk-place*****************-key. Con la tua chiave, la risposta è HTTP/1.1 200 OK e la risposta dell’agente, come {"output": "…"}.

Su Kubernetes, con applicata la build descritta in Su Kubernetes, n8n conserva i propri dati in un volume che dura quanto il suo pod, quindi un nuovo pod si avvia senza ciò che hai memorizzato; memorizza invece le credenziali e attiva il workflow sull’istanza in esecuzione. Scrivi credentials.json come fa Eseguilo, importalo tramite kubectl exec, dal suo standard input, nel namespace in cui hai applicato la build, e poi eliminalo:

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.

Inoltra una porta locale verso il Service di n8n, n8n-default, e lascia il comando in esecuzione:

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

Da un altro terminale, configura l’account proprietario tramite l’API di n8n, che ti fa accedere e conserva la sessione in cookies.txt, poi attiva il 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 seconda risposta è il workflow, con "active":true. Il messaggio di chat qui sopra lo raggiunge allora allo stesso indirizzo, senza modifiche; l’esecuzione ha ottenuto lo stesso {"message":"Error in workflow"} e lo stesso rifiuto nell’esecuzione di n8n.

Arresta lo stack con il comando qui sotto. -v rimuove anche il volume di dati di n8n, e con esso le credenziali memorizzate e l’attivazione:

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

Su Kubernetes

Lo stesso workflow si importa per Kubernetes con il target helm. Le bozze per Docker Compose si trovano già in source, e l’importazione non sovrascrive mai un Aggregate lì presente, quindi genera queste bozze in una cartella a sé con --output-dir, poi valida e compila a partire da quella:

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

Le bozze differiscono dove differisce il target. Il Manifest mappa la piattaforma a helm/n8n, il modello a helm/openai e la chiave a helm/k8s-existing-secret, che la legge da un Secret già presente nel namespace. La Release allega la chiave come core/referenced-secret, nominando quel Secret, openai-api-key, dal file delle risposte.

La build scrive semplici manifest Kubernetes in dist/helm/ alla radice del workspace, source, che da helm è ../dist/helm/. Crea il Secret nel namespace a cui applichi, con la chiave sotto la chiave dati value, poi applica la cartella come spiega il passaggio di esecuzione di Come si svolge un’importazione. Il workflow legge comunque le proprie credenziali dall’archivio di n8n, che Provalo riempie su Kubernetes.