DEV Community

Cover image for Environment Variables in Kubernetes: A Simplified Guide
Avesh
Avesh

Posted on

Environment Variables in Kubernetes: A Simplified Guide

#kubernetes #devops #100daysofcode #beginners

Introduction

Environment variables play a critical role in configuring and managing applications, especially in containerized environments like Kubernetes. They provide a flexible, secure, and centralized way to configure application behavior without hardcoding values. In this article, we'll explore the basics of environment variables, how to use them in Kubernetes, and dive into hands-on examples to get you started.

Section 1: Understanding Environment Variables

What Are Environment Variables?

Environment variables are key-value pairs used by applications to access configuration settings during runtime. Instead of embedding sensitive or dynamic configurations in the application code, developers use environment variables to decouple configuration from the application logic.

Advantages of Using Environment Variables:

  • Dynamic Configuration: Change behavior without altering the codebase.
  • Enhanced Security: Store sensitive data securely.
  • Portability: Use the same application image across environments with different configurations.

Kubernetes and Environment Variables

In Kubernetes, environment variables are used to configure Pods, enabling applications to inherit settings dynamically during deployment.

Section 2: Ways to Define Environment Variables in Kubernetes

1. Static Environment Variables in Pod Specs

Static variables are directly defined in a Pod or Deployment YAML file.

Example YAML:

apiVersion: apps/v1 kind: Deployment metadata: name: my-app spec: replicas: 2 selector: matchLabels: app: my-app template: metadata: labels: app: my-app spec: containers: - name: my-app-container image: my-app-image:latest env: - name: MY_ENV_VAR value: "my-static-value"
Enter fullscreen mode Exit fullscreen mode

2. Using ConfigMaps for Non-Sensitive Data

ConfigMaps store configuration data and can be referenced in your deployment.

ConfigMap Example:

apiVersion: v1 kind: ConfigMap metadata: name: my-config data: MY_ENV_VAR: "my-value"
Enter fullscreen mode Exit fullscreen mode

Deployment Example:

apiVersion: apps/v1 kind: Deployment metadata: name: my-app spec: template: spec: containers: - name: my-app-container image: my-app-image:latest env: - name: MY_ENV_VAR valueFrom: configMapKeyRef: name: my-config key: MY_ENV_VAR
Enter fullscreen mode Exit fullscreen mode

3. Using Secrets for Sensitive Data

Secrets securely store sensitive information, like API keys and passwords.

Secret Example:

apiVersion: v1 kind: Secret metadata: name: my-secret type: Opaque data: MY_SECRET_VAR: bXktc2VjcmV0LXZhbHVl # Base64 encoded
Enter fullscreen mode Exit fullscreen mode

Deployment Example:

apiVersion: apps/v1 kind: Deployment metadata: name: my-app spec: template: spec: containers: - name: my-app-container image: my-app-image:latest env: - name: MY_SECRET_VAR valueFrom: secretKeyRef: name: my-secret key: MY_SECRET_VAR
Enter fullscreen mode Exit fullscreen mode

Section 3: Accessing Environment Variables in Your Application

Applications access environment variables via system APIs. Here are examples in popular programming languages:

Node.js Example:

const envVar = process.env.MY_ENV_VAR; console.log(`Environment Variable: ${envVar}`);
Enter fullscreen mode Exit fullscreen mode

Python Example:

import os env_var = os.getenv('MY_ENV_VAR') print(f"Environment Variable: {env_var}")
Enter fullscreen mode Exit fullscreen mode

Java Example:

String envVar = System.getenv("MY_ENV_VAR"); System.out.println("Environment Variable: " + envVar);
Enter fullscreen mode Exit fullscreen mode

Section 4: Best Practices for Using Environment Variables

  1. Use Secrets for sensitive data.
  2. Store non-sensitive configurations in ConfigMaps.
  3. Avoid hardcoding values into your application code.
  4. Use meaningful and descriptive variable names.
  5. Document all required environment variables for your project.

Section 5: Hands-On Example

Step 1: Create a Simple Node.js Application 

// app.js  const express = require('express'); const app = express(); const port = 3000; app.get('/', (req, res) => { res.send(`Environment Variable: ${process.env.MY_ENV_VAR}`); }); app.listen(port, () => console.log(`App running on port ${port}`));
Enter fullscreen mode Exit fullscreen mode

Step 2: Build a Docker Image 

docker build -t my-app-image .
Enter fullscreen mode Exit fullscreen mode

Step 3: Deploy to Kubernetes

  • Create a ConfigMap and Deployment YAML files.
  • Apply them using: 
kubectl apply -f configmap.yaml kubectl apply -f deployment.yaml
Enter fullscreen mode Exit fullscreen mode

Step 4: Verify

  • Forward the port: 
kubectl port-forward <pod-name> 3000:3000
Enter fullscreen mode Exit fullscreen mode
  • Access the app: 
curl http://localhost:3000
Enter fullscreen mode Exit fullscreen mode

Section 6: Troubleshooting Common Issues

  1. Check Variable Availability: 
kubectl exec -it <pod-name> -- printenv
Enter fullscreen mode Exit fullscreen mode
  1. Debug Misconfigurations: Ensure the ConfigMap or Secret references in your YAML are correct.

Conclusion

Environment variables are a powerful way to manage application configurations in Kubernetes. By following best practices and leveraging tools like ConfigMaps and Secrets, you can ensure your applications are secure, flexible, and maintainable.

For more details, explore the Kubernetes documentation or experiment with advanced tools like Helm and Kustomize to streamline your deployments further.

Top comments (0)