Setting Environment Variables for Node to retrieve

Question

I'm trying to follow a tutorial and it says:

There are a few ways to load credentials.

Loaded from environment variables,

Loaded from a JSON file on disk,

The keys need to be as follows:
USER_ID, USER_KEY
...This means that if you properly set your environment variables, you do not need to manage credentials in your application at all.

Based on some Googling, it appears that I need to set the variables in process.env? How and where do I set these credentials? Example Please.

SamT · Accepted Answer · 2014-03-10T22:39:51.950

477

Environment variables (in this case) are being used to pass credentials to your application. USER_ID and USER_KEY can both be accessed from process.env.USER_ID and process.env.USER_KEY respectively. You don't need to edit them, just access their contents.

It looks like they are simply giving you the choice between loading your USER_ID and USER_KEY from either process.env or some specificed file on disk.

Now, the magic happens when you run the application.

USER_ID=239482 USER_KEY=foobar node app.js

That will pass the user id 239482 and the user key as foobar. This is suitable for testing, however for production, you will probably be configuring some bash scripts to export variables.

edited Mar 10 '14 at 22:39

answered Mar 10 '14 at 22:34

SamT

10,374
2
31
39

32

If you're using `fish` instead of `bash`, you need to use: `env USER_ID=239482 my_command`. For example, for setting environment variables for node.js' `debug` library: `env DEBUG='*' node some_file.js` http://fishshell.com/docs/current/faq.html#faq-single-env – SilentSteel Oct 22 '14 at 15:21
1

I found I had to remove the quotes around "*" for it to work: ```env DEBUG=* node some_file.js``` – divillysausages Jul 08 '15 at 21:20
@SamT how do set these variables in Ubuntu linux? – Zameer Ansari Jun 12 '17 at 19:43
1

is it possible to add a file rather than adding a large number of env scripts or does a unix user need to create a bash script? – mibbit Jul 08 '17 at 16:47
@mibbit yes, that's what [`dotenv`](https://www.npmjs.com/package/dotenv) is all about, as it will read your `.env` file and apply it. – balexandre Feb 21 '19 at 10:39

ctrlplusb · Answer 2 · 2017-06-13T23:33:43.533

237

I highly recommend looking into the dotenv package.

https://github.com/motdotla/dotenv

It's kind of similar to the library suggested within the answer from @Benxamin, but it's a lot cleaner and doesn't require any bash scripts. Also worth noting that the code base is popular and well maintained.

Basically you need a .env file (which I highly recommend be ignored from your git/mercurial/etc):

FOO=bar
BAZ=bob

Then in your application entry file put the following line in as early as possible:

require('dotenv').config();

Boom. Done. 'process.env' will now contain the variables above:

console.log(process.env.FOO);
// bar

The '.env' file isn't required so you don't need to worry about your app falling over in it's absence.

edited Jun 13 '17 at 23:33

answered Dec 08 '15 at 11:17

ctrlplusb

12,847
6
55
57

2

Although if you do put relevant configuration details that your app requires (such as this question is inquiring about), then it likely would fall over in its absence.. but it does still seem like a good option. – John Jan 13 '16 at 18:20
7

If you are looking for extra safety then https://github.com/rolodato/dotenv-safe and a few tests should do it. – ctrlplusb Jan 13 '16 at 23:35
1

If you're looking to not have to require it in your application: https://github.com/direnv/direnv – Alec Rust Jan 26 '16 at 19:16
This means comitting your secrets in git repo – zookastos Jul 23 '21 at 17:10
1

I wouldn't recommend that. This should be for your local environment only and the file should be gitignore'd. CI/CD should inject env variables for other environments. – ctrlplusb Jul 24 '21 at 04:42
If someoen runs into trouble - make sure you named your file '.env'. That's the default path dotenv looks for. – blz Sep 19 '21 at 11:29

score 167 · Answer 3 · edited Mar 12 '17 at 17:21

167

You can set the environment variable through process global variable as follows:

process.env['NODE_ENV'] = 'production';

Works in all platforms.

edited Mar 12 '17 at 17:21

Sebas

21,192
9
55
109

answered Feb 10 '16 at 14:25

jsbisht

9,079
7
50
55

43

... environment variables are intended to be set from the outside of the code, not indside -- so this is defeating the purpose and a bad example – Soren May 27 '16 at 11:40
77

@Soren our node program that launches child process benefited from this answer, so there are use cases for this even though it's a little unorthodox – pspi Jun 11 '16 at 04:42
2

@pspi -- I'm 99% sure *you are doing it wrong* and unless you are the author of a [config package](https://www.npmjs.com/search?q=config) like [this](https://www.npmjs.com/package/config) you should be using such config package instead. – Soren Jun 12 '16 at 17:59
34

This is useful if you are writing build scripts in js and running them from npm – Stephen Drew Nov 10 '16 at 22:49
55

This is also useful for e.g. setting and overriding the environment when running tests. – mtkopone May 29 '17 at 11:36
1

I agree that this is a great idea for tests but not for elsewhere. – eebbesen Jul 19 '17 at 01:55
Hey @Soren, here's another interesting use case for you: I use this to set the value of `NODE_ENV` before I `require("config")` with that same package, all within the scope of a `commander` CLI app.. :) Now I can reference the contents of named config files using a simple CLI argument. Simple and effective. – Sep 07 '17 at 22:38
This is not really effective for scripts because it only lasts for the current node session. For example, if I run this from the command line and then run `echo $NODE_ENV` is just returns undefined. – Jim Jun 21 '18 at 01:30
1

Found this useful for setting the HTTP_PROXY server details within node js code. Thanks! – A.J Nov 09 '18 at 06:55
We use AWS key rotation secrets which are set asynchronously. – Tino Costa 'El Nino' Mar 13 '21 at 14:24
If already set from command line this will have no effect. Must close and restart cmd so it doesn't already exist and then this will work from the script. Is useful for playing with UV_THREADPOOL_SIZE – isimmons Jun 09 '22 at 21:29
It was useful for Groovy script in Jenkins in my case lol, it runs a node script to interact with Jira (I know it might sound cumbersome but that's what we have) where I can't set an env var in Groovy 'execute' command (I tried but nothing works from the official docs) but can pass required env vars as cli args for node script, so used this as 'fallback' is script was called from Groovy with args instead of env vars (and avoided to rewrite the node script, by parsing args if they exist and set them as env vars). – Dmitry Shmakov Sep 06 '22 at 14:51
`node program that launches child process benefited from this answer`: When you launch a child process, you can pass in the `env`. It seems like you should avoid modifying the parent process env in that case – NSjonas Jul 03 '23 at 15:34

score 128 · Answer 4 · answered Mar 10 '14 at 22:40

128

Just provide the env values on command line

USER_ID='abc' USER_KEY='def' node app.js

answered Mar 10 '14 at 22:40

palanik

3,601
1
13
10

2

Just adding that it worked for me on Windows with bash shell (cygwin; installed with git tools I think). – markau Mar 17 '16 at 01:45
@TiborSzasz: Cygwin or Powershell should fix that. This is mentioned two years later, of course. – orlando marinella Jun 14 '16 at 14:15
15

For Windows use: SET USER_ID='abc' – Mike Aug 16 '16 at 09:08
1

@Mike, you should make that a proper answer :) – tu4n Nov 28 '16 at 08:09
6

We can use cross-env package (https://www.npmjs.com/package/cross-env) to make it work on unix or windwos – Brij Dec 20 '16 at 08:41

score 64 · Answer 5 · edited Nov 18 '15 at 15:22

64

If you want a management option, try the envs npm package. It returns environment values if they are set. Otherwise, you can specify a default value that is stored in a global defaults object variable if it is not in your environment.

Using .env ("dot ee-en-vee") or environment files is good for many reasons. Individuals may manage their own configs. You can deploy different environments (dev, stage, prod) to cloud services with their own environment settings. And you can set sensible defaults.

Inside your .env file each line is an entry, like this example:

NODE_ENV=development
API_URL=http://api.domain.com
TRANSLATION_API_URL=/translations/
GA_UA=987654321-0
NEW_RELIC_KEY=hi-mom
SOME_TOKEN=asdfasdfasdf
SOME_OTHER_TOKEN=zxcvzxcvzxcv

You should not include the .env in your version control repository (add it to your .gitignore file).

To get variables from the .env file into your environment, you can use a bash script to do the equivalent of export NODE_ENV=development right before you start your application.

#!/bin/bash
while read line; do export "$line";
done <source .env

Then this goes in your application javascript:

var envs = require('envs');

// If NODE_ENV is not set, 
// then this application will assume it's prod by default.
app.set('environment', envs('NODE_ENV', 'production')); 

// Usage examples:
app.set('ga_account', envs('GA_UA'));
app.set('nr_browser_key', envs('NEW_RELIC_BROWSER_KEY'));
app.set('other', envs('SOME_OTHER_TOKEN));

edited Nov 18 '15 at 15:22

Erik Gillespie

3,929
2
31
48

answered Mar 03 '15 at 00:00

Benxamin

4,774
3
31
30

2

Hmm, I tried to use this package but it seems to only track environment variable usage. It doesn't read .env file (https://www.npmjs.com/package/envs). Is it a correct package ? – wawka Apr 15 '15 at 11:57
2

You're right! It does not read the .env file. This is embarrassing. I forgot that I was loading the .env with a bash script as @SamT mentioned, so it worked anyway. – Benxamin Apr 15 '15 at 19:46
1

"require('envs')"? What is "envs"? – CodyBugstein Sep 26 '16 at 01:10
1

'envs' is the name of a node module: https://www.npmjs.com/package/envs – Benxamin Sep 26 '16 at 22:03
Sir how to generate .env file? As filename is must so how do we create .env file in windows? – Muneem Habib Feb 07 '17 at 12:38
".env" begins with a dot so that it is hidden by default on most *nix systems. This allows for basic privacy, and keeps the config out of the way while developing the app. You can name that file anything you like. I've seen environment variable settings like these: "qa.env", "stg-env", "PROD_ENV". – Benxamin Feb 08 '17 at 16:08
6

Also I recommend using the "dotenv" module, it put all the ENV variables into the proccess object, pretty neat by the way. – Bruno de Oliveira Feb 17 '17 at 17:30

score 46 · Answer 6 · edited Jan 25 '19 at 09:50

46

It depends on your operating system and your shell

On linux with the shell bash, you create environment variables like this(in the console):

export FOO=bar

For more information on environment variables on ubuntu (for example):

Environment variables on ubuntu

edited Jan 25 '19 at 09:50

WasiF

26,101
16
120
128

answered Mar 10 '14 at 22:31

leszek.hanusz

5,152
2
38
56

1

Then see this answer: http://stackoverflow.com/questions/135688/setting-environment-variables-in-os-x – leszek.hanusz Mar 10 '14 at 22:32
2

And what about Windows? Could you please add here? – YakovL May 24 '16 at 23:35
Ah, nevermind, looks like it's answered here: http://stackoverflow.com/questions/9249830/how-can-i-set-node-env-production-in-windows – YakovL May 24 '16 at 23:37
in Linux bash are these values persisted? what if I just want to run it only while the terminal is open so as to not cause issues with other applications later? – JesseBoyd Oct 20 '19 at 18:20
This worked perfectly for my need - for my `npm install --save geo-ip` which required an environment key=value setting for the install to work. – Scott Fleming Oct 11 '20 at 04:20
And about Mac? I use shelljs which create a child process – Charles-Lévi BRIANI Feb 15 '22 at 15:23

Drkawashima · Answer 7 · 2022-11-30T21:59:27.873

Windows-users: beware! These commands are recommended for Unix. But on Windows they don't persist, they only set a variable in your current shell, and it'll be gone when you restart.

SET TEST="hello world"
$env:TEST = "hello world"

3 ways to set a persistent environment variable on Windows:

A) .env file in your project - The best method. As you can just copy that file to any computer and get the same config when running the project.

Create an .env file in your project folder root with the content: TEST="hello world"
Write some node code that will read that file. I suggest installing dotenv ( npm install dotenv --save) and then add require('dotenv').config(); during your node setup code.
process.env.TEST is now usable in node

Env-files are a good way of keeping api-keys out of your codebase

B) Use Powershell - this will create a variable that will be accessible in other terminals. But it sucks as it'll be lost after you restart your computer.

[Environment]::SetEnvironmentVariable("TEST", "hello world", "User")

This method is widely recommended on Windows forums, people seem unaware it doesn't persist after a system restart....

C) Use the Windows GUI

Search for "Environment Variables" in the Start Menu Search or in the Control Panel, Select "Edit the system environment variables". A dialogue opens and you click the button "Environment Variables" at the bottom of the dialogue to open an edit-view where you can click the "New" button to add a new environment variable. Easy. And persists even after a restart. But not something you should use to config a specific codebase.

score 24 · Answer 8 · edited Jan 03 '22 at 07:03

24

Like ctrlplusb said, I recommend you to use the package dotenv, but another way to do this is creating a js file and requiring it on the first line of your app server.

env.js:

process.env.VAR1="foo"
process.env.VAR2="bar"

app.js:

require('./env') // env.js relative path.
console.log(process.env.VAR1) // foo

edited Jan 03 '22 at 07:03

dipenparmar12

3,042
1
29
39

answered Sep 14 '18 at 17:51

dpolicastro

1,379
1
14
22

I get error saying Error: Cannot find module 'env' – canbax Dec 05 '21 at 11:03
it should be `require('./env')` – canbax Dec 05 '21 at 11:10

score 11 · Answer 9 · answered Oct 19 '17 at 00:01

Step 1: Add your environment variables to their appropriate file. For example, your staging environment could be called .env.staging, which contains the environment variables USER_ID and USER_KEY, specific to your staging environment.

Step 2: In your package.json file, add the following:

"scripts": {
  "build": "sh -ac '. ./.env.${REACT_APP_ENV}; react-scripts build'",
  "build:staging": "REACT_APP_ENV=staging npm run build",
  "build:production": "REACT_APP_ENV=production npm run build",
  ...
}

then call it in your deploy script like this:

npm run build:staging

Super simple set up and works like a charm!

Source: https://medium.com/@tacomanator/environments-with-create-react-app-7b645312c09d

@jlguenego I agree, never use Windows for production servers for node. — Blairg23, Mar 21 '23 at 16:22

score 7 · Answer 10 · answered Aug 15 '19 at 11:46

Make your life easier with dotenv-webpack. Simply install it npm install dotenv-webpack --save-dev, then create an .env file in your application's root (remember to add this to .gitignore before you git push). Open this file, and set some environmental variables there, like for example:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Now, in your webpack config add:

const Dotenv = require('dotenv-webpack');
const webpackConfig = {
  node: { global: true, fs: 'empty' }, // Fix: "Uncaught ReferenceError: global is not defined", and "Can't resolve 'fs'".
  output: {
    libraryTarget: 'umd' // Fix: "Uncaught ReferenceError: exports is not defined".
  },
  plugins: [new Dotenv()]
};
module.exports = webpackConfig; // Export all custom Webpack configs.

Only const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()], and of course module.exports = webpackConfig; // Export all custom Webpack configs. are required. However, in some scenarios you might get some errors. For these you have the solution as well implying how you can fix certain error.

Now, wherever you want you can simply use process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3 in your application.

score 5 · Answer 11 · edited Apr 23 '23 at 04:21

5

If you are using a mac/linux and you want to retrieve local parameters to the machine you're using, this is what you'll do:

In terminal run nano ~/.zshrc
add a line like: export MY_VAR=var
save & run source ~/.zshrc
in node use like: console.log(process.env.MY_VAR);

Replace .zshrc with .bashrc or your config file, depending on what shell you're using (and replace nano with your preferred editor).

edited Apr 23 '23 at 04:21

Zac Anger

6,983
2
15
42

answered Sep 05 '19 at 15:13

TacoEater

2,115
20
22

2

This is exactly what I want. Thanks – Bablu Ahmed Feb 02 '21 at 03:25

score 4 · Answer 12 · edited May 23 '17 at 12:02

4

For windows users this Stack Overflow question and top answer is quite useful on how to set environement variables via the command line

How can i set NODE_ENV=production in Windows?

edited May 23 '17 at 12:02

Community

1
1

answered Sep 15 '14 at 20:06

asherrard

683
1
8
11

score 4 · Answer 13 · answered Jun 13 '15 at 09:44

4

Came across a nice tool for doing this.

node-env-file

Parses and loads environment files (containing ENV variable exports) into Node.js environment, i.e. process.env - Uses this style:

.env

# some env variables

FOO=foo1
BAR=bar1
BAZ=1
QUX=
# QUUX=

answered Jun 13 '15 at 09:44

Sean McClory

4,195
3
32
35

score 3 · Answer 14 · answered Jul 25 '17 at 15:30

As expansion of @ctrlplusb answer,
I would suggest you to also take a look to the env-dot-prop package.

It allows you to set/get properties from process.env using a dot-path.

Let's assume that your process.env contains the following:

process.env = {
  FOO_BAR: 'baz'
  'FOO_': '42'
}

Then you can manipulate the environment variables like that:

const envDotProp = require('env-dot-prop');

console.log(process.env);
//=> {FOO_BAR: 'baz', 'FOO_': '42'}

envDotProp.get('foo');
//=> {bar: 'baz', '': '42'}

envDotProp.get('foo.');
//=> '42'

envDotProp.get('foo.', {parse: true});
//=> 42

envDotProp.set('baz.foo', 'bar');
envDotProp.get('', {parse: true});
//=> {foo: {bar: 'baz', '': 42}, baz: {foo: 'bar'}}

console.log(process.env);
//=> {FOO_BAR: 'baz', 'FOO_': '42', BAZ_FOO: 'bar'}

envDotProp.delete('foo');
envDotProp.get('');
//=> {baz: {foo: 'bar'}}

console.log(process.env);
//=> {BAZ_FOO: 'bar'}

This helps you to parse the environment variables and use them as a config object in your app.
It also helps you implement a 12-factor configuration.

Manohar Reddy Poreddy · Answer 15 · 2017-08-18T04:01:37.917

A very good way of doing environment variables I have successfully used is below:

A. Have different config files:

dev.js // this has all environment variables for development only
The file contains:

module.exports = {
 ENV: 'dev',
 someEnvKey1 : 'some DEV Value1',
 someEnvKey2 : 'some DEV Value2'
};

stage.js // this has all environment variables for development only
```
..
```

qa.js // this has all environment variables for qa testing only
The file contains:

module.exports = {
 ENV: 'dev',
 someEnvKey1 : 'some QA Value1',
 someEnvKey2 : 'some QA Value2'
};

NOTE: the values are changing with the environment, mostly, but keys remain same.

you can have more
z__prod.js // this has all environment variables for production/live only
NOTE: This file is never bundled for deployment

Put all these config files in /config/ folder

<projectRoot>/config/dev.js
<projectRoot>/config/qa.js
<projectRoot>/config/z__prod.js
<projectRoot>/setenv.js
<projectRoot>/setenv.bat
<projectRoot>/setenv.sh

NOTE: The name of prod is different than others, as it would not be used by all.

B. Set the OS/ Lambda/ AzureFunction/ GoogleCloudFunction environment variables from config file

Now ideally, these config variables in file, should go as OS environment variables (or, LAMBDA function variables, or, Azure function variables, Google Cloud Functions, etc.)

so, we write automation in Windows OS (or other)

Assume we write 'setenv' bat file, which takes one argument that is environment that we want to set
Now run "setenv dev"

a) This takes the input from the passed argument variable ('dev' for now)
b) read the corresponding file ('config\dev.js')
c) sets the environment variables in Windows OS (or other)

For example,

The setenv.bat contents might be:

    node setenv.js

The setenv.js contents might be:

    // import "process.env.ENV".js file (dev.js example)
    // loop the imported file contents
    //     set the environment variables in Windows OS (or, Lambda, etc.)

That's all, your environment is ready for use.

When you do 'setenv qa', all qa environment variables will be ready for use from qa.js, and ready for use by same program (which always asks for process.env.someEnvKey1, but the value it gets is qa one).

Hope that helps.

Jonatas Walker · Answer 16 · 2022-07-18T18:57:56.847

Pretty much like some others answers but without any lib nor (bash) export.

I have some encrypted variables then I need to generate them on the fly.

The magic happens with set -a && ... && set +a which can be some content or a file.

#!/bin/sh

set -a    
SOMEVAR_A="abcd"
SOMEVAR_B="efgh"
SOMEVAR_C=123456
set +a

# or
set -a && . ./file && set +a

I have a docker-entrypoint.sh with:

#!/bin/sh

node app/config/set-environment.js

ENVFILE=/tmp/.env

if [[ ! -f "$ENVFILE" ]] ; then
    echo "File $ENVFILE is not there, aborting."
    exit
fi

# here is where things happen
set -a && . $ENVFILE && set +a

if [ "${NODE_ENV}" = "development" ]; then
  npx nodemon app/server.js
else
  node app/server.js
fi

exec "$@"

While set-environment.js generates a (tmp) .env file

score 0 · Answer 17 · answered Jun 02 '16 at 05:39

0

I was getting undefined after setting a system env var. When I put APP_VERSION in the User env var, then I can display the value from node via process.env.APP_VERSION

answered Jun 02 '16 at 05:39

omencat

1,155
1
11
18

score 0 · Answer 18 · answered Apr 30 '21 at 09:23

in case you're using visual studio code debugging feature, you can add "envFile": "${workspaceRoot}/.env" to launch configuration. This way you don't have to use dotenv.

{
        "cwd": "${workspaceRoot}",
        "command": "npm start",
        "name": "Run be",
        "request": "launch",
        "type": "node-terminal",
        "envFile": "${workspaceRoot}/.env"
},

score 0 · Answer 19 · answered Sep 15 '21 at 11:23

Use cross-env. It will save you a lot of headache

npm i -S cross-env

cross-env PARAM=value node ./index.js

That's usually good for non-credentials. For things like credentials and keys it's better not to store hardcoded user id and password but use .env file which is not in repo and dotenv

score 0 · Answer 20 · answered Aug 27 '22 at 06:34

0

Make a file called local-env and populate it with variables

PORT=80
DB_NAME=foo
SOME_URL=example.com

Now run node thusly:

source ./local_env ; node index.js

answered Aug 27 '22 at 06:34

Bob Smith

145
5

Setting Environment Variables for Node to retrieve

20 Answers20

Linked

Related