README
¶
env
Simple lib to parse envs to structs in Go.
Example
A very basic example:
package main
import (
"fmt"
"time"
"github.com/caarlos0/env/v6"
)
type config struct {
Home string `env:"HOME"`
Port int `env:"PORT" envDefault:"3000"`
Password string `env:"PASSWORD,unset"`
IsProduction bool `env:"PRODUCTION"`
Hosts []string `env:"HOSTS" envSeparator:":"`
Duration time.Duration `env:"DURATION"`
TempFolder string `env:"TEMP_FOLDER" envDefault:"${HOME}/tmp" envExpand:"true"`
}
func main() {
cfg := config{}
if err := env.Parse(&cfg); err != nil {
fmt.Printf("%+v\n", err)
}
fmt.Printf("%+v\n", cfg)
}
You can run it like this:
$ PRODUCTION=true HOSTS="host1:host2:host3" DURATION=1s go run main.go
{Home:/your/home Port:3000 IsProduction:true Hosts:[host1 host2 host3] Duration:1s}
Supported types and defaults
Out of the box all built-in types are supported, plus a few others that are commonly used.
Complete list:
stringboolintint8int16int32int64uintuint8uint16uint32uint64float32float64stringtime.Durationencoding.TextUnmarshalerurl.URL
Pointers, slices and slices of pointers of those types are also supported.
You can also use/define a custom parser func for any other type you want.
If you set the envDefault tag for something, this value will be used in the
case of absence of it in the environment.
By default, slice types will split the environment value on ,; you can change
this behavior by setting the envSeparator tag.
If you set the envExpand tag, environment variables (either in ${var} or
$var format) in the string will be replaced according with the actual value
of the variable.
Unexported fields are ignored.
Custom Parser Funcs
If you have a type that is not supported out of the box by the lib, you are able
to use (or define) and pass custom parsers (and their associated reflect.Type)
to the env.ParseWithFuncs() function.
In addition to accepting a struct pointer (same as Parse()), this function
also accepts a map[reflect.Type]env.ParserFunc.
env also ships with some pre-built custom parser funcs for common types. You
can check them out here.
If you add a custom parser for, say Foo, it will also be used to parse
*Foo and []Foo types.
This directory contains pre-built, custom parsers that can be used with env.ParseWithFuncs
to facilitate the parsing of envs that are not basic types.
Check the example in the go doc for more info.
A note about TextUnmarshaler and time.Time
Env supports by default anything that implements the TextUnmarshaler interface.
That includes things like time.Time for example.
The upside is that depending on the format you need, you don't need to change anything.
The downside is that if you do need time in another format, you'll need to create your own type.
Its fairly straightforward:
type MyTime time.Time
func (t *MyTime) UnmarshalText(text []byte) error {
tt, err := time.Parse("2006-01-02", string(text))
*t = MyTime(tt)
return err
}
type Config struct {
SomeTime MyTime `env:"SOME_TIME"`
}
And then you can parse Config with env.Parse.
Required fields
The env tag option required (e.g., env:"tagKey,required") can be added to ensure that some environment variable is set.
In the example above, an error is returned if the config struct is changed to:
type config struct {
SecretKey string `env:"SECRET_KEY,required"`
}
Not Empty fields
While required demands the environment variable to be check, it doesn't check its value.
If you want to make sure the environment is set and not emtpy, you need to use the notEmpty tag option instead (env:"SOME_ENV,notEmpty").
Example:
type config struct {
SecretKey string `env:"SECRET_KEY,notEmpty"`
}
Unset environment variable after reading it
The env tag option unset (e.g., env:"tagKey,unset") can be added
to ensure that some environment variable is unset after reading it.
Example:
type config struct {
SecretKey string `env:"SECRET_KEY,unset"`
}
From file
The env tag option file (e.g., env:"tagKey,file") can be added
to in order to indicate that the value of the variable shall be loaded from a file. The path of that file is given
by the environment variable associated with it
Example below
package main
import (
"fmt"
"time"
"github.com/caarlos0/env/v6"
)
type config struct {
Secret string `env:"SECRET,file"`
Password string `env:"PASSWORD,file" envDefault:"/tmp/password"`
Certificate string `env:"CERTIFICATE,file" envDefault:"${CERTIFICATE_FILE}" envExpand:"true"`
}
func main() {
cfg := config{}
if err := env.Parse(&cfg); err != nil {
fmt.Printf("%+v\n", err)
}
fmt.Printf("%+v\n", cfg)
}
$ echo qwerty > /tmp/secret
$ echo dvorak > /tmp/password
$ echo coleman > /tmp/certificate
$ SECRET=/tmp/secret \
CERTIFICATE_FILE=/tmp/certificate \
go run main.go
{Secret:qwerty Password:dvorak Certificate:coleman}
Options
Environment
By setting the Options.Environment map you can tell Parse to add those keys and values
as env vars before parsing is done. These envs are stored in the map and never actually set by os.Setenv.
This option effectively makes env ignore the OS environment variables: only the ones provided in the option are used.
This can make your testing scenarios a bit more clean and easy to handle.
package main
import (
"fmt"
"log"
"github.com/caarlos0/env/v6"
)
type Config struct {
Password string `env:"PASSWORD"`
}
func main() {
cfg := &Config{}
opts := &env.Options{Environment: map[string]string{
"PASSWORD": "MY_PASSWORD",
}}
// Load env vars.
if err := env.Parse(cfg, opts); err != nil {
log.Fatal(err)
}
// Print the loaded data.
fmt.Printf("%+v\n", cfg.envData)
}
Changing default tag name
You can change what tag name to use for setting the env vars by setting the Options.TagName
variable.
For example
package main
import (
"fmt"
"log"
"github.com/caarlos0/env/v6"
)
type Config struct {
Password string `json:"PASSWORD"`
}
func main() {
cfg := &Config{}
opts := &env.Options{TagName: "json"}
// Load env vars.
if err := env.Parse(cfg, opts); err != nil {
log.Fatal(err)
}
// Print the loaded data.
fmt.Printf("%+v\n", cfg.envData)
}
Stargazers over time
Documentation
¶
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( // ErrNotAStructPtr is returned if you pass something that is not a pointer to a // Struct to Parse. ErrNotAStructPtr = errors.New("env: expected a pointer to a Struct") )
nolint: gochecknoglobals
Functions ¶
func Parse ¶
Parse parses a struct containing `env` tags and loads its values from environment variables.
Example ¶
type inner struct {
Foo string `env:"FOO" envDefault:"foobar"`
}
type config struct {
Home string `env:"HOME,required"`
Port int `env:"PORT" envDefault:"3000"`
IsProduction bool `env:"PRODUCTION"`
Inner inner
}
os.Setenv("HOME", "/tmp/fakehome")
var cfg config
if err := Parse(&cfg); err != nil {
fmt.Println("failed:", err)
}
fmt.Printf("%+v", cfg)
Output: {Home:/tmp/fakehome Port:3000 IsProduction:false Inner:{Foo:foobar}}
func ParseWithFuncs ¶
func ParseWithFuncs(v interface{}, funcMap map[reflect.Type]ParserFunc, opts ...Options) error
ParseWithFuncs is the same as `Parse` except it also allows the user to pass in custom parsers.
Example ¶
type thing struct {
desc string
}
type conf struct {
Thing thing `env:"THING"`
}
os.Setenv("THING", "my thing")
c := conf{}
err := ParseWithFuncs(&c, map[reflect.Type]ParserFunc{
reflect.TypeOf(thing{}): func(v string) (interface{}, error) {
return thing{desc: v}, nil
},
})
if err != nil {
fmt.Println(err)
}
fmt.Println(c.Thing.desc)
Output: my thing
Types ¶
type Options ¶
type Options struct {
// Environment keys and values that will be accessible for the service.
Environment map[string]string
// TagName specifies another tagname to use rather than the default env.
TagName string
// RequiredIfNoDef automatically sets all env as required if they do not declare 'envDefault'
RequiredIfNoDef bool
// contains filtered or unexported fields
}
Options for the parser.
type ParserFunc ¶
ParserFunc defines the signature of a function that can be used within `CustomParsers`.
Source Files