Comment gérer la configuration en Go

Question

Je suis nouveau dans la programmation en Go, et je me demande : quelle est la meilleure façon de gérer les paramètres de configuration d'un programme Go (le genre de choses que l'on pourrait utiliser propriétés ou ini dans d'autres contextes) ?

Answer 1

El JSON Ce format a très bien fonctionné pour moi. La bibliothèque standard bibliothèque standard offre des méthodes pour écrire la structure de données en indentation, de sorte qu'elle est tout à fait lisible.

Voir aussi ce fil de discussion sur les golang-nuts .

Les avantages de JSON sont qu'il est assez simple à analyser et qu'il peut être lu et édité par l'homme. tout en offrant une sémantique pour les listes et les mappings (qui peut devenir très pratique), ce qui ce qui n'est pas le cas avec de nombreux analyseurs de configuration de type ini.

Exemple d'utilisation :

conf.json :

{
    "Users": ["UserA","UserB"],
    "Groups": ["GroupA"]
}

Programme pour lire la configuration

import (
    "encoding/json"
    "os"
    "fmt"
)

type Configuration struct {
    Users    []string
    Groups   []string
}

file, _ := os.Open("conf.json")
defer file.Close()
decoder := json.NewDecoder(file)
configuration := Configuration{}
err := decoder.Decode(&configuration)
if err != nil {
  fmt.Println("error:", err)
}
fmt.Println(configuration.Users) // output: [UserA, UserB]

Answer 2

Une autre option consiste à utiliser TOML qui est un format de type INI créé par Tom Preston-Werner. I construit un analyseur Go pour celui-ci c'est-à-dire largement testé . Vous pouvez l'utiliser comme les autres options proposées ici. Par exemple, si vous avez ces données TOML dans le fichier something.toml

Age = 198
Cats = [ "Cauchy", "Plato" ]
Pi = 3.14
Perfection = [ 6, 28, 496, 8128 ]
DOB = 1987-07-05T05:45:00Z

Ensuite, vous pouvez le charger dans votre programme Go avec quelque chose comme

type Config struct {
    Age int
    Cats []string
    Pi float64
    Perfection []int
    DOB time.Time
}

var conf Config
if _, err := toml.DecodeFile("something.toml", &conf); err != nil {
    // handle error
}

Answer 3

J'utilise généralement JSON pour les structures de données plus complexes. L'inconvénient est que vous vous retrouvez facilement avec un tas de code pour indiquer à l'utilisateur où se trouvait l'erreur, les différents cas limites et autres.

Pour la configuration de base (clés d'api, numéros de port, ...), j'ai eu beaucoup de chance avec le fichier gcfg paquet. Il est basé sur le format de configuration git.

Dans la documentation :

Exemple de configuration :

; Comment line
[section]
name = value # Another comment
flag # implicit value for bool is true

Allez la structure :

type Config struct {
    Section struct {
            Name string
            Flag bool
    }
}

Et le code nécessaire pour le lire :

var cfg Config
err := gcfg.ReadFileInto(&cfg, "myconfig.gcfg")

Il prend également en charge les valeurs de tranche, ce qui permet de spécifier une clé plusieurs fois et d'autres fonctionnalités intéressantes de ce type.

Answer 4

Il suffit d'utiliser la norme drapeaux de l'Union européenne con iniflags .

Les fanions standard présentent les avantages suivants :

• Idiomatique.
• Facile à utiliser. Les drapeaux peuvent être facilement ajoutés et dispersés dans les paquets arbitraires utilisés par votre projet.
• Les drapeaux sont dotés d'un support prêt à l'emploi pour les valeurs par défaut et la description.
• Les drapeaux fournissent une sortie d'aide standard avec les valeurs par défaut et la description.

Le seul inconvénient des drapeaux standard est qu'ils posent des problèmes de gestion lorsque le nombre de drapeaux utilisés dans votre application devient trop important.

Iniflags résout élégamment ce problème : il suffit de modifier deux lignes dans votre paquet principal pour qu'il prenne en charge, comme par magie, la lecture des valeurs des drapeaux depuis un fichier ini. Les drapeaux des fichiers ini peuvent être remplacés en passant de nouvelles valeurs dans la ligne de commande.

Voir aussi https://groups.google.com/forum/#!topic/golang-nuts/TByzyPgoAQE pour les détails.

Answer 5

J'ai commencé à utiliser Gcfg qui utilise des fichiers de type Ini. C'est simple - si vous voulez quelque chose de simple, c'est un bon choix.

Voici le code de chargement que j'utilise actuellement, qui a des paramètres par défaut et permet des drapeaux de ligne de commande (non montrés) qui remplacent certaines de mes configurations :

package util

import (
    "code.google.com/p/gcfg"
)

type Config struct {
    Port int
    Verbose bool
    AccessLog string
    ErrorLog string
    DbDriver string
    DbConnection string
    DbTblPrefix string
}

type configFile struct {
    Server Config
}

const defaultConfig = `
    [server]
    port = 8000
    verbose = false
    accessLog = -
    errorLog  = -
    dbDriver     = mysql
    dbConnection = testuser:TestPasswd9@/test
    dbTblPrefix  =
`

func LoadConfiguration(cfgFile string, port int, verbose bool) Config {
    var err error
    var cfg configFile

    if cfgFile != "" {
        err = gcfg.ReadFileInto(&cfg, cfgFile)
    } else {
        err = gcfg.ReadStringInto(&cfg, defaultConfig)
    }

    PanicOnError(err)

    if port != 0 {
        cfg.Server.Port = port
    }
    if verbose {
        cfg.Server.Verbose = true
    }

    return cfg.Server
}