Managing Environment Variables in Node.js Using the dotenv Package

When developing a Node.js application, managing environment variables is crucial for maintaining different configurations for various environments like development, testing, staging, and production. Environment variables allow the storing of sensitive information such as API keys, database credentials, and other configuration data outside the source code. This enhances security, flexibility, and maintainability.

The dotenv package makes it easy to manage environment variables across different environments by loading them from a .env file into process.env.

Why Use Environment Variables?

1. Security: Sensitive data (e.g., passwords, and API keys) are kept out of the source code.
2. Flexibility: You can easily switch between environments (e.g., development, testing, production) without changing the code.
3. Configuration: Environment-specific settings (e.g., database URLs, and third-party service credentials) can be adjusted without altering the application’s logic.

Installation:

First, install the package in your Node.js project:

npm install dotenv

Setting Up .env Files

Create a .env file in the root of your project, and specify key-value pairs for your environment variables. For example:

# Description: This file is used to store environment variables for the application
# Update the value of NODE_ENV to the following environments:
# development, test, staging, production
NODE_ENV=development

You can also create separate .env files for different environments:

- .env.development
- .env.test
- .env.staging
- .env.production

Each file will contain environment-specific values. For example:

# .env.development
# Description: Development environment variables
APP_NAME=MyApp (Development)
API_URL=http://dev.myapp.com
PORT=3000
NODE_ENV=development

# .env.test
# Description: Test environment variables
APP_NAME=MyApp (Testing)
API_URL=http://test.myapp.com
PORT=4000
NODE_ENV=test

# .env.staging
# Description: Staging environment configuration
APP_NAME=MyApp (Staging)
API_URL=http://stage.myapp.com
PORT=5000
NODE_ENV=staging

# .env.production
# Description: Production environment variables
APP_NAME=MyApp (Production)
API_URL=http://prod.myapp.com
PORT=3001
NODE_ENV=production

Loading Environment Variables Using dotenv

To load the variables from a specific .env file, you will require the dotenv package in your Node.js code. The best place to initialize this is usually at the very start of your application’s entry file (app.js or server.js). This will automatically load the variables from the .env file into process.env.

Handling Multiple Environments

A good practice is to load different environment variables based on the NODE_ENV value. You can use the dotenv package dynamically by specifying which file to load based on the environment.

const dotenv = require('dotenv');
const env = process.env.NODE_ENV || 'development';

switch (env) {
  case 'development':
    dotenv.config({ path: '.env.development' });
    break;
  case 'test':
    dotenv.config({ path: '.env.test' });
    break;
  case 'staging':
    dotenv.config({ path: '.env.staging' });
    break;
  case 'production':
    dotenv.config({ path: '.env.production' });
    break;
  default:
    throw new Error(`Unknown environment: ${env}`);
}

Now, based on the NODE_ENV value, the application will load the appropriate .env file.

Example Application

require("dotenv").config();
require("./config");

const express = require("express");
const app = express();

const PORT = process.env.PORT || 3000;

app.get("/", (req, res) => {
  res.json({
    API_URL: process.env.API_URL,
    APP_NAME: process.env.APP_NAME,
    NODE_ENV: process.env.NODE_ENV
  });
});

app.listen(PORT, () => {
console.log(`Server running in ${process.env.NODE_ENV} mode`);
console.log(`Listening on port http://localhost:${process.env.PORT}`);
});

Running the Application with Different Environments

There are several methods to assign the value of the .env variable; however, we will utilize the direct assignment approach by specifying it within the .env file. If you wish to gain further insights on this topic, consider investigating alternative methods and sharing your findings in the comments section.

# Set this value in your .env file.
NODE_ENV=development

Best Practices

1. Don’t Commit .env Files to Version Control: The .env files contain sensitive information, so they should not be committed to version control (e.g., Git). Add the .env file to your .gitignore.

# .gitignore
.env
.env.*

2. Use Environment Variables in CI/CD: Instead of storing environment variables in files in your production environment, consider configuring them directly in your hosting platform (e.g., AWS, Heroku, Azure) or your CI/CD pipeline.

3. Validate Environment Variables: It’s a good practice to validate the presence of required environment variables to avoid unexpected issues.

For example,

if (!process.env.DB_HOST || !process.env.DB_USER || !process.env.DB_PASS) {
throw new Error('Missing required database environment variables');
}

Conclusion

Managing environment variables in a Node.js application using the dotenv package simplifies switching between different environments and ensures secure handling of sensitive information. By organizing .env files and loading them dynamically based on NODE_ENV, you can create a flexible and maintainable configuration system that scales with your application.

Key Takeaways

1. Install and use dotenv to manage environment variables in Node.js.
2. Create separate .env files for different environments (development, testing, staging, production).
3. Use NODE_ENV to load environment-specific variables dynamically.
4. Never commit .env files to version control. (Note: I’ve committed the environment files to the GitHub repository mentioned below to give you an idea. but it should not be there in your application source code.)

Thank you for taking the time to read this post. I appreciate your engagement with my content. Feel free to share your thoughts in the comments section. Stay tuned for more updates. 🔖

GitHub: https://github.com/thegeekplanets/node-dotenv-example