godotenv

README

GoDotEnv

Forked from this project https://github.com/joho/godotenv

Addons :

Decrypting env files that was encrypted with ansible-vault. $ANSIBLE_VAULT_PASSWORD must contain decrypting key

A Go (golang) port of the Ruby dotenv project (which loads env vars from a .env file).

From the original Library:

Storing configuration in the environment is one of the tenets of a twelve-factor app. Anything that is likely to change between deployment environments–such as resource handles for databases or credentials for external services–should be extracted from the code into environment variables.

But it is not always practical to set environment variables on development machines or continuous integration servers where multiple projects are run. Dotenv load variables from a .env file into ENV when the environment is bootstrapped.

It can be used as a library (for loading in env for your own daemons etc.) or as a bin command.

There is test coverage and CI for both linuxish and Windows environments, but I make no guarantees about the bin version working on Windows.

Installation

As a library

go get github.com/direct-dev-ru/godotenv

or if you want to use it as a bin command

go >= 1.17

go install github.com/direct-dev-ru/godotenv/cmd/godotenv@latest

go < 1.17

go get github.com/direct-dev-ru/godotenv/cmd/godotenv

Usage

Add your application configuration to your .env file in the root of your project:

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE

If your env file is encrypted by ansible vault ( starts with "$ANSIBLE_VAULT;") you must provide ANSIBLE_VAULT_PASSWORD env var to your application either from shell or inside your golang code (before godotenv.Load()) If ANSIBLE_VAULT_PASSWORD is not provided, it will be asked from console

Then in your Go app you can do something like

package main

import (
    "log"
    "os"

    "github.com/joho/godotenv"
)

func main() {
  err := godotenv.Load()
  if err != nil {
    log.Fatal("Error loading .env file")
  }

  s3Bucket := os.Getenv("S3_BUCKET")
  secretKey := os.Getenv("SECRET_KEY")

  // now do something with s3 or whatever
}

If you're even lazier than that, you can just take advantage of the autoload package which will read in .env on import

import _ "github.com/joho/godotenv/autoload"

While .env in the project root is the default, you don't have to be constrained, both examples below are 100% legit

godotenv.Load("somerandomfile")
godotenv.Load("filenumberone.env", "filenumbertwo.env")

If you want to be really fancy with your env file you can do comments and exports (below is a valid env file)

# I am a comment and that is OK
SOME_VAR=someval
FOO=BAR # comments at line end are OK too
export BAR=BAZ

Or finally you can do YAML(ish) style

FOO: bar
BAR: baz

as a final aside, if you don't want godotenv munging your env you can just get a map back instead

var myEnv map[string]string
myEnv, err := godotenv.Read()

s3Bucket := myEnv["S3_BUCKET"]

... or from an io.Reader instead of a local file

reader := getRemoteFile()
myEnv, err := godotenv.Parse(reader)

... or from a string if you so desire

content := getRemoteFileContent()
myEnv, err := godotenv.Unmarshal(content)

Precedence & Conventions

Existing envs take precedence of envs that are loaded later.

The convention for managing multiple environments (i.e. development, test, production) is to create an env named {YOURAPP}_ENV and load envs in this order:

env := os.Getenv("FOO_ENV")
if "" == env {
  env = "development"
}

godotenv.Load(".env." + env + ".local")
if "test" != env {
  godotenv.Load(".env.local")
}
godotenv.Load(".env." + env)
godotenv.Load() // The Original .env

If you need to, you can also use godotenv.Overload() to defy this convention and overwrite existing envs instead of only supplanting them. Use with caution.

Command Mode

Assuming you've installed the command as above and you've got $GOPATH/bin in your $PATH

godotenv -f /some/path/to/.env some_command with some args

If you don't specify -f it will fall back on the default of loading .env in PWD

By default, it won't override existing environment variables; you can do that with the -o flag.

Writing Env Files

Godotenv can also write a map representing the environment to a correctly-formatted and escaped file

env, err := godotenv.Unmarshal("KEY=value")
err := godotenv.Write(env, "./.env")

... or to a string

env, err := godotenv.Unmarshal("KEY=value")
content, err := godotenv.Marshal(env)

Contributing

Contributions are welcome, but with some caveats.

This library has been declared feature complete (see #182 for background) and will not be accepting issues or pull requests adding new functionality or breaking the library API.

Contributions would be gladly accepted that:

• bring this library's parsing into closer compatibility with the mainline dotenv implementations, in particular Ruby's dotenv and Node.js' dotenv
• keep the library up to date with the go ecosystem (ie CI bumps, documentation changes, changes in the core libraries)
• bug fixes for use cases that pertain to the library's purpose of easing development of codebases deployed into twelve factor environments

code changes without tests and references to peer dotenv implementations will not be accepted

1. Fork it
2. Create your feature branch (git checkout -b my-new-feature)
3. Commit your changes (git commit -am 'Added some feature')
4. Push to the branch (git push origin my-new-feature)
5. Create new Pull Request

Releases

Releases should follow Semver though the first couple of releases are v1 and v1.1.

Use annotated tags for all releases. Example git tag -a v1.2.1

Who?

The original library dotenv was written by Brandon Keepers, and this port was done by John Barton based off the tests/fixtures in the original library.

Documentation

Overview

Package godotenv is a go port of the ruby dotenv library (https://github.com/bkeepers/dotenv)

Examples/readme can be found on the GitHub page at https://github.com/joho/godotenv

The TL;DR is that you make a .env file that looks something like

SOME_ENV_VAR=somevalue

and then in your go code you can call

godotenv.Load()

and all the env vars declared in .env will be available through os.Getenv("SOME_ENV_VAR")

Index

• func Exec(filenames []string, cmd string, cmdArgs []string, overload bool) error
• func Load(filenames ...string) (err error)
• func Marshal(envMap map[string]string) (string, error)
• func Overload(filenames ...string) (err error)
• func Parse(r io.Reader) (map[string]string, error)
• func Read(filenames ...string) (envMap map[string]string, err error)
• func Unmarshal(str string) (envMap map[string]string, err error)
• func UnmarshalBytes(src []byte) (map[string]string, error)
• func Write(envMap map[string]string, filename string) error

Functions

func Exec

func Exec(filenames []string, cmd string, cmdArgs []string, overload bool) error

Exec loads env vars from the specified filenames (empty map falls back to default) then executes the cmd specified.

Simply hooks up os.Stdin/err/out to the command and calls Run().

If you want more fine grained control over your command it's recommended that you use `Load()`, `Overload()` or `Read()` and the `os/exec` package yourself.

func Load

func Load(filenames ...string) (err error)

Load will read your env file(s) and load them into ENV for this process.

Call this function as close as possible to the start of your program (ideally in main).

If you call Load without any args it will default to loading .env in the current path.

You can otherwise tell it which files to load (there can be more than one) like:

godotenv.Load("fileone", "filetwo")

It's important to note that it WILL NOT OVERRIDE an env variable that already exists - consider the .env file to set dev vars or sensible defaults.

func Marshal

func Marshal(envMap map[string]string) (string, error)

Marshal outputs the given environment as a dotenv-formatted environment file. Each line is in the format: KEY="VALUE" where VALUE is backslash-escaped.

func Overload

func Overload(filenames ...string) (err error)

Overload will read your env file(s) and load them into ENV for this process.

Call this function as close as possible to the start of your program (ideally in main).

If you call Overload without any args it will default to loading .env in the current path.

You can otherwise tell it which files to load (there can be more than one) like:

godotenv.Overload("fileone", "filetwo")

It's important to note this WILL OVERRIDE an env variable that already exists - consider the .env file to forcefully set all vars.

func Parse

func Parse(r io.Reader) (map[string]string, error)

Parse reads an env file from io.Reader, returning a map of keys and values. Also decrypt if file has ansible-vault encrypting prefix Decryptyng key is expected in ANSIBLE_VAULT_PASSWORD environment variable

func Read

func Read(filenames ...string) (envMap map[string]string, err error)

Read all env (with same file loading semantics as Load) but return values as a map rather than automatically writing values into env

func Unmarshal

func Unmarshal(str string) (envMap map[string]string, err error)

Unmarshal reads an env file from a string, returning a map of keys and values.

func UnmarshalBytes

func UnmarshalBytes(src []byte) (map[string]string, error)

UnmarshalBytes parses env file from byte slice of chars, returning a map of keys and values.

func Write

func Write(envMap map[string]string, filename string) error

Write serializes the given environment and writes it to a file.