How to Set Docker Environment Variables

Docker has revolutionized how we build, deploy, and run applications. It creates lightweight, portable containers that bundle everything your app needs to run code, libraries, and dependencies. But to make your containerized apps adaptable to different environments, you’ll often need environment variables.

In Docker, environment variables allow you to adjust an app’s behavior at runtime, making it easy to switch between development, testing, and production setups without modifying your container image.

Setting Docker environment variables keeps your code cleaner, boosts flexibility, and simplifies scaling. Instead of rewriting configurations for every scenario, you can pass in values dynamically. Whether it’s database credentials, API keys, or app settings, environment variables make Docker containers smarter and more efficient.

What Are Docker Environment Variables?

Docker environment variables are dynamic values that influence how containers behave during runtime. They act as configuration inputs that allow you to change settings without modifying the application code or the container image.

Key Characteristics of Environment Variables

• Dynamic Configuration: Adjust values such as database URLs, API keys, or feature flags.  
• Separation of Concerns: Keep code clean by externalizing configuration settings.  
• Environment-Specific: Easily tailor settings for development, testing, and production environments.

Types of Environment Variables in Docker

Docker provides several predefined variables, like `HOSTNAME` (the container’s hostname) and PATH (directories for executables).

Moreover, Docker also provides custom variables added by users to pass configuration values specific to their applications, such as APP_ENV=production` or `DB_USER=root.  

Environment variables are essential for creating flexible, reusable, and secure containerized applications.

Setting Up Environment Variables in Docker

Method 1: Using the -e Flag in the docker run

The -e flag allows you to set environment variables when running a Docker container. This method is quick and ideal for one-off configurations.  

First, open your terminal or command prompt and install Docker on Ubuntu Linux then run the Docker container with the -e flag to define environment variables. 

For example, if you’re running a database container, you could set the database user and password like this:

sudo docker run -e DB_USER=root -e DB_PASSWORD=mysecretpassword -d mysql

In this example, the MySQL container will use the environment variables DB_USER and DB_PASSWORD` for database configuration.

Method 2: Using an .env File

An .env file allows you to define multiple environment variables in one place, making it easier to manage them, especially when you have several variables.  

First, you need to create a .env file in your project directory. In this file, define the variables like this:

DB_USER=root
DB_PASSWORD=mysecretpassword

When running the Docker container, reference the .env file with the –env-file option:

docker run --env-file .env -d mysql

This method is great for managing configuration values without exposing them directly in the command line.

Method 3: Defining in Dockerfile

You can also define environment variables in a Dockerfile, which is useful for container images that need to have preset environment variables every time they start.  

In your Dockerfile, use the ENV command to set environment variables. For example:

FROM mysql:latest
ENV DB_USER=root
ENV DB_PASSWORD=mysecretpassword

Next you need to build the Docker image using the docker build command:

sudo docker build -t mymysql .

Lastly, you need to run the container from the image:

docker run -d mymysql

In this case, every time you launch the `mymysql` container, the environment variables DB_USER and DB_PASSWORD` will automatically be set. 

Each method provides flexibility depending on your use case, from quick one-time configurations to reusable setups across multiple environments.

Use Cases for Docker Environment Variables

1. Simplifying Application Configuration

Environment variables centralize application settings, making configuration more manageable and accessible. Instead of hardcoding credentials or settings into your app, you pass them as variables during container runtime. This allows easy changes to parameters like API endpoints or feature toggles without altering the application code.

2. Managing Environments (Development, Testing, Production)

Different environments require unique configurations. For example, a database URL might point to a local server in development and a cloud server in production. Environment variables let you switch between these setups seamlessly, reducing errors and ensuring consistency across all stages of deployment.

3. Enhancing Security with Secrets Management

Sensitive data like passwords and API keys should not be stored in your codebase. Docker supports passing these securely as environment variables. Tools like Docker Secrets or `.env` files with proper access restrictions further enhance security, ensuring sensitive information stays protected. 

Conclusion

Docker provides various methods to manage environment variables, each with unique advantages for different scenarios. Using the -e flag is ideal for quick setups or one-off configurations, offering flexibility for testing and simple deployments. For larger projects or multiple variables, .env files centralize and streamline configuration management, making it easier to maintain consistency across environments without cluttering your command line. To set docker environment variables in Dockerfile ensures that they are baked into the container image, providing a reusable and standardized approach for frequently used presets.

Each method simplifies container management by externalizing configurations, keeping code cleaner, and reducing human error. By utilizing environment variables, you can adapt applications for development, testing, or production environments seamlessly. Whether handling database credentials, API keys, or feature flags, these tools make Dockerized applications more secure, flexible, and scalable.

FAQ