Eine Dify-Anwendung importieren
Diese Anleitung importiert eine aus Dify exportierte Anwendung — einen Chat-Assistenten auf einem OpenAI-Modell — in ein Aggregate, ein Release und ein Manifest, die so, wie sie geschrieben sind, die Dify-Installation der Standardbibliothek, die die Anwendung mitbringt, für Kubernetes bauen, baut sie anschließend und führt das Ergebnis aus. Jede Datei und jeder Ausgabeblock unten stammt aus einem echten Lauf; die Anwendung und jeder Schritt der Anleitung liegen im Beispiel import-dify, wo ein Prüfskript den Import erneut ausführt, vergleicht, was er schreibt, was er ausgibt und die von dieser Seite zitierten Blöcke mit den dort abgelegten Dateien, und validiert und baut, was der Import geschrieben hat.
Das Beispiel generieren
Sie können diesen Import mit den Befehlen auf dieser Seite ausführen oder ihn von Ihrem KI-Assistenten ausführen lassen.
Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:
aggrega scaffold --example import-difyDanach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner; der folgende, unten, wechselt in den Ordner source des neuen Ordners, der enthält, was diese Seite importiert, und in dem der Import läuft:
cd import-dify
Die Anwendung
support-assistant.yml, für diese Anleitung geschrieben, ist eine Chat-Anwendung in der DSL von Dify, dem YAML, das Dify für eine Anwendung exportiert, in der DSL-Version 0.7.0: eine Eröffnungsnachricht, ein kurzer Prompt und das Modell, mit dem sie antwortet, benannt über seinen Anbieter:
model: completion_params: stop: [] temperature: 0.4 mode: chat name: gpt-4o-mini provider: langgenius/openai/openaiDaneben macht eine .aggrega-config.yaml den Ordner zu einem Arbeitsbereich:
# The workspace key marks this directory as the workspace root, so an import run# here writes its drafts beside support-assistant.yml.workspace: {}# The registry the importer is fetched from the first time an import needs it.default_registry: hub.aggrega.aiund import-answers.yaml enthält die Antworten auf das, was keine Anwendung enthalten kann: das Anwendungsgeheimnis der Installation, den Schlüssel, mit dem Dify Sitzungen signiert und unter dem es die gespeicherten Schlüssel der Modellanbieter verschlüsselt; und das Eigentümerkonto, unter dem die Anwendung importiert wird, mit seiner E-Mail-Adresse und seinem Passwort. Auf Kubernetes wird jedes Geheimnis aus einem Kubernetes-Secret gelesen, daher ist seine Antwort der Name dieses Secrets; dieselbe Datei dient auch einem Import für Docker Compose, wie Auf Docker Compose zeigt:
# 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: # Passed down to core/dify's secret_key parameter, which has no default; that parameter's description # in core/dify says what the value is. spec.parameters.secret_key: "dify-credentials" # Email address of the installation's owner account, read only when values.app_definition is set. The # step that imports the application creates this account when it performs Dify's first-time setup, and # signs in as it; on an installation whose setup has already run, it names an existing account allowed # to import applications, and the password attached to the owner_password slot is that account's. # Required when values.app_definition is set: the build halts when it is empty. It has no default. spec.boundaries.platform.aggregates.dify.components.api.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.boundaries.platform.aggregates.dify.components.api.features.owner_password.infra.origin: "dify-owner"owner@example.com steht für eine eigene E-Mail-Adresse; dify-credentials und dify-owner sind die Secrets, die Ausführen anlegt. Ohne die Datei fragt ein Import an einem Terminal jeden der drei Werte ab, eine Frage nach der anderen, und schreibt Ihre Antworten in eine neue Antwortdatei; wo nichts gefragt werden kann, schreibt er diese Datei mit den drei Schlüsseln und leeren Antworten, listet sie auf und endet mit Status 1. Die Import-Antwortdatei beschreibt die Datei vollständig.
Der Arbeitsbereich nennt keinen Katalogordner, daher liest der Import den Katalog der Standardbibliothek aus der Registry, aus der er seinen Importer holt: einen signierten Snapshot des veröffentlichten Katalogs, den der erste Import holt, verifiziert und im Inhalts-Cache des Arbeitsbereichs ablegt und den die Aufzeichnung, die der Import neben seine Entwürfe schreibt, über seinen Digest benennt. Ein Arbeitsbereich, der eigene Katalogordner nennt — in AGGREGA_CATALOG_DIRS oder unter workspace.catalog_dirs —, importiert stattdessen gegen diese. Wechseln Sie in source:
cd sourceDen Import ausführen
Die Dify-Installation der Standardbibliothek wird auf Kubernetes und auf Docker Compose realisiert. Diese Anleitung nennt das Ziel helm:
aggrega import support-assistant.yml --target helmAuf der Standardausgabe listet er auf, was er geschrieben hat:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonAuf der Standardfehlerausgabe, wobei <workspace> für den Ordner steht, in dem Sie ihn ausgeführt haben:
[… 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 dify format, with drafted paths relative to <workspace>warn: node model_config.model (model) names the model "gpt-4o-mini" of the model provider "langgenius/openai/openai", whose credentials are set inside Dify, and core/ai-agent/dify configures that for itself rather than reaching it through a socket, so the draft wires no part for itmade no choice for model_config.model (model)Pull complete: <workspace>/release.lock (entities=25, source_artifacts=0, external_inputs=0)
- Die
warn-Zeile sagt, dass das Modell innerhalb von Dify bleibt: Dify konfiguriert seine Modellanbieter und deren Schlüssel selbst, daher verbindet der Entwurf kein Modell. Sobald Dify läuft, installieren Sie seinen OpenAI-Anbieter und setzen den Schlüssel des Anbieters, wie Testen zeigt. - Die Zeile
Pull completeist der Pull. Da jeder Wert aus der Antwortdatei beantwortet war, hat der Import die Abhängigkeiten des entworfenen Release gepullt, wie esaggrega pulltut, undrelease.lockgeschrieben; der Build unten braucht nichts weiter.
Was er schreibt
Das Aggregate, das Release und das Manifest heißen imported/support-assistant, nach dem Namen der Anwendung, Support assistant unter app, reduziert auf support-assistant — eine Anwendung ohne Namen wird nach ihrer Datei benannt —, unter dem Namespace, den die Einstellung target_namespace des Importers festlegt, imported, sofern Sie keinen anderen festlegen (Einstellungen).
aggregate.yaml — die Dify-Installation der Standardbibliothek, core/dify, ein Aggregate, das der Entwurf unter aggregates zusammensetzt, mit der Anwendung, wie geschrieben in seinem Parameter app_definition übernommen, hier größtenteils ausgelassen, und dem secret_key der Installation, weitergereicht aus einem Parameter, den der Entwurf deklariert:
apiVersion: aggrega.ai/v1beta1kind: Aggregatemetadata: name: imported/support-assistant version: 0.1.0 description: Draft Aggregate imported from a source in the dify format.spec: parameters: secret_key: type: string required: true minLength: 1 description: "Passed down to core/dify's secret_key parameter, which has no default; that parameter's description in core/dify says what the value is." aggregates: # An import sees the Components of the workspace's catalog and none of its Aggregates, so it does not check that the catalog holds core/dify. dify: type: core/dify parameters: secret_key: "{{ .parameters.secret_key }}" app_definition: | app: description: Answers questions about the support plans of a small software company. [… omitted: the rest of the application, as exported] version: 0.7.0Die Installation besteht aus zehn Komponenten — dem API-Server, dem Worker, dem Scheduler, dem Web-Frontend, der Code-Sandbox und der Plugin-Laufzeit von Dify, einem Egress-Proxy, PostgreSQL, einem Redis-kompatiblen Cache und Weaviate —, die miteinander verbunden sind, und der Import der Anwendung ist ein Schritt, den das Recipe ihres API-Servers rendert. Ihr Anwendungsgeheimnis hat in core/dify keinen Standardwert; daher deklariert der Entwurf secret_key als eigenen Parameter ohne Standardwert und reicht ihn weiter, damit das Release ihn erfüllt. Die übrigen Zugangsdaten der Installation behalten die Standardwerte, die core/dify ihnen gibt, wie Ausführen beschreibt.
release.yaml — das Release, das die Installation in eine Grenze, platform, leitet und aus der Antwortdatei erfüllt, was die Anwendung nicht liefern kann:
apiVersion: aggrega.ai/v1beta1kind: Releasemetadata: name: imported/support-assistant # 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 dify format.spec: aggregate: imported/support-assistant manifest: imported/support-assistant parameters: # Left for the Release, since the source cannot supply it: secret_key, which the drafted Aggregate declares and passes down to core/dify; that parameter's description there says what the value is secret_key: "dify-credentials" boundaries: platform: aggregates: dify: components: api: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: true # Left for the Release, since the source cannot supply it: components.api.infra.owner_email, the email of the installation's owner account the application is imported under, on the api component of core/dify owner_email: "owner@example.com" features: owner_password: type: core/referenced-secret infra: # Left for the Release, since the source cannot supply it: the name of a Kubernetes Secret already in the namespace holding, under the data key value, the owner account's password. origin: "dify-owner" worker: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: true scheduler: infra: # Lets the installation reach Dify's plugin marketplace, which the plugin serving the application's model, such as OpenAI's, is installed from. marketplace_enabled: trueenvironmentistdevelopment, ein Standardwert, der laut dem Kommentar darüber auf die Umgebung zu ändern ist, in die das Release ausgerollt wird.secret_keyist der Name des Secrets, das das Anwendungsgeheimnis enthält,dify-credentials, unter dem Datenschlüssel, den die Installation nennt,secret-key: Das Manifest liest jede Zugangsangabe aus einem Secret, das bereits im Namespace vorhanden ist.- Das Eigentümerkonto wird auf der Komponente
apider Installation gesetzt, in dem Routing-Eintrag, der die Installation in ihrer Grenze platziert: seine E-Mail-Adresse und sein Passwort, angebunden alscore/referenced-secret, das das Secret nennt, das es enthält,dify-owner, unter dem Datenschlüsselvalue. Die Kommentare über den beantworteten Werten erklären, warum der Import sie nicht entwerfen konnte. marketplace_enabledisttrueauf dem API-Server,api, seinem Worker und seinem Scheduler, auf jedem Ziel: Die Installation erreicht nichts vom Anbieter von Dify, sofern das Release es nicht erlaubt, und der OpenAI-Anbieter, mit dem die Anwendung antwortet, ist ein Plugin, das Dify aus seinem Plugin-Marketplace installiert, wie Testen zeigt. Jeder der drei liest seine eigene Einstellung.
manifest.yaml — ein Helm-Recipe für jede Komponente, die die Installation zusammensetzt, und die Realisierung, die eine Zugangsangabe aus einem Secret liest, das bereits im Namespace vorhanden ist:
apiVersion: aggrega.ai/v1beta1kind: Manifestmetadata: name: imported/support-assistant version: 0.1.0spec: mappings: components: type: core/datastore/postgres: helm/postgres core/datastore/redis: helm/redis core/datastore/weaviate: helm/weaviate core/ai-agent/dify-ssrf-proxy: helm/dify-ssrf-proxy core/ai-agent/dify-sandbox: helm/dify-sandbox core/ai-agent/dify-plugin-daemon: helm/dify-plugin-daemon core/ai-agent/dify: helm/dify core/ai-agent/dify-worker: helm/dify-worker core/ai-agent/dify-worker-beat: helm/dify-worker-beat core/ai-agent/dify-web: helm/dify-web features: type: core/referenced-secret: helm/k8s-existing-secret--target ordnet sowohl die Komponententypen der Installation, die der Entwurf zusammensetzt, als auch seine eigenen zu. Wo der Katalog mehrere Helm-Recipes für einen Typ anbietet, wie bei PostgreSQL, ordnet es das nach dem Typ benannte zu, helm/postgres.
.aggrega-import.json ist die Aufzeichnung dessen, was der Import geschrieben hat, die ein späteres aggrega import --sync liest, und release.lock fixiert jede Katalogentität, zu der das Release aufgelöst wird, nach Version und Digest.
Validieren und bauen
aggrega validate --release release.yamlaggrega build --release release.yaml

Die Validierung gibt aus:
notice: LINT: Feature "core/referenced-secret" at core/referenced-secret:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)release dependency validation passed: release.yaml (schema-pillar + dependency pillars)und der Build, wobei <workspace> für den Ordner mit den Entwürfen steht:
notice: LINT: Feature "core/referenced-secret" at core/referenced-secret: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: 24 files written to <workspace>/distDie notice-Zeile ist ein Hinweis: Das Secret-Feature akzeptiert sein origin aus den values des Aggregate oder aus der infra des Release, und der Hinweis meldet, dass ein Blatt in beiden deklariert ist. Er ändert kein Urteil.
Der Build schreibt die Kubernetes-Manifeste der Installation unter dist/boundaries/platform/helm/. Darunter ist der Job, der die Anwendung importiert, dify.api/dify-app-import.job.yaml. Er wartet, bis der API-Server von Dify antwortet, führt die Ersteinrichtung von Dify als das Eigentümerkonto durch, das das Release nennt, wo diese Einrichtung noch nicht gelaufen ist, und importiert die Anwendung:
spec: podFailurePolicy: rules: - action: FailJob onExitCodes: containerName: import operator: In values: [2] template: spec: restartPolicy: Never containers: - name: import image: "langgenius/dify-api:1.17.0" command: ["python", "/seed/import.py"] env: - name: DIFY_API_URL value: "http://dify-zdapi-default:5001" - name: OWNER_EMAIL value: "owner@example.com" - name: OWNER_PASSWORD valueFrom: secretKeyRef: name: "dify-owner" key: "value" volumeMounts: - name: seed mountPath: /seed readOnly: true volumes: - name: seed configMap: name: dify-zdapi-appDie Anwendung selbst liegt in der ConfigMap daneben. Wenn Dify ablehnt, was der Schritt ihm sendet – mit einer Client-Fehlerantwort, die weder ein Anfrage-Timeout noch eine Ratenbegrenzung ist, oder indem es meldet, dass der Import fehlgeschlagen ist –, gibt der Schritt die Meldung aus, die Difys Antwort enthält, und endet mit Status 2, wie er es tut, wenn die Definition unter app.name keine Anwendung nennt; die podFailurePolicy des Jobs lässt den Job bei diesem Versuch fehlschlagen, da ein erneuter Versuch auf dieselbe Weise abgelehnt würde; jeder andere Fehler, etwa wenn der Server nicht innerhalb von etwa zehn Minuten antwortet, wird erneut versucht.
Mit einem KI-Assistenten
Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie diesen Prompt dort ein.
Verwende nur die Aggrega-Tools und lege selbst keinen Ordner an. Wenn der Workspace-Ordner noch keinen Ordner `import-dify` enthält, rufe das Tool `scaffold` einmal mit `example` auf `import-dify` gesetzt und ohne `dir` auf: Es schreibt das Beispiel in einen neuen Ordner `import-dify`, dessen Ordner `source` enthält, was diese Seite importiert. Rufe dann das Tool `import` mit `workspace_root` auf `import-dify/source`, `source` auf `support-assistant.yml` und `target` auf `helm` gesetzt auf: Es liest die benötigten Antworten aus `import-answers.yaml` neben `support-assistant.yml`, schreibt seine Entwürfe nach `import-dify/source` und zieht, was sie benötigen. Rufe dann das Tool `validate` mit `workspace_root` auf `import-dify/source` und `release` auf `release.yaml` gesetzt auf, und das Tool `build` mit `workspace_root` auf `import-dify/source`, `release` auf `release.yaml` und `write` auf true gesetzt. Sag mir, welche Dateien der Build geschrieben hat; sie liegen unter `import-dify/source/dist/`.In VS Code öffnen
Ist die Aggrega-Erweiterung für Visual Studio Code installiert, öffnen Sie in VS Code den Ordner import-dify/source, in den der Import seine Entwürfe geschrieben hat. Der Ordner enthält ein einziges Release, das entworfene release.yaml, daher wählt der Editor es für Sie aus; sobald Auf Docker Compose ein zweites Release in compose entworfen hat, wählt Aggrega: Select Release… dasjenige, mit dem der Editor arbeitet. Der Editor prüft die Entwürfe beim Bearbeiten gegen das ausgewählte Release und markiert, was er findet, in der Datei und im Bereich „Probleme“. Aggrega: Show topology graph in der Befehlspalette zeichnet die Komponenten des ausgewählten Release und die Verbindungen zwischen ihnen. Aggrega: Build, Aggrega: Preview build und Aggrega: Pull wirken auf dasselbe Release, und jeder davon ist auch eine Schaltfläche im Bereich Commands der Ansicht Aggrega in der Aktivitätsleiste; Build schreibt seine Dateien in dist/ im Ordner. Aggrega in Visual Studio Code verwenden behandelt den Rest.
Ausführen
Bevor Sie die Manifeste anwenden, erstellen Sie die Secrets, die sie lesen. Eine Arbeitslast, die ein nicht vorhandenes Secret nennt, startet nicht. Zwei enthalten, was die Antwortdatei benannt hat: dify-owner, das das Passwort des Eigentümers unter value enthält, und dify-credentials, das das Anwendungsgeheimnis unter secret-key enthält. Die vier übrigen Zugangsdaten der Installation — ihr Datenbankpasswort und drei Schlüssel, die ihre Komponenten einander vorlegen — behalten die Standardwerte, die core/dify ihnen gibt, und auf Kubernetes ist jeder Standardwert der Name des Secrets, aus dem die Manifeste ihn lesen: dify-db-password-for-evaluation-only unter db-password, dify-code-execution-key-for-evaluation-only unter code-execution-key, dify-plugin-daemon-key-for-evaluation-only unter plugin-daemon-key und dify-inner-api-key-for-evaluation-only unter inner-api-key. Erstellen Sie auch diese vier, jedes mit einem eigenen Wert; um sie aus anders benannten Secrets zu lesen, übergeben Sie die Namen an core/dify im Eintrag dify des Aggregate, unter parameters, als db_password, code_execution_key, plugin_daemon_key und inner_api_key.
Setzen Sie das Passwort des Eigentümers in Ihrer Shell als DIFY_OWNER_PASSWORD, da Sie sich weiter unten damit anmelden. Dify akzeptiert ein Eigentümerpasswort mit mindestens acht Zeichen, das einen Buchstaben und eine Ziffer enthält: Bei jedem anderen schlägt der Import-Job fehl, sobald Dify die Ersteinrichtung ablehnt, und sein Log lautet first-time setup was refused with HTTP 422: Validation error for parameter 'payload', die Antwort, die Dify für ein Eigentümerkonto gibt, das es ablehnt. Das Warten weiter unten wartet darauf, dass der Job abgeschlossen wird, und ein fehlgeschlagener Job wird nie abgeschlossen, sodass es dann bis zu seinem Timeout läuft; führen Sie kubectl wait --for=condition=failed job/dify-zdapi-app-import --timeout=15m daneben in einem zweiten Terminal aus, und dieses Warten kehrt zurück, sobald der Job fehlschlägt. Löschen Sie den Job und das Secret dify-owner, erstellen Sie das Secret erneut mit einem Passwort, das Dify akzeptiert, und wenden Sie die Manifeste erneut an.
Schreiben Sie für jedes der fünf übrigen Secrets eine Datei mit einer Zeile: dem Datenschlüssel, = und einem eigenen Wert — dify-credentials.env mit secret-key=, db-password.env mit db-password=, code-execution-key.env mit code-execution-key=, plugin-daemon-key.env mit plugin-daemon-key= und inner-api-key.env mit inner-api-key=. Erstellen Sie dann die sechs Secrets. Danach hält der Cluster die Werte, also löschen Sie die Dateien:
printf 'value=%s\n' "$DIFY_OWNER_PASSWORD" > dify-owner.envkubectl create secret generic dify-owner --from-env-file=dify-owner.envkubectl create secret generic dify-credentials --from-env-file=dify-credentials.envkubectl create secret generic dify-db-password-for-evaluation-only --from-env-file=db-password.envkubectl create secret generic dify-code-execution-key-for-evaluation-only --from-env-file=code-execution-key.envkubectl create secret generic dify-plugin-daemon-key-for-evaluation-only --from-env-file=plugin-daemon-key.envkubectl create secret generic dify-inner-api-key-for-evaluation-only --from-env-file=inner-api-key.envrm dify-owner.env dify-credentials.env db-password.env code-execution-key.env plugin-daemon-key.env inner-api-key.envWenden Sie die Manifeste an, wie es der Ausführungsschritt von Wie ein Import abläuft erklärt — -R erreicht den Job und die beiden ConfigMaps in dify.api/ und dify.proxy/ —, warten Sie dann auf den Import-Job und lesen Sie sein Log, und warten Sie auf die Plug-in-Laufzeitumgebung:
kubectl apply -R -f dist/boundaries/platform/helm/kubectl wait --for=condition=complete job/dify-zdapi-app-import --timeout=15mkubectl logs job/dify-zdapi-app-importkubectl rollout status statefulset/dify-zdpluginsservice/dify-zdapi-default createddeployment.apps/dify-zdapi created[… omitted: a line for each of the other Services, Deployments and StatefulSets]job.batch/dify-zdapi-app-import createdconfigmap/dify-zdapi-app createdconfigmap/dify-zdproxy-config createdjob.batch/dify-zdapi-app-import condition metfirst-time setup done: owner account owner@example.comimported 'Support assistant' as application 7e03e85c-b13f-4ddc-b539-040470a61d4cpartitioned roll out complete: 1 new pods have been updated...Das Log nennt die Kennung der Anwendung, die Testen benötigt.
Testen
Die API von Dify antwortet unter http://127.0.0.1:5001. Leiten Sie auf Kubernetes einen lokalen Port an den Service des API-Servers, dify-zdapi-default, in dem Namespace weiter, in den Sie angewendet haben, und lassen Sie den Befehl in einem zweiten Terminal laufen:
kubectl port-forward -n <namespace> svc/dify-zdapi-default 5001:5001Auf Docker Compose, gestartet wie Auf Docker Compose zeigt, veröffentlicht das Release die API bereits unter dieser Adresse und die Konsole unter http://127.0.0.1:3001. Öffnen Sie http://127.0.0.1:3001/signin, die Anmeldeseite der Konsole; / leitet dorthin weiter. Die Seite sendet ihre Anfragen an die API unter http://127.0.0.1:5001, und die API von Dify antwortet einem Browser nur für Seiten, die von der Adresse ausgeliefert werden, die die entworfene console_url nennt, http://127.0.0.1:3001; melden Sie sich daher dort als Eigentümer an. Unter einer anderen Adresse geöffnet, erhalten die Anfragen der Konsole keine solche Antwort, und der Browser weist jede Antwort zurück; veröffentlichen Sie die Konsole auf einem anderen Port und ändern Sie console_url entsprechend.
Die Anwendung antwortet auch über die API, ohne dass ein Browser beteiligt ist. Melden Sie sich in einem Terminal, in dem DIFY_OWNER_PASSWORD gesetzt ist, als Eigentümer an. Die Konsolen-API nimmt das Passwort Base64-codiert entgegen, und die Anmeldung hinterlässt die Sitzung in cookies.txt. Jede spätere Konsolenanfrage sendet die Sitzung zurück, mit dem CSRF-Token aus derselben Datei in einem X-CSRF-Token-Header; eine Anfrage ohne ihn wird abgewiesen mit CSRF token is missing or invalid.
printf '{"email": "owner@example.com", "password": "%s"}' "$(printf %s "$DIFY_OWNER_PASSWORD" | base64 | tr -d '\n')" | curl -sS -c cookies.txt http://127.0.0.1:5001/console/api/login -H 'Content-Type: application/json' -d @-CSRF=$(awk '$6 == "csrf_token" {print $7}' cookies.txt){"result":"success"}Die Modellanbieter von Dify sind Plug-ins, und eine neue Installation enthält keinen. Installieren Sie den OpenAI-Anbieter von Dify in Version 1.1.0, der Version, die der Lauf installiert hat; die Plug-in-Laufzeitumgebung lädt ihn aus dem Marketplace von Dify, den die entworfene Einstellung marketplace_enabled für die Installation erreichbar macht, daher muss die Installation das Internet erreichen:
curl -sS -b cookies.txt -H "X-CSRF-Token: $CSRF" -H 'Content-Type: application/json' \ http://127.0.0.1:5001/console/api/workspaces/current/plugin/install/marketplace \ -d '{"plugin_unique_identifiers": ["langgenius/openai:1.1.0@1ded02acee56efd5788c86fd447d792e4923e959554a4942f440c7859d164340"]}'{"all_installed":false,"task_id":"01a1dc0a-653d-756b-a104-e5d6d1e43695","task":null}Wird marketplace_enabled aus dem Release gelöscht, weist Dify die Anfrage stattdessen zurück, mit {"code":"invalid_param","message":"marketplace is not enabled","status":400}. Die Installation läuft im Hintergrund. Fragen Sie ihren Task mit der task_id, die die Antwort nennt, so lange ab, bis sein status success ist:
curl -sS -b cookies.txt -H "X-CSRF-Token: $CSRF" \ http://127.0.0.1:5001/console/api/workspaces/current/plugin/tasks/<task id>{"task":{"id":"01a1dc0a-653d-756b-a104-e5d6d1e43695",[… omitted: when it was created and last updated],"status":"success","total_plugins":1,"completed_plugins":1,"plugins":[{"plugin_unique_identifier":"langgenius\/openai:1.1.0@1ded02acee56efd5788c86fd447d792e4923e959554a4942f440c7859d164340",[… omitted: the plugin's status, its icon and its names in four languages]}]}}Schreiben Sie den Schlüssel des Anbieters in openai.json, als {"credentials": {"openai_api_key": "your OpenAI key"}}, setzen Sie ihn und löschen Sie die Datei:
curl -sS -b cookies.txt -H "X-CSRF-Token: $CSRF" -H 'Content-Type: application/json' \ http://127.0.0.1:5001/console/api/workspaces/current/model-providers/langgenius/openai/openai/credentials \ -d @openai.jsonrm openai.jsonDify prüft den Schlüssel mit einer Anfrage an den Anbieter, bevor es ihn speichert, und antwortet {"result":"success"} für einen Schlüssel, den der Anbieter akzeptiert. Der Lauf setzte einen Platzhalter, und Dify wies ihn mit der Antwort von OpenAI ab:
{"code":"invalid_param","message":"Error code: 401 - {'error': {'message': 'Incorrect API key provided: sk-place*****************-key. You can find your API key at https:\/\/platform.openai.com\/account\/api-keys.', 'type': 'invalid_request_error', 'code': 'invalid_api_key', 'param': None}, 'status': 401}","status":400}Eine Anwendung beantwortet Anfragen, die mit einem eigenen API-Schlüssel gestellt werden. Erstellen Sie einen, mit der Kennung der Anwendung aus dem Log des Schritts, der sie importiert — auf Docker Compose docker compose -p support-assistant -f ../dist/boundaries/platform/compose/docker-compose.yaml logs dify-zdapi-app-import:
curl -sS -X POST -b cookies.txt -H "X-CSRF-Token: $CSRF" \ http://127.0.0.1:5001/console/api/apps/<application id>/api-keys{"id":"8d6c1eb1-cf61-4825-9b04-f32689ed0489","type":"app","token":"[… omitted: the key]","last_used_at":null,"created_at":1794693042}und senden Sie der Anwendung eine Nachricht mit dem Schlüssel, dem token der Antwort:
curl -sS http://127.0.0.1:5001/v1/chat-messages \ -H 'Authorization: Bearer <app key>' -H 'Content-Type: application/json' \ -d '{"inputs": {}, "query": "In one short sentence: what does a support plan cover?", "response_mode": "blocking", "user": "test-it"}'Da der Platzhalter abgewiesen wurde, hat das Modell keinen Schlüssel, und Dify meldet das:
{"code":"provider_not_initialize","message":"Model gpt-4o-mini credentials is not initialized.","status":400}Die Läufe auf Kubernetes und auf Docker Compose erhielten dieselben Antworten. Mit einem Schlüssel, den der Anbieter akzeptiert, enthält die Antwort die Antwort des Modells unter answer.
Beenden Sie auf Kubernetes die Portweiterleitung und entfernen Sie dann, was Sie angewendet haben, die Secrets und die Sitzungsdatei:
kubectl delete -R -f dist/boundaries/platform/helm/kubectl delete secret dify-owner dify-credentials dify-db-password-for-evaluation-only dify-code-execution-key-for-evaluation-only dify-plugin-daemon-key-for-evaluation-only dify-inner-api-key-for-evaluation-onlykubectl delete pvc data-dify-zddb-0 storage-dify-zdplugins-0 data-dify-zdvector-0rm cookies.txtKubernetes behält die Volume Claims, die ein StatefulSet angelegt hat, wenn das StatefulSet gelöscht wird, daher entfernt der dritte Befehl sie und mit ihnen die Datenbank, das installierte Plug-in und den Vektorspeicher. Auf Docker Compose entfernt docker compose -p support-assistant -f ../dist/boundaries/platform/compose/docker-compose.yaml down -v den Stack und seine Volumes.
Auf Docker Compose
Dieselbe Anwendung wird mit dem Ziel compose aus derselben Antwortdatei für Docker Compose importiert. Die Entwürfe für Kubernetes liegen bereits in source, entwerfen Sie die für Compose daher mit --output-dir in einen eigenen Ordner; der Import liest die Antwortdatei neben der Anwendung trotzdem:
aggrega import support-assistant.yml --target compose --output-dir composeDocker Compose hat kein Secret, das sich benennen ließe, daher schreibt der Entwurf für compose das Anwendungsgeheimnis und das Passwort des Eigentümers selbst, jeweils als Variablenreferenz, die Docker Compose aus der Umgebung dessen füllt, der den Stack startet. Dort wird nur die E-Mail-Adresse des Eigentümers benötigt. Der Import behält die beiden Secret-Namen in der Antwortdatei, ohne sie anzuwenden, und meldet das auf der Standardfehlerausgabe:
info: the answers file <workspace>/import-answers.yaml also answers spec.boundaries.platform.aggregates.dify.components.api.features.owner_password.infra.origin in release.yaml, spec.parameters.secret_key in release.yaml, which these drafts do not leave empty; those answers are kept there and not appliedDas entworfene Release liest das Anwendungsgeheimnis aus DIFY_SECRET_KEY und das Passwort des Eigentümers aus DIFY_OWNER_PASSWORD und veröffentlicht die API auf Port 5001 und das Frontend, console, auf Port 3001 der Loopback-Adresse:
parameters: # Passed by reference, never as a value: secret_key, which the drafted Aggregate declares and passes down to core/dify; that parameter's description there says what the value is; it is read from the variable DIFY_SECRET_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. secret_key: "${DIFY_SECRET_KEY}" [… omitted: the boundary, the marketplace switch, and the owner's email, answered as above] # 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: 5001 console_url: "http://127.0.0.1:3001" features: owner_password: type: core/referenced-secret infra: # Attached by reference, never as a value: the owner account's password, read from the variable DIFY_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: "${DIFY_OWNER_PASSWORD}" [… omitted: the worker and the scheduler, each with the marketplace switch, as above] console: infra: # 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: 3001Jeder Port ist nur von Ihrem Rechner aus erreichbar, wie sein Kommentar sagt, und wird eine Zeile gelöscht, bleibt dieser Dienst allein im Netzwerk des Stacks. Das Frontend lauscht in seinem Container auf 3000 und wird auf 3001 veröffentlicht, sodass es neben einem anderen Beispiel laufen kann, das 3000 veröffentlicht. Die console_url des API-Servers ist die Adresse, unter der das Frontend veröffentlicht wird; ein Port, den Sie für das Frontend ändern, wird daher auch dort geändert.
Das Manifest ordnet jede Komponente ihrem Compose-Recipe zu und core/referenced-secret dem compose/dotenv-referenced-secret, das jede Referenz unverändert in die Compose-Datei schreibt. Validieren und bauen Sie aus dem neuen Ordner:
cd composeaggrega validate --release release.yamlaggrega build --release release.yamlDer Build schreibt unter dist im Stammverzeichnis des Workspace, und der Workspace ist weiterhin source, der Ordner mit .aggrega-config.yaml: Die Compose-Datei ist source/dist/boundaries/platform/compose/docker-compose.yaml, von compose aus ../dist/boundaries/platform/compose/docker-compose.yaml, und innerhalb von compose wird kein Ordner dist geschrieben. Die Datei enthält SECRET_KEY: ${DIFY_SECRET_KEY} und OWNER_PASSWORD: ${DIFY_OWNER_PASSWORD} statt eines der beiden Werte. Setzen Sie beide Variablen in Ihrer Shell oder in einer Datei .env neben der Compose-Datei, bevor Sie den Stack starten.
Die vier anderen Zugangsdaten der Installation behalten die Standardwerte, die core/dify ihnen gibt, und auf Docker Compose ist jeder Standardwert der Wert selbst, unverändert in die Compose-Datei geschrieben: DB_PASSWORD: dify-db-password-for-evaluation-only, mit demselben POSTGRES_PASSWORD auf der Datenbank, und ebenso dify-code-execution-key-for-evaluation-only, dify-plugin-daemon-key-for-evaluation-only und dify-inner-api-key-for-evaluation-only. Jeder Leser des Katalogs kennt diese Standardwerte, daher dienen sie nur der Evaluierung. Um einen davon zu ersetzen, deklarieren Sie dafür einen String-Parameter im entworfenen Aggregate, reichen ihn im Eintrag dify unter parameters unter dem Namen weiter, den core/dify dafür verwendet — db_password, code_execution_key, plugin_daemon_key oder inner_api_key —, so wie der Entwurf secret_key weiterreicht, und erfüllen ihn unter den parameters des Release. Ein Release, das db_password: "${DIFY_DB_PASSWORD}" schreibt, baut eine Compose-Datei mit DB_PASSWORD: ${DIFY_DB_PASSWORD} und POSTGRES_PASSWORD: ${DIFY_DB_PASSWORD}, die wie die beiden obigen aus der Umgebung gefüllt werden.
Starten Sie den Stack aus compose, mit einem Eigentümerpasswort, das Dify akzeptiert, wie Ausführen beschreibt:
export DIFY_SECRET_KEY='a long random value of your own'export DIFY_OWNER_PASSWORD='a password of your own'docker compose -p support-assistant -f ../dist/boundaries/platform/compose/docker-compose.yaml up -d --wait--wait kehrte im Lauf nach etwa einer Minute zurück, sobald jeder Server als gesund gemeldet war. Der Schritt, der die Anwendung importiert, läuft neben ihnen und beendet sich, sobald er das getan hat; sein Log lautet dann:
first-time setup done: owner account owner@example.comimported 'Support assistant' as application 7fae73f4-826b-4918-a623-a3383aa0da8cTesten erreicht die Installation über die beiden veröffentlichten Ports.