mirror of
https://github.com/yunionio/cloudpods.git
synced 2026-09-19 02:37:24 +08:00
Zexi Li
3bdd431db0
* support comfyui and openclaw feat(region,host): support env credential of container feat(llm): openclaw url * fix(region): delete server without host_id * feat(llm): llm spec
560 lines
19 KiB
Go
560 lines
19 KiB
Go
package models
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"path"
|
|
|
|
"yunion.io/x/onecloud/pkg/apis"
|
|
computeapi "yunion.io/x/onecloud/pkg/apis/compute"
|
|
api "yunion.io/x/onecloud/pkg/apis/llm"
|
|
)
|
|
|
|
type DifyContainerEnv map[string]string
|
|
|
|
func (envsPtr *DifyContainerEnv) GetContainerEnvs(userCustomizedEnvs *DifyContainerEnv) []*apis.ContainerKeyValue {
|
|
envs := *envsPtr
|
|
if len(envs) == 0 {
|
|
return nil
|
|
}
|
|
|
|
ctrEnvs := make([]*apis.ContainerKeyValue, 0, len(envs))
|
|
for key, value := range envs {
|
|
if userCustomizedEnvs != nil && (*userCustomizedEnvs)[key] != "" {
|
|
value = (*userCustomizedEnvs)[key]
|
|
}
|
|
ctrEnvs = append(ctrEnvs, &apis.ContainerKeyValue{
|
|
Key: key,
|
|
Value: value,
|
|
})
|
|
}
|
|
return ctrEnvs
|
|
}
|
|
|
|
func (envsPtr *DifyContainerEnv) SetContainerEnv(key, value string) error {
|
|
if key == "" {
|
|
return errors.New("environment variable key cannot be empty")
|
|
}
|
|
|
|
if envsPtr == nil {
|
|
return errors.New("DifyContainerEnv pointer is nil")
|
|
}
|
|
|
|
if *envsPtr == nil {
|
|
*envsPtr = make(DifyContainerEnv)
|
|
}
|
|
|
|
(*envsPtr)[key] = value
|
|
return nil
|
|
}
|
|
|
|
// DifyCustomizedEnvsToMap converts API DifyCustomizedEnvs to DifyContainerEnv for container build. Returns nil if empty.
|
|
func DifyCustomizedEnvsToMap(envs []*api.DifyCustomizedEnv) DifyContainerEnv {
|
|
if len(envs) == 0 {
|
|
return nil
|
|
}
|
|
m := make(DifyContainerEnv, len(envs))
|
|
for _, e := range envs {
|
|
if e != nil && e.Key != "" {
|
|
m[e.Key] = e.Value
|
|
}
|
|
}
|
|
if len(m) == 0 {
|
|
return nil
|
|
}
|
|
return m
|
|
}
|
|
|
|
func getPVCMount(name, subDir, mountPath string) *apis.ContainerVolumeMount {
|
|
diskIndex := 0
|
|
pvc := &apis.ContainerVolumeMount{
|
|
UniqueName: name + "-data-pvc",
|
|
Type: apis.CONTAINER_VOLUME_MOUNT_TYPE_DISK,
|
|
Disk: &apis.ContainerVolumeMountDisk{
|
|
SubDirectory: subDir,
|
|
Index: &diskIndex,
|
|
},
|
|
MountPath: mountPath,
|
|
ReadOnly: false,
|
|
Propagation: apis.MOUNTPROPAGATION_PROPAGATION_PRIVATE,
|
|
}
|
|
|
|
return pvc
|
|
}
|
|
|
|
func _getRegistryImage(imageId string) string {
|
|
image, err := GetLLMImageManager().FetchById(imageId)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return image.(*SLLMImage).ToContainerImage()
|
|
}
|
|
|
|
// getDifySpecFromSku returns the Dify spec from the SKU via the container driver, or nil.
|
|
func getDifySpecFromSku(sku *SLLMSku) *api.LLMSpecDify {
|
|
s := sku.GetLLMContainerDriver().GetSpec(sku)
|
|
if s == nil {
|
|
return nil
|
|
}
|
|
d, _ := s.(*api.LLMSpecDify)
|
|
return d
|
|
}
|
|
|
|
func getDifyContainerByNameKeyAndSku(name, key string, difySpec *api.LLMSpecDify, customEnvs *DifyContainerEnv) (*computeapi.PodContainerCreateInput, error) {
|
|
if difySpec == nil {
|
|
return nil, errors.New("dify spec is nil")
|
|
}
|
|
switch key {
|
|
case api.DIFY_REDIS_KEY:
|
|
return getRedisContainer(name, key, _getRegistryImage(difySpec.RedisImageId), customEnvs), nil
|
|
case api.DIFY_POSTGRES_KEY:
|
|
return getPostgresContainer(name, key, _getRegistryImage(difySpec.PostgresImageId), customEnvs), nil
|
|
case api.DIFY_API_KEY:
|
|
return getApiContainer(name, key, _getRegistryImage(difySpec.DifyApiImageId), customEnvs), nil
|
|
case api.DIFY_WORKER_KEY:
|
|
return getWorkerContainer(name, key, _getRegistryImage(difySpec.DifyApiImageId), customEnvs), nil
|
|
case api.DIFY_WORKER_BEAT_KEY:
|
|
return getWorkerBeatContainer(name, key, _getRegistryImage(difySpec.DifyApiImageId), customEnvs), nil
|
|
case api.DIFY_PLUGIN_KEY:
|
|
return getPluginContainer(name, key, _getRegistryImage(difySpec.DifyPluginImageId), customEnvs), nil
|
|
case api.DIFY_WEB_KEY:
|
|
return getWebContainer(name, key, _getRegistryImage(difySpec.DifyWebImageId), customEnvs), nil
|
|
case api.DIFY_SSRF_KEY:
|
|
return getSsrfContainer(name, key, _getRegistryImage(difySpec.DifySSRFImageId), customEnvs), nil
|
|
case api.DIFY_NGINX_KEY:
|
|
return getNginxContainer(name, key, _getRegistryImage(difySpec.NginxImageId), customEnvs), nil
|
|
case api.DIFY_WEAVIATE_KEY:
|
|
return getWeaviateContainer(name, key, _getRegistryImage(difySpec.DifyWeaviateImageId), customEnvs), nil
|
|
case api.DIFY_SANDBOX_KEY:
|
|
return getSandboxContainer(name, key, _getRegistryImage(difySpec.DifySandboxImageId), customEnvs), nil
|
|
default:
|
|
return nil, errors.New("unsupported container key")
|
|
}
|
|
}
|
|
|
|
// DifyContainerKeys is the ordered list of container keys for a Dify pod (used by driver and SDify).
|
|
var DifyContainerKeys = []string{
|
|
api.DIFY_POSTGRES_KEY,
|
|
api.DIFY_REDIS_KEY,
|
|
api.DIFY_API_KEY,
|
|
api.DIFY_WORKER_KEY,
|
|
api.DIFY_WORKER_BEAT_KEY,
|
|
api.DIFY_PLUGIN_KEY,
|
|
api.DIFY_SANDBOX_KEY,
|
|
api.DIFY_SSRF_KEY,
|
|
api.DIFY_WEB_KEY,
|
|
api.DIFY_NGINX_KEY,
|
|
api.DIFY_WEAVIATE_KEY,
|
|
}
|
|
|
|
// mergeDifyContainerEnvs merges base and overrides; overrides take precedence. Returns nil if both are nil/empty.
|
|
func mergeDifyContainerEnvs(base, overrides *DifyContainerEnv) *DifyContainerEnv {
|
|
if base == nil && overrides == nil {
|
|
return nil
|
|
}
|
|
out := make(DifyContainerEnv)
|
|
if base != nil {
|
|
for k, v := range *base {
|
|
out[k] = v
|
|
}
|
|
}
|
|
if overrides != nil {
|
|
for k, v := range *overrides {
|
|
out[k] = v
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return nil
|
|
}
|
|
return &out
|
|
}
|
|
|
|
func GetDifyContainersByNameAndSku(name string, sku *SLLMSku, customEnvs *DifyContainerEnv, difySpec *api.LLMSpecDify) []*computeapi.PodContainerCreateInput {
|
|
if difySpec == nil {
|
|
difySpec = getDifySpecFromSku(sku)
|
|
}
|
|
var skuEnvs *DifyContainerEnv
|
|
if difySpec != nil && len(difySpec.CustomizedEnvs) > 0 {
|
|
m := DifyCustomizedEnvsToMap(difySpec.CustomizedEnvs)
|
|
if m != nil {
|
|
skuEnvs = &m
|
|
}
|
|
}
|
|
mergedEnvs := mergeDifyContainerEnvs(skuEnvs, customEnvs)
|
|
|
|
var out []*computeapi.PodContainerCreateInput
|
|
for _, key := range DifyContainerKeys {
|
|
c, err := getDifyContainerByNameKeyAndSku(name, key, difySpec, mergedEnvs)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
c.AlwaysRestart = true
|
|
out = append(out, c)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func getRedisContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"REDISCLI_AUTH": api.DIFY_REDISCLI_AUTH,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, key, api.DIFY_REDIS_PVC_MOUNT_PATH),
|
|
}
|
|
|
|
// set command
|
|
ctr.Args = []string{
|
|
"redis-server", "--requirepass", api.DIFY_REDISCLI_AUTH,
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getPostgresContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"POSTGRES_USER": api.DIFY_POSTGRES_USER,
|
|
"POSTGRES_PASSWORD": api.DIFY_POSTGRES_PASSWORD,
|
|
"POSTGRES_DB": api.DIFY_POSTGRES_DB,
|
|
"PGDATA": path.Join(api.DIFY_POSTGRES_PVC_MOUNT_PATH, api.DIFY_POSTGRES_PGDATA),
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, key, api.DIFY_POSTGRES_PVC_MOUNT_PATH),
|
|
}
|
|
|
|
// set command for ctr
|
|
ctr.Args = []string{
|
|
"postgres",
|
|
"-c", "max_connections=" + api.DIFY_POSTGRES_MAX_CONNECTIONS,
|
|
"-c", "shared_buffers=" + api.DIFY_POSTGRES_SHARED_BUFFERS,
|
|
"-c", "work_mem=" + api.DIFY_POSTGRES_WORK_MEM,
|
|
"-c", "maintenance_work_mem=" + api.DIFY_POSTGRES_MAINTENANCE_WORK_MEM,
|
|
"-c", "effective_cache_size=" + api.DIFY_POSTGRES_EFFECTIVE_CACHE_SIZE,
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getApiContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set depends on
|
|
ctr.DependsOn = []string{
|
|
name + "-" + api.DIFY_REDIS_KEY,
|
|
name + "-" + api.DIFY_POSTGRES_KEY,
|
|
}
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"MODE": api.DIFY_API_MODE,
|
|
"SENTRY_DSN": api.DIFY_API_SENTRY_DSN,
|
|
"SENTRY_TRACES_SAMPLE_RATE": api.DIFY_API_SENTRY_TRACES_SAMPLE_RATE,
|
|
"SENTRY_PROFILES_SAMPLE_RATE": api.DIFY_API_SENTRY_PROFILES_SAMPLE_RATE,
|
|
"PLUGIN_REMOTE_INSTALL_HOST": api.DIFY_LOCALHOST,
|
|
"PLUGIN_REMOTE_INSTALL_PORT": api.DIFY_PLUGIN_REMOTE_INSTALLING_PORT,
|
|
"PLUGIN_MAX_PACKAGE_SIZE": api.DIFY_PLUGIN_MAX_PACKAGE_SIZE,
|
|
"INNER_API_KEY_FOR_PLUGIN": api.DIFY_API_INNER_KEY,
|
|
}
|
|
ctr.Envs = append(getSharedApiWorkerEnv(customEnvs), envs.GetContainerEnvs(customEnvs)...)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, "api", api.DIFY_API_PVC_MOUNT_PATH),
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getWorkerContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set depends on
|
|
ctr.DependsOn = []string{
|
|
name + "-" + api.DIFY_REDIS_KEY,
|
|
name + "-" + api.DIFY_POSTGRES_KEY,
|
|
}
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"MODE": api.DIFY_WORKER_MODE,
|
|
"SENTRY_DSN": api.DIFY_API_SENTRY_DSN,
|
|
"SENTRY_TRACES_SAMPLE_RATE": api.DIFY_API_SENTRY_TRACES_SAMPLE_RATE,
|
|
"SENTRY_PROFILES_SAMPLE_RATE": api.DIFY_API_SENTRY_PROFILES_SAMPLE_RATE,
|
|
"PLUGIN_MAX_PACKAGE_SIZE": api.DIFY_PLUGIN_MAX_PACKAGE_SIZE,
|
|
"INNER_API_KEY_FOR_PLUGIN": api.DIFY_API_INNER_KEY,
|
|
}
|
|
ctr.Envs = append(getSharedApiWorkerEnv(customEnvs), envs.GetContainerEnvs(customEnvs)...)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, "api", api.DIFY_API_PVC_MOUNT_PATH),
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getWorkerBeatContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set depends on
|
|
ctr.DependsOn = []string{
|
|
name + "-" + api.DIFY_REDIS_KEY,
|
|
name + "-" + api.DIFY_POSTGRES_KEY,
|
|
}
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"MODE": api.DIFY_WORKER_BEAT_MODE,
|
|
}
|
|
ctr.Envs = append(getSharedApiWorkerEnv(customEnvs), envs.GetContainerEnvs(customEnvs)...)
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getPluginContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set depends on
|
|
ctr.DependsOn = []string{
|
|
name + "-" + api.DIFY_POSTGRES_KEY,
|
|
}
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"DB_DATABASE": api.DIFY_PLUGIN_DB_DATABASE,
|
|
"SERVER_PORT": api.DIFY_PLUGIN_SERVER_PORT,
|
|
"SERVER_KEY": api.DIFY_PLUGIN_SERVER_KEY,
|
|
"MAX_PACKAGE_CACHE_PATH": api.DIFY_PLUGIN_PACKAGE_CACHE_PATH,
|
|
"PPROF_ENABLED": api.DIFY_PLUGIN_PPROF_ENABLED,
|
|
"DIFY_INNER_API_URL": api.DIFY_PLUGIN_DIFY_INNER_API_URL,
|
|
"DIFY_INNER_API_KEY": api.DIFY_API_INNER_KEY,
|
|
"PLUGIN_REMOTE_INSTALLING_HOST": api.DIFY_PLUGIN_REMOTE_INSTALLING_HOST,
|
|
"PLUGIN_REMOTE_INSTALLING_PORT": api.DIFY_PLUGIN_REMOTE_INSTALLING_PORT,
|
|
"PLUGIN_WORKING_PATH": api.DIFY_PLUGIN_WORKING_PATH,
|
|
"FORCE_VERIFYING_SIGNATURE": api.DIFY_PLUGIN_FORCE_VERIFYING_SIGNATURE,
|
|
"PYTHON_ENV_INIT_TIMEOUT": api.DIFY_PLUGIN_PYTHON_ENV_INIT_TIMEOUT,
|
|
"PLUGIN_MAX_EXECUTION_TIMEOUT": api.DIFY_PLUGIN_MAX_EXECUTION_TIMEOUT,
|
|
"PIP_MIRROR_URL": api.PIP_MIRROR_URL,
|
|
"PLUGIN_STORAGE_TYPE": api.DIFY_PLUGIN_STORAGE_TYPE,
|
|
"PLUGIN_STORAGE_LOCAL_ROOT": api.DIFY_PLUGIN_STORAGE_LOCAL_ROOT,
|
|
"PLUGIN_INSTALLED_PATH": api.DIFY_PLUGIN_INSTALLED_PATH,
|
|
"PLUGIN_PACKAGE_CACHE_PATH": api.DIFY_PLUGIN_PACKAGE_CACHE_PATH,
|
|
"PLUGIN_MEDIA_CACHE_PATH": api.DIFY_PLUGIN_MEDIA_CACHE_PATH,
|
|
}
|
|
ctr.Envs = append(getSharedApiWorkerEnv(customEnvs), envs.GetContainerEnvs(customEnvs)...)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, key, api.DIFY_PLUGIN_STORAGE_LOCAL_ROOT),
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getWebContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"HOSTNAME": "", // set HOSTNAME to empty, to avoid Error: getaddrinfo ENOTFOUND
|
|
"CONSOLE_API_URL": api.DIFY_WEB_CONSOLE_API_URL,
|
|
"APP_API_URL": api.DIFY_WEB_APP_API_URL,
|
|
"SENTRY_DSN": api.DIFY_WEB_SENTRY_DSN,
|
|
"NEXT_TELEMETRY_DISABLED": api.DIFY_WEB_NEXT_TELEMETRY_DISABLED,
|
|
"TEXT_GENERATION_TIMEOUT_MS": api.DIFY_WEB_TEXT_GENERATION_TIMEOUT_MS,
|
|
"CSP_WHITELIST": api.DIFY_WEB_CSP_WHITELIST,
|
|
"ALLOW_EMBED": api.DIFY_WEB_ALLOW_EMBED,
|
|
"ALLOW_UNSAFE_DATA_SCHEME": api.DIFY_WEB_ALLOW_UNSAFE_DATA_SCHEME,
|
|
"MARKETPLACE_API_URL": api.DIFY_WEB_MARKETPLACE_API_URL,
|
|
"MARKETPLACE_URL": api.DIFY_WEB_MARKETPLACE_URL,
|
|
"TOP_K_MAX_VALUE": api.DIFY_WEB_TOP_K_MAX_VALUE,
|
|
"INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH": api.DIFY_WEB_INDEXING_MAX_SEGMENTATION_TOKENS_LENGTH,
|
|
"PM2_INSTANCES": api.DIFY_WEB_PM2_INSTANCES,
|
|
"LOOP_NODE_MAX_COUNT": api.DIFY_WEB_LOOP_NODE_MAX_COUNT,
|
|
"MAX_TOOLS_NUM": api.DIFY_WEB_MAX_TOOLS_NUM,
|
|
"MAX_PARALLEL_LIMIT": api.DIFY_WEB_MAX_PARALLEL_LIMIT,
|
|
"MAX_ITERATIONS_NUM": api.DIFY_WEB_MAX_ITERATIONS_NUM,
|
|
"ENABLE_WEBSITE_JINAREADER": api.DIFY_WEB_ENABLE_WEBSITE_JINAREADER,
|
|
"ENABLE_WEBSITE_FIRECRAWL": api.DIFY_WEB_ENABLE_WEBSITE_FIRECRAWL,
|
|
"ENABLE_WEBSITE_WATERCRAWL": api.DIFY_WEB_ENABLE_WEBSITE_WATERCRAWL,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getSsrfContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
// "VISIBLE_HOSTNAME": "localhost", // set VISIBLE_HOSTNAME to localhost, to avoid rDNS test failed
|
|
"HTTP_PORT": api.DIFY_SSRF_HTTP_PORT,
|
|
"COREDUMP_DIR": api.DIFY_SSRF_COREDUMP_DIR,
|
|
"REVERSE_PROXY_PORT": api.DIFY_SANDBOX_PORT,
|
|
"SANDBOX_HOST": api.DIFY_LOCALHOST,
|
|
"SANDBOX_PORT": api.DIFY_SANDBOX_PORT,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
// ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
// getPVCMount(key, key, api.SSRF_MOUNT_PATH),
|
|
// }
|
|
|
|
// generate entrypoint
|
|
entrypointSH := fmt.Sprintf(api.DIFY_SSRF_ENTRYPINT_SHELL, api.DIFY_SSRF_SQUID_CONFIGURATION_FILE)
|
|
ctr.Command = []string{
|
|
"/bin/sh", "-c", entrypointSH,
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getNginxContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set depends on
|
|
ctr.DependsOn = []string{
|
|
name + "-" + api.DIFY_API_KEY,
|
|
name + "-" + api.DIFY_WEB_KEY,
|
|
}
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"NGINX_SERVER_NAME": api.DIFY_NGINX_SERVER_NAME,
|
|
"NGINX_PORT": api.DIFY_NGINX_PORT,
|
|
"NGINX_WORKER_PROCESSES": api.DIFY_NGINX_WORKER_PROCESSES,
|
|
"NGINX_CLIENT_MAX_BODY_SIZE": api.DIFY_NGINX_CLIENT_MAX_BODY_SIZE,
|
|
"NGINX_KEEPALIVE_TIMEOUT": api.DIFY_NGINX_KEEPALIVE_TIMEOUT,
|
|
"NGINX_PROXY_READ_TIMEOUT": api.DIFY_NGINX_PROXY_READ_TIMEOUT,
|
|
"NGINX_PROXY_SEND_TIMEOUT": api.DIFY_NGINX_PROXY_SEND_TIMEOUT,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, key, api.DIFY_NGINX_MOUNT_PATH),
|
|
}
|
|
|
|
// generate entrypoint
|
|
entrypointSH := fmt.Sprintf(api.DIFY_NGINX_ENTRYPINT_SHELL, api.DIFY_NGINX_NGINX_CONF_FILE, api.DIFY_NGINX_PROXY_CONF_FILE, api.DIFY_NGINX_DEFAULT_CONF_FILE)
|
|
ctr.Command = []string{
|
|
"/bin/sh", "-c", entrypointSH,
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getWeaviateContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"PERSISTENCE_DATA_PATH": api.DIFY_WEAVIATE_PERSISTENCE_DATA_PATH,
|
|
"QUERY_DEFAULTS_LIMIT": api.DIFY_WEAVIATE_QUERY_DEFAULTS_LIMIT,
|
|
"AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED": api.DIFY_WEAVIATE_AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED,
|
|
"DEFAULT_VECTORIZER_MODULE": api.DIFY_WEAVIATE_DEFAULT_VECTORIZER_MODULE,
|
|
"CLUSTER_HOSTNAME": api.DIFY_WEAVIATE_CLUSTER_HOSTNAME,
|
|
"AUTHENTICATION_APIKEY_ENABLED": api.DIFY_WEAVIATE_AUTHENTICATION_APIKEY_ENABLED,
|
|
"AUTHENTICATION_APIKEY_ALLOWED_KEYS": api.DIFY_WEAVIATE_AUTHENTICATION_APIKEY_ALLOWED_KEYS,
|
|
"AUTHENTICATION_APIKEY_USERS": api.DIFY_WEAVIATE_AUTHENTICATION_APIKEY_USERS,
|
|
"AUTHORIZATION_ADMINLIST_ENABLED": api.DIFY_WEAVIATE_AUTHORIZATION_ADMINLIST_ENABLED,
|
|
"AUTHORIZATION_ADMINLIST_USERS": api.DIFY_WEAVIATE_AUTHORIZATION_ADMINLIST_USERS,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key, key, api.DIFY_WEAVIATE_PERSISTENCE_DATA_PATH),
|
|
}
|
|
|
|
return ctr
|
|
}
|
|
|
|
func getSandboxContainer(name, key, image string, customEnvs *DifyContainerEnv) *computeapi.PodContainerCreateInput {
|
|
// set name and image
|
|
ctr := &computeapi.PodContainerCreateInput{
|
|
Name: name + "-" + key,
|
|
}
|
|
ctr.Image = image
|
|
|
|
// set container environments
|
|
envs := &DifyContainerEnv{
|
|
"API_KEY": api.DIFY_SANDBOX_API_KEY,
|
|
"GIN_MODE": api.DIFY_SANDBOX_GIN_MODE,
|
|
"WORKER_TIMEOUT": api.DIFY_SANDBOX_WORKER_TIMEOUT,
|
|
"ENABLE_NETWORK": api.DIFY_SANDBOX_ENABLE_NETWORK,
|
|
"HTTP_PROXY": api.DIFY_SANDBOX_HTTP_PROXY,
|
|
"HTTPS_PROXY": api.DIFY_SANDBOX_HTTPS_PROXY,
|
|
"SANDBOX_PORT": api.DIFY_SANDBOX_PORT,
|
|
"PIP_MIRROR_URL": api.PIP_MIRROR_URL,
|
|
}
|
|
ctr.Envs = envs.GetContainerEnvs(customEnvs)
|
|
|
|
// set PVC to store data
|
|
ctr.VolumeMounts = []*apis.ContainerVolumeMount{
|
|
getPVCMount(key+"conf", key+"conf", api.DIFY_SANDBOX_CONF_MOUNT_PATH),
|
|
getPVCMount(key+"dep", key+"dep", api.DIFY_SANDBOX_DEP_MOUNT_PATH),
|
|
}
|
|
|
|
// set command
|
|
writeConfigCommand := fmt.Sprintf(api.DIFY_SANDBOX_WRITE_CONF_SHELL, api.DIFY_SANDBOX_CONF_FILE, api.DIFY_SANDBOX_CONF_TEMP_FILE)
|
|
ctr.Command = []string{
|
|
"/bin/sh", "-c", writeConfigCommand,
|
|
}
|
|
|
|
return ctr
|
|
}
|