Introduction to Viper in Go and Golang


In Go, there are a lot of packages to deal with utility configuration. The viper package deal is hottest amongst them in offering a whole configuration resolution of an utility. It helps quite a few configuration file codecs akin to JSON, YAML, TOML, HCL and Java properties format. This programming tutorial introduces Golang’s viper package deal with Go code examples.

Seeking to be taught Go or Golang in a web based course surroundings? We now have a listing of the Greatest On-line Programs to Be taught Go and Golang that can assist you get began.

What’s the viper Library in Go and Golang?

As talked about, viper is a package deal that gives a whole configuration resolution in a Go venture. Managing and sustaining configuration for a giant and sophisticated utility – akin to constructing a server utility or some other utility which relies upon so much on consumer manipulation of configurations – shouldn’t be a simple job. Furthermore, fashionable functions are constructed to deploy in several types of environments, akin to in Docker, cloud infrastructures, and so forth. Because of this, with a purpose to keep consistency throughout deployment, functions needs to be constructed to be open from little to excessive configurability. An exterior assist that helps on this respect shouldn’t be solely a respite, but additionally very a lot welcome for the builders concerned in constructing such an answer.

The viper library, on this respect, can solely substitute the flag package deal, which supplies provisions for growing UNIX techniques, akin to command line utilities. Based on the viper documentation, viper, aside from being a whole configuration resolution for Go functions, additionally helps 12-Issue apps. 12-Issue app is a strategy for constructing software-as-a-service (SAAS) functions. Launched by Heroku, this system leverages portability, declarative codecs, and automation that makes functions extra resilient to the adaptive wants of the altering surroundings of software program deployment.

Learn: Use the flag Bundle in Go

What Does the viper Library Help in Go?

Based on the viper documentation, it helps the next in Go functions:

  • Studying JSON, TOML, YAML, HCL, envfile and Java properties config recordsdata. Most configuration info of an utility is written on this format. Viper helps most of them.
  • Establishing default configurations
  • Studying surroundings variables
  • Studying distant configuration techniques
  • Studying from command line flags
  • Studying from buffer
  • Setting express values

Set up viper in Go

The steps to put in viper are much like putting in some other package deal in Go. As soon as a Go utility venture has been arrange correctly with the required module file utilizing the go mod init command, a go.mod file can be created. This file maintains the checklist of packages used within the present venture. Simply sort: go get github.com/spf13/viper to put in the viper package deal. Observe {that a} new checklist of packages associated to the viper package deal can be added within the go.mod file.

Go viper Code Instance

Suppose we need to get the values of the frequent Working System surroundings variable referred to as PATH. Builders might accomplish that utilizing the next Go code instance:

package deal major

import (
"fmt"
"github.com/spf13/viper"
)

func major() {
viper.BindEnv("PATH")
val := viper.Get("PATH")
fmt.Println("PATH:", val)
}

Be aware that, within the operate major(), we used viper.BindEnv to bind a viper key to the surroundings variable referred to as PATH. It’s case delicate, which means, as the bottom line is supplied, it should use the surroundings key that matches the important thing in uppercase if given in uppercase. Since, BindEnv can take a couple of argument, every will characterize surroundings variable names that bind to this key and can be taken within the specified order.

The viper.Get operate is used to retrieve any worth given the important thing to make use of. Right here, we use it to retrieve the worth within the Working System’s PATH surroundings variable. Observe within the following Golang code instance that we cannot solely retrieve values from the surroundings variable, but additionally set them as required:

viper.BindEnv("GOMAXPROCS")
eval := viper.Get("GOMAXPROCS")
fmt.Println("GOMAXPROCS:", eval) 

viper.Set("GOMAXPROCS", 20)
eval = viper.Get("GOMAXPROCS")
fmt.Println("GOMAXPROCS:", eval)

We are able to additionally set new surroundings variables by way of Go code, topic to the Working System’s permission, in fact:

viper.BindEnv("MYVARIABLE")
cval := viper.Get("MYVARIABLE")
if cval == nil {
	fmt.Println("MYVARIABLE couldn't be outlined.")
}

Be aware that the flag package deal doesn’t supply such flexibility, however the os package deal in the usual library gives some. Nevertheless, the viper package deal makes it a lot simpler to make use of.

Learn: The Greatest Instruments for Distant Builders

Learn JSON Configuration Recordsdata in Go together with viper

Generally, configuration recordsdata are written in a separate configuration file in one of many many alternative out there codecs, akin to JSON. The viper package deal is absolutely geared up to learn and extract info saved there. Right here is a few fast instance code of find out how to learn a JSON configuration file in Go.

Let the JSON config file: testJSONConfig.json be as follows:

{
"init-param": {
"installAt": "Philadelphia, PA",
"adminEmail": "[email protected]",
"staticPath": "/content material/static"
},
"taglib": {
"taglib-uri":"xyz.tld",
"taglib-loc":"/WEB-INF/tlds/xyz.tld"
}
}

The Go code snippet to learn the JSON file is as follows:

viper.SetConfigType("json")
viper.SetConfigFile("./testJSONConfig.json")
fmt.Printf("Utilizing config: %sn", viper.ConfigFileUsed())
viper.ReadInConfig()

if viper.IsSet("init-param.installAt") {
fmt.Println("init-param.installAt:", viper.Get("init-param.installAt"))
} else {
fmt.Println(" init-param.installAt not set.")
}
if viper.IsSet("init-param.staticPath") {
fmt.Println("init-param.staticPath:", viper.Get("init-param.staticPath"))
} else {
fmt.Println(" init-param.staticPath shouldn't be set.")
}

Working with different widespread file codecs, akin to YAML, TOML, HCL, and so forth, utilizing viper is kind of related.

Unmarshalling By means of viper in Go

Apparently, viper additionally supplies the characteristic of unmarshalling of values from configuration recordsdata to Go varieties akin to struct, map, and so forth. Here’s a fast instance of find out how to unmarshal with viper in Go:

sort configType struct {
InstallAt string
Model string
StaticPath string
}

var config configType

err := viper.Unmarshal(&config)
if err != nil {
fmt.Println("Unmarshalling failed!")
}

Be aware that the marshalling options are usually supplied by the package deal of the file format we need to marshall. For instance, if we need to marshall a Go sort right into a YAML file, then the YAML Go package deal will present the marshalling characteristic.

Ultimate Ideas on the Go Library viper

This has been a fast overview of the viper package deal, with a glimpse of its use in Go. Extra detailed info may be obtained from the viper documentation itself. Perceive that viper, in spite of everything, is a software for use in line with the requirement of the software program being developed. It helps many glorious options associated to storing and retrieving configuration info sought by programmers in fashionable utility growth.

Each functionality of viper is probably not required in the meanwhile, however that ought to not cease one from utilizing a few of its options. Utilizing judiciously is the important thing. For instance, it’s higher to make use of configuration recordsdata as a substitute of utilizing command line utilities to provide too many configuration parameters and flags. On this state of affairs, the options supplied by the viper package deal may be fairly useful.

Learn extra Go programming tutorials and Golang growth suggestions.

Leave a Reply