In this blog, I write about Web Development, Blockchain, and DevOps. I am a Docker Captain, Public Speaker, and Developer Advocate at daily.dev. Check my YouTube channel.
Environment variables are a set of key-value pairs stored in the operating system.
They are used to store configuration settings and other information required by the system and other applications.
In this article, we'll explore how to work with environment variables in Rust using the standard library and the dotenv crate.
What Are Environment Variables?
Environment variables provide a flexible way to configure your applications without hardcoding values directly in your source code.
This makes it easier to manage different configurations for different environments, (development, testing, and production) and to keep sensitive information, such as API keys, secure.
Let's see 3 different examples of how we can use the environment variables in Rust.
Using the std::env module
Using the command line (Windows and Linux)
Using the dotenv crate
If you prefer a video version:
All the code is available on Github (link in the video description)
1. Environemnt Variables using the std::env module
Rust provides the std::env module to interact with environment variables. This module can read, set, and remove environment variables.
Importing the env Module
First, import the env module from the standard library:
use std::env;
You can test this by typing cargo run in the terminal.
Your output should be something like this:
Setting an Environment Variable
You can set an environment variable using the set_var function. Here's an example where we set a variable AAA with the value 123:
fnmain() {
let key = "AAA";
std::env::set_var(key, "123"); // Sets AAA to 123
}
Removing an Environment Variable
To remove an environment variable, use the remove_var function:
fnmain() {
let key = "AAA";
env::remove_var(key); // Removes the variable AAA
}
Checking If an Environment Variable Exists
To check if an environment variable exists, use the env::var function, which returns a Result. You can handle this with a match statement:
To read them from the command line, you can use the following commands:
On Linux/macOS:
CLI_ARG=TEST cargo run
On Windows(powershell):
$env:CLI_ARG="TEST"; cargo run
3. Environment Variables with the dotenv Crate
In addition to the standard library, you can use the dotenv crate to load environment variables from a .env file. This is particularly useful in development environments.
First, add dotenv to your Cargo.toml file:
[dependencies]dotenv = "0.15.0"
And create a .env file in the root of your project with the following content:
API_KEY=1234567890
Loading Environment Variables from a .env File
After adding dotenv, you can use it to load variables from a .env file:
use dotenv::dotenv;
use std::env;
fnmain() {
dotenv().ok(); // Reads the .env filelet api_key = env::var("API_KEY");
match api_key {
Ok(val) => println!("API_KEY: {:?}", val),
Err(e) => println!("Error API_KEY: {}", e),
}
//Simulate the execution of the rest of the programprintln!("...program continues...");
}
And you if you run the program, you should see the output:
In the example above, the dotenv().ok(); line loads the variables from a .env file located in the root of your project. The program then attempts to read the API_KEY variable and prints its value or an error if it is not set.
Conclusion
These are just three basic examples of working with environment variables in Rust.
I hope everything is clear and you can use them in your projects. If you have any questions, feel free to ask in the comments below.
If you prefer a video version:
If you prefer a video version:
All the code is available on Github (link in the video description)
