Basic to Advanced Guide on Environment Variables for MongoDB in
JavaScript
Environment variables are a powerful and essential part of modern application development.
They allow you to configure your application's behavior without changing the code itself, which
is crucial for security, maintainability, and deployment across different environments (e.g.,
development, testing, production).
This guide will walk you through using environment variables with a MongoDB database in a
JavaScript/[Link] application, from the basic concepts to more advanced practices.
Basic Concepts: What are Environment Variables?
An environment variable is a dynamically named value that can be accessed by a computer
program. They are part of the operating system's environment and can be set and accessed at
the system or process level.
In [Link], you can access environment variables through the global [Link] object. This is
a simple key-value pair object where the keys are the variable names and the values are their
strings.
Why use them for a MongoDB connection?
The most common and important reason is security. A MongoDB connection string often
contains sensitive information like usernames and passwords. Hardcoding these credentials
directly into your application's source code is a major security risk. If your code is committed to a
public repository like GitHub, your credentials would be exposed.
By using environment variables, you keep this sensitive information separate from your code.
Basic Implementation: The .env File and dotenv
While you can set environment variables directly in your operating system, this isn't always
practical, especially for local development. The standard practice for [Link] is to use a .env file
and the dotenv package.
Step 1: Set up your project and install packages.
First, create a new [Link] project and install the necessary packages. You'll need dotenv to
load the variables and a MongoDB driver like mongoose or the official mongodb package.
mkdir my-mongo-app
cd my-mongo-app
npm init -y
npm install dotenv mongoose
Step 2: Create the .env file.
In the root of your project directory, create a file named .env. This file will store your key-value
pairs. By convention, variable names are often written in all caps.
touch .env
Inside your .env file, add your MongoDB connection string.
# .env file
MONGO_URI=mongodb+srv://<username>:<password>@[Link].n
et/mydatabase?retryWrites=true&w=majority
PORT=3000
Important: You must replace <username>, <password>, and mydatabase with your actual
MongoDB credentials and database name.
Step 3: Add .env to .gitignore.
This is a critical security step. You must prevent your .env file from being committed to your
version control system (e.g., Git). Create a .gitignore file in your project's root and add .env to it.
touch .gitignore
Inside .gitignore, add the following line:
# .gitignore
.env
Step 4: Use the variables in your JavaScript code.
Now, in your main application file (e.g., [Link]), you can load the environment variables using
dotenv and then access them via [Link]. The [Link]() method should be called as
early as possible in your application's entry point.
// [Link]
require('dotenv').config();
const mongoose = require('mongoose');
const mongoURI = [Link].MONGO_URI;
const port = [Link];
const connectDB = async () => {
try {
await [Link](mongoURI, {
useNewUrlParser: true,
useUnifiedTopology: true,
});
[Link]('MongoDB connected successfully!');
} catch (err) {
[Link]('MongoDB connection error:', [Link]);
// Exit process with a failure
[Link](1);
}
};
connectDB();
// You can now use the port variable
[Link](`Server will run on port ${port}`);
// Example of a simple Mongoose model
const userSchema = new [Link]({
name: String,
email: String
});
const User = [Link]('User', userSchema);
// Example of using the model
async function createUser() {
const newUser = new User({
name: 'John Doe',
email: '[Link]@[Link]'
});
await [Link]();
[Link]('User created:', newUser);
}
// You would call this function after the database is connected
// createUser();
Advanced Concepts and Best Practices
1. Handling different environments.
You will have different connection strings for development, testing, and production. It's a best
practice to have separate .env files for each environment, such as .[Link],
.[Link], etc.
You can then conditionally load the correct file based on the NODE_ENV environment variable.
Example:
// [Link]
const path = require('path');
const dotenv = require('dotenv');
const envPath = [Link].NODE_ENV === 'production'
? '.[Link]'
: '.[Link]';
[Link]({ path: [Link](__dirname, envPath) });
// Now the rest of your application code
const mongoose = require('mongoose');
const mongoURI = [Link].MONGO_URI;
// ... (rest of your connection logic)
How to run it:
You would set the NODE_ENV variable when you run your application.
# For development
NODE_ENV=development node [Link]
# For production
NODE_ENV=production node [Link]
2. Using environment variables with Docker.
When deploying with Docker, you shouldn't put a .env file directly into your image. Instead, you
can pass environment variables to your container at runtime.
Example Dockerfile:
# ... (your other build steps)
# Don't copy .env file
COPY package*.json ./
RUN npm install
COPY . .
# ... (rest of the Dockerfile)
EXPOSE 3000
CMD ["node", "[Link]"]
Example [Link]:
version: '3.8'
services:
app:
build: .
ports:
- "3000:3000"
environment:
- MONGO_URI=mongodb://db:27017/mydatabase
- PORT=3000
depends_on:
- db
db:
image: mongo:latest
ports:
- "27017:27017"
volumes:
- mongo-data:/data/db
volumes:
mongo-data:
In this setup, MONGO_URI is passed directly to the app service, and the database host is set to
db, which is the name of the MongoDB service in the docker-compose file.
3. Securing environment variables in production.
For production deployments, storing secrets in a .env file on the server is a bad idea. A better
approach is to use a secure secrets management system provided by your hosting platform.
● Heroku: Uses a "Config Vars" system in the dashboard.
● AWS: Uses AWS Secrets Manager or Parameter Store.
● Kubernetes: Uses a "Secrets" object.
These systems inject the secrets as environment variables into your application's runtime
environment, so your code still accesses them via [Link] without needing a .env file.
Example: A Complete MongoDB Connection with Mongoose
This example demonstrates how to set up a robust, production-ready database connection
using environment variables, Mongoose, and a simple configuration file.
1. Project Structure:
my-mongo-app/
├── .env
├── .gitignore
├── config/
│ └── [Link]
├── models/
│ └── [Link]
├── [Link]
└── [Link]
2. .env file:
# .env
MONGO_URI=mongodb+srv://<username>:<password>@[Link].n
et/mydatabase?retryWrites=true&w=majority
3. config/[Link] (The connection logic):
// config/[Link]
const mongoose = require('mongoose');
const connectDB = async () => {
try {
await [Link]([Link].MONGO_URI, {
useNewUrlParser: true,
useUnifiedTopology: true,
});
[Link]('MongoDB connected successfully!');
} catch (err) {
[Link]('MongoDB connection error:', [Link]);
// Exit process with a failure
[Link](1);
}
};
[Link] = connectDB;
4. models/[Link] (A Mongoose model):
// models/[Link]
const mongoose = require('mongoose');
const userSchema = new [Link]({
name: {
type: String,
required: true,
},
email: {
type: String,
required: true,
unique: true,
}
});
const User = [Link]('User', userSchema);
[Link] = User;
5. [Link] (The main application file):
// [Link]
require('dotenv').config();
const connectDB = require('./config/db');
const User = require('./models/User');
// Connect to the database
connectDB();
// A simple example of using the model
async function createAndFindUser() {
try {
// Create a new user
const newUser = new User({
name: 'Jane Doe',
email: '[Link]@[Link]'
});
await [Link]();
[Link]('User created:', newUser);
// Find the user
const foundUser = await [Link]({ name: 'Jane Doe' });
[Link]('User found:', foundUser);
} catch (err) {
[Link]('Error in database operation:', err);
}
}
// Call the function after a slight delay to ensure connection is
established
setTimeout(createAndFindUser, 3000);
This final example shows how to separate concerns, making your code cleaner and more
maintainable. The database connection logic is in its own module, and all sensitive information
is safely stored in an environment variable, never to be committed to source control.