Friday, October 7, 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 package deal is hottest amongst them in offering an entire configuration answer of an software. 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 atmosphere? Now we have a listing of the Finest On-line Programs to Be taught Go and Golang that will help you get began.

What’s the viper Library in Go and Golang?

As talked about, viper is a package deal that gives an entire configuration answer in a Go venture. Managing and sustaining configuration for a giant and complex software – akin to constructing a server software or some other software which relies upon quite a bit on person manipulation of configurations – just isn’t a straightforward job. Furthermore, fashionable purposes are constructed to deploy in several types of environments, akin to in Docker, cloud infrastructures, and so forth. Consequently, with a purpose to preserve consistency throughout deployment, purposes needs to be constructed to be open from little to excessive configurability. An exterior assist that helps on this respect just isn’t 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 offers provisions for creating UNIX techniques, akin to command line utilities. Based on the viper documentation, viper, other than being an entire configuration answer for Go purposes, additionally helps 12-Issue apps. 12-Issue app is a strategy for constructing software-as-a-service (SAAS) purposes. Launched by Heroku, this system leverages portability, declarative codecs, and automation that makes purposes extra resilient to the adaptive wants of the altering atmosphere of software program deployment.

Learn: The best way to Use the flag Package deal in Go

What Does the viper Library Help in Go?

Based on 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.
  • Organising default configurations
  • Studying atmosphere variables
  • Studying distant configuration techniques
  • Studying from command line flags
  • Studying from buffer
  • Setting express values

The best way to 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 software venture has been arrange correctly with the required module file utilizing the go mod init command, a go.mod file shall be created. This file maintains the checklist of packages used within the present venture. Simply sort: go get to put in the viper package deal. Observe {that a} new checklist of packages associated to the viper package deal shall be added within the go.mod file.

Go viper Code Instance

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

package deal predominant

import (

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

Observe that, within the operate predominant(), we used viper.BindEnv to bind a viper key to the atmosphere variable known as PATH. It’s case delicate, which means, as the hot button is supplied, it’ll use the atmosphere key that matches the important thing in uppercase if given in uppercase. Since, BindEnv can take a couple of argument, every will characterize atmosphere variable names that bind to this key and shall 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 atmosphere variable. Observe within the following Golang code instance that we can’t solely retrieve values from the atmosphere 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 atmosphere variables by Go code, topic to the Working System’s permission, after all:

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

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

Learn: The Finest Instruments for Distant Builders

The best way 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 obtainable codecs, akin to JSON. The viper package deal is absolutely outfitted to learn and extract data saved there. Right here is a few fast instance code of 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 just isn't set.")

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

Unmarshalling By viper in Go

Apparently, viper additionally offers the function of unmarshalling of values from configuration recordsdata to Go varieties akin to struct, map, and so forth. Here’s a fast instance of 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!")

Observe 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 function.

Closing 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 data could be obtained from the viper documentation itself. Perceive that viper, in spite of everything, is a device for use based on the requirement of the software program being developed. It helps many wonderful options associated to storing and retrieving configuration data sought by programmers in fashionable software growth.

Each functionality of viper might not be 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 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 package deal could be fairly useful.

Learn extra Go programming tutorials and Golang growth suggestions.



Please enter your comment!
Please enter your name here

Most Popular

Recent Comments