Un guide de gestion de configuration dans Go avec Viper

Introduction

La gestion efficace des configurations est la pierre angulaire de la création de logiciels évolutifs et maintenables. Dans Go, le forfait Viper ? se distingue comme une solution robuste pour gérer les configurations d’applications. Grâce à la prise en charge de plusieurs formats de fichiers, de variables d'environnement et à une désorganisation transparente des structures, Viper simplifie la gestion de la configuration pour les applications modernes.

Dans ce blog, nous expliquerons comment utiliser Viper pour charger et gérer des configurations à partir de différentes sources, les mapper aux structures Go et intégrer dynamiquement des variables d'environnement.

?‍? Configuration de Viper :

Plongeons dans la mise en œuvre pratique de Viper dans une application Go. Pour ce guide, nous utiliserons un exemple de configuration d'application simple avec un fichier YAML et des variables d'environnement.

Étape 1 : Installer le package Viper

Commencez par installer Viper dans votre projet :

go get github.com/spf13/viper

Étape 2 : Créer un fichier de configuration

Créez un fichier config.yaml dans le répertoire racine de votre projet. Ce fichier définira la configuration par défaut de votre application :

app:
  name: "MyApp"
  port: 8080
namespace: "myapp"
owner: "John Doe"

? Implémentation de Viper dans Go

Voici comment utiliser Viper dans votre application. Vous trouverez ci-dessous l'exemple de code de main.go :

package main

import (
    "fmt"
    "log"
    "strings"

    "github.com/spf13/viper"
)

type AppConfig struct {
    App struct {
        Name string `mapstructure:"name"`
        Port int    `mapstructure:"port"`
    } `mapstructure:"app"`
    NS    string `mapstructure:"namespace"`
    Owner string `mapstructure:"owner"`
}

func main() {
    // Set up viper to read the config.yaml file
    viper.SetConfigName("config") // Config file name without extension
    viper.SetConfigType("yaml")   // Config file type
    viper.AddConfigPath(".")      // Look for the config file in the current directory


    /*
        AutomaticEnv will check for an environment variable any time a viper.Get request is made.
        It will apply the following rules.
            It will check for an environment variable with a name matching the key uppercased and prefixed with the EnvPrefix if set.
    */
    viper.AutomaticEnv()
    viper.SetEnvPrefix("env")                              // will be uppercased automatically
    viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_")) // this is useful e.g. want to use . in Get() calls, but environmental variables to use _ delimiters (e.g. app.port -> APP_PORT)

    // Read the config file
    err := viper.ReadInConfig()
    if err != nil {
        log.Fatalf("Error reading config file, %s", err)
    }

    // Set up environment variable mappings if necessary
    /*
        BindEnv takes one or more parameters. The first parameter is the key name, the rest are the name of the environment variables to bind to this key.
        If more than one are provided, they will take precedence in the specified order. The name of the environment variable is case sensitive.
        If the ENV variable name is not provided, then Viper will automatically assume that the ENV variable matches the following format: prefix + "_" + the key name in ALL CAPS.
        When you explicitly provide the ENV variable name (the second parameter), it does not automatically add the prefix.
            For example if the second parameter is "id", Viper will look for the ENV variable "ID".
    */
    viper.BindEnv("app.name", "APP_NAME") // Bind the app.name key to the APP_NAME environment variable

    // Get the values, using env variables if present
    appName := viper.GetString("app.name")
    namespace := viper.GetString("namespace") // AutomaticEnv will look for an environment variable called `ENV_NAMESPACE` ( prefix + "_" + key in ALL CAPS)
    appPort := viper.GetInt("app.port")       // AutomaticEnv will look for an environment variable called `ENV_APP_PORT` ( prefix + "_" + key in ALL CAPS with _ delimiters)

    // Output the configuration values
    fmt.Printf("App Name: %s\n", appName)
    fmt.Printf("Namespace: %s\n", namespace)
    fmt.Printf("App Port: %d\n", appPort)

    // Create an instance of AppConfig
    var config AppConfig
    // Unmarshal the config file into the AppConfig struct
    err = viper.Unmarshal(&config)
    if err != nil {
        log.Fatalf("Unable to decode into struct, %v", err)
    }

    // Output the configuration values
    fmt.Printf("Config: %v\n", config)
}

Utiliser des variables d'environnement ?

Pour intégrer dynamiquement les variables d'environnement, créez un fichier .env avec le contenu suivant :

export APP_NAME="MyCustomApp"
export ENV_NAMESPACE="go-viper"
export ENV_APP_PORT=9090

Exécutez la commande pour charger les variables d'environnement :

source .env

Dans le code, les méthodes AutomaticEnv et SetEnvKeyReplacer de Viper vous permettent de mapper des clés de configuration imbriquées comme app.port à des variables d'environnement telles que APP_PORT. Voici comment cela fonctionne :

1. Préfixe avec SetEnvPrefix : La ligne viper.SetEnvPrefix("env") garantit que toutes les recherches de variables d'environnement portent le préfixe ENV_. Par exemple:
   • app.port devient ENV_APP_PORT
   • l'espace de noms devient ENV_NAMESPACE
2. Remplacements de clés avec SetEnvKeyReplacer : Le SetEnvKeyReplacer(strings.NewReplacer(".", "_")) remplace . avec _ dans les noms de clés, afin que les clés imbriquées comme app.port puissent être mappées directement aux variables d'environnement.

En combinant ces deux méthodes, vous pouvez remplacer de manière transparente des valeurs de configuration spécifiques à l'aide de variables d'environnement.

? Exécution de l'exemple

Exécutez l'application en utilisant :

go get github.com/spf13/viper

Résultat attendu :

app:
  name: "MyApp"
  port: 8080
namespace: "myapp"
owner: "John Doe"

Meilleures pratiques ?

• Utiliser des variables d'environnement pour les données sensibles : évitez de stocker des secrets dans les fichiers de configuration. Utilisez des variables d'environnement ou des outils de gestion des secrets.
• Définir les valeurs par défaut : Utilisez viper.SetDefault("key", value) pour vous assurer que votre application a des valeurs par défaut raisonnables.
• Valider la configuration : Après avoir chargé les configurations, validez-les pour éviter les erreurs d'exécution.
• Gardez la configuration organisée : Regroupez les configurations associées et utilisez des structures imbriquées pour plus de clarté.

? Conclusion

En tirant parti de Viper, vous pouvez simplifier la gestion de la configuration dans vos applications Go. Sa flexibilité pour intégrer plusieurs sources, la prise en charge des variables d'environnement dynamiques et la désorganisation des structures en font un outil indispensable pour les développeurs.

Commencez à utiliser Viper dans votre prochain projet et découvrez une gestion de configuration sans tracas. Bon codage ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!