HomeBlogWeb DevelopmentA Guide to Node Environment Variables [Process.env Node]

A Guide to Node Environment Variables [Process.env Node]

Published
25th May, 2024
Views
view count loader
Read it in
11 Mins
In this article
    A Guide to Node Environment Variables [Process.env Node]

    Developers need to pay attention to several things when configuring Nodejs applications. All applications are typically required to deploy in a development environment before being deployed in the production environment, and it is crucial to be certain that each environment has been set up right. If our production application is using our development credentials, it will be disastrous. 

    Here Environment variables come in handy, they are one of the preferred strategies to define and consume environment-specific configurations and are supported by all the major operating systems. Environment variables allow us to supervise the configuration of our applications separately from our base code. Separate configurations promote the implementation of our application in different environments (development, test, production), allowing our app to behave differently based on the environment they are running in.  

    An alternate approach to learning more about node environment variables is to go through this Node.js full course. The env files provide a popular solution for setting up the environment variables, particularly in Node.js. Platforms like Heroku, for example, use .env files as recommended best practices. They can be defined in the majority of cloud-provider Platforms as a Service (PaaS) offerings, and are a typical method for configuring many platforms like Heroku, Azure, AWS, etc. 

    In this post, let us look at a simple Node.js application configured via node environment variables and walk-through creating and using environment variables, leading to a Node.js app that can run anywhere. 

    Basics of Node Environment Variables

    In Node.js, Environment variables are Accessible and supported out of the box. When the Node.js process boots up, it automatically provides access to all the existent environment variables by building the env object as a property of the global object called process. 

    These variables are external to our application and reside in the operating system or the container of the running application. An environment variable is merely a name assigned to a value. 

    By convention, the names are capitalized and the values are strings.
    For example, PORT = 3000. 


    When a Node.js application commences or a script is run, a new child process is launched, inheriting the `environment variables` from the parent process. These environment variables are parsed by the node application, creating a process.env object with string format key value pairing. Some common examples are: 

    • HTTP Address and Port number. 
    • Database Credentials. 
    • Location of static files and folders. 
    • Credentials of External API. 

    Do you want to see how to utilize this in real projects? Then check out the Full-stack Developer course with placement guarantee. 

    What is process.env in Node JS?

    The process.env is a global variable injected at runtime by your Node.js application to depict the state of the environment your app is in at the time of initiation and utilize the same at runtime. There by, its basic use is to depict the state of the system environment of our app on initialization. 

    For example, if you set a PORT variable in the system, it can be accessed through the process.env.PORT variable because, when we set an environment variable, it is loaded into process.env during runtime and can later be accessed. 

    To inspect the contents of process.env, we can use an interactive Node terminal as done below. 

    Till now you would have understood how environment variables in a Node application are populated, so let's dive in to understand how to work with them. 

    Also, read about how to export Node.js modules using exports. 

    process.env: Listing of Environment Variables

    The process.env is a global object used to access all the environment variables of the environment your application is running. That means that it is accessible everywhere in our application. 

    If you want to take a look at this object, run the Node.js REPL with “node” in your command line and then type: 

    console.log(process.env);

    This code will output all environment variables that this Node.js process can pick up. 


    Now that we have accessed the process.env object by logging it onto the console, we can also similarly list the default environment variables of our application. Accessing an environment variable from process.env is no different from that of a typical object: 

    const PATH = process.env.PATH

    The one significant difference with the process.env object is that all the key and value pairs will always be strings, as environment variables can only be strings. 

    Note* 

    On the contrary, if a value in the environment variables needs to be of non-string type, it must be parsed or cast, e.g., casting a PORT environment variable to an integer:r: 

    const PORT = parseInt(process.env.PORT); 

    Installing Environment Variables

    Node.js natively does not load .env files, so we must utilize the dotenv package to load the file and expose the values via process.env. 

    As per the definition from its package, Dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment separate from code is based on The Twelve-Factor App methodology. 

    Let's start by adding dotenv as a project dependency in the package.json file under the dependencies property. 

    Next, download the dependency with the following: 

    npm i 

    Alternatively, you can use the below command which will automatically update the package file. 

    npm install dotenv --save

    Now we can create a .env file at the root of our node.js project, which will contain all your environment variables related to your project. Though, to load the .env file, we must load the dotenv package and call the configure() function at the very start of the index.js file: 

    require('dotenv').config();

    The above code present in your index file automatically loads the .env file in the root of your project and initializes the values, skipping any variables already present. Though, be careful and do not use .env files in your production environment. Instead, place them on the respective host to secure them. And therefore, you should wrap your load statement in an if statement using the node js node_env variable like the one below. 

    if (process.env.NODE_ENV !== 'production') { 
  require('dotenv').config(); 
}

    Now we can access our environment variables and list them in our node.js project for node_env development. 

    Installing Custom Environment Variables

    As our application now has the power to read the .env file, it becomes even easier to customize and create custom environment variables. 

    Customizing a .env file can be done by writing the name of the environment variable we want to override at the start of each line, followed by ‘=’ sign and then the string value that is to be assigned to it. 

    Let us understand the same by taking the example below, we assign new values for the variables PORT and MYNAME in the .env file as shown: 

    Now, run the application with the following command: 

    node src/index.js 

    Next, open http://localhost:5001; notice the port changed and the message Hello, Jane! returns. 

    This example helps us understand how easy it is to add custom variables to our env file. Similarly, many more variables can be added to the env file as per the environment. 

    For next steps, check out our blog posts about what is Node_ENV production and how to get it on windows? 

    How to Check If Environment Variables are Installed? 

    Ensuring that Node environment variables are present is essential to the stability of a Node.js application. Use conditional statements to check if specific variables exist in process.env, ensuring they're set before utilization. For instance: 

    if (process.env.MY_VARIABLE) { 
  console.log('MY_VARIABLE is present:', process.env.MY_VARIABLE); 
} else { 
  console.error('MY_VARIABLE is not set. Please configure it.'); 
  // Handle absence appropriately, e.g., throw an error or exit. 
} 

    Enhance robustness by providing default values for critical variables, ensuring your application gracefully handles potential absence. Additionally, implement health checks that assess overall application health, including the presence of essential environment variables: 

    const requiredVariables = ['API_KEY', 'DATABASE_URL', 'SECRET_KEY']; 
for (const variable of requiredVariables) { 
  if (!process.env[variable]) { 
    console.error(`${variable} is missing. Application cannot start.`); 
    process.exit(1); // Exit with an error code. 
  } 
} 

    By adopting these practices, fortify your Node.js application against potential issues related to environment variable management. 

    How to Initialize Your First env Variable with Node JS? 

    In Node.js, setting up your first environment variable is an essential part of application configuration. Follow these three straightforward steps to initialize and manage node environment variables effectively: 

    Step 1: Declare the Variable  

    Begin by declaring your environment variable within your Node.js application. You can accomplish this by giving the process.env object a value. For example, if you want to set a variable named DATABASE_URL to store your database connection string, add the following line to your code: 

    // Inside your Node.js script or main file 
process.env.DATABASE_URL = "your_database_connection_string"; 

    The DATABASE_URL environment variable is given a connection string by this code. Ensure that this declaration is made early in your application, preferably near the beginning of your script. 

    Step 2: Storing Sensitive Information 

    When dealing with sensitive information like API keys or passwords, it's essential to prioritize security. Steers clear of hardcoding private information into your code directly. Instead, use node environment variables to store and access these values securely. For instance: 

    process.env.API_KEY = 'your_api_key'; 
process.env.DB_PASSWORD = 'your_database_password'; 

    Step 3: Accessing the Variable in Your Code 

    Once your environment variable is declared and populated, you can access it within your Node.js application. Use the variable wherever needed, enhancing the flexibility of your code. For example: 

    const dbConnectionString = process.env.DB_CONNECTION_STRING; 
console.log(`Connected to the database using: ${dbConnectionString}`); 

    By following these steps, you've successfully initialized your first environment variable in Node.js. This practice not only streamlines configuration but also enhances security by keeping sensitive information separate from your codebase. As you continue developing your application, leverage node environment variables for efficient and secure configuration management. 

    How to Use Node Environment Variables?   

    It's usual practice to configure and customize your Node.js apps by using environment variables. During runtime, your Node.js application can access external values through environment variables. They are useful for storing configuration settings, sensitive information, or any data that may vary between different environments (e.g., development, testing, production).  

    This is a comprehensive explanation describing how to utilize node environment variables in Node.js: 

    A. Understanding Environment Variables 

    • Environment variables in Node.js are key-value pairs that exist outside of your application code. 
    • They are often used to store configuration details such as API keys, database URLs, and other sensitive information. 
    • With the process.env object in Node.js, you may retrieve Node environment variables. 

    B. Setting Environment Variables 

    Command Line 

    • Set environment variables in Node.js before running your Node.js script in the command line. 
    • Example: 
    NODE_ENV=production node app.js 

    Using a .env file (recommended for development): 

    • Create a file named .env in your project's root. 
    • Add key-value pairs in the format KEY=VALUE for each variable. 
    DATABASE_URL=mongodb://localhost:27017/mydatabase 
API_KEY=your_api_key 

    • Use a package like dotenv to load these variables into your Node.js script. 

    C. Cloud Environments 

    In cloud platforms (e.g., Heroku, AWS Lambda), configure environment variables through the respective platform's interface. 

    D. Accessing Environment Variables in Node.js 

    • Use process.env to access environment variables in your Node.js code. 
    • For example, to access the DATABASE_URL variable: 
    const databaseUrl = process.env.DATABASE_URL; 

    E. Using a Package for .env Files 

    • For development, consider using a package like dotenv to load environment variables from a .env file. 
    • Install the package: 
    npm install dotenv 

    • In your Node.js script, add the following at the top: 

    require('dotenv').config(); 

    Now, you can access node environment variables without explicitly loading them. 

    F. Default Values and Validation 

    a. Provide Default Values: Provide default values for env variables in node.js to handle cases where they are not set. 

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

    Validation: Validate the presence of critical variables to avoid runtime errors. 

    if (!process.env.API_KEY) { 
  console.error('API_KEY is not set. Exiting...'); 
  process.exit(1); 
} 

    G. Security Considerations 

    1. Sensitive Information 

    • Refrain from putting private data straight into your code.  
    • When working with secrets, use node environment variables.  
    • When it's feasible, encrypt private information.  

    2. Setting up for Production 

    • Configure node environment variables securely in production environments. 
    • Limit access to sensitive variables. 

    Examples 

    • A simple example accessing an environment variable: 
    const apiKey = process.env.API_KEY; 
console.log(`API Key: ${apiKey}`); 
    • Using default values: 
    const port = process.env.PORT || 3000; 
console.log(`Server is running on port ${port}`); 

    Usage Best Practices with Examples  

    When incorporating env variables in Node.js applications, it's crucial to follow best practices to ensure security, maintainability, and adaptability to different environments. 

    1. Dos 

    A. Use Descriptive Names: Use meaningful names for node environment variables to enhance code readability and facilitate easier maintenance. 

    // Good 
const databaseUrl = process.env.DATABASE_URL; 
// Avoid 
const db = process.env.DB; 

    B. Default Values: Provide default values for essential variables to ensure your application gracefully handles scenarios where a variable is not set. 

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

    C. Configuration Settings: Leverage node environment variables for configuration settings. For instance, use them for database connections, API keys, or feature flags, making your application more adaptable. 

    const dbConnection = createConnection(process.env.DB_URL); 

    2. Don'ts 

    A. Hardcoding Sensitive Data 

    Refrain from hardcoding sensitive information directly into your code. Instead, securely store such details in env variables in node.js. 

    // Avoid 
const apiKey = 'your-api-key'; 
// Better 
const apiKey = process.env.API_KEY; 

    B. Avoid Overloading a Single Variable 

    Resist the temptation to overload a single node environment variable with multiple values. This can lead to confusion and increased code complexity. 

    // Avoid 
const config = process.env.CONFIG; // Difficult to manage 
// Better 
const apiKey = process.env.API_KEY; 
const apiUrl = process.env.API_URL; 

    Common Pitfalls and How to Avoid Them?

    While using node environment variables, be mindful of common pitfalls to prevent potential issues in your Node.js applications. 

    Pitfall 1: Lack of Validation 

    • Issue: Not validating or sanitizing environment variable inputs can lead to unexpected behavior or security vulnerabilities. 
    • Solution: Implement thorough validation and sanitization for user inputs, especially when using env variables in node.jsto configure sensitive aspects of your application. 

    Pitfall 2: Ignoring Error Handling 

    • Issue: Neglecting error handling when accessing node environment variables can result in runtime errors and application crashes. 
    • Solution: Implement robust error handling mechanisms to gracefully manage scenarios where required node environment variables are missing or incorrectly configured. 

    Pitfall 3: Hardcoding Values in Code 

    • Issue: Hardcoding values in your code rather than using env variables in node.js can expose sensitive information and hinder the portability of your application. 
    • Solution: Store sensitive information, configuration details, and API keys in env variables in node.js for improved security and flexibility across different environments. 

    By diligently adhering to these best practices and avoiding common pitfalls, you can harness the full potential of env variables Node.js applications, ensuring they remain secure, scalable, and maintainable throughout their lifecycle. 

    Benefits of Using the Environment Variables

    The benefits of using the environment variables can be listed below. 

    • Security: API keys/other secret keys should not be put in plain text in the code to be directly visible. 
    • Flexibility: you can introduce conditional statements based on environments like “If production server then do X else if test server then do Y…”. 
    • Adoption: Popular services like Azure or Heroku support the usage of environment variables. 

    Unlock the power of Python programming with our unique certification course. Learn Python programming and earn a certificate in just a few weeks. Start your journey today!

    Conclusion 

    This article concentrates on understanding the use of environment variables in a node application and the convenience that it brings when included in a .env file to define the configuration values related to an environment without managing them as a part of your operating system or adding them via the terminal every time you need to run a script.

    These are just some of the things you can do with environment variables and all the tools that exist. Now that you’ve learned a bit more about environment variables in Node.js, it's high time to try out KnowledgeHut’s Node.js full course to understand how to utilize this in real projects. 

    Frequently Asked Questions (FAQs)

    1. What is the meaning of .env in Node.js?

    The env files or the environment files provide a popular solution for setting up the environment variables, particularly in Node.js. Platforms like Heroku, for example, use .env files as recommended best practices. 

    2. How can I see node environment variables?

    If you want to take a look at the node's environment variables, you can run the Node.js REPL with “node” in your command line and then type: 

    console.log(process.env); 
    Copy Code

    It will output all environment variables that this Node.js process can pick up. 

    Now that we have accessed the process.env object by logging it onto the console, we can also similarly list the default environment variables of our application. To access a specific variable, access it like you would access any property of an object: 

    EG: 

    console.log('The value of PORT is:', process.env.PORT); 
    3. How can I set environment variables? 

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

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

    or 

    You can add the same in the .env file of your project and then access it via the dotenv package in your codebase. 

    4. What do you mean by process environment?

    In Node.js, process.env is a global variable injected during runtime. It is a view of the state of the system environment variables. When we set an environment variable, it gets loaded into the process. 

    If you want to take a look at this object, run the Node.js REPL with “node” in your command line and then type: 

    console.log(process.env); 
    Copy Code

    This code will output all environment variables that this Node.js process can pick up. 

    Profile

    Nikhilesh Pandey

    Author

    "Experienced Lead Developer oriented towards problem-solving and analyzing impacts, both technically and functionally, Enjoy's working with web technologies with a strong focus on quality code and robust system architecture."

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Select
    Your Message (Optional)

    Upcoming Web Development Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon