Importar uma aplicação Dify
Este guia passo a passo importa uma aplicação exportada do Dify — um assistente de conversação sobre um modelo da OpenAI — para um Aggregate, uma Release e um Manifest que, tal como estão escritos, compilam para Kubernetes a instalação do Dify da biblioteca padrão, que transporta a aplicação; depois compila-os e executa o resultado. Cada ficheiro e cada bloco de saída abaixo provêm de uma execução real; a aplicação e cada etapa do guia estão no exemplo import-dify, onde um script de verificação volta a executar a importação, compara o que ela escreve, o que imprime e os blocos que esta página cita com os ficheiros aí guardados, e valida e compila o que a importação escreveu.
Gerar o exemplo
É possível executar esta importação com os comandos desta página ou pedir ao seu assistente de IA que a execute.
Escreva o exemplo numa nova pasta com o nome dele:
aggrega scaffold --example import-difyDepois, imprime os próximos comandos a executar. O primeiro entra na nova pasta; o seguinte, abaixo, entra na pasta source da nova pasta, que contém o que esta página importa e é onde a importação é executada:
cd import-dify
A aplicação
support-assistant.yml, escrito para este guia, é uma aplicação de conversação na DSL do Dify, o YAML que o Dify exporta para uma aplicação, na versão de DSL 0.7.0: uma mensagem de abertura, um prompt curto e o modelo com que responde, nomeado pelo seu fornecedor:
model: completion_params: stop: [] temperature: 0.4 mode: chat name: gpt-4o-mini provider: langgenius/openai/openaiAo lado dele, um .aggrega-config.yaml torna a pasta um espaço de trabalho:
# 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.aie import-answers.yaml contém as respostas ao que nenhuma aplicação pode conter: o segredo de aplicação da instalação, a chave com que o Dify assina as sessões e sob a qual cifra as chaves dos fornecedores de modelos que armazena; e a conta de proprietário sob a qual a aplicação é importada, o seu e-mail e a sua palavra-passe. Em Kubernetes, cada segredo é lido de um Secret do Kubernetes, pelo que a sua resposta é o nome desse Secret; o mesmo ficheiro serve também uma importação para Docker Compose, como mostra No 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 um e-mail próprio; dify-credentials e dify-owner são os Secrets que Executar cria. Sem o ficheiro, uma importação num terminal pede cada um dos três valores, uma pergunta de cada vez, e escreve as respostas num novo ficheiro de respostas; onde nada pode ser perguntado, escreve esse ficheiro com as três chaves e respostas vazias, lista-as e termina com o estado 1. O ficheiro de respostas da importação descreve o ficheiro na íntegra.
O espaço de trabalho não indica nenhuma pasta de catálogo, pelo que a importação lê o catálogo da biblioteca padrão a partir do registry de onde obtém o seu importador: um snapshot assinado do catálogo publicado, que a primeira importação obtém, verifica e guarda na cache de conteúdo do espaço de trabalho, e que o registo que a importação escreve junto aos seus rascunhos indica pelo seu digest. Um espaço de trabalho que indique as suas próprias pastas de catálogo — em AGGREGA_CATALOG_DIRS, ou em workspace.catalog_dirs — importa antes com base nessas pastas. Entre em source:
cd sourceExecutar a importação
A instalação do Dify da biblioteca padrão é realizada em Kubernetes e em Docker Compose. Este guia nomeia o destino helm:
aggrega import support-assistant.yml --target helmNa saída padrão, lista o que escreveu:
wrote aggregate.yamlwrote release.yamlwrote manifest.yamlwrote .aggrega-import.jsonNa saída de erro padrão, com <workspace> a representar a pasta em que a executou:
[… 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)
- A linha
warnindica que o modelo fica dentro do Dify: o Dify configura os seus fornecedores de modelos, e as respetivas chaves, por si próprio, pelo que o rascunho não liga nenhum modelo. Assim que o Dify estiver em execução, instala-se o respetivo fornecedor OpenAI e define-se a chave do fornecedor, como mostra Teste. - A linha
Pull completeé o pull. Com todos os valores respondidos a partir do ficheiro de respostas, a importação fez o pull das dependências da Release em rascunho, como fazaggrega pull, e escreveurelease.lock; o build abaixo não precisa de mais nada.
O que a importação escreve
O Aggregate, a Release e o Manifest chamam-se imported/support-assistant, a partir do nome da aplicação, Support assistant em app, reduzido a support-assistant — uma aplicação sem nome recebe o nome do seu ficheiro — no namespace que a definição target_namespace do importador estabelece, imported, salvo se definir outro (Definições).
aggregate.yaml — a instalação do Dify da biblioteca padrão, core/dify, um Aggregate que o rascunho compõe em aggregates, com a aplicação transportada tal como escrita no seu parâmetro app_definition, em grande parte omitida aqui, e o secret_key da instalação transmitido a partir de um parâmetro que o rascunho declara:
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.0A instalação tem dez componentes — o servidor de API do Dify, o seu worker, o seu agendador, o seu front-end web, a sua sandbox de código, o seu runtime de plugins, um proxy de saída, PostgreSQL, uma cache compatível com Redis e Weaviate — ligados entre si, e a importação da aplicação é um passo que a Recipe do servidor de API renderiza. O segredo da aplicação não tem predefinição em core/dify, pelo que o rascunho declara secret_key como um parâmetro próprio, sem predefinição, e transmite-o para que a Release o preencha. As restantes credenciais da instalação mantêm as predefinições que core/dify lhes atribui, como descreve Executar.
release.yaml — a Release, que encaminha a instalação para uma fronteira, platform, e preenche, a partir do ficheiro de respostas, o que a aplicação não consegue fornecer:
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: trueenvironmentédevelopment, uma predefinição que o comentário acima indica que se deve alterar para o ambiente em que a Release é implementada.secret_keyé o nome do Secret que contém o segredo da aplicação,dify-credentials, sob a chave de dados que a instalação nomeia,secret-key: o Manifest lê cada credencial de um Secret já existente no namespace.- A conta de proprietário é definida no componente
apida instalação, na entrada de encaminhamento que coloca a instalação na sua fronteira: o respetivo e-mail e a respetiva palavra-passe, anexada como umcore/referenced-secretque nomeia o Secret que a contém,dify-owner, sob a chave de dadosvalue. Os comentários acima dos valores respondidos explicam porque é que a importação não os pôde redigir. marketplace_enabledétrueno servidor da API,api, no seu worker e no seu agendador, em todos os destinos: a instalação não alcança nada do fornecedor do Dify a menos que a Release o permita, e o fornecedor OpenAI com que a aplicação responde é um plugin que o Dify instala a partir do seu marketplace de plugins, como mostra Testar. Cada um dos três lê a sua própria definição.
manifest.yaml — uma Recipe Helm para cada componente que a instalação compõe, e a realização que lê uma credencial de um Secret já existente no 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 mapeia os tipos de componente da instalação que o rascunho compõe, bem como os seus próprios. Quando o catálogo oferece várias Recipes Helm para um tipo, como acontece com o PostgreSQL, mapeia a que tem o nome do tipo, helm/postgres.
.aggrega-import.json é o registo do que a importação escreveu, que um aggrega import --sync posterior lê, e release.lock fixa cada entidade do catálogo para a qual a Release se resolve, por versão e digest.
Validar e compilar
aggrega validate --release release.yamlaggrega build --release release.yaml

A validação 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)e a compilação, com <workspace> a representar a pasta que contém os rascunhos:
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>/distA linha notice é apenas informativa: a Feature de segredo aceita o seu origin dos values do Aggregate ou da infra da Release, e a notificação informa que uma folha está declarada em ambos. Não altera nenhum veredicto.
A compilação escreve os manifestos Kubernetes da instalação em dist/boundaries/platform/helm/. Entre eles está o Job que importa a aplicação, dify.api/dify-app-import.job.yaml. Este espera que o servidor de API do Dify responda, executa a configuração inicial do Dify como a conta de proprietário que a Release nomeia, onde essa configuração ainda não tenha sido executada, e importa a aplicação:
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-appA aplicação propriamente dita está no ConfigMap ao lado. Quando o Dify recusa o que o passo lhe envia, com uma resposta de erro do cliente que não seja um tempo limite do pedido nem um limite de taxa, ou comunicando que a importação falhou, o passo imprime a mensagem que a resposta do Dify contém e termina com o estado 2, tal como faz quando a definição não nomeia nenhuma aplicação em app.name; a podFailurePolicy do Job faz o Job falhar nessa tentativa, uma vez que uma nova tentativa seria recusada da mesma forma; qualquer outra falha, como o servidor não responder em cerca de dez minutos, é repetida.
Com um assistente de IA
Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole nele este prompt.
Usa apenas as ferramentas do Aggrega e não cries nenhuma pasta por ti. Se a pasta do Workspace ainda não contiver uma pasta `import-dify`, chama a ferramenta `scaffold` uma vez com `example` definido como `import-dify` e sem `dir`: escreve o exemplo numa nova pasta `import-dify`, cuja pasta `source` contém o que esta página importa. Em seguida, chama a ferramenta `import` com `workspace_root` definido como `import-dify/source`, `source` definido como `support-assistant.yml` e `target` definido como `helm`: lê as respostas de que precisa a partir de `import-answers.yaml`, ao lado de `support-assistant.yml`, escreve os seus rascunhos em `import-dify/source` e obtém aquilo de que precisam. Em seguida, chama a ferramenta `validate` com `workspace_root` definido como `import-dify/source` e `release` definido como `release.yaml`, e a ferramenta `build` com `workspace_root` definido como `import-dify/source`, `release` definido como `release.yaml` e `write` definido como true. Diz-me que ficheiros a compilação escreveu; estão em `import-dify/source/dist/`.Abrir no VS Code
Com a extensão do Aggrega para Visual Studio Code instalada, abra no VS Code a pasta import-dify/source, onde a importação escreveu os seus rascunhos. A pasta contém uma única Release, o release.yaml em rascunho, pelo que o editor a seleciona automaticamente; depois de No Docker Compose ter redigido uma segunda Release em compose, Aggrega: Select Release… escolhe aquela com que o editor trabalha. O editor verifica os rascunhos face à Release selecionada à medida que são editados, assinalando o que encontra no ficheiro e no painel Problemas. Aggrega: Show topology graph, na paleta de comandos, desenha os componentes da Release selecionada e as ligações entre eles. Aggrega: Build, Aggrega: Preview build e Aggrega: Pull atuam sobre a mesma Release, e cada um é também um botão no painel Commands da vista Aggrega na barra de atividade; o Build escreve os seus ficheiros no dist/ da pasta. Utilizar o Aggrega no Visual Studio Code trata do resto.
Execução
Antes de aplicar os manifestos, crie os Secrets que estes leem. Uma carga de trabalho que indique um Secret inexistente não arranca. Dois guardam o que o ficheiro de respostas indicou: dify-owner, que guarda a palavra-passe do proprietário em value, e dify-credentials, que guarda o segredo da aplicação em secret-key. As outras quatro credenciais da instalação — a palavra-passe da base de dados e três chaves que os respetivos componentes apresentam uns aos outros — mantêm os valores predefinidos que core/dify lhes atribui, e no Kubernetes cada valor predefinido é o nome do Secret a partir do qual os manifestos o leem: dify-db-password-for-evaluation-only em db-password, dify-code-execution-key-for-evaluation-only em code-execution-key, dify-plugin-daemon-key-for-evaluation-only em plugin-daemon-key e dify-inner-api-key-for-evaluation-only em inner-api-key. Crie também esses quatro, cada um com um valor próprio; para os ler a partir de Secrets com outros nomes, passe os nomes a core/dify na entrada dify do Aggregate, em parameters, como db_password, code_execution_key, plugin_daemon_key e inner_api_key.
Defina a palavra-passe do proprietário na sua shell, como DIFY_OWNER_PASSWORD, uma vez que é com ela que se inicia sessão mais abaixo. O Dify aceita uma palavra-passe de proprietário com pelo menos oito caracteres que contenha uma letra e um dígito: com qualquer outra, o Job de importação falha assim que o Dify recusa a configuração inicial, e o respetivo registo indica first-time setup was refused with HTTP 422: Validation error for parameter 'payload', a resposta que o Dify dá a uma conta de proprietário que recusa. A espera abaixo aguarda que o Job seja concluído, e um Job falhado nunca é concluído, pelo que a espera se prolonga então até ao tempo limite; execute kubectl wait --for=condition=failed job/dify-zdapi-app-import --timeout=15m num segundo terminal ao lado, e essa espera termina assim que o Job falha. Elimine o Job e o Secret dify-owner, crie novamente o Secret com uma palavra-passe que o Dify aceite e aplique de novo os manifestos.
Escreva um ficheiro para cada um dos outros cinco Secrets, com uma linha: a chave de dados, = e um valor próprio — dify-credentials.env com secret-key=, db-password.env com db-password=, code-execution-key.env com code-execution-key=, plugin-daemon-key.env com plugin-daemon-key= e inner-api-key.env com inner-api-key=. Em seguida, crie os seis Secrets. A partir daí, o cluster guarda os valores, pelo que deve eliminar os ficheiros:
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.envAplique os manifestos, como explica o passo de execução de Como decorre uma importação — -R alcança o Job e os dois ConfigMaps em dify.api/ e dify.proxy/ — e depois aguarde pelo Job de importação e leia o respetivo registo, e aguarde pelo 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...O registo indica o identificador da aplicação, de que Teste precisa.
Testar
A API do Dify responde em http://127.0.0.1:5001. Em Kubernetes, reencaminhe uma porta local para o Service do servidor de API, dify-zdapi-default, no namespace em que aplicou os manifestos, e deixe o comando em execução num segundo terminal:
kubectl port-forward -n <namespace> svc/dify-zdapi-default 5001:5001No Docker Compose, iniciado como mostra No Docker Compose, a Release já publica a API nesse endereço, e a consola em http://127.0.0.1:3001. Abra http://127.0.0.1:3001/signin, a página de início de sessão da consola; / redireciona para lá. A página envia os seus pedidos à API em http://127.0.0.1:5001, e a API do Dify só responde a um navegador para páginas servidas a partir do endereço que o console_url do rascunho indica, http://127.0.0.1:3001, pelo que deve iniciar sessão aí como proprietário. Aberta em qualquer outro endereço, os pedidos da consola não obtêm essa resposta e o navegador recusa cada resposta; publique a consola noutra porta e altere console_url em conformidade.
A aplicação também responde através da API, sem nenhum navegador envolvido. Num terminal onde DIFY_OWNER_PASSWORD esteja definida, inicie sessão como proprietário. A API da consola recebe a palavra-passe codificada em Base64, e o início de sessão deixa a sessão em cookies.txt. Cada pedido posterior à consola reenvia a sessão, com o token CSRF do mesmo ficheiro num cabeçalho X-CSRF-Token; um pedido sem ele é recusado com 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"}Os fornecedores de modelos do Dify são plugins, e uma instalação nova não contém nenhum. Instale o fornecedor OpenAI do Dify, na versão 1.1.0, a que a execução instalou; o runtime de plugins obtém-no a partir do marketplace do Dify, que o marketplace_enabled do rascunho permite à instalação alcançar, pelo que a instalação tem de conseguir chegar à 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}Com marketplace_enabled eliminado da Release, o Dify recusa antes o pedido, com {"code":"invalid_param","message":"marketplace is not enabled","status":400}. A instalação é executada em segundo plano. Consulte a respetiva tarefa, com o task_id que a resposta indica, até que o seu status seja 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]}]}}Escreva a chave do fornecedor em openai.json, como {"credentials": {"openai_api_key": "your OpenAI key"}}, defina-a e elimine o ficheiro:
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.jsonO Dify verifica a chave com um pedido ao fornecedor antes de a guardar, e responde {"result":"success"} para uma chave que o fornecedor aceita. A execução definiu um valor provisório, e o Dify recusou-o com a resposta da 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}Uma aplicação responde a pedidos feitos com uma chave de API própria. Crie uma, com o identificador da aplicação retirado do registo do passo que a importa — no 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}e envie à aplicação uma mensagem com a chave, o token da resposta:
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"}'Com o valor provisório recusado, o modelo não tem chave, e o Dify indica-o:
{"code":"provider_not_initialize","message":"Model gpt-4o-mini credentials is not initialized.","status":400}As execuções em Kubernetes e em Docker Compose obtiveram as mesmas respostas. Com uma chave que o fornecedor aceite, a resposta traz a resposta do modelo em answer.
Em Kubernetes, pare o reencaminhamento de porta e, em seguida, remova o que aplicou, os Secrets e o ficheiro de sessão:
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.txtO Kubernetes mantém as reivindicações de volume que um StatefulSet criou quando o StatefulSet é eliminado, pelo que o terceiro comando as remove, e com elas a base de dados, o plugin instalado e o armazenamento vetorial. No Docker Compose, docker compose -p support-assistant -f ../dist/boundaries/platform/compose/docker-compose.yaml down -v remove a stack e os seus volumes.
No Docker Compose
A mesma aplicação importa-se para Docker Compose com o destino compose, a partir do mesmo ficheiro de respostas. Os rascunhos para Kubernetes já estão em source, pelo que deve gerar os de Compose numa pasta própria com --output-dir; a importação lê na mesma o ficheiro de respostas ao lado da aplicação:
aggrega import support-assistant.yml --target compose --output-dir composeO Docker Compose não tem nenhum Secret a indicar, pelo que, para compose, o próprio rascunho escreve o segredo da aplicação e a palavra-passe do proprietário, cada um como uma referência a variável que o Docker Compose preenche a partir do ambiente de quem arranca a stack. Aí só é necessário o e-mail do proprietário. A importação mantém os dois nomes de Secret no ficheiro de respostas sem os aplicar, e indica-o na saída de erro padrão:
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 appliedA Release em rascunho lê o segredo da aplicação de DIFY_SECRET_KEY e a palavra-passe do proprietário de DIFY_OWNER_PASSWORD, e publica a API na porta 5001 e o front-end, console, na 3001 do endereço 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 porta só é acessível a partir da sua máquina, como diz o respetivo comentário, e eliminar uma linha mantém esse serviço apenas na rede da stack. O front-end está à escuta na 3000 dentro do seu contentor e é publicado na 3001, pelo que pode ser executado ao lado de outro exemplo que publique a 3000. O console_url do servidor da API é o endereço em que o front-end é publicado, pelo que uma porta que altere para o front-end é alterada também aí.
O Manifest associa cada componente à respetiva Recipe de Compose e core/referenced-secret a compose/dotenv-referenced-secret, que escreve cada referência no ficheiro Compose tal como está. Valide e compile a partir da nova pasta:
cd composeaggrega validate --release release.yamlaggrega build --release release.yamlA compilação escreve em dist na raiz do workspace, e o workspace continua a ser source, a pasta que contém .aggrega-config.yaml: o ficheiro Compose é source/dist/boundaries/platform/compose/docker-compose.yaml, que a partir de compose é ../dist/boundaries/platform/compose/docker-compose.yaml, e nenhuma pasta dist é escrita dentro de compose. O ficheiro contém SECRET_KEY: ${DIFY_SECRET_KEY} e OWNER_PASSWORD: ${DIFY_OWNER_PASSWORD} em vez de qualquer um dos valores. Defina ambas as variáveis na sua shell, ou num ficheiro .env ao lado do ficheiro Compose, antes de arrancar a stack.
As outras quatro credenciais da instalação mantêm os valores predefinidos que core/dify lhes dá, e no Docker Compose cada valor predefinido é o próprio valor, escrito no ficheiro Compose tal como está: DB_PASSWORD: dify-db-password-for-evaluation-only, com o mesmo POSTGRES_PASSWORD na base de dados, e do mesmo modo dify-code-execution-key-for-evaluation-only, dify-plugin-daemon-key-for-evaluation-only e dify-inner-api-key-for-evaluation-only. Qualquer leitor do catálogo conhece estes valores predefinidos, pelo que servem apenas para avaliação. Para substituir um, declare um parâmetro de cadeia para ele no Aggregate em rascunho, passe-o nos parameters da entrada dify com o nome que core/dify lhe dá — db_password, code_execution_key, plugin_daemon_key ou inner_api_key —, tal como o rascunho passa secret_key, e preencha-o nos parameters da Release. Uma Release que escreve db_password: "${DIFY_DB_PASSWORD}" gera um ficheiro Compose que contém DB_PASSWORD: ${DIFY_DB_PASSWORD} e POSTGRES_PASSWORD: ${DIFY_DB_PASSWORD}, preenchidos a partir do ambiente como os dois acima.
Arranque a stack a partir de compose, com uma palavra-passe de proprietário que o Dify aceite, como descreve Execução:
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 --waitNa execução, --wait regressou ao fim de cerca de um minuto, assim que todos os servidores se declararam saudáveis. O passo que importa a aplicação é executado ao lado deles e termina depois de o fazer; o seu registo indica então:
first-time setup done: owner account owner@example.comimported 'Support assistant' as application 7fae73f4-826b-4918-a623-a3383aa0da8cTeste chega à instalação nas duas portas publicadas.