Umgang mit der Konfiguration in Go [geschlossen]

Ich bin neu in der Go-Programmierung und frage mich: Was ist die bevorzugte Methode zum Behandeln von Konfigurationsparametern für ein Go-Programm (die Art von Dingen , für die man in anderen Kontexten Eigenschaftendateien oder INI- Dateien verwenden könnte )?

Das JSON- Format hat bei mir ganz gut funktioniert. Die Standardbibliothek bietet Methoden zum Schreiben der eingerückten Datenstruktur, sodass sie gut lesbar ist.

Siehe auch diesen Golang-Muttern-Faden .

Die Vorteile von JSON sind, dass es ziemlich einfach zu analysieren und von Menschen lesbar / bearbeitbar ist, während Semantik für Listen und Zuordnungen angeboten wird (was sehr praktisch sein kann), was bei vielen Konfigurationsparsern vom Typ ini nicht der Fall ist.

Anwendungsbeispiel:

conf.json :

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

Programm zum Lesen der Konfiguration

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]

Eine weitere Option ist die Verwendung von TOML , einem INI-ähnlichen Format, das von Tom Preston-Werner erstellt wurde. Ich habe dafür einen Go-Parser erstellt , der ausführlich getestet wird . Sie können es wie andere hier vorgeschlagene Optionen verwenden. Zum Beispiel, wenn Sie diese TOML-Daten in habensomething.toml

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

Dann können Sie es mit so etwas in Ihr Go-Programm laden

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 ist ein Golang-Konfigurationsmanagementsystem, das mit JSON, YAML und TOML zusammenarbeitet. Es sieht ziemlich interessant aus.

Normalerweise verwende ich JSON für kompliziertere Datenstrukturen. Der Nachteil ist, dass Sie leicht eine Menge Code erhalten, um dem Benutzer mitzuteilen, wo der Fehler war, verschiedene Randfälle und was nicht.

Für die Basiskonfiguration (API-Schlüssel, Portnummern, ...) hatte ich sehr viel Glück mit dem gcfg- Paket. Es basiert auf dem Git-Konfigurationsformat.

Aus der Dokumentation:

Beispielkonfiguration:

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

Go struct:

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

Und der Code, der zum Lesen benötigt wird:

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

Es werden auch Slice-Werte unterstützt, sodass Sie die mehrfache Angabe eines Schlüssels und andere nützliche Funktionen wie diese zulassen können.

Verwenden Sie einfach Standard- Go-Flags mit Iniflags .

Standard-Go-Flags bieten folgende Vorteile:

• Idiomatisch.
• Einfach zu verwenden. Flags können einfach hinzugefügt und auf beliebige Pakete verteilt werden, die Ihr Projekt verwendet.
• Flags unterstützen sofort Standardwerte und Beschreibungen.
• Flags bieten eine Standard-Hilfeausgabe mit Standardwerten und einer Beschreibung.

Der einzige Nachteil, den Standard-Go-Flags haben, sind Verwaltungsprobleme, wenn die Anzahl der in Ihrer App verwendeten Flags zu groß wird.

Iniflags löst dieses Problem auf elegante Weise: Ändern Sie einfach zwei Zeilen in Ihrem Hauptpaket, und das Lesen von Flag-Werten aus der INI-Datei wird auf magische Weise unterstützt. Flags aus INI-Dateien können überschrieben werden, indem neue Werte in der Befehlszeile übergeben werden.

Weitere Informationen finden Sie unter https://groups.google.com/forum/#!topic/golang-nuts/TByzyPgoAQE .

Ich habe angefangen, Gcfg zu verwenden, das Ini-ähnliche Dateien verwendet. Es ist einfach - wenn Sie etwas Einfaches wollen, ist dies eine gute Wahl.

Hier ist der Ladecode, den ich derzeit verwende, der Standardeinstellungen hat und Befehlszeilenflags (nicht gezeigt) zulässt, die einige meiner Konfigurationen überschreiben:

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
}

schau dir gonfig an

// 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 und https://github.com/zpatrick/go-config sind ziemlich gute Bibliotheken für Konfigurationsdateien.

Verwenden Sie toml wie diesen Artikel Lesen von Konfigurationsdateien auf Go-Weise

Ich habe eine einfache Ini-Konfigurationsbibliothek in Golang geschrieben.

https://github.com/c4pt0r/cfg

Goroutine-sicher, einfach zu bedienen

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)
    }
}

=================== Update ======================

Vor kurzem brauche ich einen INI-Parser mit Abschnittsunterstützung und schreibe ein einfaches Paket:

github.com/c4pt0r/cfg

Sie können INI wie mit dem "Flag" -Paket analysieren:

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)
}

Vielleicht interessiert Sie auch go-libucl , eine Reihe von Go-Bindungen für UCL, die universelle Konfigurationssprache. UCL ist ein bisschen wie JSON, aber mit besserer Unterstützung für Menschen: Es unterstützt Kommentare und lesbare Konstrukte wie SI-Multiplikatoren (10k, 40M usw.) und hat ein bisschen weniger Boilerplate (z. B. Anführungszeichen um Schlüssel). Es kommt dem Format der Nginx-Konfigurationsdatei ziemlich nahe, wenn Sie damit bereits vertraut sind.

Ich stimme nemo zu und habe ein kleines Tool geschrieben, um alles wirklich einfach zu machen.

bitbucket.org/gotamer/cfg ist ein JSON- Konfigurationspaket

• Sie definieren Ihre Konfigurationselemente in Ihrer Anwendung als Struktur.
• Eine json-Konfigurationsdateivorlage aus Ihrer Struktur wird beim ersten Ausführen gespeichert
• Sie können Laufzeitänderungen an der Konfiguration speichern

Ein Beispiel finden Sie unter doc.go

Ich habe JSON ausprobiert. Es funktionierte. Aber ich hasse es, die Struktur der genauen Felder und Typen erstellen zu müssen, die ich möglicherweise einstelle. Für mich war das ein Schmerz. Ich bemerkte, dass dies die Methode war, die von allen Konfigurationsoptionen verwendet wurde, die ich finden konnte. Vielleicht macht mich mein Hintergrund in dynamischen Sprachen blind für die Vorteile einer solchen Ausführlichkeit. Ich habe ein neues einfaches Konfigurationsdateiformat und eine dynamischere Bibliothek zum Auslesen erstellt.

https://github.com/chrisftw/ezconf

Ich bin ziemlich neu in der Go-Welt, daher ist es möglicherweise nicht der Go-Weg. Aber es funktioniert, es ist ziemlich schnell und super einfach zu bedienen.

Vorteile

• Super einfach
• Weniger Code

Nachteile

• Keine Arrays oder Map-Typen
• Sehr flaches Dateiformat
• Nicht standardmäßige conf-Dateien
• Hat eine kleine Konvention eingebaut, die ich jetzt in der Go-Community generell verpönt habe. (Sucht nach Konfigurationsdatei im Konfigurationsverzeichnis)