Importar una aplicación de Dify
Esta guía paso a paso importa una aplicación exportada desde Dify — un asistente de chat sobre un modelo de OpenAI — en un Aggregate, una Release y un Manifest que, tal como están escritos, construyen para Kubernetes la instalación de Dify de la biblioteca estándar, que lleva la aplicación; luego los construye y ejecuta el resultado. Cada archivo y cada bloque de salida que aparecen a continuación provienen de una ejecución real; la aplicación y cada etapa de la guía están en el ejemplo import-dify, donde un script de comprobación vuelve a ejecutar la importación, compara lo que escribe, lo que imprime y los bloques que cita esta página con los archivos guardados allí, y valida y construye lo que escribió la importación.
Generar el ejemplo
Puedes ejecutar esta importación con los comandos de esta página o pedir a tu asistente de IA que la ejecute por ti.
Escribe el ejemplo en una carpeta nueva con su nombre:
aggrega scaffold --example import-difyDespués imprime los comandos que hay que ejecutar a continuación. El primero entra en la carpeta nueva; el siguiente, más abajo, entra en la carpeta source de la carpeta nueva, que contiene lo que esta página importa y es donde se ejecuta la importación:
cd import-dify
La aplicación
support-assistant.yml, escrito para esta guía, es una aplicación de chat en el DSL de Dify, el YAML que Dify exporta para una aplicación, en la versión de DSL 0.7.0: un mensaje de apertura, un prompt breve y el modelo con el que responde, nombrado por su proveedor:
model: completion_params: stop: [] temperature: 0.4 mode: chat name: gpt-4o-mini provider: langgenius/openai/openaiA su lado, un archivo .aggrega-config.yaml convierte la carpeta en un espacio de trabajo:
# 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.aiy import-answers.yaml contiene las respuestas a lo que ninguna aplicación puede contener: el secreto de aplicación de la instalación, la clave con la que Dify firma las sesiones y bajo la que cifra las claves de los proveedores de modelos que almacena; y la cuenta propietaria bajo la que se importa la aplicación, su correo electrónico y su contraseña. En Kubernetes cada secreto se lee de un Secret de Kubernetes, así que su respuesta es el nombre de ese Secret; el mismo archivo sirve también para una importación para Docker Compose, como muestra En Docker Compose:
# 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 representa un correo electrónico tuyo; dify-credentials y dify-owner son los Secrets que crea Ejecútalo. Sin el archivo, una importación en un terminal pide cada uno de los tres valores, una pregunta cada vez, y escribe tus respuestas en un nuevo archivo de respuestas; donde no se puede preguntar nada, escribe ese archivo con las tres claves y respuestas vacías, las enumera y termina con el estado 1. El archivo de respuestas de importación describe el archivo por completo.
El espacio de trabajo no indica ninguna carpeta de catálogo, así que la importación lee el catálogo de la biblioteca estándar desde el registro del que obtiene su importador: una instantánea firmada del catálogo publicado, que la primera importación obtiene, verifica y guarda en la caché de contenido del espacio de trabajo, y que el historial que la importación escribe junto a sus borradores nombra por su resumen criptográfico. Un espacio de trabajo que indica sus propias carpetas de catálogo — en AGGREGA_CATALOG_DIRS, o bajo workspace.catalog_dirs — importa en cambio a partir de ellas. Entra en source:
cd sourceEjecutar la importación
La instalación de Dify de la biblioteca estándar se realiza en Kubernetes y en Docker Compose. Esta guía nombra el destino helm:
aggrega import support-assistant.yml --target helmEn la salida estándar enumera lo que escribió:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonEn la salida de error estándar, donde <workspace> representa la carpeta en la que la ejecutaste:
[… 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)
- La línea
warnindica que el modelo queda dentro de Dify: Dify configura por sí mismo sus proveedores de modelos, y sus claves, así que el borrador no conecta ningún modelo. Una vez que Dify esté en marcha, instalas su proveedor OpenAI y defines la clave del proveedor, como muestra Prueba. - La línea
Pull completees el pull. Con cada valor respondido desde el archivo de respuestas, la importación hizo el pull de las dependencias de la Release esbozada, como haceaggrega pull, y escribiórelease.lock; la compilación siguiente no necesita nada más.
Lo que escribe
El Aggregate, la Release y el Manifest se llaman imported/support-assistant, por el nombre de la aplicación, Support assistant bajo app, reducido a support-assistant — una aplicación sin nombre recibe el nombre de su archivo — bajo el namespace que fija el ajuste target_namespace del importador, imported salvo que fijes otro (Ajustes).
aggregate.yaml — la instalación de Dify de la biblioteca estándar, core/dify, un Aggregate que el borrador compone bajo aggregates, con la aplicación trasladada tal como está escrita en su parámetro app_definition, omitida aquí en su mayor parte, y el secret_key de la instalación transmitido desde un parámetro que declara el borrador:
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.0La instalación consta de diez componentes — el servidor de API de Dify, su worker, su planificador, su front end web, su sandbox de código, su runtime de plugins, un proxy de salida, PostgreSQL, una caché compatible con Redis y Weaviate — conectados entre sí, y la importación de la aplicación es un paso que renderiza la Recipe de su servidor de API. Su secreto de aplicación no tiene valor predeterminado en core/dify, así que el borrador declara secret_key como parámetro propio, sin valor predeterminado, y lo transmite para que la Release lo satisfaga. Las demás credenciales de la instalación conservan los valores predeterminados que les da core/dify, como describe Ejecútalo.
release.yaml — la Release, que encamina la instalación a una frontera, platform, y satisface desde el archivo de respuestas lo que la aplicación no puede aportar:
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: trueenvironmentesdevelopment, un valor predeterminado que el comentario de encima indica cambiar por el entorno en el que se despliega la Release.secret_keyes el nombre del Secret que contiene el secreto de aplicación,dify-credentials, bajo la clave de datos que nombra la instalación,secret-key: el Manifest lee cada credencial de un Secret que ya existe en el namespace.- La cuenta propietaria se define en el componente
apide la instalación, en la entrada de encaminamiento que coloca la instalación en su frontera: su correo electrónico, y su contraseña adjuntada como uncore/referenced-secretque nombra el Secret que la contiene,dify-owner, bajo la clave de datosvalue. Los comentarios encima de los valores respondidos explican por qué la importación no pudo redactarlos. marketplace_enabledestrueen el servidor de la API,api, su worker y su planificador, en todos los destinos: la instalación no llega a nada del proveedor de Dify a menos que la Release lo permita, y el proveedor de OpenAI con el que responde la aplicación es un plugin que Dify instala desde su marketplace de plugins, como muestra Probarlo. Cada uno de los tres lee su propia configuración.
manifest.yaml — una Recipe de Helm para cada componente que compone la instalación, y la realización que lee una credencial de un Secret que ya existe en el namespace:
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 asigna los tipos de componente de la instalación que compone el borrador además de los suyos. Donde el catálogo ofrece varias Recipes de Helm para un tipo, como ocurre con PostgreSQL, asigna la que lleva el nombre del tipo, helm/postgres.
.aggrega-import.json es el registro de lo que escribió la importación, que lee un aggrega import --sync posterior, y release.lock fija cada entidad del catálogo a la que se resuelve la Release, por versión y digest.
Validar y compilar
aggrega validate --release release.yamlaggrega build --release release.yaml

La validación imprime:
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)y la compilación, donde <workspace> representa la carpeta que contiene los borradores:
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>/distLa línea notice es informativa: la Feature de secreto acepta su origin desde los values del Aggregate o desde la infra de la Release, y el aviso informa de que una hoja está declarada en ambos. No cambia ningún veredicto.
La compilación escribe los manifiestos de Kubernetes de la instalación en dist/boundaries/platform/helm/. Entre ellos está el Job que importa la aplicación, dify.api/dify-app-import.job.yaml. Espera a que el servidor de API de Dify responda, realiza la configuración inicial de Dify como la cuenta propietaria que nombra la Release, allí donde esa configuración no se ha ejecutado, e importa la aplicación:
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-appLa aplicación en sí está en el ConfigMap contiguo. Cuando Dify rechaza lo que el paso le envía, con una respuesta de error del cliente distinta de un tiempo de espera agotado de la solicitud o un límite de frecuencia, o informando de que la importación falló, el paso imprime el mensaje que lleva la respuesta de Dify y termina con el estado 2, como hace cuando la definición no nombra ninguna aplicación bajo app.name; la podFailurePolicy del Job hace fallar el Job en ese intento, ya que un reintento se rechazaría de la misma manera; cualquier otro fallo, como que el servidor no responda en unos diez minutos, se reintenta.
Con un asistente de IA
Un asistente de IA configurado con las herramientas de Aggrega puede hacer lo mismo: pega en él este prompt.
Usa solo las herramientas de Aggrega y no crees ninguna carpeta por tu cuenta. Si la carpeta del Workspace aún no contiene una carpeta `import-dify`, llama una vez a la herramienta `scaffold` con `example` establecido en `import-dify` y sin `dir`: escribe el ejemplo en una nueva carpeta `import-dify`, cuya carpeta `source` contiene lo que esta página importa. Después llama a la herramienta `import` con `workspace_root` establecido en `import-dify/source`, `source` establecido en `support-assistant.yml` y `target` establecido en `helm`: lee las respuestas que necesita de `import-answers.yaml`, junto a `support-assistant.yml`, escribe sus borradores en `import-dify/source` y descarga lo que necesitan. Después llama a la herramienta `validate` con `workspace_root` establecido en `import-dify/source` y `release` establecido en `release.yaml`, y a la herramienta `build` con `workspace_root` establecido en `import-dify/source`, `release` establecido en `release.yaml` y `write` establecido en true. Dime qué archivos escribió la compilación; están en `import-dify/source/dist/`.Ábrelo en VS Code
Con la extensión de Aggrega para Visual Studio Code instalada, abre en VS Code la carpeta import-dify/source, donde la importación escribió sus borradores. La carpeta contiene una sola Release, el release.yaml en borrador, así que el editor la selecciona por ti; una vez que En Docker Compose haya redactado una segunda Release en compose, Aggrega: Select Release… elige aquella con la que trabaja el editor. El editor comprueba los borradores con respecto a la Release seleccionada mientras los editas, marcando lo que encuentra en el archivo y en el panel Problemas. Aggrega: Show topology graph, en la paleta de comandos, dibuja los componentes de la Release seleccionada y las conexiones entre ellos. Aggrega: Build, Aggrega: Preview build y Aggrega: Pull actúan sobre la misma Release, y cada uno es también un botón del panel Commands de la vista Aggrega en la barra de actividades; Build escribe sus archivos en el dist/ de la carpeta. Usar Aggrega en Visual Studio Code cubre el resto.
Ejecución
Antes de aplicar los manifiestos, crea los Secrets que leen. Una carga de trabajo que nombra un Secret que no existe no se inicia. Dos guardan lo que nombró el archivo de respuestas: dify-owner, que guarda la contraseña del propietario bajo value, y dify-credentials, que guarda el secreto de la aplicación bajo secret-key. Las otras cuatro credenciales de la instalación — su contraseña de base de datos y tres claves que sus componentes se presentan entre sí — conservan los valores predeterminados que les da core/dify, y en Kubernetes cada valor predeterminado es el nombre del Secret del que lo leen los manifiestos: dify-db-password-for-evaluation-only bajo db-password, dify-code-execution-key-for-evaluation-only bajo code-execution-key, dify-plugin-daemon-key-for-evaluation-only bajo plugin-daemon-key y dify-inner-api-key-for-evaluation-only bajo inner-api-key. Crea también esos cuatro, cada uno con un valor propio; para leerlos de Secrets con otros nombres, pasa los nombres a core/dify en la entrada dify del Aggregate, bajo parameters, como db_password, code_execution_key, plugin_daemon_key e inner_api_key.
Define la contraseña del propietario en tu shell, como DIFY_OWNER_PASSWORD, ya que inicias sesión con ella más abajo. Dify acepta una contraseña de propietario de al menos ocho caracteres que contenga una letra y un dígito: con cualquier otra, el Job de importación falla en cuanto Dify rechaza la configuración inicial, y su registro dice first-time setup was refused with HTTP 422: Validation error for parameter 'payload', la respuesta que Dify da a una cuenta de propietario que rechaza. La espera de más abajo espera a que el Job se complete, y un Job fallido nunca se completa, así que entonces se prolonga hasta agotar su tiempo límite; ejecuta kubectl wait --for=condition=failed job/dify-zdapi-app-import --timeout=15m en una segunda terminal junto a ella, y esa espera termina en cuanto el Job falla. Elimina el Job y el Secret dify-owner, vuelve a crear el Secret con una contraseña que Dify acepte y aplica de nuevo los manifiestos.
Escribe un archivo para cada uno de los otros cinco Secrets, con una línea: la clave de datos, = y un valor propio — dify-credentials.env con secret-key=, db-password.env con db-password=, code-execution-key.env con code-execution-key=, plugin-daemon-key.env con plugin-daemon-key= e inner-api-key.env con inner-api-key=. Luego crea los seis Secrets. A partir de entonces el clúster guarda los valores, así que elimina los archivos:
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.envAplica los manifiestos, como explica el paso de ejecución de Cómo se ejecuta una importación — -R alcanza el Job y los dos ConfigMaps en dify.api/ y dify.proxy/ — y luego espera al Job de importación y lee su registro, y espera al runtime de plugins:
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...El registro indica el identificador de la aplicación, que Prueba necesita.
Probarlo
La API de Dify responde en http://127.0.0.1:5001. En Kubernetes, reenvía un puerto local al Service del servidor de API, dify-zdapi-default, en el espacio de nombres en el que aplicaste los manifiestos, y deja el comando ejecutándose en una segunda terminal:
kubectl port-forward -n <namespace> svc/dify-zdapi-default 5001:5001En Docker Compose, iniciado como muestra En Docker Compose, la Release ya publica la API en esa dirección, y la consola en http://127.0.0.1:3001. Abre http://127.0.0.1:3001/signin, la página de inicio de sesión de la consola; / redirige allí. La página envía sus solicitudes a la API en http://127.0.0.1:5001, y la API de Dify solo responde a un navegador para páginas servidas desde la dirección que indica el console_url del borrador, http://127.0.0.1:3001, así que inicia sesión allí como propietario. Abierta en cualquier otra dirección, las solicitudes de la consola no obtienen esa respuesta y el navegador rechaza cada respuesta; publica la consola en otro puerto y cambia console_url en consecuencia.
La aplicación también responde a través de la API, sin ningún navegador de por medio. En una terminal donde esté definida DIFY_OWNER_PASSWORD, inicia sesión como propietario. La API de consola recibe la contraseña codificada en Base64, y al iniciar sesión la sesión queda en cookies.txt. Cada solicitud posterior a la consola devuelve la sesión, con el token CSRF del mismo archivo en un encabezado X-CSRF-Token; una solicitud sin él se rechaza con 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"}Los proveedores de modelos de Dify son plugins, y una instalación nueva no contiene ninguno. Instala el proveedor OpenAI de Dify, en la versión 1.1.0, la que instaló la ejecución; el runtime de plugins lo obtiene del marketplace de Dify, al que el marketplace_enabled del borrador permite llegar a la instalación, así que la instalación debe poder llegar a internet:
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}Con marketplace_enabled eliminado de la Release, Dify rechaza en cambio la solicitud, con {"code":"invalid_param","message":"marketplace is not enabled","status":400}. La instalación se ejecuta en segundo plano. Consulta su tarea, con el task_id que indica la respuesta, hasta que su status sea success:
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]}]}}Escribe la clave del proveedor en openai.json, como {"credentials": {"openai_api_key": "your OpenAI key"}}, defínela y elimina el archivo:
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 comprueba la clave con una solicitud al proveedor antes de guardarla, y responde {"result":"success"} para una clave que el proveedor acepta. La ejecución definió un valor de marcador, y Dify lo rechazó con la respuesta de OpenAI:
{"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}Una aplicación responde a las solicitudes hechas con una clave de API propia. Crea una, con el identificador de la aplicación del registro del paso que la importa — en 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}y envía un mensaje a la aplicación con la clave, el token de la respuesta:
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"}'Con el marcador rechazado, el modelo no tiene clave, y Dify lo indica:
{"code":"provider_not_initialize","message":"Model gpt-4o-mini credentials is not initialized.","status":400}Las ejecuciones en Kubernetes y en Docker Compose obtuvieron las mismas respuestas. Con una clave que el proveedor acepte, la respuesta lleva la contestación del modelo en answer.
En Kubernetes, detén el reenvío de puertos y luego elimina lo que aplicaste, los Secrets y el archivo de sesión:
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 conserva las reclamaciones de volumen que creó un StatefulSet cuando se elimina el StatefulSet, así que el tercer comando las elimina, y con ellas la base de datos, el plugin instalado y el almacén de vectores. En Docker Compose, docker compose -p support-assistant -f ../dist/boundaries/platform/compose/docker-compose.yaml down -v elimina el stack y sus volúmenes.
En Docker Compose
La misma aplicación se importa para Docker Compose con el destino compose, desde el mismo archivo de respuestas. Los borradores para Kubernetes ya están en source, así que genera los de Compose en una carpeta propia con --output-dir; la importación lee igualmente el archivo de respuestas que está junto a la aplicación:
aggrega import support-assistant.yml --target compose --output-dir composeDocker Compose no tiene ningún Secret que nombrar, así que para compose el borrador escribe él mismo el secreto de la aplicación y la contraseña del propietario, cada uno como una referencia a variable que Docker Compose rellena desde el entorno de quien inicia el stack. Allí solo se requiere el correo electrónico del propietario. La importación conserva los dos nombres de Secret en el archivo de respuestas sin aplicarlos, y lo indica en la salida de error estándar:
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 appliedLa Release en borrador lee el secreto de la aplicación de DIFY_SECRET_KEY y la contraseña del propietario de DIFY_OWNER_PASSWORD, y publica la API en el puerto 5001 y el front end, console, en el 3001 de la dirección de loopback:
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: 3001Cada puerto es accesible solo desde tu máquina, como dice su comentario, y al eliminar una línea ese servicio queda solo en la red del stack. El front end escucha en el 3000 dentro de su contenedor y se publica en el 3001, así que puede ejecutarse junto a otro ejemplo que publique el 3000. El console_url del servidor de la API es la dirección en la que se publica el front end, así que un puerto que cambies para el front end se cambia también allí.
El Manifest asigna cada componente a su Recipe de Compose y core/referenced-secret a compose/dotenv-referenced-secret, que escribe cada referencia tal cual en el archivo Compose. Valida y compila desde la nueva carpeta:
cd composeaggrega validate --release release.yamlaggrega build --release release.yamlLa compilación escribe en dist en la raíz del espacio de trabajo, y el espacio de trabajo sigue siendo source, la carpeta que contiene .aggrega-config.yaml: el archivo Compose es source/dist/boundaries/platform/compose/docker-compose.yaml, que desde compose es ../dist/boundaries/platform/compose/docker-compose.yaml, y no se escribe ninguna carpeta dist dentro de compose. El archivo contiene SECRET_KEY: ${DIFY_SECRET_KEY} y OWNER_PASSWORD: ${DIFY_OWNER_PASSWORD} en lugar de cualquiera de los dos valores. Define ambas variables en tu shell, o en un archivo .env junto al archivo Compose, antes de iniciar el stack.
Las otras cuatro credenciales de la instalación conservan los valores predeterminados que les da core/dify, y en Docker Compose cada valor predeterminado es el propio valor, escrito tal cual en el archivo Compose: DB_PASSWORD: dify-db-password-for-evaluation-only, con el mismo POSTGRES_PASSWORD en la base de datos, y del mismo modo dify-code-execution-key-for-evaluation-only, dify-plugin-daemon-key-for-evaluation-only y dify-inner-api-key-for-evaluation-only. Cualquiera que lea el catálogo conoce estos valores predeterminados, así que solo sirven para una evaluación. Para reemplazar uno, declara un parámetro de tipo cadena para él en el Aggregate en borrador, pásalo en los parameters de la entrada dify con el nombre que le da core/dify — db_password, code_execution_key, plugin_daemon_key o inner_api_key —, igual que el borrador pasa secret_key, y cúmplelo en los parameters de la Release. Una Release que escribe db_password: "${DIFY_DB_PASSWORD}" compila un archivo Compose que contiene DB_PASSWORD: ${DIFY_DB_PASSWORD} y POSTGRES_PASSWORD: ${DIFY_DB_PASSWORD}, rellenados desde el entorno como los dos anteriores.
Inicia el stack desde compose, con una contraseña de propietario que Dify acepte, como describe Ejecución:
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 terminó en aproximadamente un minuto en la ejecución, una vez que todos los servidores informaron de que estaban en buen estado. El paso que importa la aplicación se ejecuta junto a ellos y termina una vez hecha la importación; su registro dice entonces:
first-time setup done: owner account owner@example.comimported 'Support assistant' as application 7fae73f4-826b-4918-a623-a3383aa0da8cPrueba llega a la instalación en los dos puertos publicados.