分布式配置中心

本篇是 Go 微服务系列的第六篇。微服务系统中配置无处不在：数据库连接、Redis 地址、限流阈值、功能开关、日志级别……如果把它们写死在代码或本地配置文件里，修改一次就要重新打包部署，运维成本极高。配置中心（Config Center）就是为了集中化、动态化管理这些配置而出现的。本篇将讲解配置中心的需求、Viper 的使用、从 Consul KV 读取配置、热更新实现、配置校验和多环境管理。

一、分布式配置的需求与挑战

1. 配置的演进

阶段一：写死在代码里 → 改配置要重新编译，灾难。
阶段二：本地配置文件（YAML/JSON）→ 改配置要重启，多实例难以同步。
阶段三：环境变量 → 适合简单场景，复杂结构难表达，无热更新。
阶段四：配置中心 → 集中管理、动态推送、版本审计、多环境隔离。

2. 配置中心的核心能力

集中存储：所有服务的配置统一存储在一处。
动态推送：配置变更后实时推送到客户端，无需重启。
版本管理：每次变更留痕，可回滚。
多环境隔离：dev / staging / prod 各自独立。
权限审计：谁能改哪些配置，何时改的，可追溯。
灰度发布：配置只对部分实例生效，验证后再全量推送。

3. 主流方案对比

方案	一致性	多数据中心	Go 生态	特点
Consul KV	CP (Raft)	原生支持	官方 SDK	与服务发现一体
Etcd	CP (Raft)	需自己搭	官方 SDK	K8s 底座，稳定
Apollo	最终一致	多机房	第三方 SDK	携程开源，UI 完善
Nacos	AP/CP	支持	第三方 SDK	阿里开源，配置 + 注册一体
Spring Cloud Config	取决于存储	弱	无官方 Go 客户端	Java 生态为主

本篇以 Consul KV 为例，因为它与服务发现天然集成，部署一套即可解决两个问题。

二、Viper 配置管理

1. Viper 简介

Viper 是 Go 生态最流行的配置库（spf13 出品），核心能力：

支持多种格式：JSON、YAML、TOML、HCL、env、.env。
多来源融合：文件、环境变量、命令行参数、远程 KV、默认值。
热更新：通过 WatchConfig 监听文件变化。
嵌套访问：用点号路径访问 a.b.c。
强类型解析：Unmarshal 到结构体。

2. 基础用法

package main

import (
	"fmt"
	"log"

	"github.com/spf13/viper"
)

type Config struct {
	Server struct {
		Host string `mapstructure:"host"`
		Port int    `mapstructure:"port"`
	} `mapstructure:"server"`
	DB struct {
		Driver string `mapstructure:"driver"`
		DSN    string `mapstructure:"dsn"`
	} `mapstructure:"db"`
	LogLevel string `mapstructure:"log_level"`
}

func main() {
	v := viper.New()
	// 默认值
	v.SetDefault("server.host", "0.0.0.0")
	v.SetDefault("server.port", 8080)
	v.SetDefault("log_level", "info")

	// 配置文件
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath(".")
	v.AddConfigPath("./configs")
	if err := v.ReadInConfig(); err != nil {
		log.Printf("read config failed: %v (use defaults)", err)
	}

	var cfg Config
	if err := v.Unmarshal(&cfg); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("config: %+v\n", cfg)
}

对应的 config.yaml：

yaml

server:
  host: 127.0.0.1
  port: 8080
db:
  driver: mysql
  dsn: "user:pass@tcp(localhost:3306)/app"
log_level: debug

3. 多来源优先级

Viper 按以下优先级（从高到低）合并配置：

显式 Set 调用
命令行 flag
环境变量
配置文件
远程 KV（Consul / Etcd）
默认值

这种优先级让「本地覆盖远程、环境覆盖文件」成为可能，部署非常灵活。

三、从环境变量、文件、Consul KV 读取配置

1. 环境变量

package main

import (
	"fmt"
	"log"

	"github.com/spf13/viper"
)

func main() {
	v := viper.New()
	v.AutomaticEnv() // 自动把 key 转成大写下划线，如 server.port -> SERVER_PORT
	v.SetEnvPrefix("APP")
	// 自定义 key 与环境变量的映射
	v.BindEnv("db.dsn", "DATABASE_URL")
	v.BindEnv("server.port", "PORT")

	// 设置默认值
	v.SetDefault("server.host", "0.0.0.0")
	v.SetDefault("server.port", 8080)

	fmt.Printf("host=%s port=%d dsn=%s\n",
		v.GetString("server.host"),
		v.GetInt("server.port"),
		v.GetString("db.dsn"))
	log.Println("done")
}

启动时：

bash

APP_PORT=9090 DATABASE_URL="postgres://localhost/app" go run main.go

2. 多来源融合示例

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/spf13/viper"
)

func loadConfig() (*viper.Viper, error) {
	v := viper.New()

	// 默认值
	v.SetDefault("server.host", "0.0.0.0")
	v.SetDefault("server.port", 8080)
	v.SetDefault("log_level", "info")
	v.SetDefault("feature.new_ui", false)

	// 文件
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath("./configs")
	v.AddConfigPath(".")

	// 环境变量
	v.AutomaticEnv()
	v.SetEnvPrefix("APP")
	v.BindEnv("server.port", "APP_PORT")
	v.BindEnv("db.dsn", "DATABASE_URL")
	v.BindEnv("log_level", "LOG_LEVEL")

	// 命令行参数（手动解析示例）
	for i, arg := range os.Args {
		if arg == "--port" && i+1 < len(os.Args) {
			v.Set("server.port", os.Args[i+1])
		}
	}

	if err := v.ReadInConfig(); err != nil {
		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
			return nil, fmt.Errorf("read config: %w", err)
		}
		log.Println("no config file, use env / defaults")
	}
	return v, nil
}

func main() {
	v, err := loadConfig()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("server: %s:%d\n", v.GetString("server.host"), v.GetInt("server.port"))
	fmt.Printf("log_level: %s\n", v.GetString("log_level"))
	fmt.Printf("new_ui: %v\n", v.GetBool("feature.new_ui"))
}

3. 从 Consul KV 读取

Viper 内建对 Consul 的支持（通过 viper/remote）：

package main

import (
	"fmt"
	"log"

	"github.com/spf13/viper"
	_ "github.com/spf13/viper/remote"
)

func main() {
	v := viper.New()
	// 从 Consul 读取 config/app 路径下的配置（默认 JSON 编码）
	err := v.AddRemoteProvider("consul", "127.0.0.1:8500", "config/app")
	if err != nil {
		log.Fatal(err)
	}
	v.SetConfigType("json") // Consul KV 用 json 编码

	if err := v.ReadRemoteConfig(); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("server.port = %d\n", v.GetInt("server.port"))
	fmt.Printf("log_level = %s\n", v.GetString("log_level"))
}

在 Consul 中预先写入 KV：

bash

curl -X PUT http://localhost:8500/v1/kv/config/app \
  -d '{"server":{"port":9090},"log_level":"debug"}'

四、热更新配置实现

1. 文件热更新

Viper 的 WatchConfig 监听本地文件变化：

package main

import (
	"fmt"
	"log"
	"sync/atomic"
	"time"

	"github.com/fsnotify/fsnotify"
	"github.com/spf13/viper"
)

type DynamicConfig struct {
	LogLevel atomic.Value // string
	Port     atomic.Int32
}

func main() {
	v := viper.New()
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath(".")
	if err := v.ReadInConfig(); err != nil {
		log.Fatal(err)
	}

	cfg := &DynamicConfig{}
	cfg.LogLevel.Store(v.GetString("log_level"))
	cfg.Port.Store(int32(v.GetInt("server.port")))

	v.OnConfigChange(func(e fsnotify.Event) {
		log.Printf("config changed: %s", e.Name)
		cfg.LogLevel.Store(v.GetString("log_level"))
		cfg.Port.Store(int32(v.GetInt("server.port")))
	})
	v.WatchConfig()

	// 模拟业务逻辑读取最新配置
	for i := 0; i < 30; i++ {
		fmt.Printf("log_level=%s port=%d\n", cfg.LogLevel.Load(), cfg.Port.Load())
		time.Sleep(2 * time.Second)
	}
}

2. 远程 KV 热更新

Viper 提供 WatchRemoteConfig（注意：Consul KV 的 watch 是基于长轮询，延迟通常在几秒）：

package main

import (
	"fmt"
	"log"
	"sync/atomic"
	"time"

	"github.com/spf13/viper"
	_ "github.com/spf13/viper/remote"
)

func main() {
	v := viper.New()
	if err := v.AddRemoteProvider("consul", "127.0.0.1:8500", "config/app"); err != nil {
		log.Fatal(err)
	}
	v.SetConfigType("json")
	if err := v.ReadRemoteConfig(); err != nil {
		log.Fatal(err)
	}

	var logLevel atomic.Value
	logLevel.Store(v.GetString("log_level"))

	// 后台轮询拉取最新配置
	go func() {
		for {
			time.Sleep(5 * time.Second)
			if err := v.WatchRemoteConfig(); err != nil {
				log.Printf("watch remote failed: %v", err)
				continue
			}
			newLevel := v.GetString("log_level")
			if newLevel != logLevel.Load() {
				logLevel.Store(newLevel)
				log.Printf("log_level updated to: %s", newLevel)
			}
		}
	}()

	for i := 0; i < 60; i++ {
		fmt.Printf("current log_level=%s\n", logLevel.Load())
		time.Sleep(time.Second)
	}
}

3. 配置变更通知业务

热更新只是手段，目的是让业务代码感知变更。常见模式：

原子值：用 atomic.Value 存配置指针，业务每次读取最新值。
回调注册：业务方注册监听函数，配置变更时回调。
订阅 channel：配置变更通过 channel 推送。

回调模式示例：

package main

import (
	"log"
	"sync"

	"github.com/fsnotify/fsnotify"
	"github.com/spf13/viper"
)

type ConfigManager struct {
	v        *viper.Viper
	mu       sync.RWMutex
	listeners []func(*viper.Viper)
}

func NewConfigManager(path string) (*ConfigManager, error) {
	v := viper.New()
	v.SetConfigFile(path)
	if err := v.ReadInConfig(); err != nil {
		return nil, err
	}
	cm := &ConfigManager{v: v}
	v.OnConfigChange(func(e fsnotify.Event) {
		cm.mu.RLock()
		defer cm.mu.RUnlock()
		log.Printf("config changed, notifying %d listeners", len(cm.listeners))
		for _, fn := range cm.listeners {
			fn(cm.v)
		}
	})
	v.WatchConfig()
	return cm, nil
}

func (cm *ConfigManager) OnChange(fn func(*viper.Viper)) {
	cm.mu.Lock()
	defer cm.mu.Unlock()
	cm.listeners = append(cm.listeners, fn)
}

func (cm *ConfigManager) Get() *viper.Viper {
	return cm.v
}

func main() {
	cm, err := NewConfigManager("config.yaml")
	if err != nil {
		log.Fatal(err)
	}

	// 业务模块注册监听
	cm.OnChange(func(v *viper.Viper) {
		log.Printf("[logger] level changed to %s", v.GetString("log_level"))
	})
	cm.OnChange(func(v *viper.Viper) {
		log.Printf("[db] pool size changed to %d", v.GetInt("db.pool_size"))
	})

	// 业务读取当前配置
	log.Printf("init log_level=%s", cm.Get().GetString("log_level"))

	select {}
}

五、配置结构化与校验

1. Unmarshal 到结构体

把配置映射到结构体，方便业务使用：

package main

import (
	"fmt"
	"log"

	"github.com/spf13/viper"
)

type ServerConfig struct {
	Host         string `mapstructure:"host"`
	Port         int    `mapstructure:"port"`
	ReadTimeout  int    `mapstructure:"read_timeout"`
	WriteTimeout int    `mapstructure:"write_timeout"`
}

type DBConfig struct {
	Driver   string `mapstructure:"driver"`
	DSN      string `mapstructure:"dsn"`
	MaxOpen  int    `mapstructure:"max_open"`
	MaxIdle  int    `mapstructure:"max_idle"`
	MaxLife  int    `mapstructure:"max_life"`
}

type AppConfig struct {
	Server   ServerConfig `mapstructure:"server"`
	DB       DBConfig     `mapstructure:"db"`
	LogLevel string       `mapstructure:"log_level"`
	Features struct {
		NewUI    bool `mapstructure:"new_ui"`
		CacheTTL int  `mapstructure:"cache_ttl"`
	} `mapstructure:"features"`
}

func main() {
	v := viper.New()
	v.SetConfigFile("config.yaml")
	if err := v.ReadInConfig(); err != nil {
		log.Fatal(err)
	}

	var cfg AppConfig
	if err := v.Unmarshal(&cfg); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%+v\n", cfg)
}

2. 校验配置

Unmarshal 不做语义校验，需要借助 validator 库或自定义校验：

package main

import (
	"fmt"
	"log"

	"github.com/go-playground/validator/v10"
	"github.com/spf13/viper"
)

type ServerConfig struct {
	Host         string `mapstructure:"host" validate:"required"`
	Port         int    `mapstructure:"port" validate:"required,min=1,max=65535"`
	ReadTimeout  int    `mapstructure:"read_timeout" validate:"min=1"`
	WriteTimeout int    `mapstructure:"write_timeout" validate:"min=1"`
}

type DBConfig struct {
	Driver  string `mapstructure:"driver" validate:"required,oneof=mysql postgres"`
	DSN     string `mapstructure:"dsn" validate:"required"`
	MaxOpen int    `mapstructure:"max_open" validate:"min=1"`
	MaxIdle int    `mapstructure:"max_idle" validate:"min=1"`
}

type AppConfig struct {
	Server   ServerConfig `mapstructure:"server"`
	DB       DBConfig     `mapstructure:"db"`
	LogLevel string       `mapstructure:"log_level" validate:"oneof=debug info warn error"`
}

func LoadAndValidate(path string) (*AppConfig, error) {
	v := viper.New()
	v.SetConfigFile(path)
	if err := v.ReadInConfig(); err != nil {
		return nil, fmt.Errorf("read config: %w", err)
	}
	var cfg AppConfig
	if err := v.Unmarshal(&cfg); err != nil {
		return nil, fmt.Errorf("unmarshal: %w", err)
	}
	validate := validator.New()
	if err := validate.Struct(&cfg); err != nil {
		return nil, fmt.Errorf("validate: %w", err)
	}
	return &cfg, nil
}

func main() {
	cfg, err := LoadAndValidate("config.yaml")
	if err != nil {
		log.Fatalf("config invalid: %v", err)
	}
	log.Printf("config ok: port=%d db=%s", cfg.Server.Port, cfg.DB.Driver)
}

启动时若配置非法，进程直接退出，避免带病运行。

六、多环境配置管理

1. 多文件方案

最常见的多环境方案：

configs/
  config.yaml           # 通用默认值
  config.dev.yaml       # 开发环境覆盖
  config.staging.yaml   # 预发环境覆盖
  config.prod.yaml      # 生产环境覆盖

Viper 用 SetConfigName + AddConfigPath 加载。也可以分两次加载，让环境特定文件覆盖通用文件：

package main

import (
	"fmt"
	"os"

	"github.com/spf13/viper"
)

func loadConfig(env string) (*viper.Viper, error) {
	v := viper.New()
	v.SetConfigName("config")
	v.SetConfigType("yaml")
	v.AddConfigPath("./configs")
	if err := v.ReadInConfig(); err != nil {
		return nil, err
	}

	// 用环境特定文件覆盖
	override := viper.New()
	override.SetConfigName("config." + env)
	override.SetConfigType("yaml")
	override.AddConfigPath("./configs")
	if err := override.ReadInConfig(); err == nil {
		v.MergeConfigMap(override.AllSettings())
	}
	return v, nil
}

func main() {
	env := os.Getenv("APP_ENV")
	if env == "" {
		env = "dev"
	}
	v, err := loadConfig(env)
	if err != nil {
		panic(err)
	}
	fmt.Printf("env=%s port=%d log_level=%s\n",
		env, v.GetInt("server.port"), v.GetString("log_level"))
}

2. 单文件 + 环境段

也可以在一个文件里按环境分段：

yaml

default:
  server:
    host: 0.0.0.0
  log_level: info
dev:
  server:
    port: 8080
  db:
    dsn: "mysql://localhost/dev"
prod:
  server:
    port: 80
  db:
    dsn: "mysql://prod-db/app"

v.SetConfigType("yaml")
v.ReadInConfig()
// 取出特定段
sub := v.Sub(os.Getenv("APP_ENV"))

3. 12-Factor App 建议

《十二要素应用》建议：配置应该和环境严格分离，配置通过环境变量注入。

实践做法：

通用结构在配置文件中。
环境差异化部分（DB DSN、密钥、域名）通过环境变量注入。
容器编排平台（K8s ConfigMap / Secret）统一管理环境变量。

这样配置文件可随代码仓库提交，不包含任何环境敏感信息。

七、完整示例：基于 Consul 的配置中心

下面给出一个完整可运行的示例：从 Consul KV 读取配置，启动 HTTP 服务，支持热更新。

前置准备：启动 Consul 并写入配置：

bash

consul agent -dev -client=0.0.0.0

curl -X PUT http://localhost:8500/v1/kv/config/user-service \
  -d '{
    "server": {"port": 8080, "read_timeout": 10},
    "db": {"dsn": "mysql://localhost/app", "max_open": 50},
    "log_level": "info",
    "features": {"new_cache": true}
  }'

Go 代码：

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"sync/atomic"
	"syscall"
	"time"

	"github.com/hashicorp/consul/api"
)

// AppConfig 应用配置
type AppConfig struct {
	Server struct {
		Port        int `json:"port"`
		ReadTimeout int `json:"read_timeout"`
	} `json:"server"`
	DB struct {
		DSN     string `json:"dsn"`
		MaxOpen int    `json:"max_open"`
	} `json:"db"`
	LogLevel string `json:"log_level"`
	Features struct {
		NewCache bool `json:"new_cache"`
	} `json:"features"`
}

// ConfigManager 配置管理器，支持热更新
type ConfigManager struct {
	consul  *api.Client
	key     string
	current atomic.Value // *AppConfig
}

func NewConfigManager(consulAddr, key string) (*ConfigManager, error) {
	cfg := api.DefaultConfig()
	cfg.Address = consulAddr
	c, err := api.NewClient(cfg)
	if err != nil {
		return nil, err
	}
	cm := &ConfigManager{consul: c, key: key}
	if err := cm.reload(); err != nil {
		return nil, err
	}
	return cm, nil
}

func (cm *ConfigManager) reload() error {
	pair, _, err := cm.consul.KV().Get(cm.key, nil)
	if err != nil {
		return err
	}
	if pair == nil {
		return fmt.Errorf("config key %s not found", cm.key)
	}
	var cfg AppConfig
	if err := json.Unmarshal(pair.Value, &cfg); err != nil {
		return err
	}
	cm.current.Store(&cfg)
	log.Printf("[config] loaded: port=%d log_level=%s new_cache=%v",
		cfg.Server.Port, cfg.LogLevel, cfg.Features.NewCache)
	return nil
}

func (cm *ConfigManager) Get() *AppConfig {
	return cm.current.Load().(*AppConfig)
}

// Watch 长轮询监听配置变化
func (cm *ConfigManager) Watch(ctx context.Context) {
	var lastIndex uint64
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			default:
			}
			pair, meta, err := cm.consul.KV().Get(cm.key, &api.QueryOptions{
				WaitIndex: lastIndex,
				WaitTime:  30 * time.Second,
			})
			if err != nil {
				log.Printf("[config] watch err: %v", err)
				time.Sleep(3 * time.Second)
				continue
			}
			if meta.LastIndex > lastIndex {
				lastIndex = meta.LastIndex
				if pair != nil {
					var cfg AppConfig
					if err := json.Unmarshal(pair.Value, &cfg); err != nil {
						log.Printf("[config] parse err: %v", err)
						continue
					}
					cm.current.Store(&cfg)
					log.Printf("[config] updated: port=%d log_level=%s",
						cfg.Server.Port, cfg.LogLevel)
				}
			}
		}
	}()
}

func main() {
	consulAddr := "127.0.0.1:8500"
	configKey := "config/user-service"

	cm, err := NewConfigManager(consulAddr, configKey)
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	cm.Watch(ctx)

	mux := http.NewServeMux()
	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})
	// 暴露当前配置（调试用）
	mux.HandleFunc("/debug/config", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(cm.Get())
	})
	// 业务接口：根据配置开关决定行为
	mux.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
		cfg := cm.Get()
		if cfg.Features.NewCache {
			_, _ = fmt.Fprintf(w, "serving from cache (log_level=%s)\n", cfg.LogLevel)
			return
		}
		_, _ = fmt.Fprintf(w, "serving from db (log_level=%s)\n", cfg.LogLevel)
	})

	cfg := cm.Get()
	srv := &http.Server{
		Addr:         fmt.Sprintf(":%d", cfg.Server.Port),
		Handler:      mux,
		ReadTimeout:  time.Duration(cfg.Server.ReadTimeout) * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	go func() {
		log.Printf("server on :%d", cfg.Server.Port)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %v", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("shutting down")

	shutCtx, shutCancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer shutCancel()
	_ = srv.Shutdown(shutCtx)
}

启动后修改 Consul 中的配置：

bash

curl -X PUT http://localhost:8500/v1/kv/config/user-service \
  -d '{
    "server": {"port": 8080, "read_timeout": 10},
    "db": {"dsn": "mysql://localhost/app", "max_open": 50},
    "log_level": "debug",
    "features": {"new_cache": false}
  }'

你会看到日志打印 [config] updated: ...，再访问 /api/data 会发现行为已经改变——全程无需重启服务。

八、小结

本篇我们学习了分布式配置中心的设计与实现：

演进：从写死代码 → 本地文件 → 环境变量 → 配置中心。
核心能力：集中存储、动态推送、版本管理、多环境隔离、权限审计。
Viper：Go 生态主流配置库，支持多来源融合、热更新、嵌套访问、结构化解析。
多来源：默认值 < 配置文件 < 环境变量 < 命令行参数，可灵活覆盖。
Consul KV：与服务发现一体，通过长轮询实现 watch。
热更新模式：原子值（无锁读取）、回调注册、channel 推送。
配置校验：用 validator 在启动时校验，避免带病运行。
多环境：多文件 + Merge / 单文件分段 / 环境变量注入，推荐 12-Factor 风格。

下一篇我们将进入链路追踪与可观测性，学习 OpenTelemetry + Jaeger + Prometheus + Grafana 这套现代化的可观测性栈。

延伸阅读：
Viper 文档：https://github.com/spf13/viper
12-Factor App：https://12factor.net/zh_cn/config
Consul KV API：https://developer.hashicorp.com/consul/api-docs/kv

入门篇

进阶篇

资深篇

分布式配置中心

一、分布式配置的需求与挑战

1. 配置的演进

2. 配置中心的核心能力

3. 主流方案对比

二、Viper 配置管理

1. Viper 简介

2. 基础用法

3. 多来源优先级

三、从环境变量、文件、Consul KV 读取配置

1. 环境变量

2. 多来源融合示例

3. 从 Consul KV 读取

四、热更新配置实现

1. 文件热更新

2. 远程 KV 热更新

3. 配置变更通知业务

五、配置结构化与校验

1. Unmarshal 到结构体

2. 校验配置

六、多环境配置管理

1. 多文件方案

2. 单文件 + 环境段

3. 12-Factor App 建议

七、完整示例：基于 Consul 的配置中心

八、小结

分布式配置中心 ​

一、分布式配置的需求与挑战 ​

1. 配置的演进 ​

2. 配置中心的核心能力 ​

3. 主流方案对比 ​

二、Viper 配置管理 ​

1. Viper 简介 ​

2. 基础用法 ​

3. 多来源优先级 ​

三、从环境变量、文件、Consul KV 读取配置 ​

1. 环境变量 ​

2. 多来源融合示例 ​

3. 从 Consul KV 读取 ​

四、热更新配置实现 ​

1. 文件热更新 ​

2. 远程 KV 热更新 ​

3. 配置变更通知业务 ​

五、配置结构化与校验 ​

1. Unmarshal 到结构体 ​

2. 校验配置 ​

六、多环境配置管理 ​

1. 多文件方案 ​

2. 单文件 + 环境段 ​

3. 12-Factor App 建议 ​

七、完整示例：基于 Consul 的配置中心 ​

八、小结 ​

分布式配置中心

一、分布式配置的需求与挑战

1. 配置的演进

2. 配置中心的核心能力

3. 主流方案对比

二、Viper 配置管理

1. Viper 简介

2. 基础用法

3. 多来源优先级

三、从环境变量、文件、Consul KV 读取配置

1. 环境变量

2. 多来源融合示例

3. 从 Consul KV 读取

四、热更新配置实现

1. 文件热更新

2. 远程 KV 热更新

3. 配置变更通知业务

五、配置结构化与校验

1. Unmarshal 到结构体

2. 校验配置

六、多环境配置管理

1. 多文件方案

2. 单文件 + 环境段

3. 12-Factor App 建议

七、完整示例：基于 Consul 的配置中心

八、小结