Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Importowanie chatflow z Flowise

Ten przewodnik krok po kroku importuje chatflow wyeksportowany z Flowise — łańcuch konwersacji z modelem czatu i pamięcią — do encji Aggregate, Release i Manifest, które w zapisanej postaci budują Flowise z tym chatflow dla Docker Compose, a następnie je buduje i uruchamia wynik. Każdy plik i każdy blok wyjścia poniżej pochodzi z rzeczywistego uruchomienia; chatflow i każdy etap przewodnika znajdują się w przykładzie import-flowise, w którym skrypt sprawdzający ponownie uruchamia import, porównuje to, co zapisuje, to, co wypisuje, oraz bloki cytowane na tej stronie z przechowywanymi tam plikami, a także waliduje i buduje to, co zapisał import.

Generowanie przykładu

Ten import można uruchomić poleceniami z tej strony albo zlecić to asystentowi AI.

Należy zapisać przykład w nowym folderze nazwanym tak jak on:

Terminal window
aggrega scaffold --example import-flowise

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu; kolejne, poniżej, przechodzi do folderu source w nowym folderze, w którym uruchamia się import. Ten folder zawiera plik chatflow, support-chat.json, który ta strona opisuje, zamiast go cytować:

Terminal window
cd import-flowise

Folder source wygenerowanego przykładu otwarty w Visual Studio Code, z eksportem chatflow Flowise czatu wsparcia, otwartym na węźle ChatOpenAI.

Chatflow

support-chat.json, napisany na potrzeby tego przewodnika w postaci, w jakiej edytor Flowise eksportuje chatflow, zawiera trzy węzły i dwie krawędzie między nimi: węzeł ChatOpenAI wybierający gpt-4o-mini, węzeł Buffer Memory oraz węzeł Conversation Chain, który przyjmuje oba i odpowiada krótkim komunikatem systemowym. Węzeł ChatOpenAI nie wybiera żadnego zapisanego poświadczenia i pozostawia pusty Base Path, więc klient OpenAI, na którym Flowise go uruchamia, odczytuje swój adres i klucz ze środowiska Flowise.

Obok chatflow plik .aggrega-config.yaml czyni folder przestrzenią roboczą:

# The workspace key marks this directory as the workspace root, so an import run
# here writes its drafts beside support-chat.json.
workspace: {}
# The registry the importer is fetched from the first time an import needs it.
default_registry: hub.aggrega.ai

a import-answers.yaml zawiera odpowiedzi na to, czego żaden chatflow nie może zawierać. Flowise nie ładuje przy starcie żadnego chatflow z pliku, więc kompilacja ładuje go przez własne API Flowise na koncie właściciela, a żaden eksport nie wskazuje tego konta: jego adres e-mail jest jedyną odpowiedzią, której potrzebuje import dla Docker Compose. Import dla Kubernetes potrzebuje też nazwy obiektu Secret Kubernetes przechowującego każdy sekret — hasło właściciela i klucz OpenAI — więc plik wskazuje również te dwa obiekty Secret (zob. W 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:
# Email address of the platform's owner account, read only when values.flow_definition is set. The
# step that seeds the chatflow registers this account when the instance has no owner yet, which makes
# it the owner, and signs in as it; on an instance that already has one, it names an account allowed
# to import chatflows, and the password attached to the owner_password slot is that account's.
# Required when values.flow_definition is set: the build halts when it is empty. It has no default.
spec.components.flowise.infra.owner_email: "owner@example.com"
# 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.flowise.features.owner_password.infra.origin: "flowise-owner"
# 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.flowise.uses.model.chatopenai-0.features.credential.infra.origin: "openai-api-key"

owner@example.com oznacza własny adres e-mail. Bez tego pliku import uruchomiony w terminalu pyta o każdą wartość, po jednym pytaniu naraz, sformułowanym na podstawie opisu nad jej kluczem, i zapisuje odpowiedzi w nowym pliku odpowiedzi; tam, gdzie nie można o nic zapytać, zapisuje ten plik z kluczami i pustymi odpowiedziami, wypisuje je i kończy działanie ze statusem 1. Plik odpowiedzi importu opisuje ten plik w całości.

Import porównuje każdy węzeł z encjami Components z katalogu przestrzeni roboczej, a --target tworzy szkic encji Manifest na podstawie jego encji Recipes. Przestrzeń robocza nie wskazuje żadnego folderu katalogu, więc import odczytuje katalog biblioteki standardowej z rejestru, z którego pobiera swój importer: podpisaną migawkę opublikowanego katalogu, którą pierwszy import pobiera, weryfikuje i przechowuje w pamięci podręcznej treści przestrzeni roboczej i którą rekord zapisywany przez import obok jego szkiców wskazuje za pomocą jej skrótu. Przestrzeń robocza, która wskazuje własne foldery katalogu — w AGGREGA_CATALOG_DIRS lub pod workspace.catalog_dirs — importuje zamiast tego względem nich. Należy przejść do source:

Terminal window
cd source

Uruchomienie importu

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

Na standardowym wyjściu wymienia to, co zapisał:

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

Na standardowym wyjściu błędów, gdzie <workspace> oznacza folder, w którym go uruchomiono:

[… 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 flowise format, with drafted paths relative to <workspace>
warn: node chatOpenAI_0 reaches chatopenai-0 through the model connection chatopenai-0 of core/ai-agent/flowise: its Base Path is empty, so the OpenAI client Flowise runs it on reads the address the platform delivers for this connection, OPENAI_BASE_URL, and, since it selects no credential, the key delivered as OPENAI_API_KEY
info: the answers file <workspace>/import-answers.yaml also answers spec.components.flowise.features.owner_password.infra.origin in release.yaml, spec.components.flowise.uses.model.chatopenai-0.features.credential.infra.origin in release.yaml, which these drafts do not leave empty; those answers are kept there and not applied
mapped chatOpenAI_0 (chatOpenAI) to core/ai-model/openai as a reference, HIGH at 0.9
made no choice for bufferMemory_0 (bufferMemory)
made no choice for conversationChain_0 (conversationChain)
warning: node "flowise" (provider "compose"): artifact "flowise-flow/flowise-flow.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)

Import uruchomiony z edytora: szkice encji Aggregate, Release i Manifest pojawiają się obok eksportu chatflow, wyjście Aggrega wymienia, jak zmapowano każdy węzeł, oraz zapisane pliki, a powiadomienie mówi, że import utworzył szkice 3 plików, rozpoznane jako flowise.

  • Wiersz mapped mówi, że węzeł ChatOpenAI stał się modelem OpenAI z biblioteki standardowej, core/ai-model/openai, do którego się odwołano zamiast tworzyć szkic, ponieważ został dopasowany na wysokim poziomie, z wynikiem 0.9: osobny komponent, podłączony do gniazda model platformy.
  • Wiersz warn mówi, w jaki sposób chatflow dociera do tego modelu: węzeł odczytuje adres i klucz, które platforma dostarcza dla połączenia z modelem, więc klucz, który encja Release dołącza do połączenia, jest tym, którego używa chatflow.
  • Wiersz info dotyczy pliku odpowiedzi. Plik ten podał adres e-mail właściciela, który szkice pozostawiły pusty; jego dwie nazwy obiektów Secret odpowiadają na to, co pusty pozostawia tylko import dla Kubernetes, więc pozostają w pliku, tutaj nieużywane.
  • Wiersze made no choice mówią, że pamięć i łańcuch pozostają wewnątrz chatflow: żadne gniazdo platformy ich nie przyjmuje.
  • Ostatnie dwa wiersze to pull. Ponieważ na każdą wartość udzielono odpowiedzi, import pobrał zależności szkicu encji Release, tak jak robi to aggrega pull, i zapisał release.lock; poniższa kompilacja nie potrzebuje niczego więcej. Wiersz warning wypisuje również kompilacja, a Walidacja i kompilacja go wyjaśnia.

Co zapisuje import

Encje Aggregate, Release i Manifest otrzymują nazwę imported/support-chat od pliku, support-chat.json, ponieważ eksport z Flowise nie ma własnej nazwy, w przestrzeni nazw określonej przez ustawienie target_namespace importera, imported, o ile nie ustawi się innej (Ustawienia).

aggregate.yaml — jedna instancja platformy Flowise z biblioteki standardowej, core/ai-agent/flowise, niosąca chatflow w takiej postaci, w jakiej został wyeksportowany, tutaj w większości pominięty, oraz model podłączony do jej gniazda model:

apiVersion: aggrega.ai/v1beta1
kind: Aggregate
metadata:
name: imported/support-chat
version: 0.1.0
description: Draft Aggregate imported from a source in the flowise format.
spec:
components:
flowise:
type: core/ai-agent/flowise
features:
# For the compose target, the lines below declare owner_password on flowise: 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.
owner_password:
type: core/secret-value
values:
key: OWNER_PASSWORD
values:
# chatflow_id is derived from the exported flow, which gives no identifier of its own.
chatflow_id: '40d9f5c5-5187-54c1-a9f5-a8dac92f88bb'
flow_definition: |
{
"nodes": [
[… omitted: the chatflow's nodes, as exported, up to the Conversation Chain's inputs]
"inputs": {
"model": "{{"{{"}}chatOpenAI_0.data.instance}}",
"memory": "{{"{{"}}bufferMemory_0.data.instance}}",
[… omitted: the rest of the chatflow, as exported]
}
uses:
model:
chatopenai-0:
target: chatopenai-0
# For the compose target, the lines below declare credential on chatopenai-0: 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.4000) by setting type: core/ai-model/azure-openai
chatopenai-0:
type: core/ai-model/openai
values:
model: |-
gpt-4o-mini
  • Model to core/ai-model/openai, z modelem wybranym przez węzeł, gpt-4o-mini. Komentarz nad nim wskazuje inną encję Component z katalogu, do której węzeł jest podobny, wraz z jej wynikiem.
  • Dwa sekrety — hasło konta właściciela, na którym ładowany jest chatflow, oraz klucz OpenAI, który platforma przekazuje modelowi — są zadeklarowane tutaj wraz ze zmienną, pod którą każdy z nich trafia do środowiska Flowise, OWNER_PASSWORD i OPENAI_API_KEY. W Docker Compose sekret dołączony wyłącznie przez encję Release trafiłby pod klucz value i oba by się zderzyły; zadeklarowany tutaj, każdy ma własny klucz. Encja Release określa, skąd pochodzi każdy z nich.
  • chatflow_id jest wyprowadzany z chatflow, ponieważ eksport z edytora Flowise nie zawiera własnego identyfikatora, więc jeden chatflow zawsze daje ten sam identyfikator. Chatflow z Flowise zapisuje {{<node id>.data.instance}} dla każdego połączenia między dwoma węzłami, a tekst encji Aggregate jest odczytywany jako szablon, więc szkic zapisuje każde {{ jako {{"{{"}}, które kompilacja zamienia z powrotem na dwa nawiasy klamrowe.

release.yaml — encja Release, która wdraża encję Aggregate z encją Manifest:

apiVersion: aggrega.ai/v1beta1
kind: Release
metadata:
name: imported/support-chat
# 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 flowise format.
spec:
aggregate: imported/support-chat
manifest: imported/support-chat
components:
flowise:
infra:
# The image running core/ai-agent/flowise, 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: "flowiseai/flowise:3.1.3"
# Left for the Release, since the source cannot supply it: infra.owner_email, the email address of the platform's owner account, required while values.flow_definition is set
owner_email: "owner@example.com"
# 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: 3000
features:
owner_password:
type: core/secret-value
infra:
# Attached by reference, never as a value: the owner account's password, required while values.flow_definition is set, read from the variable FLOWISE_OWNER_PASSWORD, 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: "${FLOWISE_OWNER_PASSWORD}"
uses:
model:
chatopenai-0:
features:
credential:
type: core/secret-value
infra:
# Attached by reference, never as a value: the credential flowise presents to chatopenai-0 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}"
chatopenai-0: {}
  • environment ma wartość development, domyślną, którą według komentarza nad nią należy zmienić na środowisko, w którym wdrażana jest encja Release.
  • Obraz to Flowise 3.1.3, wersja uruchamiana przez encje Recipes z katalogu dla Flowise.
  • published_port ma wartość 3000, czyli port, na którym działa Flowise, więc odpowiada on pod http://127.0.0.1:3000 na tym komputerze. Jak mówi komentarz, każdy proces na tym komputerze może tam do niego dotrzeć, a nic poza nim nie może; usunięcie wiersza pozostawia Flowise wyłącznie w sieci stosu.
  • owner_email to odpowiedź z pliku odpowiedzi. Komentarz nad nim wyjaśnia, dlaczego import nie mógł utworzyć jego szkicu.
  • Dwa sekrety to odwołania do zmiennych, ${FLOWISE_OWNER_PASSWORD} i ${OPENAI_API_KEY}, które Docker Compose wypełnia z powłoki przy uruchamianiu stosu, więc żaden plik nie zawiera żadnej z tych wartości.

manifest.yaml — encje Recipes dla Compose dla platformy i modelu oraz realizacja, która zapisuje odwołanie do zmiennej sekretu w pliku Compose dosłownie:

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

.aggrega-import.json to zapis tego, co zapisał import, odczytywany przez późniejsze aggrega import --sync, a release.lock przypina każdą encję katalogu, na którą rozwiązuje się encja Release, według wersji i skrótu (digest).

Walidacja i kompilacja

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

Szkic encji Release otwarty w edytorze po walidacji; wyjście Aggrega i powiadomienie zgłaszają, że nie znaleziono problemów.

Build szkicu encji Release: w Eksploratorze pojawia się folder dist, wyjście Aggrega wymienia zapisany plik Docker Compose, a powiadomienie informuje, że zapisano 1 plik.

Walidacja wypisuje:

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)

a kompilacja, gdzie <workspace> oznacza folder zawierający szkice:

warning: node "flowise" (provider "compose"): artifact "flowise-flow/flowise-flow.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

Wiersz warning dotyczy części pliku Compose, która niesie chatflow, wpisu configs najwyższego poziomu, który nie ma żadnej usługi, na której można by umieścić etykiety kompilacji. Wiersz notice ma charakter informacyjny: encja Feature sekretu przyjmuje swój origin z values encji Aggregate lub z infra encji Release, a komunikat zgłasza, że jeden liść jest zadeklarowany w obu miejscach. Żaden z nich nie zmienia werdyktu.

dist/compose/docker-compose.yaml zawiera dwie usługi. Sam Flowise:

flowise:
image: flowiseai/flowise:3.1.3
environment:
DATABASE_PATH: /home/node/.flowise
SECRETKEY_PATH: /home/node/.flowise
OPENAI_BASE_URL: https://api.openai.com/v1
OPENAI_API_KEY: ${OPENAI_API_KEY}
ports:
- 127.0.0.1:3000:3000
[… 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: flowise--data
target: /home/node
networks:
- compose
[… omitted: the service's health check]

oraz usługę, która ładuje chatflow, gdy tylko Flowise zgłosi poprawny stan, a następnie kończy działanie:

flowise-flow-seed:
image: flowiseai/flowise:3.1.3
entrypoint:
- node
- /seed/seed.js
environment:
FLOWISE_URL: http://127.0.0.1:3000
OWNER_EMAIL: owner@example.com
OWNER_PASSWORD: ${FLOWISE_OWNER_PASSWORD}
CHATFLOW_ID: 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb
CHATFLOW_NAME: 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb
[… omitted: the labels the build writes on every service]
network_mode: service:flowise
depends_on:
flowise:
condition: service_healthy
restart: "no"
configs:
- source: flowise-flow
target: /seed/flow.json
- source: flowise-flow-seed
target: /seed/seed.js

Rejestruje ona konto właściciela w świeżej instancji Flowise lub loguje się na nie i zapisuje chatflow pod chatflow_id. Klucz i hasło są odwołaniami do zmiennych, wypełnianymi z powłoki przy uruchamianiu stosu. Encja Recipe Compose dla Flowise publikuje port na maszynie lokalnej tylko wtedy, gdy encja Release ustawia published_port w infra Flowise, i wówczas wyłącznie na adresie pętli zwrotnej 127.0.0.1; bez tego usługa jest osiągalna tylko w sieci stosu.

Z asystentem AI

Asystent AI skonfigurowany z narzędziami Aggrega może zrobić to samo: wystarczy wkleić do niego ten prompt.

Używaj wyłącznie narzędzi Aggrega i nie twórz samodzielnie żadnego folderu. Jeśli folder Workspace nie zawiera jeszcze folderu `import-flowise`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `import-flowise` i bez `dir`: zapisuje ono przykład w nowym folderze `import-flowise`, którego folder `source` zawiera to, co importuje ta strona. Następnie wywołaj narzędzie `import` z `workspace_root` ustawionym na `import-flowise/source`, `source` ustawionym na `support-chat.json` i `target` ustawionym na `compose`: odczytuje ono potrzebne odpowiedzi z `import-answers.yaml` obok `support-chat.json`, zapisuje swoje szkice w `import-flowise/source` i pobiera to, czego one potrzebują. Następnie wywołaj narzędzie `validate` z `workspace_root` ustawionym na `import-flowise/source` i `release` ustawionym na `release.yaml` oraz narzędzie `build` z `workspace_root` ustawionym na `import-flowise/source`, `release` ustawionym na `release.yaml` i `write` ustawionym na true. Podaj mi, które pliki zapisał build; znajdują się w `import-flowise/source/dist/`.

Otwieranie w VS Code

Po zainstalowaniu rozszerzenia Aggrega dla Visual Studio Code należy otworzyć w VS Code folder import-flowise/source, w którym import zapisał swoje szkice. Folder zawiera jedną encję Release, szkic release.yaml, więc edytor wybiera ją automatycznie i podczas edycji sprawdza szkice względem tej encji Release, oznaczając znalezione problemy w pliku i w panelu Problemy. Aggrega: Show topology graph w palecie poleceń rysuje komponenty encji Release i połączenia między nimi. Aggrega: Build, Aggrega: Preview build i Aggrega: Pull działają na tej samej encji Release, a każde z nich jest też przyciskiem w panelu Commands widoku Aggrega na pasku działań; Build zapisuje swoje pliki w dist/ tego folderu. Używanie Aggrega w Visual Studio Code opisuje resztę.

Uruchomienie

Należy ustawić w powłoce klucz i hasło właściciela, uruchomić Flowise, a następnie uruchomić usługę inicjalizującą:

Terminal window
export OPENAI_API_KEY='your OpenAI key'
export FLOWISE_OWNER_PASSWORD='a password of your own'
docker compose -p support-chat -f dist/compose/docker-compose.yaml up -d --wait flowise
docker compose -p support-chat -f dist/compose/docker-compose.yaml up flowise-flow-seed

-p nadaje nazwę projektowi, jak wyjaśnia krok uruchamiania w Jak przebiega import. --wait kończy działanie, gdy Flowise zgłosi, że jest zdrowy; wskazuje tylko flowise, ponieważ każdy kontener, który zakończył działanie, liczy jako błąd, a usługa inicjalizująca kończy działanie z założenia. Drugie polecenie uruchamia usługę inicjalizującą, wypisuje jej log i kończy działanie, gdy ona się zakończy:

flowise-flow-seed-1 | registered the owner account owner@example.com
flowise-flow-seed-1 | imported chatflow 40d9f5c5-5187-54c1-a9f5-a8dac92f88bb as "40d9f5c5-5187-54c1-a9f5-a8dac92f88bb"
flowise-flow-seed-1 exited with code 0

Jeśli inny program na maszynie lokalnej nasłuchuje już na 127.0.0.1:3000, pierwsze polecenie zatrzymuje się z failed to bind host port 127.0.0.1:3000/tcp: address already in use: należy ustawić published_port na wolny port i ponownie wykonać build. Poniższe uruchomienie tak zrobiło, z portem 3002, i użyło tego portu zamiast 3000.

Testowanie

Należy otworzyć http://127.0.0.1:3000, adres publikowany przez published_port, i zalogować się adresem e-mail i hasłem właściciela: chatflow z inicjalizacji jest we Flowise.

Chatflow, który nie ustawia własnego klucza API, odpowiada na swoim punkcie końcowym predykcji bez klucza. Można zadać mu pytanie:

Terminal window
curl -sS -X POST http://127.0.0.1:3000/api/v1/prediction/40d9f5c5-5187-54c1-a9f5-a8dac92f88bb \
-H 'Content-Type: application/json' -d '{"question": "In one short sentence: what is Docker Compose?"}'

Uruchomienie użyło symbolu zastępczego dla klucza OpenAI, więc odpowiedzią jest odrzucenie go przez OpenAI, co pokazuje, że chatflow wykonał się aż do wywołania modelu:

{"statusCode":500,"success":false,"message":"401 Unauthorized – check your API key and ensure it has access to the requested model.","stack":{}}

Z własnym kluczem odpowiedź zawiera wynik w text.

W Kubernetes, po zastosowaniu buildu opisanego w W Kubernetes i zakończeniu jego Job inicjalizującego, należy przekierować port lokalny do obiektu Service Flowise, flowise-default, w przestrzeni nazw, do której zastosowano build, i pozostawić polecenie uruchomione:

Terminal window
kubectl port-forward -n <namespace> svc/flowise-default 3000:3000

Z innego terminala powyższe pytanie dociera do chatflow pod tym samym adresem, bez zmian; uruchomienie otrzymało to samo odrzucenie klucza zastępczego.

Stack zatrzymuje się poniższym poleceniem. -v usuwa także wolumen danych Flowise, a wraz z nim konto właściciela i chatflow zapisany przez usługę inicjalizującą:

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

Na Kubernetes

Ten sam chatflow importuje się dla Kubernetes z celem helm. Szkice dla Docker Compose znajdują się już w source, a import nigdy nie nadpisuje znajdującej się tam encji Aggregate, dlatego należy utworzyć te szkice w osobnym folderze za pomocą --output-dir, a następnie z niego walidować i budować:

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

Szkice różnią się tam, gdzie różni się cel. Encja Manifest mapuje platformę na helm/flowise, model na helm/openai, a każdy sekret na helm/k8s-existing-secret, który odczytuje go z obiektu Secret istniejącego już w przestrzeni nazw. Encja Release dołącza hasło właściciela i klucz OpenAI jako core/referenced-secret, każde wskazując swój Secret, i pobiera wszystkie trzy odpowiedzi z pliku odpowiedzi: adres e-mail właściciela, flowise-owner i openai-api-key.

Kompilacja zapisuje zwykłe manifesty Kubernetes w dist/helm/ w katalogu głównym obszaru roboczego, source, czyli patrząc z helm w ../dist/helm/, w tym seed chatflow jako Job. Należy utworzyć dwa obiekty Secret w przestrzeni nazw, do której się stosuje, każdy przechowujący swoją wartość pod kluczem danych value, a następnie zastosować folder zgodnie z opisem w kroku uruchamiania w Jak przebiega import.