cleanenv alternatives and similar packages
Based on the "Configuration" category.
Alternatively, view cleanenv alternatives based on common mentions on social networks and blogs.
-
kelseyhightower/envconfig
Go library for managing configuration data from environment variables. -
konfig
Composable, observable and performant config handling for Go for the distributed processing era. -
koanf
Light weight, extensible library for reading config in Go applications. Built in support for JSON, TOML, YAML, env, command line. -
confita
Load configuration in cascade from multiple backends into a struct. -
config
JSON or YAML configuration wrapper with environment variables and flags parsing. -
gookit/config
application config manage(load,get,set). support JSON, YAML, TOML, INI, HCL. multi file load, data override merge. -
hjson
Human JSON, a configuration file format for humans. Relaxed syntax, fewer mistakes, more comments. -
gcfg
read INI-style configuration files into Go structs; supports user-defined types and subsections -
joshbetz/config
A small configuration library for Go that parses environment variables, JSON files, and reloads automatically on SIGHUP. -
goConfig
Parse a struct as input and populates the fields of this struct with parameters fom command line, environment variables and configuration file. -
harvester
Harvester, a easy to use static and dynamic configuration package supportig seeding, env vars and Consul integration. -
onion
Layer based configuration for Go, Supports JSON, TOML, YAML, properties, etcd, env, and encryption using PGP. -
go-aws-ssm
Go package that fetches parameters from AWS System Manager -
configuro
opinionated configuration loading & validation framework from ENV and Files focused towards 12-Factor compliant applications. -
configure
Provides configuration through multiple sources, including JSON, flags and environment variables. -
configuration
Library for initializing configuration structs from env variables, files, flags and 'default' tag. -
go-up
A simple configuration library with recursive placeholders resolution and no magic. -
hocon
Configuration library for working with the HOCON(a human-friendly JSON superset) format, supports features like environment variables, referencing other values, comments and multiple files. -
CONFLATE
Library providing routines to merge and validate JSON, YAML and/or TOML files -
go-ssm-config
Go utility for loading configuration parameters from AWS SSM (Parameter Store). -
swap
Instantiate/configure structs recursively, based on build environment. (YAML, TOML, JSON and env). -
sprbox
Build-environment aware toolbox factory and agnostic config parser (YAML, TOML, JSON and Environment vars). -
typenv
Minimalistic, zero dependency, typed environment variables library. -
gonfig
Tag-based configuration parser which loads values from different providers into typesafe struct. -
nasermirzaei89/env
Simple useful package for read environment variables. -
gone/jconf
Modular JSON configuration. Keep you config structs along the code they configure and delegate parsing to submodules without sacrificing full config serialization. -
txgruppi-config
Quick and easy way to load config files based on a simple set of rules.
Scout APM - Leading-edge performance monitoring starting at $39/month
Do you think we are missing an alternative of cleanenv or a related project?
Popular Comparisons
README
[Clean Env](logo.svg)
Clean Env
Minimalistic configuration reader
Overview
This is a simple configuration reading tool. It just does the following:
- reads and parses configuration structure from the file
- reads and overwrites configuration structure from environment variables
- writes a detailed variable list to help output
Content
- Installation
- Usage
- Model Format
- Supported types
- Custom Functions
- Supported File Formats
- Integration
- Examples
- Contribution
- Thanks
Installation
To install the package run
go get -u github.com/ilyakaznacheev/cleanenv
Usage
The package is oriented to be simple in use and explicitness.
The main idea is to use a structured configuration variable instead of any sort of dynamic set of configuration fields like some libraries does, to avoid unnecessary type conversions and move the configuration through the program as a simple structure, not as an object with complex behavior.
There are just several actions you can do with this tool and probably only things you want to do with your config if your application is not too complicated.
- read configuration file
- read environment variables
- read some environment variables again
Read Configuration
You can read a configuration file and environment variables in a single function call.
import github.com/ilyakaznacheev/cleanenv
type ConfigDatabase struct {
Port string `yaml:"port" env:"PORT" env-default:"5432"`
Host string `yaml:"host" env:"HOST" env-default:"localhost"`
Name string `yaml:"name" env:"NAME" env-default:"postgres"`
User string `yaml:"user" env:"USER" env-default:"user"`
Password string `yaml:"password" env:"PASSWORD"`
}
var cfg ConfigDatabase
err := cleanenv.ReadConfig("config.yml", &cfg)
if err != nil {
...
}
This will do the following:
- parse configuration file according to YAML format (
yaml
tag in this case); - reads environment variables and overwrites values from the file with the values which was found in the environment (
env
tag); - if no value was found on the first two steps, the field will be filled with the default value (
env-default
tag) if it is set.
Read Environment Variables Only
Sometimes you don't want to use configuration files at all, or you may want to use .env
file format instead. Thus, you can limit yourself with only reading environment variables:
import github.com/ilyakaznacheev/cleanenv
type ConfigDatabase struct {
Port string `env:"PORT" env-default:"5432"`
Host string `env:"HOST" env-default:"localhost"`
Name string `env:"NAME" env-default:"postgres"`
User string `env:"USER" env-default:"user"`
Password string `env:"PASSWORD"`
}
var cfg ConfigDatabase
err := cleanenv.ReadEnv(&cfg)
if err != nil {
...
}
Update Environment Variables
Some environment variables may change during the application run. To get the new values you need to mark these variables as updatable with the tag env-upd
and then run the update function:
import github.com/ilyakaznacheev/cleanenv
type ConfigRemote struct {
Port string `env:"PORT" env-upd`
Host string `env:"HOST" env-upd`
UserName string `env:"USERNAME"`
}
var cfg ConfigRemote
cleanenv.ReadEnv(&cfg)
// ... some actions in-between
err := cleanenv.UpdateEnv(&cfg)
if err != nil {
...
}
Here remote host and port may change in a distributed system architecture. Fields cfg.Port
and cfg.Host
can be updated in the runtime from corresponding environment variables. You can update them before the remote service call. Field cfg.UserName
will not be changed after the initial read, though.
Description
You can get descriptions of all environment variables to use them in the help documentation.
import github.com/ilyakaznacheev/cleanenv
type ConfigServer struct {
Port string `env:"PORT" env-description:"server port"`
Host string `env:"HOST" env-description:"server host"`
}
var cfg ConfigRemote
help, err := cleanenv.GetDescription(&cfg, nil)
if err != nil {
...
}
You will get the following:
Environment variables:
PORT server port
HOST server host
Model Format
Library uses tags to configure the model of configuration structure. There are the following tags:
env="<name>"
- environment variable name (e.g.env="PORT"
);env-upd
- flag to mark a field as updatable. RunUpdateEnv(&cfg)
to refresh updatable variables from environment;env-required
- flag to mark a field as required. If set will return an error during environment parsing when the flagged as required field is empty (default Go value). Tagenv-default
is ignored in this case;env-default="<value>"
- default value. If the field wasn't filled from the environment variable default value will be used instead;env-separator="<value>"
- custom list and map separator. If not set, the default separator,
will be used;env-description="<value>"
- environment variable description;env-layout="<value>"
- parsing layout (for types liketime.Time
);
Supported types
There are following supported types:
int
(any kind);float
(any kind);string
;boolean
;- slices (of any other supported type);
- maps (of any other supported type);
time.Duration
;time.Time
(layout by default is RFC3339, may be overridden byenv-layout
);- any type implementing
cleanenv.Setter
interface.
Custom Functions
To enhance package abilities you can use some custom functions.
Custom Value Setter
To make custom type allows to set the value from the environment variable, you need to implement the Setter
interface on the field level:
type MyField string
func (f *MyField) SetValue(s string) error {
if s == "" {
return fmt.Errorf("field value can't be empty")
}
*f = MyField("my field is: "+ s)
return nil
}
type Config struct {
Field MyField `env="MY_VALUE"`
}
SetValue
method should implement conversion logic from string to custom type.
Custom Value Update
You may need to execute some custom field update logic, e.g. for remote config load.
Thus, you need to implement the Updater
interface on the structure level:
type Config struct {
Field string
}
func (c *Config) Update() error {
newField, err := SomeCustomUpdate()
f.Field = newField
return err
}
Supported File Formats
There are several most popular config file formats supported:
- YAML
- JSON
- TOML
- ENV
- EDN
Integration
The package can be used with many other solutions. To make it more useful, we made some helpers.
Flag
You can use the cleanenv help together with Golang flag
package.
// create some config structure
var cfg config
// create flag set using `flag` package
fset := flag.NewFlagSet("Example", flag.ContinueOnError)
// get config usage with wrapped flag usage
fset.Usage = cleanenv.FUsage(fset.Output(), &cfg, nil, fset.Usage)
fset.Parse(os.Args[1:])
Examples
type Config struct {
Port string `yaml:"port" env:"PORT" env-default:"8080"`
Host string `yaml:"host" env:"HOST" env-default:"localhost"`
}
var cfg Config
err := ReadConfig("config.yml", &cfg)
if err != nil {
...
}
This code will try to read and parse the configuration file config.yml
as the structure is described in the Config
structure. Then it will overwrite fields from available environment variables (PORT
, HOST
).
For more details check the example directory.
Contribution
The tool is open-sourced under the [MIT](LICENSE) license.
If you will find some error, want to add something or ask a question - feel free to create an issue and/or make a pull request.
Any contribution is welcome.
Thanks
Big thanks to a project kelseyhightower/envconfig for inspiration.
The logo was made by alexchoffy.
Blog Posts
*Note that all licence references and agreements mentioned in the cleanenv README section above
are relevant to that project's source code only.