야, 솔직히 말해봐. 개발하다가 이런 상황 한 번쯤 겪어봤지? 🤔

로컬에서는 잘 돌아가던 코드가 배포 서버에 올리는 순간 "DB 연결 실패" 뜨면서 멘탈이 나가는 그 순간... 😭
아니면 개발팀 동료가 "야, 네 코드에 DB 비밀번호가 하드코딩 되어있어!" 라고 슬랙으로 DM 날리는 그 아찔한 경험...

이게 다 설정 관리(Configuration Management)를 제대로 안 해서 생기는 문제야. Go 언어로 실무 프로젝트를 개발할 때 환경별 설정을 어떻게 관리하느냐는 진짜 중요한 문제거든.

오늘은 Go 생태계에서 가장 널리 쓰이는 설정 관리 라이브러리인 Viper를 중심으로, 환경별 설정 시스템을 제대로 구축하는 방법을 완전 친절하게 파헤쳐볼게! 🚀

Go를 처음 접하는 분부터 실무에서 이미 쓰고 있는 분까지 모두 도움이 될 내용이니까 끝까지 따라와줘! 😎

먼저 기본 개념부터 잡고 가자. 설정 관리(Configuration Management)란 애플리케이션이 실행되는 환경에 따라 달라지는 값들을 코드와 분리해서 관리하는 것을 말해.

예를 들어볼게. 너의 Go 앱이 이런 정보들을 필요로 한다고 해봐:

이 값들이 로컬 개발 환경, 테스트 서버, 프로덕션 서버에서 모두 달라. 로컬에서는 localhost:5432에 DB가 있지만, 프로덕션에서는 AWS RDS 엔드포인트를 써야 하잖아.

만약 이걸 코드에 직접 박아넣으면 (하드코딩) 어떻게 될까? 🤦

그래서 등장한 게 바로 12-Factor App 방법론이야. 이 방법론의 3번째 원칙이 바로 "설정을 환경에 저장하라(Store config in the environment)"야. 코드와 설정을 완전히 분리하라는 거지.

Go 생태계에서 이 원칙을 가장 우아하게 구현할 수 있게 해주는 게 바로 Viper야! 🐍

Viper는 Go 언어를 위한 완전한 설정 솔루션이야. spf13(Steve Francia, 전 Docker/MongoDB 개발자)이 만들었고, GitHub에서 수만 개의 스타를 받은 Go 생태계의 대표 라이브러리야. 🌟

Viper가 지원하는 기능들을 보면 왜 이렇게 인기 있는지 바로 이해가 돼:

특히 Viper의 가장 강력한 특징은 우선순위 기반 설정 병합이야. 여러 소스에서 설정을 읽어올 때 자동으로 우선순위를 적용해줘:

이게 왜 좋냐면, 예를 들어 설정 파일에 DB 포트를 5432로 설정해뒀어도, 배포할 때 환경변수로 DB_PORT=5433을 주면 자동으로 환경변수 값이 우선 적용돼. 코드 수정 없이! 🎉

자, 이제 실제로 써보자! 먼저 Go 모듈 프로젝트를 만들고 Viper를 설치해야 해.

mkdir my-go-app
cd my-go-app
go mod init github.com/yourname/my-go-app

go get github.com/spf13/viper

package main

import (
    "fmt"
    "github.com/spf13/viper"
)

func main() {
    // 기본값 설정
    viper.SetDefault("server.port", 8080)
    viper.SetDefault("server.host", "localhost")
    viper.SetDefault("database.name", "mydb")

    // 값 읽기
    port := viper.GetInt("server.port")
    host := viper.GetString("server.host")
    dbName := viper.GetString("database.name")

    fmt.Printf("서버: %s:%d\n", host, port)
    fmt.Printf("DB: %s\n", dbName)
}

이제 Viper가 지원하는 Get 함수들을 알아보자. 타입 안전성을 위해 다양한 타입별 함수를 제공해:

// 다양한 타입으로 값 읽기
viper.GetString("key")      // string
viper.GetInt("key")         // int
viper.GetInt64("key")       // int64
viper.GetFloat64("key")     // float64
viper.GetBool("key")        // bool
viper.GetDuration("key")    // time.Duration
viper.GetTime("key")        // time.Time
viper.GetStringSlice("key") // []string
viper.GetStringMap("key")   // map[string]interface{}
viper.GetStringMapString("key") // map[string]string

// 키 존재 여부 확인
viper.IsSet("key")          // bool

// 모든 설정 가져오기
viper.AllSettings()         // map[string]interface{}

실무에서 가장 많이 쓰는 방식은 YAML 파일로 설정을 관리하는 거야. YAML은 가독성이 좋고 계층 구조를 표현하기 쉬워서 설정 파일로 딱이거든. 😊

먼저 프로젝트 구조를 이렇게 잡아보자:

my-go-app/
├── config/
│   ├── config.go          # 설정 로딩 로직
│   ├── config.yaml        # 기본 설정
│   ├── config.dev.yaml    # 개발 환경 설정
│   ├── config.staging.yaml # 스테이징 환경 설정
│   └── config.prod.yaml   # 프로덕션 환경 설정
├── main.go
└── go.mod

기본 설정 파일 config.yaml을 이렇게 작성해:

# config/config.yaml
app:
  name: "My Awesome App"
  version: "1.0.0"
  env: "development"

server:
  host: "0.0.0.0"
  port: 8080
  read_timeout: 30s
  write_timeout: 30s
  idle_timeout: 120s

database:
  host: "localhost"
  port: 5432
  name: "myapp_dev"
  user: "postgres"
  password: ""
  ssl_mode: "disable"
  max_open_conns: 25
  max_idle_conns: 5
  conn_max_lifetime: 5m

redis:
  host: "localhost"
  port: 6379
  password: ""
  db: 0

jwt:
  secret: "your-super-secret-key-change-in-production"
  expiry: 24h

log:
  level: "debug"
  format: "text"  # text 또는 json

이제 Go 코드에서 이 파일을 읽어보자:

// config/config.go
package config

import (
    "fmt"
    "strings"
    "github.com/spf13/viper"
)

// Config 구조체 - 설정값을 담는 타입 안전한 구조체
type Config struct {
    App      AppConfig      `mapstructure:"app"`
    Server   ServerConfig   `mapstructure:"server"`
    Database DatabaseConfig `mapstructure:"database"`
    Redis    RedisConfig    `mapstructure:"redis"`
    JWT      JWTConfig      `mapstructure:"jwt"`
    Log      LogConfig      `mapstructure:"log"`
}

type AppConfig struct {
    Name    string `mapstructure:"name"`
    Version string `mapstructure:"version"`
    Env     string `mapstructure:"env"`
}

type ServerConfig struct {
    Host         string        `mapstructure:"host"`
    Port         int           `mapstructure:"port"`
    ReadTimeout  time.Duration `mapstructure:"read_timeout"`
    WriteTimeout time.Duration `mapstructure:"write_timeout"`
    IdleTimeout  time.Duration `mapstructure:"idle_timeout"`
}

type DatabaseConfig struct {
    Host            string        `mapstructure:"host"`
    Port            int           `mapstructure:"port"`
    Name            string        `mapstructure:"name"`
    User            string        `mapstructure:"user"`
    Password        string        `mapstructure:"password"`
    SSLMode         string        `mapstructure:"ssl_mode"`
    MaxOpenConns    int           `mapstructure:"max_open_conns"`
    MaxIdleConns    int           `mapstructure:"max_idle_conns"`
    ConnMaxLifetime time.Duration `mapstructure:"conn_max_lifetime"`
}

type RedisConfig struct {
    Host     string `mapstructure:"host"`
    Port     int    `mapstructure:"port"`
    Password string `mapstructure:"password"`
    DB       int    `mapstructure:"db"`
}

type JWTConfig struct {
    Secret string        `mapstructure:"secret"`
    Expiry time.Duration `mapstructure:"expiry"`
}

type LogConfig struct {
    Level  string `mapstructure:"level"`
    Format string `mapstructure:"format"`
}

// Load 함수 - 설정을 로드하고 Config 구조체를 반환
func Load(configPath string) (*Config, error) {
    v := viper.New()

    // 설정 파일 경로 지정
    v.SetConfigFile(configPath)
    v.SetConfigType("yaml")

    // 환경변수 자동 바인딩 (APP_SERVER_PORT → server.port)
    v.AutomaticEnv()
    v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    v.SetEnvPrefix("APP")

    // 설정 파일 읽기
    if err := v.ReadInConfig(); err != nil {
        return nil, fmt.Errorf("설정 파일 읽기 실패: %w", err)
    }

    // 구조체로 언마샬링
    var cfg Config
    if err := v.Unmarshal(&cfg); err != nil {
        return nil, fmt.Errorf("설정 파싱 실패: %w", err)
    }

    return &cfg, nil
}

자, 이제 진짜 실무에서 쓰는 패턴을 알아보자. 환경별로 설정을 관리하는 방법은 크게 두 가지야:

실무에서는 두 전략을 조합해서 쓰는 게 가장 좋아. 공통 설정은 파일로, 민감한 정보는 환경변수로! 이렇게 구현해보자:

// config/config.go (완전한 버전)
package config

import (
    "fmt"
    "os"
    "strings"
    "time"

    "github.com/spf13/viper"
)

type Config struct {
    App      AppConfig      `mapstructure:"app"`
    Server   ServerConfig   `mapstructure:"server"`
    Database DatabaseConfig `mapstructure:"database"`
    Redis    RedisConfig    `mapstructure:"redis"`
    JWT      JWTConfig      `mapstructure:"jwt"`
    Log      LogConfig      `mapstructure:"log"`
}

// ... (구조체 정의는 앞에서 본 것과 동일)

// LoadConfig - 환경에 따라 적절한 설정 파일을 로드
func LoadConfig(configDir string) (*Config, error) {
    v := viper.New()

    // 1. 기본 설정 파일 로드
    v.SetConfigName("config")
    v.SetConfigType("yaml")
    v.AddConfigPath(configDir)
    v.AddConfigPath(".")

    if err := v.ReadInConfig(); err != nil {
        return nil, fmt.Errorf("기본 설정 파일 읽기 실패: %w", err)
    }

    // 2. 환경별 설정 파일 병합 (있으면)
    env := os.Getenv("APP_ENV")
    if env == "" {
        env = "development" // 기본값
    }

    v.SetConfigName(fmt.Sprintf("config.%s", env))
    if err := v.MergeInConfig(); err != nil {
        // 환경별 파일이 없어도 에러 아님 (선택적)
        if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
            return nil, fmt.Errorf("환경별 설정 파일 병합 실패: %w", err)
        }
    }

    // 3. 환경변수 바인딩
    v.SetEnvPrefix("APP")
    v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    v.AutomaticEnv()

    // 4. 특정 환경변수 명시적 바인딩
    // 환경변수 APP_DATABASE_PASSWORD → database.password
    bindEnvs := []struct {
        key string
        env string
    }{
        {"database.password", "APP_DATABASE_PASSWORD"},
        {"database.user", "APP_DATABASE_USER"},
        {"jwt.secret", "APP_JWT_SECRET"},
        {"redis.password", "APP_REDIS_PASSWORD"},
    }

    for _, b := range bindEnvs {
        if err := v.BindEnv(b.key, b.env); err != nil {
            return nil, fmt.Errorf("환경변수 바인딩 실패 (%s): %w", b.key, err)
        }
    }

    // 5. 구조체로 언마샬링
    var cfg Config
    if err := v.Unmarshal(&cfg); err != nil {
        return nil, fmt.Errorf("설정 파싱 실패: %w", err)
    }

    // 6. 설정 유효성 검사
    if err := cfg.Validate(); err != nil {
        return nil, fmt.Errorf("설정 유효성 검사 실패: %w", err)
    }

    return &cfg, nil
}

// Validate - 필수 설정값 검증
func (c *Config) Validate() error {
    if c.Database.Password == "" && c.App.Env == "production" {
        return fmt.Errorf("프로덕션 환경에서 DB 비밀번호는 필수입니다")
    }
    if c.JWT.Secret == "" {
        return fmt.Errorf("JWT 시크릿은 필수입니다")
    }
    if len(c.JWT.Secret) < 32 && c.App.Env == "production" {
        return fmt.Errorf("프로덕션 JWT 시크릿은 최소 32자 이상이어야 합니다")
    }
    return nil
}

이제 main.go에서 이렇게 사용해:

// main.go
package main

import (
    "log"
    "github.com/yourname/my-go-app/config"
)

func main() {
    cfg, err := config.LoadConfig("./config")
    if err != nil {
        log.Fatalf("설정 로드 실패: %v", err)
    }

    log.Printf("앱 시작: %s v%s (환경: %s)",
        cfg.App.Name,
        cfg.App.Version,
        cfg.App.Env,
    )
    log.Printf("서버 주소: %s:%d", cfg.Server.Host, cfg.Server.Port)

    // 이제 cfg를 의존성 주입으로 전달
    // server := NewServer(cfg)
    // server.Start()
}

Viper의 환경변수 바인딩은 정말 강력한데, 처음엔 좀 헷갈릴 수 있어. 차근차근 설명해줄게! 😊

AutomaticEnv()를 사용하면 Viper가 자동으로 환경변수를 읽어오는데, 이때 키 변환 규칙이 있어:

v := viper.New()
v.SetEnvPrefix("APP")           // 접두사 설정
v.SetEnvKeyReplacer(
    strings.NewReplacer(".", "_") // 점을 언더스코어로 변환
)
v.AutomaticEnv()

// 이렇게 하면:
// viper 키 "server.port" → 환경변수 "APP_SERVER_PORT"
// viper 키 "database.host" → 환경변수 "APP_DATABASE_HOST"
// viper 키 "jwt.secret" → 환경변수 "APP_JWT_SECRET"

실제로 환경변수를 설정하는 방법들:

# 방법 1: 쉘에서 직접 설정
export APP_ENV=production
export APP_DATABASE_PASSWORD=super_secret_password
export APP_JWT_SECRET=my-very-long-jwt-secret-key-32chars

# 방법 2: .env 파일 (개발 환경에서만!)
# .env 파일 내용:
APP_ENV=development
APP_DATABASE_PASSWORD=devpassword
APP_JWT_SECRET=dev-jwt-secret-key

# 방법 3: Docker 실행 시
docker run -e APP_ENV=production \
           -e APP_DATABASE_PASSWORD=secret \
           my-app

# 방법 4: Kubernetes Secret
kubectl create secret generic app-secrets \
  --from-literal=APP_DATABASE_PASSWORD=secret \
  --from-literal=APP_JWT_SECRET=my-jwt-secret

환경변수 바인딩에서 자주 실수하는 부분이 있어. 대소문자 처리야:

// ⚠️ 주의! Viper는 기본적으로 모든 키를 소문자로 처리해
// 환경변수는 대문자가 관례이므로 SetEnvKeyReplacer가 필요해

v.SetEnvKeyReplacer(strings.NewReplacer(
    ".", "_",   // 점 → 언더스코어
    "-", "_",   // 하이픈 → 언더스코어 (필요시)
))

// 명시적 바인딩이 가장 확실해
v.BindEnv("database.password", "DB_PASSWORD")
// 이제 DB_PASSWORD 환경변수가 database.password로 매핑됨

설정을 잘 로드했으면, 이걸 앱 전체에 어떻게 전달하느냐가 중요해. Go에서는 의존성 주입(Dependency Injection) 패턴을 사용하는 게 베스트 프랙티스야.

전역 변수로 설정을 관리하는 건 테스트하기 어렵고 코드 결합도가 높아져서 좋지 않아. 이렇게 해보자:

// 프로젝트 구조
my-go-app/
├── cmd/
│   └── server/
│       └── main.go          # 진입점
├── config/
│   ├── config.go            # 설정 구조체 및 로딩
│   ├── config.yaml          # 기본 설정
│   └── config.dev.yaml      # 개발 환경 설정
├── internal/
│   ├── server/
│   │   └── server.go        # HTTP 서버
│   ├── database/
│   │   └── database.go      # DB 연결
│   ├── handler/
│   │   └── user.go          # HTTP 핸들러
│   └── service/
│       └── user.go          # 비즈니스 로직
└── go.mod

// internal/database/database.go
package database

import (
    "database/sql"
    "fmt"
    "time"

    "github.com/yourname/my-go-app/config"
    _ "github.com/lib/pq" // PostgreSQL 드라이버
)

type DB struct {
    *sql.DB
}

// New - 설정을 받아서 DB 연결 생성
func New(cfg config.DatabaseConfig) (*DB, error) {
    dsn := fmt.Sprintf(
        "host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
        cfg.Host,
        cfg.Port,
        cfg.User,
        cfg.Password,
        cfg.Name,
        cfg.SSLMode,
    )

    db, err := sql.Open("postgres", dsn)
    if err != nil {
        return nil, fmt.Errorf("DB 연결 실패: %w", err)
    }

    // 연결 풀 설정
    db.SetMaxOpenConns(cfg.MaxOpenConns)
    db.SetMaxIdleConns(cfg.MaxIdleConns)
    db.SetConnMaxLifetime(cfg.ConnMaxLifetime)

    // 연결 확인
    if err := db.Ping(); err != nil {
        return nil, fmt.Errorf("DB Ping 실패: %w", err)
    }

    return &DB{db}, nil
}

// cmd/server/main.go
package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/yourname/my-go-app/config"
    "github.com/yourname/my-go-app/internal/database"
    "github.com/yourname/my-go-app/internal/server"
)

func main() {
    // 1. 설정 로드
    cfg, err := config.LoadConfig("./config")
    if err != nil {
        log.Fatalf("❌ 설정 로드 실패: %v", err)
    }
    log.Printf("✅ 설정 로드 완료 (환경: %s)", cfg.App.Env)

    // 2. DB 연결 (설정 주입)
    db, err := database.New(cfg.Database)
    if err != nil {
        log.Fatalf("❌ DB 연결 실패: %v", err)
    }
    defer db.Close()
    log.Printf("✅ DB 연결 완료")

    // 3. 서버 생성 (설정 주입)
    srv := server.New(cfg, db)

    // 4. Graceful Shutdown 설정
    go func() {
        addr := fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port)
        log.Printf("🚀 서버 시작: http://%s", addr)
        if err := srv.Start(addr); err != nil && err != http.ErrServerClosed {
            log.Fatalf("서버 에러: %v", err)
        }
    }()

    // 5. 종료 시그널 대기
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("🛑 서버 종료 중...")
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("서버 강제 종료: %v", err)
    }
    log.Println("✅ 서버 정상 종료")
}

Viper의 숨겨진 킬러 기능 중 하나가 바로 설정 파일 실시간 감시야! 서버를 재시작하지 않고도 설정을 바꿀 수 있어. 로그 레벨을 프로덕션에서 갑자기 debug로 바꿔야 할 때 진짜 유용하거든. 😎

package config

import (
    "log"
    "sync"

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

type DynamicConfig struct {
    mu  sync.RWMutex
    cfg *Config
    v   *viper.Viper
}

func NewDynamicConfig(configDir string) (*DynamicConfig, error) {
    v := viper.New()
    v.SetConfigName("config")
    v.SetConfigType("yaml")
    v.AddConfigPath(configDir)

    if err := v.ReadInConfig(); err != nil {
        return nil, err
    }

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

    dc := &DynamicConfig{cfg: &cfg, v: v}

    // 파일 변경 감시 시작
    v.WatchConfig()
    v.OnConfigChange(func(e fsnotify.Event) {
        log.Printf("⚡ 설정 파일 변경 감지: %s", e.Name)

        dc.mu.Lock()
        defer dc.mu.Unlock()

        var newCfg Config
        if err := v.Unmarshal(&newCfg); err != nil {
            log.Printf("❌ 설정 재로드 실패: %v", err)
            return
        }

        dc.cfg = &newCfg
        log.Printf("✅ 설정 재로드 완료 (로그 레벨: %s)", newCfg.Log.Level)
    })

    return dc, nil
}

// Get - 현재 설정 반환 (스레드 안전)
func (dc *DynamicConfig) Get() *Config {
    dc.mu.RLock()
    defer dc.mu.RUnlock()
    return dc.cfg
}

설정 코드도 테스트해야 해! 특히 환경별로 다른 설정이 제대로 로드되는지 확인하는 게 중요해. Viper 인스턴스를 사용하면 테스트가 훨씬 쉬워져:

// config/config_test.go
package config_test

import (
    "os"
    "testing"

    "github.com/spf13/viper"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestLoadConfig_DefaultValues(t *testing.T) {
    // 테스트용 임시 설정 파일 생성
    configContent := `
app:
  name: "Test App"
  env: "test"
server:
  port: 9090
database:
  host: "testhost"
  port: 5432
jwt:
  secret: "test-secret-key-that-is-long-enough"
`
    // 임시 파일 생성
    tmpFile, err := os.CreateTemp("", "config-*.yaml")
    require.NoError(t, err)
    defer os.Remove(tmpFile.Name())

    _, err = tmpFile.WriteString(configContent)
    require.NoError(t, err)
    tmpFile.Close()

    // 설정 로드
    cfg, err := LoadConfigFromFile(tmpFile.Name())
    require.NoError(t, err)

    // 검증
    assert.Equal(t, "Test App", cfg.App.Name)
    assert.Equal(t, "test", cfg.App.Env)
    assert.Equal(t, 9090, cfg.Server.Port)
    assert.Equal(t, "testhost", cfg.Database.Host)
}

func TestLoadConfig_EnvOverride(t *testing.T) {
    // 환경변수로 오버라이드 테스트
    os.Setenv("APP_SERVER_PORT", "7777")
    os.Setenv("APP_DATABASE_PASSWORD", "test_password")
    defer func() {
        os.Unsetenv("APP_SERVER_PORT")
        os.Unsetenv("APP_DATABASE_PASSWORD")
    }()

    v := viper.New()
    v.SetDefault("server.port", 8080)
    v.SetDefault("database.password", "")
    v.SetEnvPrefix("APP")
    v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    v.AutomaticEnv()

    // 환경변수가 기본값을 오버라이드하는지 확인
    assert.Equal(t, 7777, v.GetInt("server.port"))
    assert.Equal(t, "test_password", v.GetString("database.password"))
}

func TestConfig_Validate_Production(t *testing.T) {
    // 프로덕션 환경에서 필수값 검증 테스트
    cfg := &Config{
        App: AppConfig{Env: "production"},
        Database: DatabaseConfig{Password: ""}, // 비밀번호 없음!
        JWT: JWTConfig{Secret: "short"}, // 너무 짧은 시크릿!
    }

    err := cfg.Validate()
    assert.Error(t, err) // 에러가 발생해야 함
}

마이크로서비스 아키텍처에서는 설정을 중앙에서 관리하는 게 중요해. Viper는 etcd와 Consul 같은 분산 키-값 저장소와 연동을 지원해. 이걸 쓰면 여러 서비스의 설정을 한 곳에서 관리하고, 실시간으로 변경사항을 반영할 수 있어! 🚀

// 원격 설정 사용을 위한 추가 패키지
import (
    _ "github.com/spf13/viper/remote"
)

func LoadRemoteConfig() (*Config, error) {
    v := viper.New()

    // etcd 연결
    err := v.AddRemoteProvider(
        "etcd3",
        "http://etcd-server:2379",
        "/config/myapp",
    )
    if err != nil {
        return nil, fmt.Errorf("etcd 연결 실패: %w", err)
    }

    v.SetConfigType("yaml")

    // 원격 설정 읽기
    if err := v.ReadRemoteConfig(); err != nil {
        return nil, fmt.Errorf("원격 설정 읽기 실패: %w", err)
    }

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

    // 원격 설정 실시간 감시
    go func() {
        for {
            time.Sleep(5 * time.Second)
            if err := v.WatchRemoteConfig(); err != nil {
                log.Printf("원격 설정 감시 에러: %v", err)
                continue
            }
            v.Unmarshal(&cfg)
            log.Println("원격 설정 업데이트됨!")
        }
    }()

    return &cfg, nil
}

자, 이제 실무에서 바로 써먹을 수 있는 팁들을 모아봤어. 재능넷에서 Go 개발 관련 재능을 공유하는 분들이라면 특히 유용할 내용들이야! 😊

팁 1: 설정 구조체에 DSN 생성 메서드 추가하기

// DatabaseConfig에 편의 메서드 추가
func (d DatabaseConfig) DSN() string {
    return fmt.Sprintf(
        "host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
        d.Host, d.Port, d.User, d.Password, d.Name, d.SSLMode,
    )
}

func (d DatabaseConfig) RedactedDSN() string {
    // 로그용 - 비밀번호 마스킹
    return fmt.Sprintf(
        "host=%s port=%d user=%s password=*** dbname=%s sslmode=%s",
        d.Host, d.Port, d.User, d.Name, d.SSLMode,
    )
}

// 사용
log.Printf("DB 연결: %s", cfg.Database.RedactedDSN())
db, err := sql.Open("postgres", cfg.Database.DSN())

팁 2: 설정 로드 시 환경 자동 감지

func detectEnvironment() string {
    // 우선순위: 환경변수 > 기본값
    if env := os.Getenv("APP_ENV"); env != "" {
        return env
    }
    if env := os.Getenv("GO_ENV"); env != "" {
        return env
    }
    if env := os.Getenv("ENVIRONMENT"); env != "" {
        return env
    }
    // 기본값: development
    return "development"
}

// 사용
env := detectEnvironment()
log.Printf("감지된 환경: %s", env)

팁 3: 설정 덤프 (디버깅용)

func (c *Config) Debug() {
    // 민감한 정보를 마스킹하고 설정 출력
    log.Printf("=== 현재 설정 ===")
    log.Printf("앱: %s v%s (%s)", c.App.Name, c.App.Version, c.App.Env)
    log.Printf("서버: %s:%d", c.Server.Host, c.Server.Port)
    log.Printf("DB: %s@%s:%d/%s",
        c.Database.User,
        c.Database.Host,
        c.Database.Port,
        c.Database.Name,
    )
    log.Printf("로그 레벨: %s", c.Log.Level)
    log.Printf("JWT 시크릿: %s***", c.JWT.Secret[:4]) // 앞 4자만 표시
}

팁 4: 설정 변경 이벤트 채널로 전달

type ConfigManager struct {
    v       *viper.Viper
    current *Config
    mu      sync.RWMutex
    changes chan *Config // 변경 이벤트 채널
}

func NewConfigManager(path string) (*ConfigManager, error) {
    cm := &ConfigManager{
        v:       viper.New(),
        changes: make(chan *Config, 10),
    }

    // ... 설정 로드 ...

    cm.v.WatchConfig()
    cm.v.OnConfigChange(func(e fsnotify.Event) {
        var newCfg Config
        if err := cm.v.Unmarshal(&newCfg); err != nil {
            return
        }
        cm.mu.Lock()
        cm.current = &newCfg
        cm.mu.Unlock()

        // 변경 이벤트 발행 (논블로킹)
        select {
        case cm.changes <- &newCfg:
        default: // 채널이 꽉 찼으면 스킵
        }
    })

    return cm, nil
}

// 변경 이벤트 구독
func (cm *ConfigManager) Subscribe() <-chan *Config {
    return cm.changes
}

// 사용 예시
go func() {
    for newCfg := range configManager.Subscribe() {
        log.Printf("설정 변경됨! 새 로그 레벨: %s", newCfg.Log.Level)
        // 로거 재설정 등 처리
        updateLogger(newCfg.Log.Level)
    }
}()

설정 관리에서 보안은 정말 중요해. 특히 프로덕션 환경에서 DB 비밀번호, API 키, JWT 시크릿 같은 민감한 정보를 어떻게 다루느냐가 핵심이야.

절대 하면 안 되는 것들:

AWS Secrets Manager와 Viper 연동 예시:

// AWS Secrets Manager에서 시크릿 로드
package config

import (
    "encoding/json"
    "fmt"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/secretsmanager"
    "github.com/spf13/viper"
)

type AWSSecrets struct {
    DBPassword string `json:"db_password"`
    JWTSecret  string `json:"jwt_secret"`
    RedisPass  string `json:"redis_password"`
}

func loadAWSSecrets(secretName string) (*AWSSecrets, error) {
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        return nil, fmt.Errorf("AWS 설정 로드 실패: %w", err)
    }

    client := secretsmanager.NewFromConfig(cfg)
    result, err := client.GetSecretValue(context.TODO(),
        &secretsmanager.GetSecretValueInput{
            SecretId: aws.String(secretName),
        },
    )
    if err != nil {
        return nil, fmt.Errorf("시크릿 조회 실패: %w", err)
    }

    var secrets AWSSecrets
    if err := json.Unmarshal([]byte(*result.SecretString), &secrets); err != nil {
        return nil, fmt.Errorf("시크릿 파싱 실패: %w", err)
    }

    return &secrets, nil
}

// Viper에 시크릿 주입
func injectSecrets(v *viper.Viper, secrets *AWSSecrets) {
    v.Set("database.password", secrets.DBPassword)
    v.Set("jwt.secret", secrets.JWTSecret)
    v.Set("redis.password", secrets.RedisPass)
}

Kubernetes 환경에서는 Secret 리소스를 환경변수로 주입하는 방식이 일반적이야:

# kubernetes/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-go-app
spec:
  template:
    spec:
      containers:
      - name: app
        image: my-go-app:latest
        env:
        - name: APP_ENV
          value: "production"
        - name: APP_DATABASE_PASSWORD
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: db-password
        - name: APP_JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: jwt-secret

Go 생태계에는 Viper 말고도 다른 설정 관리 라이브러리들이 있어. 어떤 게 더 나은지 비교해볼게:

어떤 걸 선택해야 할까? 🤔

자, 이제 지금까지 배운 모든 것을 합쳐서 완성된 설정 시스템을 만들어보자. 이게 실무에서 바로 쓸 수 있는 완전한 버전이야! 💪

// config/config.go - 완전한 프로덕션 레디 버전
package config

import (
    "fmt"
    "os"
    "strings"
    "time"

    "github.com/spf13/viper"
)

// ===== 설정 구조체 =====

type Config struct {
    App      AppConfig      `mapstructure:"app"`
    Server   ServerConfig   `mapstructure:"server"`
    Database DatabaseConfig `mapstructure:"database"`
    Redis    RedisConfig    `mapstructure:"redis"`
    JWT      JWTConfig      `mapstructure:"jwt"`
    Log      LogConfig      `mapstructure:"log"`
}

type AppConfig struct {
    Name    string `mapstructure:"name"`
    Version string `mapstructure:"version"`
    Env     string `mapstructure:"env"`
}

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

type DatabaseConfig struct {
    Host            string        `mapstructure:"host"`
    Port            int           `mapstructure:"port"`
    Name            string        `mapstructure:"name"`
    User            string        `mapstructure:"user"`
    Password        string        `mapstructure:"password"`
    SSLMode         string        `mapstructure:"ssl_mode"`
    MaxOpenConns    int           `mapstructure:"max_open_conns"`
    MaxIdleConns    int           `mapstructure:"max_idle_conns"`
    ConnMaxLifetime time.Duration `mapstructure:"conn_max_lifetime"`
}

func (d DatabaseConfig) DSN() string {
    return fmt.Sprintf(
        "host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
        d.Host, d.Port, d.User, d.Password, d.Name, d.SSLMode,
    )
}

type RedisConfig struct {
    Host     string `mapstructure:"host"`
    Port     int    `mapstructure:"port"`
    Password string `mapstructure:"password"`
    DB       int    `mapstructure:"db"`
}

func (r RedisConfig) Addr() string {
    return fmt.Sprintf("%s:%d", r.Host, r.Port)
}

type JWTConfig struct {
    Secret string        `mapstructure:"secret"`
    Expiry time.Duration `mapstructure:"expiry"`
}

type LogConfig struct {
    Level  string `mapstructure:"level"`
    Format string `mapstructure:"format"`
}

// ===== 설정 로더 =====

type Loader struct {
    v          *viper.Viper
    configDir  string
    configName string
}

func NewLoader(configDir string) *Loader {
    return &Loader{
        v:          viper.New(),
        configDir:  configDir,
        configName: "config",
    }
}

func (l *Loader) Load() (*Config, error) {
    // 1. 기본값 설정
    l.setDefaults()

    // 2. 기본 설정 파일 로드
    l.v.SetConfigName(l.configName)
    l.v.SetConfigType("yaml")
    l.v.AddConfigPath(l.configDir)
    l.v.AddConfigPath(".")

    if err := l.v.ReadInConfig(); err != nil {
        if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
            return nil, fmt.Errorf("설정 파일 읽기 실패: %w", err)
        }
        // 설정 파일 없어도 계속 진행 (기본값 + 환경변수로만 동작)
    }

    // 3. 환경별 설정 파일 병합
    env := l.detectEnv()
    if env != "" && env != "development" {
        l.v.SetConfigName(fmt.Sprintf("%s.%s", l.configName, env))
        if err := l.v.MergeInConfig(); err != nil {
            if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
                return nil, fmt.Errorf("환경별 설정 병합 실패: %w", err)
            }
        }
    }

    // 4. 환경변수 바인딩
    l.v.SetEnvPrefix("APP")
    l.v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    l.v.AutomaticEnv()

    // 5. 구조체 언마샬링
    var cfg Config
    if err := l.v.Unmarshal(&cfg); err != nil {
        return nil, fmt.Errorf("설정 파싱 실패: %w", err)
    }

    // 6. 환경 정보 설정
    cfg.App.Env = env

    // 7. 유효성 검사
    if err := cfg.validate(); err != nil {
        return nil, fmt.Errorf("설정 유효성 검사 실패: %w", err)
    }

    return &cfg, nil
}

func (l *Loader) setDefaults() {
    l.v.SetDefault("app.name", "Go App")
    l.v.SetDefault("app.version", "0.0.1")
    l.v.SetDefault("server.host", "0.0.0.0")
    l.v.SetDefault("server.port", 8080)
    l.v.SetDefault("server.read_timeout", "30s")
    l.v.SetDefault("server.write_timeout", "30s")
    l.v.SetDefault("database.port", 5432)
    l.v.SetDefault("database.ssl_mode", "disable")
    l.v.SetDefault("database.max_open_conns", 25)
    l.v.SetDefault("database.max_idle_conns", 5)
    l.v.SetDefault("database.conn_max_lifetime", "5m")
    l.v.SetDefault("redis.port", 6379)
    l.v.SetDefault("redis.db", 0)
    l.v.SetDefault("jwt.expiry", "24h")
    l.v.SetDefault("log.level", "info")
    l.v.SetDefault("log.format", "json")
}

func (l *Loader) detectEnv() string {
    for _, key := range []string{"APP_ENV", "GO_ENV", "ENVIRONMENT"} {
        if env := os.Getenv(key); env != "" {
            return env
        }
    }
    return "development"
}

func (cfg *Config) validate() error {
    if cfg.App.Env == "production" {
        if cfg.Database.Password == "" {
            return fmt.Errorf("프로덕션: DB 비밀번호 필수")
        }
        if len(cfg.JWT.Secret) < 32 {
            return fmt.Errorf("프로덕션: JWT 시크릿 최소 32자")
        }
    }
    if cfg.Server.Port < 1 || cfg.Server.Port > 65535 {
        return fmt.Errorf("유효하지 않은 서버 포트: %d", cfg.Server.Port)
    }
    return nil
}

// ===== 편의 함수 =====

// MustLoad - 실패 시 패닉 (main에서 사용)
func MustLoad(configDir string) *Config {
    cfg, err := NewLoader(configDir).Load()
    if err != nil {
        panic(fmt.Sprintf("설정 로드 실패: %v", err))
    }
    return cfg
}

와, 정말 긴 여정이었어! 🎉 Go 언어에서 Viper를 활용한 환경별 설정 시스템을 처음부터 끝까지 다 살펴봤어. 마지막으로 핵심 원칙들을 정리해줄게:

Go 언어로 개발할 때 설정 관리를 제대로 하면 팀 협업도 쉬워지고, 배포도 안전해지고, 보안 사고도 예방할 수 있어. Viper는 이 모든 걸 가능하게 해주는 강력한 도구야.

혹시 Go 개발 관련해서 더 배우고 싶거나, 실무 프로젝트에서 설정 시스템 구축을 도움받고 싶다면 재능넷(https://www.jaenung.net)에서 Go 전문 개발자들의 재능을 찾아볼 수 있어. 다양한 Go 개발 전문가들이 코드 리뷰부터 아키텍처 설계까지 도움을 줄 수 있거든! 😊

자, 이제 너의 Go 프로젝트에 Viper를 도입해봐! 처음엔 좀 복잡해 보여도, 한 번 제대로 세팅해두면 나중에 정말 편해. 특히 팀 프로젝트나 배포 자동화를 할 때 그 진가를 발휘하거든. 화이팅! 🚀

Go 언어의 설정 관리는 처음엔 복잡해 보이지만, Viper를 제대로 이해하고 나면 정말 강력한 도구가 돼. 오늘 배운 내용을 바탕으로 너의 프로젝트에 적용해보고, 궁금한 점이 있으면 언제든지 Go 커뮤니티나 재능넷 같은 플랫폼에서 전문가의 도움을 받아봐! 🎉

코딩 즐겁게 하고, 설정 때문에 밤새는 일 없기를 바랄게! 🌙✨