Setting Up Multi-File Configuration Management with Viper in Golang

Managing configuration in modern applications can be tricky, especially when dealing with multiple environments and configuration sources. Enter Viper - a complete configuration solution for Go applications that takes the pain out of handling configuration files. Today, let’s explore how to implement a robust multi-file configuration setup using Viper.

Why Multi-File Configuration?

Just like how we organize our codebase into different modules, splitting configuration files makes perfect sense. You might want separate files for database settings, API configurations, and environment-specific overrides. This approach improves maintainability and makes it easier to manage different deployment environments.

Setting Up the Project Structure

Let’s set up a practical project structure that separates our configuration files logically:

project/
  ├── config/
  │   ├── config.go
  │   ├── database.yaml
  │   ├── api.yaml
  │   └── environment/
  │       ├── development.yaml
  │       └── production.yaml
  ├── go.mod
  └── main.go

Implementing the Configuration Manager

Our configuration manager needs to handle multiple YAML files and merge them appropriately. Here’s how we can implement this:

package config

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

type Config struct {
    Database DatabaseConfig
    API      APIConfig
    Environment string
}

type DatabaseConfig struct {
    Host     string
    Port     int
    Username string
    Password string
}

type APIConfig struct {
    Port    int
    Timeout int
    Version string
}

func LoadConfig(env string) (*Config, error) {
    v := viper.New()

    // Load base configurations
    v.SetConfigType("yaml")
    v.AddConfigPath("./config")

    // Load and merge database config
    v.SetConfigName("database")
    if err := v.MergeInConfig(); err != nil {
        return nil, fmt.Errorf("error loading database config: %w", err)
    }

    // Load and merge API config
    v.SetConfigName("api")
    if err := v.MergeInConfig(); err != nil {
        return nil, fmt.Errorf("error loading api config: %w", err)
    }

    // Load environment-specific config
    v.AddConfigPath(fmt.Sprintf("./config/environment"))
    v.SetConfigName(env)
    if err := v.MergeInConfig(); err != nil {
        return nil, fmt.Errorf("error loading environment config: %w", err)
    }

    var config Config
    if err := v.Unmarshal(&config); err != nil {
        return nil, fmt.Errorf("unable to decode config into struct: %w", err)
    }

    return &config, nil
}

Using the Configuration in Your Application

Now that we have our configuration manager set up, using it in your application is straightforward:

func main() {
    config, err := config.LoadConfig("development")
    if err != nil {
        log.Fatalf("Error loading config: %v", err)
    }

    fmt.Printf("Database Host: %s\n", config.Database.Host)
    fmt.Printf("API Version: %s\n", config.API.Version)
}

The beauty of this setup is that you can easily override specific settings for different environments while maintaining a clear, organized structure. Environment-specific configurations will automatically merge with and override the base settings, giving you complete control over your application’s behavior in different deployment scenarios.

Best Practices

1. Always validate configuration values after loading
2. Use environment variables for sensitive information
3. Keep configuration files as simple as possible
4. Document all configuration options
5. Use strong typing for configuration structs

By following these patterns, you’ll have a maintainable and scalable configuration system that can grow with your application.