Monday, September 26, 2022
HomeSoftware DevelopmentIntroduction to Viper in Go and Golang

Introduction to Viper in Go and Golang

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

Seeking to study Go or Golang in a web-based course setting? We’ve got an inventory of the Greatest On-line Programs to Study Go and Golang that will help you get began.

What’s the viper Library in Go and Golang?

As talked about, viper is a bundle that gives an entire configuration resolution in a Go mission. Managing and sustaining configuration for an enormous and sophisticated software – reminiscent of constructing a server software or some other software which relies upon lots on consumer manipulation of configurations – is just not a simple job. Furthermore, trendy purposes are constructed to deploy in several types of environments, reminiscent of in Docker, cloud infrastructures, and so forth. Consequently, to be able to keep consistency throughout deployment, purposes must be constructed to be open from little to excessive configurability. An exterior help that helps on this respect is just not 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 completely exchange the flag bundle, which gives provisions for growing UNIX programs, reminiscent of command line utilities. In keeping with the viper documentation, viper, aside from being an entire configuration resolution for Go purposes, additionally helps 12-Issue apps. 12-Issue app is a technique for constructing software-as-a-service (SAAS) purposes. Launched by Heroku, this method leverages portability, declarative codecs, and automation that makes purposes extra resilient to the adaptive wants of the altering setting of software program deployment.

Learn: Learn how to Use the flag Bundle in Go

What Does the viper Library Help in Go?

In keeping with the viper documentation, it helps the next in Go purposes:

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

Learn how to Set up viper in Go

The steps to put in viper are just like putting in some other bundle in Go. As soon as a Go software mission has been arrange correctly with the required module file utilizing the go mod init command, a go.mod file might be created. This file maintains the listing of packages used within the present mission. Simply kind: go get to put in the viper bundle. Observe {that a} new listing of packages associated to the viper bundle might be added within the go.mod file.

Go viper Code Instance

Suppose we need to get the values of the widespread Working System setting variable known as PATH. Builders could achieve this utilizing the next Go code instance:

bundle primary

import (

func primary() {
val := viper.Get("PATH")
fmt.Println("PATH:", val)

Be aware that, within the operate primary(), we used viper.BindEnv to bind a viper key to the setting variable known as PATH. It’s case delicate, which means, as the hot button is supplied, it’s going to use the setting key that matches the important thing in uppercase if given in uppercase. Since, BindEnv can take multiple argument, every will characterize setting variable names that bind to this key and might 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 setting variable. Observe within the following Golang code instance that we cannot solely retrieve values from the setting variable, but additionally set them as required:

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

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

We will additionally set new setting variables via Go code, topic to the Working System’s permission, in fact:

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

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

Learn: The Greatest Instruments for Distant Builders

Learn how to Learn JSON Configuration Recordsdata in Go along with viper

Typically, configuration recordsdata are written in a separate configuration file in one of many many alternative accessible codecs, reminiscent of JSON. The viper bundle is absolutely geared up to learn and extract data 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": {

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

fmt.Printf("Utilizing config: %sn", viper.ConfigFileUsed())

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 is just not set.")

Working with different widespread file codecs, reminiscent of YAML, TOML, HCL, and so forth, utilizing viper is kind of comparable.

Unmarshalling By means of viper in Go

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

kind 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 sometimes supplied by the bundle of the file format we need to marshall. For instance, if we need to marshall a Go kind right into a YAML file, then the YAML Go bundle will present the marshalling characteristic.

Remaining Ideas on the Go Library viper

This has been a fast overview of the viper bundle, with a glimpse of its use in Go. Extra detailed data might 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 data sought by programmers in trendy software growth.

Each functionality of viper will not be required in the mean time, 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 an alternative of utilizing command line utilities to produce too many configuration parameters and flags. On this state of affairs, the options supplied by the viper bundle might be fairly useful.

Learn extra Go programming tutorials and Golang growth ideas.



Please enter your comment!
Please enter your name here

Most Popular