feat: config center (#2997)

* chore: config * chore: config * chore: config * chore: config * chore: config * feat: config * fix: config * fix: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * feat: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config * fix: config
2026-05-12 21:16:00 +08:00 · 2024-12-25 18:08:08 +08:00
parent 66abd9e1b9
commit 1110af98ef
43 changed files with 1042 additions and 281 deletions
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/api"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -31,16 +32,36 @@ type ApiCmd struct {
 }

 func NewApiCmd() *ApiCmd {
-	var apiConfig api.Config
+	apiConfig := api.Config{AllConfig: &config.AllConfig{}}
 	ret := &ApiCmd{apiConfig: &apiConfig}
 	ret.configMap = map[string]any{
-		OpenIMAPICfgFileName:    &apiConfig.API,
-		ShareFileName:           &apiConfig.Share,
-		DiscoveryConfigFilename: &apiConfig.Discovery,
+		config.DiscoveryConfigFilename:          &apiConfig.Discovery,
+		config.KafkaConfigFileName:              &apiConfig.Kafka,
+		config.LocalCacheConfigFileName:         &apiConfig.LocalCache,
+		config.LogConfigFileName:                &apiConfig.Log,
+		config.MinioConfigFileName:              &apiConfig.Minio,
+		config.MongodbConfigFileName:            &apiConfig.Mongo,
+		config.NotificationFileName:             &apiConfig.Notification,
+		config.OpenIMAPICfgFileName:             &apiConfig.API,
+		config.OpenIMCronTaskCfgFileName:        &apiConfig.CronTask,
+		config.OpenIMMsgGatewayCfgFileName:      &apiConfig.MsgGateway,
+		config.OpenIMMsgTransferCfgFileName:     &apiConfig.MsgTransfer,
+		config.OpenIMPushCfgFileName:            &apiConfig.Push,
+		config.OpenIMRPCAuthCfgFileName:         &apiConfig.Auth,
+		config.OpenIMRPCConversationCfgFileName: &apiConfig.Conversation,
+		config.OpenIMRPCFriendCfgFileName:       &apiConfig.Friend,
+		config.OpenIMRPCGroupCfgFileName:        &apiConfig.Group,
+		config.OpenIMRPCMsgCfgFileName:          &apiConfig.Msg,
+		config.OpenIMRPCThirdCfgFileName:        &apiConfig.Third,
+		config.OpenIMRPCUserCfgFileName:         &apiConfig.User,
+		config.RedisConfigFileName:              &apiConfig.Redis,
+		config.ShareFileName:                    &apiConfig.Share,
+		config.WebhooksConfigFileName:           &apiConfig.Webhooks,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
 	ret.Command.RunE = func(cmd *cobra.Command, args []string) error {
+		apiConfig.ConfigPath = ret.configPath
 		return ret.runE()
 	}
 	return ret
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/auth"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,10 +36,10 @@ func NewAuthRpcCmd() *AuthRpcCmd {
 	var authConfig auth.Config
 	ret := &AuthRpcCmd{authConfig: &authConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCAuthCfgFileName: &authConfig.RpcConfig,
-		RedisConfigFileName:      &authConfig.RedisConfig,
-		ShareFileName:            &authConfig.Share,
-		DiscoveryConfigFilename:  &authConfig.Discovery,
+		config.OpenIMRPCAuthCfgFileName: &authConfig.RpcConfig,
+		config.RedisConfigFileName:      &authConfig.RedisConfig,
+		config.ShareFileName:            &authConfig.Share,
+		config.DiscoveryConfigFilename:  &authConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -56,5 +57,12 @@ func (a *AuthRpcCmd) Exec() error {
 func (a *AuthRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.authConfig.Discovery, &a.authConfig.RpcConfig.Prometheus, a.authConfig.RpcConfig.RPC.ListenIP,
 		a.authConfig.RpcConfig.RPC.RegisterIP, a.authConfig.RpcConfig.RPC.AutoSetPorts, a.authConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.authConfig.Discovery.RpcService.Auth, nil, a.authConfig, auth.Start)
+		a.Index(), a.authConfig.Discovery.RpcService.Auth, nil, a.authConfig,
+		[]string{
+			a.authConfig.RpcConfig.GetConfigFileName(),
+			a.authConfig.Share.GetConfigFileName(),
+			a.authConfig.RedisConfig.GetConfigFileName(),
+			a.authConfig.Discovery.GetConfigFileName(),
+		},
+		auth.Start)
 }
@@ -1,96 +0,0 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package cmd
-
-import (
-	"strings"
-)
-
-var (
-	FileName                         string
-	NotificationFileName             string
-	ShareFileName                    string
-	WebhooksConfigFileName           string
-	LocalCacheConfigFileName         string
-	KafkaConfigFileName              string
-	RedisConfigFileName              string
-	MongodbConfigFileName            string
-	MinioConfigFileName              string
-	LogConfigFileName                string
-	OpenIMAPICfgFileName             string
-	OpenIMCronTaskCfgFileName        string
-	OpenIMMsgGatewayCfgFileName      string
-	OpenIMMsgTransferCfgFileName     string
-	OpenIMPushCfgFileName            string
-	OpenIMRPCAuthCfgFileName         string
-	OpenIMRPCConversationCfgFileName string
-	OpenIMRPCFriendCfgFileName       string
-	OpenIMRPCGroupCfgFileName        string
-	OpenIMRPCMsgCfgFileName          string
-	OpenIMRPCThirdCfgFileName        string
-	OpenIMRPCUserCfgFileName         string
-	DiscoveryConfigFilename          string
-)
-
-var ConfigEnvPrefixMap map[string]string
-
-func init() {
-	FileName = "config.yaml"
-	NotificationFileName = "notification.yml"
-	ShareFileName = "share.yml"
-	WebhooksConfigFileName = "webhooks.yml"
-	LocalCacheConfigFileName = "local-cache.yml"
-	KafkaConfigFileName = "kafka.yml"
-	RedisConfigFileName = "redis.yml"
-	MongodbConfigFileName = "mongodb.yml"
-	MinioConfigFileName = "minio.yml"
-	LogConfigFileName = "log.yml"
-	OpenIMAPICfgFileName = "openim-api.yml"
-	OpenIMCronTaskCfgFileName = "openim-crontask.yml"
-	OpenIMMsgGatewayCfgFileName = "openim-msggateway.yml"
-	OpenIMMsgTransferCfgFileName = "openim-msgtransfer.yml"
-	OpenIMPushCfgFileName = "openim-push.yml"
-	OpenIMRPCAuthCfgFileName = "openim-rpc-auth.yml"
-	OpenIMRPCConversationCfgFileName = "openim-rpc-conversation.yml"
-	OpenIMRPCFriendCfgFileName = "openim-rpc-friend.yml"
-	OpenIMRPCGroupCfgFileName = "openim-rpc-group.yml"
-	OpenIMRPCMsgCfgFileName = "openim-rpc-msg.yml"
-	OpenIMRPCThirdCfgFileName = "openim-rpc-third.yml"
-	OpenIMRPCUserCfgFileName = "openim-rpc-user.yml"
-	DiscoveryConfigFilename = "discovery.yml"
-
-	ConfigEnvPrefixMap = make(map[string]string)
-	fileNames := []string{
-		FileName, NotificationFileName, ShareFileName, WebhooksConfigFileName,
-		KafkaConfigFileName, RedisConfigFileName,
-		MongodbConfigFileName, MinioConfigFileName, LogConfigFileName,
-		OpenIMAPICfgFileName, OpenIMCronTaskCfgFileName, OpenIMMsgGatewayCfgFileName,
-		OpenIMMsgTransferCfgFileName, OpenIMPushCfgFileName, OpenIMRPCAuthCfgFileName,
-		OpenIMRPCConversationCfgFileName, OpenIMRPCFriendCfgFileName, OpenIMRPCGroupCfgFileName,
-		OpenIMRPCMsgCfgFileName, OpenIMRPCThirdCfgFileName, OpenIMRPCUserCfgFileName, DiscoveryConfigFilename,
-	}
-
-	for _, fileName := range fileNames {
-		envKey := strings.TrimSuffix(strings.TrimSuffix(fileName, ".yml"), ".yaml")
-		envKey = "IMENV_" + envKey
-		envKey = strings.ToUpper(strings.ReplaceAll(envKey, "-", "_"))
-		ConfigEnvPrefixMap[fileName] = envKey
-	}
-}
-
-const (
-	FlagConf          = "config_folder_path"
-	FlagTransferIndex = "index"
-)
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/conversation"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,13 +36,13 @@ func NewConversationRpcCmd() *ConversationRpcCmd {
 	var conversationConfig conversation.Config
 	ret := &ConversationRpcCmd{conversationConfig: &conversationConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCConversationCfgFileName: &conversationConfig.RpcConfig,
-		RedisConfigFileName:              &conversationConfig.RedisConfig,
-		MongodbConfigFileName:            &conversationConfig.MongodbConfig,
-		ShareFileName:                    &conversationConfig.Share,
-		NotificationFileName:             &conversationConfig.NotificationConfig,
-		LocalCacheConfigFileName:         &conversationConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:          &conversationConfig.Discovery,
+		config.OpenIMRPCConversationCfgFileName: &conversationConfig.RpcConfig,
+		config.RedisConfigFileName:              &conversationConfig.RedisConfig,
+		config.MongodbConfigFileName:            &conversationConfig.MongodbConfig,
+		config.ShareFileName:                    &conversationConfig.Share,
+		config.NotificationFileName:             &conversationConfig.NotificationConfig,
+		config.LocalCacheConfigFileName:         &conversationConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:          &conversationConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -58,5 +59,15 @@ func (a *ConversationRpcCmd) Exec() error {
 func (a *ConversationRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.conversationConfig.Discovery, &a.conversationConfig.RpcConfig.Prometheus, a.conversationConfig.RpcConfig.RPC.ListenIP,
 		a.conversationConfig.RpcConfig.RPC.RegisterIP, a.conversationConfig.RpcConfig.RPC.AutoSetPorts, a.conversationConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.conversationConfig.Discovery.RpcService.Conversation, &a.conversationConfig.NotificationConfig, a.conversationConfig, conversation.Start)
+		a.Index(), a.conversationConfig.Discovery.RpcService.Conversation, &a.conversationConfig.NotificationConfig, a.conversationConfig,
+		[]string{
+			a.conversationConfig.RpcConfig.GetConfigFileName(),
+			a.conversationConfig.RedisConfig.GetConfigFileName(),
+			a.conversationConfig.MongodbConfig.GetConfigFileName(),
+			a.conversationConfig.NotificationConfig.GetConfigFileName(),
+			a.conversationConfig.Share.GetConfigFileName(),
+			a.conversationConfig.LocalCacheConfig.GetConfigFileName(),
+			a.conversationConfig.Discovery.GetConfigFileName(),
+		},
+		conversation.Start)
 }
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/tools"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -34,9 +35,9 @@ func NewCronTaskCmd() *CronTaskCmd {
 	var cronTaskConfig tools.CronTaskConfig
 	ret := &CronTaskCmd{cronTaskConfig: &cronTaskConfig}
 	ret.configMap = map[string]any{
-		OpenIMCronTaskCfgFileName: &cronTaskConfig.CronTask,
-		ShareFileName:             &cronTaskConfig.Share,
-		DiscoveryConfigFilename:   &cronTaskConfig.Discovery,
+		config.OpenIMCronTaskCfgFileName: &cronTaskConfig.CronTask,
+		config.ShareFileName:             &cronTaskConfig.Share,
+		config.DiscoveryConfigFilename:   &cronTaskConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/relation"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,14 +36,14 @@ func NewFriendRpcCmd() *FriendRpcCmd {
 	var relationConfig relation.Config
 	ret := &FriendRpcCmd{relationConfig: &relationConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCFriendCfgFileName: &relationConfig.RpcConfig,
-		RedisConfigFileName:        &relationConfig.RedisConfig,
-		MongodbConfigFileName:      &relationConfig.MongodbConfig,
-		ShareFileName:              &relationConfig.Share,
-		NotificationFileName:       &relationConfig.NotificationConfig,
-		WebhooksConfigFileName:     &relationConfig.WebhooksConfig,
-		LocalCacheConfigFileName:   &relationConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:    &relationConfig.Discovery,
+		config.OpenIMRPCFriendCfgFileName: &relationConfig.RpcConfig,
+		config.RedisConfigFileName:        &relationConfig.RedisConfig,
+		config.MongodbConfigFileName:      &relationConfig.MongodbConfig,
+		config.ShareFileName:              &relationConfig.Share,
+		config.NotificationFileName:       &relationConfig.NotificationConfig,
+		config.WebhooksConfigFileName:     &relationConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName:   &relationConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:    &relationConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -59,5 +60,16 @@ func (a *FriendRpcCmd) Exec() error {
 func (a *FriendRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.relationConfig.Discovery, &a.relationConfig.RpcConfig.Prometheus, a.relationConfig.RpcConfig.RPC.ListenIP,
 		a.relationConfig.RpcConfig.RPC.RegisterIP, a.relationConfig.RpcConfig.RPC.AutoSetPorts, a.relationConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.relationConfig.Discovery.RpcService.Friend, &a.relationConfig.NotificationConfig, a.relationConfig, relation.Start)
+		a.Index(), a.relationConfig.Discovery.RpcService.Friend, &a.relationConfig.NotificationConfig, a.relationConfig,
+		[]string{
+			a.relationConfig.RpcConfig.GetConfigFileName(),
+			a.relationConfig.RedisConfig.GetConfigFileName(),
+			a.relationConfig.MongodbConfig.GetConfigFileName(),
+			a.relationConfig.NotificationConfig.GetConfigFileName(),
+			a.relationConfig.Share.GetConfigFileName(),
+			a.relationConfig.WebhooksConfig.GetConfigFileName(),
+			a.relationConfig.LocalCacheConfig.GetConfigFileName(),
+			a.relationConfig.Discovery.GetConfigFileName(),
+		},
+		relation.Start)
 }
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/group"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/storage/versionctx"
 	"github.com/openimsdk/open-im-server/v3/version"
@@ -36,14 +37,14 @@ func NewGroupRpcCmd() *GroupRpcCmd {
 	var groupConfig group.Config
 	ret := &GroupRpcCmd{groupConfig: &groupConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCGroupCfgFileName: &groupConfig.RpcConfig,
-		RedisConfigFileName:       &groupConfig.RedisConfig,
-		MongodbConfigFileName:     &groupConfig.MongodbConfig,
-		ShareFileName:             &groupConfig.Share,
-		NotificationFileName:      &groupConfig.NotificationConfig,
-		WebhooksConfigFileName:    &groupConfig.WebhooksConfig,
-		LocalCacheConfigFileName:  &groupConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:   &groupConfig.Discovery,
+		config.OpenIMRPCGroupCfgFileName: &groupConfig.RpcConfig,
+		config.RedisConfigFileName:       &groupConfig.RedisConfig,
+		config.MongodbConfigFileName:     &groupConfig.MongodbConfig,
+		config.ShareFileName:             &groupConfig.Share,
+		config.NotificationFileName:      &groupConfig.NotificationConfig,
+		config.WebhooksConfigFileName:    &groupConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName:  &groupConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:   &groupConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -60,5 +61,16 @@ func (a *GroupRpcCmd) Exec() error {
 func (a *GroupRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.groupConfig.Discovery, &a.groupConfig.RpcConfig.Prometheus, a.groupConfig.RpcConfig.RPC.ListenIP,
 		a.groupConfig.RpcConfig.RPC.RegisterIP, a.groupConfig.RpcConfig.RPC.AutoSetPorts, a.groupConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.groupConfig.Discovery.RpcService.Group, &a.groupConfig.NotificationConfig, a.groupConfig, group.Start, versionctx.EnableVersionCtx())
+		a.Index(), a.groupConfig.Discovery.RpcService.Group, &a.groupConfig.NotificationConfig, a.groupConfig,
+		[]string{
+			a.groupConfig.RpcConfig.GetConfigFileName(),
+			a.groupConfig.RedisConfig.GetConfigFileName(),
+			a.groupConfig.MongodbConfig.GetConfigFileName(),
+			a.groupConfig.NotificationConfig.GetConfigFileName(),
+			a.groupConfig.Share.GetConfigFileName(),
+			a.groupConfig.WebhooksConfig.GetConfigFileName(),
+			a.groupConfig.LocalCacheConfig.GetConfigFileName(),
+			a.groupConfig.Discovery.GetConfigFileName(),
+		},
+		group.Start, versionctx.EnableVersionCtx())
 }
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/msg"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,15 +36,15 @@ func NewMsgRpcCmd() *MsgRpcCmd {
 	var msgConfig msg.Config
 	ret := &MsgRpcCmd{msgConfig: &msgConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCMsgCfgFileName:  &msgConfig.RpcConfig,
-		RedisConfigFileName:      &msgConfig.RedisConfig,
-		MongodbConfigFileName:    &msgConfig.MongodbConfig,
-		KafkaConfigFileName:      &msgConfig.KafkaConfig,
-		ShareFileName:            &msgConfig.Share,
-		NotificationFileName:     &msgConfig.NotificationConfig,
-		WebhooksConfigFileName:   &msgConfig.WebhooksConfig,
-		LocalCacheConfigFileName: &msgConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:  &msgConfig.Discovery,
+		config.OpenIMRPCMsgCfgFileName:  &msgConfig.RpcConfig,
+		config.RedisConfigFileName:      &msgConfig.RedisConfig,
+		config.MongodbConfigFileName:    &msgConfig.MongodbConfig,
+		config.KafkaConfigFileName:      &msgConfig.KafkaConfig,
+		config.ShareFileName:            &msgConfig.Share,
+		config.NotificationFileName:     &msgConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &msgConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &msgConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &msgConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -60,5 +61,17 @@ func (a *MsgRpcCmd) Exec() error {
 func (a *MsgRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.msgConfig.Discovery, &a.msgConfig.RpcConfig.Prometheus, a.msgConfig.RpcConfig.RPC.ListenIP,
 		a.msgConfig.RpcConfig.RPC.RegisterIP, a.msgConfig.RpcConfig.RPC.AutoSetPorts, a.msgConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.msgConfig.Discovery.RpcService.Msg, &a.msgConfig.NotificationConfig, a.msgConfig, msg.Start)
+		a.Index(), a.msgConfig.Discovery.RpcService.Msg, &a.msgConfig.NotificationConfig, a.msgConfig,
+		[]string{
+			a.msgConfig.RpcConfig.GetConfigFileName(),
+			a.msgConfig.RedisConfig.GetConfigFileName(),
+			a.msgConfig.MongodbConfig.GetConfigFileName(),
+			a.msgConfig.KafkaConfig.GetConfigFileName(),
+			a.msgConfig.NotificationConfig.GetConfigFileName(),
+			a.msgConfig.Share.GetConfigFileName(),
+			a.msgConfig.WebhooksConfig.GetConfigFileName(),
+			a.msgConfig.LocalCacheConfig.GetConfigFileName(),
+			a.msgConfig.Discovery.GetConfigFileName(),
+		},
+		msg.Start)
 }
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/msggateway"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/version"

 	"github.com/openimsdk/tools/system/program"
@@ -35,11 +36,11 @@ func NewMsgGatewayCmd() *MsgGatewayCmd {
 	var msgGatewayConfig msggateway.Config
 	ret := &MsgGatewayCmd{msgGatewayConfig: &msgGatewayConfig}
 	ret.configMap = map[string]any{
-		OpenIMMsgGatewayCfgFileName: &msgGatewayConfig.MsgGateway,
-		ShareFileName:               &msgGatewayConfig.Share,
-		RedisConfigFileName:         &msgGatewayConfig.RedisConfig,
-		WebhooksConfigFileName:      &msgGatewayConfig.WebhooksConfig,
-		DiscoveryConfigFilename:     &msgGatewayConfig.Discovery,
+		config.OpenIMMsgGatewayCfgFileName: &msgGatewayConfig.MsgGateway,
+		config.ShareFileName:               &msgGatewayConfig.Share,
+		config.RedisConfigFileName:         &msgGatewayConfig.RedisConfig,
+		config.WebhooksConfigFileName:      &msgGatewayConfig.WebhooksConfig,
+		config.DiscoveryConfigFilename:     &msgGatewayConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/msgtransfer"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
 	"github.com/spf13/cobra"
@@ -34,13 +35,13 @@ func NewMsgTransferCmd() *MsgTransferCmd {
 	var msgTransferConfig msgtransfer.Config
 	ret := &MsgTransferCmd{msgTransferConfig: &msgTransferConfig}
 	ret.configMap = map[string]any{
-		OpenIMMsgTransferCfgFileName: &msgTransferConfig.MsgTransfer,
-		RedisConfigFileName:          &msgTransferConfig.RedisConfig,
-		MongodbConfigFileName:        &msgTransferConfig.MongodbConfig,
-		KafkaConfigFileName:          &msgTransferConfig.KafkaConfig,
-		ShareFileName:                &msgTransferConfig.Share,
-		WebhooksConfigFileName:       &msgTransferConfig.WebhooksConfig,
-		DiscoveryConfigFilename:      &msgTransferConfig.Discovery,
+		config.OpenIMMsgTransferCfgFileName: &msgTransferConfig.MsgTransfer,
+		config.RedisConfigFileName:          &msgTransferConfig.RedisConfig,
+		config.MongodbConfigFileName:        &msgTransferConfig.MongodbConfig,
+		config.KafkaConfigFileName:          &msgTransferConfig.KafkaConfig,
+		config.ShareFileName:                &msgTransferConfig.Share,
+		config.WebhooksConfigFileName:       &msgTransferConfig.WebhooksConfig,
+		config.DiscoveryConfigFilename:      &msgTransferConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -15,6 +15,7 @@
 package cmd

 import (
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/spf13/cobra"
 )

@@ -26,11 +27,11 @@ func (m *MsgUtilsCmd) AddUserIDFlag() {
 	m.Command.PersistentFlags().StringP("userID", "u", "", "openIM userID")
 }
 func (m *MsgUtilsCmd) AddIndexFlag() {
-	m.Command.PersistentFlags().IntP(FlagTransferIndex, "i", 0, "process startup sequence number")
+	m.Command.PersistentFlags().IntP(config.FlagTransferIndex, "i", 0, "process startup sequence number")
 }

 func (m *MsgUtilsCmd) AddConfigDirFlag() {
-	m.Command.PersistentFlags().StringP(FlagConf, "c", "", "path of config directory")
+	m.Command.PersistentFlags().StringP(config.FlagConf, "c", "", "path of config directory")

 }

@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/push"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,14 +36,14 @@ func NewPushRpcCmd() *PushRpcCmd {
 	var pushConfig push.Config
 	ret := &PushRpcCmd{pushConfig: &pushConfig}
 	ret.configMap = map[string]any{
-		OpenIMPushCfgFileName:    &pushConfig.RpcConfig,
-		RedisConfigFileName:      &pushConfig.RedisConfig,
-		KafkaConfigFileName:      &pushConfig.KafkaConfig,
-		ShareFileName:            &pushConfig.Share,
-		NotificationFileName:     &pushConfig.NotificationConfig,
-		WebhooksConfigFileName:   &pushConfig.WebhooksConfig,
-		LocalCacheConfigFileName: &pushConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:  &pushConfig.Discovery,
+		config.OpenIMPushCfgFileName:    &pushConfig.RpcConfig,
+		config.RedisConfigFileName:      &pushConfig.RedisConfig,
+		config.KafkaConfigFileName:      &pushConfig.KafkaConfig,
+		config.ShareFileName:            &pushConfig.Share,
+		config.NotificationFileName:     &pushConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &pushConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &pushConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &pushConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -60,5 +61,16 @@ func (a *PushRpcCmd) Exec() error {
 func (a *PushRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.pushConfig.Discovery, &a.pushConfig.RpcConfig.Prometheus, a.pushConfig.RpcConfig.RPC.ListenIP,
 		a.pushConfig.RpcConfig.RPC.RegisterIP, a.pushConfig.RpcConfig.RPC.AutoSetPorts, a.pushConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.pushConfig.Discovery.RpcService.Push, &a.pushConfig.NotificationConfig, a.pushConfig, push.Start)
+		a.Index(), a.pushConfig.Discovery.RpcService.Push, &a.pushConfig.NotificationConfig, a.pushConfig,
+		[]string{
+			a.pushConfig.RpcConfig.GetConfigFileName(),
+			a.pushConfig.RedisConfig.GetConfigFileName(),
+			a.pushConfig.KafkaConfig.GetConfigFileName(),
+			a.pushConfig.NotificationConfig.GetConfigFileName(),
+			a.pushConfig.Share.GetConfigFileName(),
+			a.pushConfig.WebhooksConfig.GetConfigFileName(),
+			a.pushConfig.LocalCacheConfig.GetConfigFileName(),
+			a.pushConfig.Discovery.GetConfigFileName(),
+		},
+		push.Start)
 }
@@ -1,28 +1,20 @@
-// Copyright © 2023 OpenIM. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
 package cmd

 import (
+	"context"
+	"encoding/json"
 	"fmt"

 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
+	kdisc "github.com/openimsdk/open-im-server/v3/pkg/common/discovery"
+	disetcd "github.com/openimsdk/open-im-server/v3/pkg/common/discovery/etcd"
 	"github.com/openimsdk/open-im-server/v3/version"
+	"github.com/openimsdk/tools/discovery/etcd"
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/utils/runtimeenv"
 	"github.com/spf13/cobra"
+	clientv3 "go.etcd.io/etcd/client/v3"
 )

 type RootCmd struct {
@@ -33,6 +25,7 @@ type RootCmd struct {
 	log            config.Log
 	index          int
 	configPath     string
+	etcdClient     *clientv3.Client
 }

 func (r *RootCmd) ConfigPath() string {
@@ -80,19 +73,43 @@ func NewRootCmd(processName string, opts ...func(*CmdOpts)) *RootCmd {
 		SilenceUsage:  true,
 		SilenceErrors: false,
 	}
-	cmd.Flags().StringP(FlagConf, "c", "", "path of config directory")
-	cmd.Flags().IntP(FlagTransferIndex, "i", 0, "process startup sequence number")
+	cmd.Flags().StringP(config.FlagConf, "c", "", "path of config directory")
+	cmd.Flags().IntP(config.FlagTransferIndex, "i", 0, "process startup sequence number")

 	rootCmd.Command = cmd
 	return rootCmd
 }

+func (r *RootCmd) initEtcd() error {
+	configDirectory, _, err := r.getFlag(&r.Command)
+	if err != nil {
+		return err
+	}
+	disConfig := config.Discovery{}
+	env := runtimeenv.PrintRuntimeEnvironment()
+	err = config.Load(configDirectory, config.DiscoveryConfigFilename, config.EnvPrefixMap[config.DiscoveryConfigFilename],
+		env, &disConfig)
+	if err != nil {
+		return err
+	}
+	if disConfig.Enable == config.ETCD {
+		discov, _ := kdisc.NewDiscoveryRegister(&disConfig, env)
+		r.etcdClient = discov.(*etcd.SvcDiscoveryRegistryImpl).GetClient()
+	}
+	return nil
+}
+
 func (r *RootCmd) persistentPreRun(cmd *cobra.Command, opts ...func(*CmdOpts)) error {
+	if err := r.initEtcd(); err != nil {
+		return err
+	}
 	cmdOpts := r.applyOptions(opts...)
 	if err := r.initializeConfiguration(cmd, cmdOpts); err != nil {
 		return err
 	}
-
+	if err := r.updateConfigFromEtcd(cmdOpts); err != nil {
+		return err
+	}
 	if err := r.initializeLogger(cmdOpts); err != nil {
 		return errs.WrapMsg(err, "failed to initialize logger")
 	}
@@ -111,13 +128,43 @@ func (r *RootCmd) initializeConfiguration(cmd *cobra.Command, opts *CmdOpts) err
 	// Load common configuration file
 	//opts.configMap[ShareFileName] = StructEnvPrefix{EnvPrefix: shareEnvPrefix, ConfigStruct: &r.share}
 	for configFileName, configStruct := range opts.configMap {
-		err := config.Load(configDirectory, configFileName, ConfigEnvPrefixMap[configFileName], runtimeEnv, configStruct)
+		err := config.Load(configDirectory, configFileName, config.EnvPrefixMap[configFileName], runtimeEnv, configStruct)
 		if err != nil {
 			return err
 		}
 	}
 	// Load common log configuration file
-	return config.Load(configDirectory, LogConfigFileName, ConfigEnvPrefixMap[LogConfigFileName], runtimeEnv, &r.log)
+	return config.Load(configDirectory, config.LogConfigFileName, config.EnvPrefixMap[config.LogConfigFileName], runtimeEnv, &r.log)
+}
+
+func (r *RootCmd) updateConfigFromEtcd(opts *CmdOpts) error {
+	if r.etcdClient == nil {
+		return nil
+	}
+
+	update := func(configFileName string, configStruct any) error {
+		key := disetcd.BuildKey(configFileName)
+		etcdRes, err := r.etcdClient.Get(context.TODO(), key)
+		if err != nil || etcdRes.Count == 0 {
+			return nil
+		}
+		err = json.Unmarshal(etcdRes.Kvs[0].Value, configStruct)
+		if err != nil {
+			return errs.WrapMsg(err, "failed to unmarshal config from etcd")
+		}
+		return nil
+	}
+	for configFileName, configStruct := range opts.configMap {
+		if err := update(configFileName, configStruct); err != nil {
+			return err
+		}
+	}
+	if err := update(config.LogConfigFileName, &r.log); err != nil {
+		return err
+	}
+	// Load common log configuration file
+	return nil
+
 }

 func (r *RootCmd) applyOptions(opts ...func(*CmdOpts)) *CmdOpts {
@@ -158,12 +205,12 @@ func defaultCmdOpts() *CmdOpts {
 }

 func (r *RootCmd) getFlag(cmd *cobra.Command) (string, int, error) {
-	configDirectory, err := cmd.Flags().GetString(FlagConf)
+	configDirectory, err := cmd.Flags().GetString(config.FlagConf)
 	if err != nil {
 		return "", 0, errs.Wrap(err)
 	}
 	r.configPath = configDirectory
-	index, err := cmd.Flags().GetInt(FlagTransferIndex)
+	index, err := cmd.Flags().GetInt(config.FlagTransferIndex)
 	if err != nil {
 		return "", 0, errs.Wrap(err)
 	}
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/third"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,14 +36,14 @@ func NewThirdRpcCmd() *ThirdRpcCmd {
 	var thirdConfig third.Config
 	ret := &ThirdRpcCmd{thirdConfig: &thirdConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCThirdCfgFileName: &thirdConfig.RpcConfig,
-		RedisConfigFileName:       &thirdConfig.RedisConfig,
-		MongodbConfigFileName:     &thirdConfig.MongodbConfig,
-		ShareFileName:             &thirdConfig.Share,
-		NotificationFileName:      &thirdConfig.NotificationConfig,
-		MinioConfigFileName:       &thirdConfig.MinioConfig,
-		LocalCacheConfigFileName:  &thirdConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:   &thirdConfig.Discovery,
+		config.OpenIMRPCThirdCfgFileName: &thirdConfig.RpcConfig,
+		config.RedisConfigFileName:       &thirdConfig.RedisConfig,
+		config.MongodbConfigFileName:     &thirdConfig.MongodbConfig,
+		config.ShareFileName:             &thirdConfig.Share,
+		config.NotificationFileName:      &thirdConfig.NotificationConfig,
+		config.MinioConfigFileName:       &thirdConfig.MinioConfig,
+		config.LocalCacheConfigFileName:  &thirdConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:   &thirdConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -59,5 +60,16 @@ func (a *ThirdRpcCmd) Exec() error {
 func (a *ThirdRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.thirdConfig.Discovery, &a.thirdConfig.RpcConfig.Prometheus, a.thirdConfig.RpcConfig.RPC.ListenIP,
 		a.thirdConfig.RpcConfig.RPC.RegisterIP, a.thirdConfig.RpcConfig.RPC.AutoSetPorts, a.thirdConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.thirdConfig.Discovery.RpcService.Third, &a.thirdConfig.NotificationConfig, a.thirdConfig, third.Start)
+		a.Index(), a.thirdConfig.Discovery.RpcService.Third, &a.thirdConfig.NotificationConfig, a.thirdConfig,
+		[]string{
+			a.thirdConfig.RpcConfig.GetConfigFileName(),
+			a.thirdConfig.RedisConfig.GetConfigFileName(),
+			a.thirdConfig.MongodbConfig.GetConfigFileName(),
+			a.thirdConfig.NotificationConfig.GetConfigFileName(),
+			a.thirdConfig.Share.GetConfigFileName(),
+			a.thirdConfig.MinioConfig.GetConfigFileName(),
+			a.thirdConfig.LocalCacheConfig.GetConfigFileName(),
+			a.thirdConfig.Discovery.GetConfigFileName(),
+		},
+		third.Start)
 }
@@ -18,6 +18,7 @@ import (
 	"context"

 	"github.com/openimsdk/open-im-server/v3/internal/rpc/user"
+	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/startrpc"
 	"github.com/openimsdk/open-im-server/v3/version"
 	"github.com/openimsdk/tools/system/program"
@@ -35,15 +36,15 @@ func NewUserRpcCmd() *UserRpcCmd {
 	var userConfig user.Config
 	ret := &UserRpcCmd{userConfig: &userConfig}
 	ret.configMap = map[string]any{
-		OpenIMRPCUserCfgFileName: &userConfig.RpcConfig,
-		RedisConfigFileName:      &userConfig.RedisConfig,
-		MongodbConfigFileName:    &userConfig.MongodbConfig,
-		KafkaConfigFileName:      &userConfig.KafkaConfig,
-		ShareFileName:            &userConfig.Share,
-		NotificationFileName:     &userConfig.NotificationConfig,
-		WebhooksConfigFileName:   &userConfig.WebhooksConfig,
-		LocalCacheConfigFileName: &userConfig.LocalCacheConfig,
-		DiscoveryConfigFilename:  &userConfig.Discovery,
+		config.OpenIMRPCUserCfgFileName: &userConfig.RpcConfig,
+		config.RedisConfigFileName:      &userConfig.RedisConfig,
+		config.MongodbConfigFileName:    &userConfig.MongodbConfig,
+		config.KafkaConfigFileName:      &userConfig.KafkaConfig,
+		config.ShareFileName:            &userConfig.Share,
+		config.NotificationFileName:     &userConfig.NotificationConfig,
+		config.WebhooksConfigFileName:   &userConfig.WebhooksConfig,
+		config.LocalCacheConfigFileName: &userConfig.LocalCacheConfig,
+		config.DiscoveryConfigFilename:  &userConfig.Discovery,
 	}
 	ret.RootCmd = NewRootCmd(program.GetProcessName(), WithConfigMap(ret.configMap))
 	ret.ctx = context.WithValue(context.Background(), "version", version.Version)
@@ -60,5 +61,17 @@ func (a *UserRpcCmd) Exec() error {
 func (a *UserRpcCmd) runE() error {
 	return startrpc.Start(a.ctx, &a.userConfig.Discovery, &a.userConfig.RpcConfig.Prometheus, a.userConfig.RpcConfig.RPC.ListenIP,
 		a.userConfig.RpcConfig.RPC.RegisterIP, a.userConfig.RpcConfig.RPC.AutoSetPorts, a.userConfig.RpcConfig.RPC.Ports,
-		a.Index(), a.userConfig.Discovery.RpcService.User, &a.userConfig.NotificationConfig, a.userConfig, user.Start)
+		a.Index(), a.userConfig.Discovery.RpcService.User, &a.userConfig.NotificationConfig, a.userConfig,
+		[]string{
+			a.userConfig.RpcConfig.GetConfigFileName(),
+			a.userConfig.RedisConfig.GetConfigFileName(),
+			a.userConfig.MongodbConfig.GetConfigFileName(),
+			a.userConfig.KafkaConfig.GetConfigFileName(),
+			a.userConfig.NotificationConfig.GetConfigFileName(),
+			a.userConfig.Share.GetConfigFileName(),
+			a.userConfig.WebhooksConfig.GetConfigFileName(),
+			a.userConfig.LocalCacheConfig.GetConfigFileName(),
+			a.userConfig.Discovery.GetConfigFileName(),
+		},
+		user.Start)
 }