Let's write config for your Golang web app on right way — YAML 👌

$ tree . . ├── Makefile ├── config.yml ├── go.mod ├── go.sum └── main.go 

# config.yml server: host: 127.0.0.1 port: 8080 timeout: server: 30 read: 15 write: 10 idle: 5 

package main import ( "context" "flag" "fmt" "log" "net/http" "os" "os/signal" "syscall" "time" "gopkg.in/yaml.v2" ) // Config struct for webapp config type Config struct { Server struct { // Host is the local machine IP Address to bind the HTTP Server to Host string `yaml:"host"` // Port is the local machine TCP Port to bind the HTTP Server to Port string `yaml:"port"` Timeout struct { // Server is the general server timeout to use // for graceful shutdowns Server time.Duration `yaml:"server"` // Write is the amount of time to wait until an HTTP server // write opperation is cancelled Write time.Duration `yaml:"write"` // Read is the amount of time to wait until an HTTP server // read operation is cancelled Read time.Duration `yaml:"read"` // Read is the amount of time to wait // until an IDLE HTTP session is closed Idle time.Duration `yaml:"idle"` } `yaml:"timeout"` } `yaml:"server"` } // NewConfig returns a new decoded Config struct func NewConfig(configPath string) (*Config, error) { // Create config structure config := &Config{} // Open config file file, err := os.Open(configPath) if err != nil { return nil, err } defer file.Close() // Init new YAML decode d := yaml.NewDecoder(file) // Start YAML decoding from file if err := d.Decode(&config); err != nil { return nil, err } return config, nil } // ValidateConfigPath just makes sure, that the path provided is a file, // that can be read func ValidateConfigPath(path string) error { s, err := os.Stat(path) if err != nil { return err } if s.IsDir() { return fmt.Errorf("'%s' is a directory, not a normal file", path) } return nil } // ParseFlags will create and parse the CLI flags // and return the path to be used elsewhere func ParseFlags() (string, error) { // String that contains the configured configuration path var configPath string // Set up a CLI flag called "-config" to allow users // to supply the configuration file flag.StringVar(&configPath, "config", "./config.yml", "path to config file") // Actually parse the flags flag.Parse() // Validate the path first if err := ValidateConfigPath(configPath); err != nil { return "", err } // Return the configuration path return configPath, nil } // NewRouter generates the router used in the HTTP Server func NewRouter() *http.ServeMux { // Create router and define routes and return that router router := http.NewServeMux() router.HandleFunc("/welcome", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, you've requested: %s\n", r.URL.Path) }) return router } // Run will run the HTTP Server func (config Config) Run() { // Set up a channel to listen to for interrupt signals var runChan = make(chan os.Signal, 1) // Set up a context to allow for graceful server shutdowns in the event // of an OS interrupt (defers the cancel just in case) ctx, cancel := context.WithTimeout( context.Background(), config.Server.Timeout.Server, ) defer cancel() // Define server options server := &http.Server{ Addr: config.Server.Host + ":" + config.Server.Port, Handler: NewRouter(), ReadTimeout: config.Server.Timeout.Read * time.Second, WriteTimeout: config.Server.Timeout.Write * time.Second, IdleTimeout: config.Server.Timeout.Idle * time.Second, } // Handle ctrl+c/ctrl+x interrupt signal.Notify(runChan, os.Interrupt, syscall.SIGTSTP) // Alert the user that the server is starting log.Printf("Server is starting on %s\n", server.Addr) // Run the server on a new goroutine go func() { if err := server.ListenAndServe(); err != nil { if err == http.ErrServerClosed { // Normal interrupt operation, ignore } else { log.Fatalf("Server failed to start due to err: %v", err) } } }() // Block on this channel listeninf for those previously defined syscalls assign // to variable so we can let the user know why the server is shutting down interrupt := <-runChan // If we get one of the pre-prescribed syscalls, gracefully terminate the server // while alerting the user log.Printf("Server is shutting down due to %+v\n", interrupt) if err := server.Shutdown(ctx); err != nil { log.Fatalf("Server was unable to gracefully shutdown due to err: %+v", err) } } // Func main should be as small as possible and do as little as possible by convention func main() { // Generate our config based on the config supplied // by the user in the flags cfgPath, err := ParseFlags() if err != nil { log.Fatal(err) } cfg, err := NewConfig(cfgPath) if err != nil { log.Fatal(err) } // Run the server cfg.Run() } 

$ go run ./...  # OR with different config file  $ go run ./... -config ./static/my-other-config.yml 

Hello, you've requested: /welcome