Managing Environment Variables

Environment variables play a crucial role in configuring nodeJS applications across different deployment environments. They allow developers to manage sensitive information, such as API keys, API Tokens or database URLs, without hardcoding them into the source code.

In this part, we'll explore how to read environment variables in Node.js and best practices for handling them

What are Environment Variables?

Environment variables are dynamic values that are set outside of the application and are accessible by all processes running on the system.

They are commonly used to store configuration settings such as API keys, database URLs, and other sensitive information. They provide a convenient way to manage configuration without hardcoding values into the application code.

Accessing Environment Variables in Node.js

NodeJS provides access to environment variables through the process.env object. This object contains key-value pairs of environment variable names and their corresponding values, that were set at the moment the node process was started.

Here's a basic example of how to access an environment in node:

// Accessing the value of the PORT environment variable
const port = process.env.PORT || 3000;

In this example, we're accessing the value of the `PORT` environment variable. If the `PORT` variable is not set, the application will default to using port 3000.

In the same way you can access any number of custom environment variable you set.

Setting Environment Variables

Environment variables can be set in various ways depending on the deployment environment. Let's explore some common methods:

1. Command Line:

Environment variables can be set directly in the terminal before running the node application.

The following example runs index.js and sets PORT, PAGE_SIZE, UNIVERSAL_TOKEN.

$ PORT=8080 PAGE_SIZE=50 UNIVERSAL_TOKEN=xxpro000111 node app.js

That will pass the user PORT as 8080, the PAGE_SIZE as 50 and the UNIVERSAL_TOKEN as xxpro000111.

This is suitable for development, testing, however for production, you will probably be configuring some bash scripts to export variables.

Her's how you can access the above set environment varibles:

const PORT = process.env.PORT ; 
const PAGE_SIZE = process.env.PAGE_SIZE ; 
const UNIVERSAL_TOKEN = process.env.UNIVERSAL_TOKEN ; 

// or you can use destructuring
//const {PORT, PAGE_SIZE, UNIVERSAL_TOKEN} = process.env ;

2. Environment Configuration Files

Environment variables can be stored in configuration files specific to each environment (e.g., development, staging and production).

Tools like `dotenv` (dotenv npm package) can be used to load these variables from a .env file into process.env.

- Start by installing the package in your project.

npm i dotenv

- Then create a .env file and add the following to it.

PORT=8080 
PAGE_SIZE=50 
UNIVERSAL_TOKEN=xxpro000111

- Finally, in your codebase, most often in app entry file (server.js, index.js or app.js), you can read the variable as below:

// app.js or server.js, or index.js
require('dotenv').config();

// some more imports

const PORT = process.env.PORT ; 
const PAGE_SIZE = process.env.PAGE_SIZE ; 
const UNIVERSAL_TOKEN = process.env.UNIVERSAL_TOKEN ; 

// or you can use destructuring
//const {PORT, PAGE_SIZE, UNIVERSAL_TOKEN} = process.env ;

// rest of the code

Using environment configuration files enhances portability and ensures consistency across different environments. However, be cautious not to expose sensitive information in these files.

3. Deployment Platforms

Many cloud platforms and hosting services allow you to set environment variables through their dashboards or command-line interfaces.

For example, on Heroku, you can use the Heroku CLI to set environment variables as shown in the command below:

$ heroku config:set PORT=8080

Similarly, AWS Elastic Beanstalk provides a web interface for configuring environment variables.

Personally, I think the prefered option is to use the dashboard rather than the CLI for setting your environment variable whenever applicable.

EXTRA: Built-in .env file support

Starting from Node.js v20.6.0, node supports .env files for configuring environment variables by specifying an environment file using the --env-file argument.

This feature allows you to load environment variables from a file directly without using a third-party library like dotenv.

Depending on the usecase, you can run the command as follows:

$ node --env-file .env.production app.js

Reading Multiple Environment Files

Sometimes, it's necessary to load environment variables from multiple files, such as separate files for different deployment stages (e.g., development, production).

You can achieve this by chaining multiple dotenv configurations in your node application.

require('dotenv').config(); // Load default .env file

// Load additional environment files
require('dotenv').config({ path: '.env.development' });
require('dotenv').config({ path: '.env.production' });
require('dotenv').config({ path: '.env.staging' });

This approach allows you to specify different environment variables for each deployment stage while maintaining the simplicity and consistency of using environment configuration files.

Precedence and Collision Resolution

When multiple methods are used to set environment variables, precedence rules determine which value takes effect:

1. 1.Command Line Arguments: Environment variables passed as command-line arguments take the highest precedence. They override values from all other sources.
2. 2.Environment Configuration Files: Values from .env files are typically used during development. They take precedence over values set in the system environment but are overridden by command-line arguments.
3. 3.System Environment Variables: Environment variables set directly in the system environment have lower precedence. They are overridden by values from command-line arguments, .env files, and --env-file arguments.
   

Conclusion

In modeJS applications, managing environment variables effectively is crucial for maintaining security and portability.

By understanding the various methods for setting and reading environment variables, along with their precedence rules, developers can configure their applications reliably across different deployment environments.

Whether it's through command-line arguments, environment configuration files, deployment platforms, or experimental features like --env-file, choosing the right method depends on the specific requirements and constraints of your project.

By following best practices and understanding precedence rules, you can ensure that your node applications are well-configured and ready for deployment.

In the next part, we'll explore writing out to the command line.