Nodejs Environment Variables And Dotenv Complete Guide

Node.js Environment Variables and dotenv: A Comprehensive Guide

In software development, environment variables are a way to manage external configurations without embedding them directly within the codebase. They are dynamic-named values that can affect the way running processes will behave on a computer. In the context of Node.js, environment variables are commonly used to store sensitive information like API keys, database credentials, configuration settings, and more, which can vary between development, testing, and production environments.

Why Use Environment Variables?

1. Security: Protect against leaks of sensitive information by keeping secrets out of your codebase.
2. Flexibility: Easily switch between different configurations (e.g., development vs. production) without modifying the source code.
3. Separation of Concerns: Configuration settings should not be hardcoded in your application logic.
4. Scalability: Allows for scaling environments more efficiently as each instance or server can have its own set of environment variables.

Setting Environment Variables in Node.js

There are several ways to set environment variables in Node.js:

1. Command Line: You can set them before starting your node process.

   NODE_ENV=production node app.js
   

2. Operating System Configuration: Environment variables can also be configured in the OS-level settings.

3. Configuration Files: Storing environment variables in files is another approach.

dotenv Package

dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment rather than in the code is based on The Twelve-Factor App.

How to Use dotenv in Node.js Projects

1. Installation First, you need to install the dotenv package within your project:

   npm install dotenv
   

2. Create a .env File Create a .env file at the root of your project and add your configuration inside it:

   DB_HOST=localhost
   DB_USER=root
   DB_PASS=s1mpl3
   PORT=3000
   API_KEY=your_api_key_here
   

3. Configure dotenv in Your Application In your main application entry file (commonly index.js or app.js), require and configure dotenv at the very top of the file before importing any other modules:

   require('dotenv').config();
   
   const express = require('express');
   const app = express();
   
   // Now you can access your environment variables using process.env.VARIABLE_NAME
   const port = process.env.PORT || 3000;
   const dbHost = process.env.DB_HOST;
   const dbUser = process.env.DB_USER;
   const dbPass = process.env.DB_PASS;
   const apiKey = process.env.API_KEY;
   
   // For example, setting up a database connection
   const mysql = require('mysql');
   const dbConnection = mysql.createConnection({
     host: dbHost,
     user: dbUser,
     password: dbPass,
     database: 'example_db'
   });
   
   dbConnection.connect((err) => {
     if (err) throw err;
     console.log('Connected to MySQL Database!');
   });
   
   app.get('/', (req, res) => {
     res.send(`Welcome to our API with access to API_KEY=${apiKey}`);
   });
   
   app.listen(port, () => {
     console.log(`Server is running on port ${port}`);
   });
   

4. Using Multiple .env Files While dotenv reads the .env file by default, you can use different .env files for different environments. For example, you can have:

   • .env.development
   • .env.test
   • .env.production

   Then, specify the path in the config method:

   require('dotenv').config({ path: `.env.${process.env.NODE_ENV}` });
   

5. Avoiding Leaks Always add your .env and other sensitive files into the .gitignore of your project to prevent them from being pushed to version control systems like GitHub:

   # Ignore env files.
   .env
   .env.local
   .env.*.local
   

6. Error Handling Optionally, you can handle errors thrown by dotenv:

   const result = require('dotenv').config();
   
   if (result.error) {
     throw result.error
   }
   
   console.log(result.parsed);
   

7. Loading Specific Files Based on Conditions You can load different .env files based on specific conditions or logic in your application:

   let envFile = '.env';
   if (process.env.NODE_ENV === 'development') {
     envFile = '.env.development';
   } else if (process.env.NODE_ENV === 'test') {
     envFile = '.env.test';
   } else if (process.env.NODE_ENV === 'production') {
     envFile = '.env.production';
   }
   require('dotenv').config({ path: envFile });
   

8. Best Practices

   • Use environment variables for different sets of configuration.
   • Encrypt sensitive data stored in environment variables.
   • Keep your .env files private and secure.

9. Accessing in JavaScript Code After loading the .env file, you can access these variables anywhere in your application using process.env.VARIABLE_NAME.

   const host = process.env.DB_HOST || 'default_host';
   const port = process.env.DB_PORT || 5432;
   

10. Advanced Configuration dotenv supports options like encoding, debug, etc. Check dotenv’s documentation for more details.

11. Types of Information Common types of information stored in environment variables include:

    • API_KEYS: Keys required to interact with third-party APIs.
    • DATABASE_CREDENTIALS: Usernames, passwords, and endpoint URLs for databases.
    • SMTP_SETTINGS: Details required for sending emails.
    • OAUTH_SECRETS: Client and secret tokens for OAuth providers.
    • AWS_CREDENTIALS: Access keys and secret keys for AWS services.

Alternatives to dotenv

• Config Module: Another module similar to dotenv provides additional features like default configuration support.
• Vercel's dotenv-cli: Useful for running scripts with environment variables.
• dotenv-expand: Expands variables already in .env file.