Comment gérer la configuration dans Go [fermé]

Je suis nouveau dans la programmation 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 pour les fichiers de propriétés ou les fichiers ini , dans d'autres contextes)?

Le format JSON a très bien fonctionné pour moi. La bibliothèque standard propose des méthodes pour écrire la structure de données en retrait, elle est donc assez lisible.

Voir aussi ce fil écrou golang .

Les avantages de JSON sont qu'il est assez simple à analyser et lisible / modifiable par l'homme tout en offrant une sémantique pour les listes et les mappages (qui peut devenir très pratique), 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]

Une autre option consiste à utiliser TOML , qui est un format de type INI créé par Tom Preston-Werner. J'ai construit un analyseur Go pour lui qui est largement testé . Vous pouvez l'utiliser comme les autres options proposées ici. Par exemple, si vous avez ces données TOML danssomething.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
}

Viper est un système de gestion de configuration golang qui fonctionne avec JSON, YAML et TOML. Ça a l'air assez intéressant.

J'utilise généralement JSON pour des structures de données plus complexes. L'inconvénient est que vous vous retrouvez facilement avec un tas de code pour dire à l'utilisateur où était l'erreur, divers cas marginaux et ce qui ne l'est pas.

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

De la documentation:

Exemple de configuration:

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

Allez struct:

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, vous pouvez donc permettre de spécifier plusieurs fois une clé et d'autres fonctionnalités intéressantes comme celle-ci.

Utilisez simplement des drapeaux go standard avec des iniflags .

Les drapeaux go standard ont les avantages suivants:

• Idiomatique.
• Facile à utiliser. Les indicateurs peuvent être facilement ajoutés et dispersés dans des packages arbitraires utilisés par votre projet.
• Les indicateurs ont une prise en charge prête à l'emploi pour les valeurs et la description par défaut.
• Les indicateurs fournissent une sortie d'aide standard avec des valeurs et une description par défaut.

Le seul inconvénient des drapeaux go standard est: les problèmes de gestion lorsque le nombre de drapeaux utilisés dans votre application devient trop important.

Iniflags résout ce problème avec élégance: il suffit de modifier deux lignes dans votre package principal et il prend comme par magie la prise en charge de la lecture des valeurs d'indicateur à partir du fichier ini. Les indicateurs des fichiers ini peuvent être remplacés en passant de nouvelles valeurs en ligne de commande.

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

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 indicateurs de ligne de commande (non affichés) qui remplacent une partie de ma configuration:

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
}

jetez un oeil à gonfig

// load
config, _ := gonfig.FromJson(myJsonFile)
// read with defaults
host, _ := config.GetString("service/host", "localhost")
port, _ := config.GetInt("service/port", 80)
test, _ := config.GetBool("service/testing", false)
rate, _ := config.GetFloat("service/rate", 0.0)
// parse section into target structure
config.GetAs("service/template", &template)

https://github.com/spf13/viper et https://github.com/zpatrick/go-config sont de très bonnes bibliothèques pour les fichiers de configuration.

Utilisez toml comme cet article Lire les fichiers de configuration à la manière

J'ai écrit une simple bibliothèque de configuration ini dans golang.

https://github.com/c4pt0r/cfg

sans danger pour la goroutine, facile à utiliser

package cfg
import (
    "testing"
)

func TestCfg(t *testing.T) {
    c := NewCfg("test.ini")
    if err := c.Load() ; err != nil {
        t.Error(err)
    }
    c.WriteInt("hello", 42)
    c.WriteString("hello1", "World")

    v, err := c.ReadInt("hello", 0)
    if err != nil || v != 42 {
        t.Error(err)
    }

    v1, err := c.ReadString("hello1", "")
    if err != nil || v1 != "World" {
        t.Error(err)
    }

    if err := c.Save(); err != nil {
        t.Error(err)
    }
}

=================== Mise à jour ========================

Récemment, j'ai besoin d'un analyseur INI avec support de section, et j'écris un package simple:

github.com/c4pt0r/cfg

vous pouvez analyser INI comme utiliser le package "flag":

package main

import (
    "log"
    "github.com/c4pt0r/ini"
)

var conf = ini.NewConf("test.ini")

var (
    v1 = conf.String("section1", "field1", "v1")
    v2 = conf.Int("section1", "field2", 0)
)

func main() {
    conf.Parse()

    log.Println(*v1, *v2)
}

Vous pourriez également être intéressé par go-libucl , un ensemble de liaisons Go pour UCL, Universal Configuration Language. UCL est un peu comme JSON, mais avec un meilleur support pour les humains: il prend en charge les commentaires et les constructions lisibles par l'homme comme les multiplicateurs SI (10k, 40M, etc.) et a un peu moins de passe-partout (par exemple, les guillemets autour des clés). Il est en fait assez proche du format de fichier de configuration nginx, si vous le connaissez déjà.

Je suis d'accord avec nemo et j'ai écrit un petit outil pour que tout soit vraiment simple.

bitbucket.org/gotamer/cfg est un package de configuration json

• Vous définissez vos éléments de configuration dans votre application comme une structure.
• Un modèle de fichier de configuration json de votre structure est enregistré lors de la première exécution
• Vous pouvez enregistrer les modifications d'exécution de la configuration

Voir doc.go pour un exemple

J'ai essayé JSON. Ça a marché. Mais je déteste devoir créer la structure des champs et types exacts que je pourrais définir. Pour moi, c'était une douleur. J'ai remarqué que c'était la méthode utilisée par toutes les options de configuration que je pouvais trouver. Peut-être que mon expérience dans les langues dynamiques me rend aveugle aux avantages d'une telle verbosité. J'ai fait un nouveau format de fichier de configuration simple, et une bibliothèque plus dynamique pour le lire.

https://github.com/chrisftw/ezconf

Je suis assez nouveau dans le monde du Go, donc ce n'est peut-être pas le chemin du Go. Mais cela fonctionne, il est assez rapide et super simple à utiliser.

Avantages

• Super simple
• Moins de code

Les inconvénients

• Aucun tableau ni type de carte
• Format de fichier très plat
• Fichiers de conf non standard
• A une petite convention intégrée, que je désapprouve maintenant en général dans la communauté Go. (Recherche le fichier de configuration dans le répertoire de configuration)