Using ConfigMaps as environment variables in Kubernetes - Step-by-Step Execution

Process Flow - Using ConfigMaps as environment variables

Create ConfigMap with key-value pairs

↓

Define Pod spec referencing ConfigMap

↓

Pod starts, Kubernetes injects env vars

↓

Container reads env vars from ConfigMap

↓

Application uses env vars at runtime

This flow shows how a ConfigMap is created and then used to inject environment variables into a Kubernetes Pod, which the containerized app can access.

Execution Sample

Kubernetes

kubectl create configmap app-config --from-literal=APP_MODE=production

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
spec:
  containers:
  - name: app
    image: busybox
    envFrom:
    - configMapRef:
        name: app-config

Creates a ConfigMap with APP_MODE=production and a Pod that uses this ConfigMap to set environment variables in its container.

Process Table

Step	Action	Resource Affected	Result	Notes
1	Create ConfigMap 'app-config' with APP_MODE=production	ConfigMap	ConfigMap 'app-config' created	ConfigMap stores key-value pairs
2	Define Pod spec referencing ConfigMap 'app-config'	Pod spec	Pod spec includes envFrom with configMapRef	Pod will use ConfigMap for env vars
3	Apply Pod spec to cluster	Pod	Pod 'example-pod' created and scheduled	Pod starts running
4	Kubernetes injects env vars from ConfigMap into container	Container environment	Container env var APP_MODE=production set	Env vars available inside container
5	Container application reads APP_MODE env var	Application runtime	APP_MODE=production accessible	App can use config values dynamically
6	Pod runs normally with env vars	Pod status	Pod Running	Execution complete

💡 Pod is running with environment variables injected from ConfigMap

Status Tracker

Variable	Start	After Step 1	After Step 4	Final
ConfigMap 'app-config'	Not created	Created with APP_MODE=production	Unchanged	Exists with APP_MODE=production
Pod environment variable APP_MODE	Not set	Not set	Set to 'production'	Set to 'production'

Key Moments - 3 Insights

Why doesn't the environment variable appear in the container before the Pod starts?

Environment variables from ConfigMaps are injected only when the Pod starts and the container is created, as shown in step 4 of the execution_table.

What happens if the ConfigMap is changed after the Pod is running?

The running Pod's environment variables do not update automatically; the Pod must be restarted to pick up ConfigMap changes, as environment variables are set at container start.

Can multiple ConfigMaps be used to set environment variables in one Pod?

Yes, multiple ConfigMaps can be referenced using multiple envFrom entries or individual env entries, but each must be defined explicitly in the Pod spec.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the environment variable APP_MODE set inside the container?

A Step 2

B Step 4

C Step 1

D Step 6

💡 Hint

Check the 'Result' column in step 4 where container env var APP_MODE=production is set.

According to variable_tracker, what is the value of APP_MODE after step 1?

A production

B undefined

C Not set

D null

💡 Hint

Step 1 creates the ConfigMap but environment variables are injected later, see variable_tracker row for APP_MODE.

If the Pod is restarted after changing the ConfigMap, what will happen to the environment variable APP_MODE?

A It updates to the new ConfigMap value

B It remains the old value

C It becomes empty

D Pod fails to start

💡 Hint

Refer to key_moments about ConfigMap changes requiring Pod restart to update env vars.

Concept Snapshot

Create a ConfigMap with key-value pairs
Reference it in Pod spec using envFrom with configMapRef
When Pod starts, env vars from ConfigMap are injected into container
App reads env vars at runtime
Changes to ConfigMap require Pod restart to take effect

Full Transcript

This visual execution shows how to use Kubernetes ConfigMaps as environment variables in Pods. First, a ConfigMap named 'app-config' is created with a key APP_MODE set to 'production'. Then, a Pod specification is defined that references this ConfigMap under the envFrom field. When the Pod is applied and starts running, Kubernetes injects the environment variables from the ConfigMap into the container. The containerized application can then read these environment variables at runtime. The environment variables are only set when the Pod starts, so changes to the ConfigMap after the Pod is running require restarting the Pod to update the environment variables. This method allows configuration to be managed separately from container images and easily updated.