DevOPS Kubernetes

Configmaps in Kubernetes


Mục Lục

A ConfigMap is used to store non-confidential data. The data is in key-value pairs. Pods can consume ConfigMaps as command-line arguments, environment variables or as configuration files in a volume. 

Using a ConfigMap we can decouple environment-specific configuration from the container images. This can help us create our portable applications. ConfigMap does not provide encryption so it is always recommended not to store confidential information in the Configmap. Instead of using config, secretes can be used to store confidential information or security keys or passwords.

There are following different ways using which ConfigMap  data can be used inside a Pod:

  1. Command-line arguments to a container
  2. Environment variables for a container
  3. Add a file in read-only volume.
  4. Write code to run inside the Pod that uses the Kubernetes API to read a ConfigMap.

To know more about Configmap, visit Kubernetes’ official page here.

In this article, we will see two examples to access data from configmaps. In one example we will use config maps as environment variables in the pod command and in the other we will populate a volume with data stored in a ConfigMap.


  1. Kubernetes Cluster with at least 1 worker node.
    If you want to learn to create a Kubernetes Cluster, click here. This guide will help you create a Kubernetes cluster with 1 Master and 2 Nodes on AWS Ubuntu 18.04 EC2 Instances.

What will we do?

  1. Create a Configmap and access its data

Create a Configmap and access its data.

Create a file with the following config-map definition. 

vim my-configmap-demo1.yaml
apiVersion: v1
kind: ConfigMap
  name: my-configmap-demo1
  variable_one: one
  variable_two: two


Configmap can be created using the following command.

kubectl create -f my-configmap-demo1.yaml

Get details of the config map we created.

kubectl get configmaps
kubectl describe configmaps my-configmap-demo1



In the above screenshot, you can see that we have our data “variable_one” and “variable_two” available in the config map we created.

Now, this config map can be accessed in the Pod.

To access configmap data as environment variables in pod commands, let’s create a pod definition file with the following content.

vim my-pod-with-configmaps-as-environment-variables.yml
apiVersion: v1
kind: Pod
  name: my-pod-configmap-demo
    - name: my-container-configmap-demo
      command: [ "/bin/sh", "-c", "echo $(variable_one_env) $(variable_two_env)" ]
        - name: variable_one_env
              name: my-configmap-demo1
              key: variable_one
        - name: variable_two_env
              name: my-configmap-demo1
              key: variable_two
  restartPolicy: Never


Now, we are ready to create a pod that can access data from configmap as environment variables.

kubectl get podss
kubectl create -f my-pod-with-configmaps-as-environment-variables.yml
kubectl get pod


Since the pod has successfully completed its execution and existed as there is no process that can keep the pods alive, we can check its logs to see if configmap was available in the pod or not. To verify this, we have used echo command in the pod that will print the values of the variables.

kubectl get pods
kubectl logs my-pod-configmap-demo



In the above screenshot, it can be seen that the configmap data was accessible in the pod and it has printed values using echo command as “one” and “two”.

Configmap data is also available as files in volumes.

To access configmap data through volume, create a pod definition using the following content.

vim my-pod-with-configmaps-added-to-volume.yml
apiVersion: v1
kind: Pod
  name: my-pod-configmap-demo2
    - name: my-container-configmap-demo2
      command: [ "/bin/sh", "-c", "ls /etc/myconfig/" ]
      - name: my-config-volume
        mountPath: /etc/myconfig
    - name: my-config-volume
        name: my-configmap-demo1
  restartPolicy: Never


Now, let’s create a pod that can have configmap data available as files from “my-config-volume” volume. This configmap data will be available under “/etc/myconfig” directory in the pod.

kubectl get pods
kubectl create -f my-pod-with-configmaps-added-to-volume.yml
kubectl get pods


This time also, the pod has exited successfully as there is no process to keep the pod alive.

But, we have used “ls /etc/myconfig” command which will list the content of “/etc/myconfig” directory.

kubectl get pods

In the logs we can see of configmap data was available as files under “/etc/myconfig”

kubectl logs my-pod-configmap-demo2


In the above screenshot, you can see that the configmap data was available in the pod as “variable_one” and “variable_two” files.


In this article, we learned to create a configmap and access it in 2 ways. We saw the steps to access the configmap data as environment variables to the pod command and files in volume in the pod.

logo 1024

Đăng Ký Liền Tay

Nhận Ngay Bài Viết

We don’t spam! Read our privacy policy for more info.

Add Comment

Click here to post a comment