See these pages for more details about ConfigMaps:
https://kubernetes.io/docs/concepts/configuration/configmap/
https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names

ConfigMaps allows creating data objects that can be consumed by Pods at runtime.

Here's an example of a ConfigMap (YAML):

apiVersion: v1
data:
  key1: value1
  key2: value2
kind: ConfigMap
metadata:
  name: configmapexample

The manifest file of the ConfigMap is pretty simple. It contains the fields apiVersion, kind, and metadata. It also contain the data field that contains the keys-values of the ConfigMap.

The data in ConfigMaps is stored as key-value entries:

• Key: is a string value formed by alphanumeric, dot (.), dash (-), and underscore (_) characters.
  
  
• Value: is a string value that can contain any character, including carriage returns. For multiple lines, the data must be indented properly.
  
  

The key and the value, in the ConfigMap, are separated with a colon (key:value).

The name of the ConfigMap must be a valid DNS subdomain name.

Examples of values that can be saved in ConfigMaps include:

• Application settings.
  
  
• Configuration files (json/xml/properties files, shell scripts, ...).
  
  
• Base64 encoded data.
  
  

ConfigMaps are not meant to store sensitive data (credentials, certificates, ...). Kubernetes Secrets should be used instead.

The data stored in a ConfigMap can be consumed in a container in one the following ways:

• Environment variables.
  
  
• Command-line arguments of the container command.
  
  
• Files in volumes.
  
  
• Custom code (read the ConfigMap directly from the Kubernetes API).
  
  

Note: If you update a ConfigMap that was already posted to the Kubernetes API server, then Pods that were already created will be able to leverage the new data only if it was injected as files in a volume. ConfigMaps data injected as environment variables won't be updated in a running Pod unless you recreate it.

The data of the ConfigMaps can be specified using one of the following methods:

• --from-literal:
  This command allows you to specify a key and literal value to insert in the ConfigMap.
  
  Create the ConfigMap:
  

  $ kubectl create configmap configmapfromliteral --from-literal="key1=value1" --from-literal="key2=value2"

  configmap/configmapfromliteral created

  Check the ConfigMap:
  

  $ kubectl get configmap configmapfromliteral

  NAME                   DATA   AGE
  configmapfromliteral   2      2m10s

  Describe the ConfigMap:
  

  $ kubectl describe configmap configmapfromliteral

  Name:         configmapfromliteral
  Namespace:    default
  Labels:       <none>
  Annotations:  <none>
  
  Data
  ====
  key1:
  ----
  value1
  
  key2:
  ----
  value2
  Events:  <none>

  View the YAML file of the ConfigMap:
  

  $ kubectl get configmap configmapfromliteral -o yaml

  apiVersion: v1
  data:
    key1: value1
    key2: value2
  kind: ConfigMap
  metadata:
    name: configmapfromliteral

  
  
• --from-file:
  This command allows you to specify a file path (--from-file="./configmaps/file1.txt"), in which case the file base name (file1.txt) will be used as the ConfigMap key.
  
  Optionally you can use a key with the file path (--from-file="mykey1=./configmaps/file1.txt"), in which case the given key (mykey1) will be used as the ConfigMap key.
  
  If you specify a directory (--from-file="./configmaps/") then kubectl will iterate each file in the directory and create a new entry for each file whose base name is a valid ConfigMap key.
  
  The path to the file (or directory) can be an absolute path or relative to the location from where the "kubectl create configmap" is executed.
  
  The content of the file can be anything.
  
  Let's crate a directory to hold the ConfigMaps data (this can be any location you want):
  

  $ mkdir ./configmaps/

  Create a sample file "file1.txt" (single line text):
  

  $ echo -n 'value1' > "./configmaps/file1.txt"

  Create a sample file "file2.txt" (multiple lines text):
  

  $ echo 'value2-1' > "./configmaps/file2.txt"
  $ echo 'value2-2' >> "./configmaps/file2.txt"

  • Create the ConfigMap from a file without a key:
    

    $ kubectl create configmap configmap1fromfile --from-file="./configmaps/file1.txt" --from-file="./configmaps/file2.txt"

    configmap/configmap1fromfile created

    View the ConfigMap (notice that the content of the file is indented properly):
    

    $ kubectl get configmap configmap1fromfile -o yaml

    apiVersion: v1
    data:
      file1.txt: value1 # note that the name of the key is file1.txt and the value is single line
      file2.txt: | # note that the name of the key is file2.txt and the value is multiple lines
        value2-1
        value2-2
    kind: ConfigMap
    metadata:
      name: configmap1fromfile

  • Create the ConfigMap from a file with a key:
    

    $ kubectl create configmap configmap2fromfile --from-file="mykey1=./configmaps/file1.txt" --from-file="mykey2=./configmaps/file2.txt"

    configmap/configmap2fromfile created

    View the ConfigMap (notice that the content of the file is indented properly):
    

    $ kubectl get configmap configmap2fromfile -o yaml

    apiVersion: v1
    data:
      mykey1: value1 # note that the name of the key is mykey1 and the value is single line
      mykey2: | # note that the name of the key is mykey2 and the value is multiple lines
        value2-1
        value2-2
    kind: ConfigMap
    metadata:
      name: configmap2fromfile

  • Create the ConfigMap from a directory:
    

    $ kubectl create configmap configmapfromdirectory --from-file="./configmaps/"

    configmap/configmapfromdirectory created

    View the ConfigMap (notice that the content of the file is indented properly):
    

    $ kubectl get configmap configmapfromdirectory -o yaml

    apiVersion: v1
    data:
      file1.txt: value1 # note that the name of the key is file1.txt and the value is single line
      file2.txt: | # note that the name of the key is file2.txt and the value is multiple lines
        value2-1
        value2-2
    kind: ConfigMap
    metadata:
      name: configmapfromdirectory

  
  
• --from-env-file:
  This command allows you to specify the path to an environement (properties) file (--from-file="./configmaps/file1.properties") to read lines of key=value pairs to insert in the ConfigMap.
  
  Create a sample property file:
  

  $ vi "./configmaps/file1.properties"

  key1=value1
  key2=value2

  Create the ConfigMap:
  

  $ kubectl create configmap configmapfromenvfile --from-env-file="./configmaps/file1.properties"

  configmap/configmapfromenvfile created

  View the ConfigMap (notice that each entry in the property file is represented by a key:value pairs in the ConfigMap):
  

  $ kubectl get configmap configmapfromenvfile -o yaml

  apiVersion: v1
  data:
    key1: value1
    key2: value2
  kind: ConfigMap
  metadata:
    name: configmapfromenvfile

The manifest YAML file defines ConfigMags with key:value entries.

You can define ConfigMags with keys and multi-line values entries. The key should be followed by the pipe character (|) and the value can span multiple lines. Note though that all the lines should be indented properly.

Here's a sample YAML with simple values entries:

$ vi configmapkeyvalue.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: configmapkeyvalue
data:
  key1: value1
  key2: value2

To apply the file:

$ kubectl apply -f configmapkeyvalue.yaml

configmap/configmapkeyvalue created

Here's a sample YAML with multi-line values entries:

$ vi configmapmultilinevalue.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: configmapmultilinevalue
data:
  key3: |
    first line
    second line
    third line

If you have created a ConfigMap using the manifest YAML file, then to change that ConfigMap you can adjust the YAML file and run the command kubectl apply -f CONFIGMAP-YAML-FILE-PATH

You can also use the command kubectl edit configmap CONFIGMAP-NAME to edit a ConfigMap. The command will open the ConfigMap in your default text editor. Make your changes then save and exit the editor. Your changes will be submitted to API Server.

For example to view and edit the ConfigMap "configmapkeyvalue":

$ kubectl edit configmap configmapkeyvalue

# Please edit the object below.
# Lines beginning with a '#' will be ignored, and an empty file will abort the edit.
# If an error occurs while saving this file will be reopened with the relevant failures.
#
apiVersion: v1
data:
  key1: value1
  key2: value2
kind: ConfigMap
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","data":{"key1":"value1","key2":"value2"},"kind":"ConfigMap","metadata":{"annotations":{},"name":"configmapkeyvalue"}}
  name: configmapkeyvalue

configmap/configmapkeyvalue edited

In a Pod YAML file, you can reference the entries of the ConfigMap directly in the "spec.containers.env" field. The environment variables will be set like any other standard Linux environment variables. You can check them using the env command directly from inside the container.

• env/valueFrom/configMapKeyRef
  
  Let's use the ConfiMap "configmapkeyvalue" (see above) with the Pod "hello-busybox-configmap-keyref":
  
  

  $ vi hello-busybox-configmap-keyref.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: hello-busybox-configmap-keyref
  spec:
    containers:
      - name: hello-busybox-configmap-keyref
        image: busybox:latest
        command: ['sh', '-c', 'sleep 300;']
        env:
          - name: mykey1
            valueFrom:
              configMapKeyRef:
                name: configmapkeyvalue
                key: key1
          - name: mykey2
            valueFrom:
              configMapKeyRef:
                name: configmapkeyvalue
                key: key2

  Note: You can give the environment variable a different name than the ConfigMap key name (i.e. name: mykey1).
  
  Apply the Pod:
  

  $ kubectl apply -f hello-busybox-configmap-keyref.yaml

  pod/hello-busybox-configmap-keyref created

  Check the environment variables:
  

  $ kubectl exec hello-busybox-configmap-keyref -- env | grep key

  mykey1=value1
  mykey2=value2

• envFrom/configMapRef
  
  Instead of referencing individual entries of the ConfiMap, you can use the "spec.containers.envFrom" field to reference all entries of the ConfiMap:
  
  

  $ vi hello-busybox-configmap-ref.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: hello-busybox-configmap-ref
  spec:
    containers:
      - name: hello-busybox-configmap-ref
        image: busybox:latest
        command: ['sh', '-c', 'sleep 300;']
        envFrom:
          - configMapRef:
              name: configmapkeyvalue

  Apply the Pod:
  

  $ kubectl apply -f hello-busybox-configmap-ref.yaml

  pod/hello-busybox-configmap-ref created

  Check the environment variables:
  

  $ kubectl exec hello-busybox-configmap-ref -- env | grep key

  key1=value1
  key2=value2

ConfigMaps can also be referenced using volumes. Usually this is helpful when the ConfigMap contains configuration data (logging, ...).

Each entry of the ConfigMap will be referenced as a separate file in the volume.

The changes to the ConfigMap will be reflected directly in the volumes.

The ConfigMap is defined as a volume (spec.volumes) and mounted to the container (spec.containers.volumeMounts).

• In the following example, the spec.volumes field creates a volume (named configmapkeyvalue) from the ConfigMap "configmapkeyvalue".
  
  The spec.containers.volumeMounts field mounts the volume (configmapkeyvalue) into the container (under /tmp/configmapkeyvalue).
  
  The volume will be populated with the files inside the mounted directory. The files names are the keys of the ConfigMap (key1, key2). The content of the files are the values of the keys (value1, value2).
  
  

  $ vi hello-busybox-configmap-volume.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: hello-busybox-configmap-volume
  spec:
    containers:
      - name: hello-busybox-configmap-volume
        image: busybox:latest
        command: ['sh', '-c', 'sleep 300;']
        volumeMounts:
          - name: configmapkeyvalue
            mountPath: /tmp/configmapkeyvalue
    volumes:
      - name: configmapkeyvalue
        configMap:
          name: configmapkeyvalue

  Apply the Pod:
  

  $ kubectl apply -f hello-busybox-configmap-volume.yaml

  pod/hello-busybox-configmap-volume created

  Check the files in the volume (notice two files are created: key1, key2):
  

  $ kubectl exec hello-busybox-configmap-volume -- ls -l /tmp/configmapkeyvalue

  lrwxrwxrwx    1    root    root    key1 -> ..data/key1
  lrwxrwxrwx    1    root    root    key2 -> ..data/key2

  Check the content of the files:
  

  $ kubectl exec hello-busybox-configmap-volume -- cat /tmp/configmapkeyvalue/key1

  value1

• You can also decide what entries of the ConfigMag can be mounted.
  
  You can also decide the names of the files in the volume "path".
  
  

  $ vi hello-busybox-configmap-volume-item.yaml

  apiVersion: v1
  kind: Pod
  metadata:
    name: hello-busybox-configmap-volume-item
  spec:
    containers:
      - name: hello-busybox-configmap-volume-item
        image: busybox:latest
        command: ['sh', '-c', 'sleep 300;']
        volumeMounts:
          - name: configmapkeyvalue
            mountPath: /tmp/configmapkeyvalue
    volumes:
      - name: configmapkeyvalue
        configMap:
          name: configmapkeyvalue
          items:
            - key: key1
              path: key1path

  Apply the Pod:
  

  $ kubectl apply -f hello-busybox-configmap-volume-item.yaml

  pod/hello-busybox-configmap-volume-item created

  Check the files in the volume (notice the "key1path" file was created):
  

  $ kubectl exec hello-busybox-configmap-volume-item -- ls /tmp/configmapkeyvalue

  key1path

  Check the content of the files:
  

  $ kubectl exec hello-busybox-configmap-volume-item -- cat /tmp/configmapkeyvalue/key1path

  value1

You can use the data of the ConfigMap to set the arguments of the container command.

You need to use the following syntax to reference the environment variable: $(ENV_VAR_NAME).

As previously mentioned, changes to the ConfigMap won't be reflected on the environment variables already set.

$ vi hello-busybox-configmap-keyref-arg.yaml

apiVersion: v1
kind: Pod
metadata:
  name: hello-busybox-configmap-keyref-arg
spec:
  containers:
    - name: hello-busybox-configmap-keyref-arg
      image: busybox:latest
      command: ['sh', '-c', 'echo "mykey1:$(mykey1) | mykey2:$(mykey2)"; sleep 300;']
      env:
        - name: mykey1
          valueFrom:
            configMapKeyRef:
              name: configmapkeyvalue
              key: key1
        - name: mykey2
          valueFrom:
            configMapKeyRef:
              name: configmapkeyvalue
              key: key2

Apply the Pod:

$ kubectl apply -f hello-busybox-configmap-keyref-arg.yaml

pod/hello-busybox-configmap-keyref-arg created

Check the logs of the Pod:

$ kubectl logs hello-busybox-configmap-keyref-arg

mykey1:value1 | mykey2:value2

To delete a ConfigMap using the manifest file:

$ kubectl delete -f configmapkeyvalue.yaml

configmap "configmapkeyvalue" deleted

To delete a ConfigMap using its name:

$ kubectl delete configmap configmapkeyvalue

configmap "configmapkeyvalue" deleted