Kubectl update configMap

Question

I am using the following command to create a configMap.

kubectl create configmap test --from-file=./application.properties --from-file=./mongo.properties --from-file=./logback.xml 

Now, I have modified a value for a key from mongo.properties which I need to update in Kubernetes.

Option 1:

kubectl edit test

Here, it opens the entire file. But, I want to just update mongo.properties and hence want to see only the mongo.properties. Is there any other way?

Note: I don't want to have mongo.properties in a separate configMap.

Answer 1

This is what worked for me:

• k get -n kube-system configmap/aws-auth -o yaml > file.yaml

• modify the file.yaml with required changes

• k apply -f file.yaml

Answer 2

Suggestion

I would highly consider using a CLI editor like k9s (which is more like a K8S CLI managment tool).

As you can see below (ignore all white placeholders), when your cluster's context is set on terminal you just type k9s and you will reach a nice terminal where you can inspect all cluster resources.

Just type ":" and enter the resource name (configmaps in our case) which will appear in the middle of screen (green rectangle).
Then you can choose the relevant configmap with the up and down arrows and type e to edit it (see green arrow).

For all Configmaps in all namespaces you choose 0, for a specific namespace you choose the number from the upper left menu - for example 1 for kube-system:

Answer 3

Another option is actually you can use this command:

kubectl create configmap some-config \
  --from-file=some-key=some-config.yaml \
  -n some-namespace \
  -o yaml \
  --dry-run | kubectl apply -f - 

Refer to Github issue: Support updating config map and secret with --from-file

Answer 4

I managed to update a setting ("large-client-header-buffers") in the nginx pod's /etc/nginx/nginx.conf via configmap. Here are the steps I have followed..

1. Find the configmap name in the nginx ingress controller pod describition

kubectl -n utility describe pods/test-nginx-ingress-controller-584dd58494-d8fqr |grep configmap
      --configmap=test-namespace/test-nginx-ingress-controller

Note: In my case, the namespace is "test-namespace" and the configmap name is "test-nginx-ingress-controller"

2. Create a configmap yaml

cat  << EOF > test-nginx-ingress-controller-configmap.yaml

kind: ConfigMap
apiVersion: v1
metadata:
  name: test-nginx-ingress-controller
  namespace: test-namespace
data:
  large-client-header-buffers: "4 16k"
EOF

Note: Please replace the namespace and configmap name as per finding in the step 1

3. Deploy the configmap yaml

kubectl apply -f test-nginx-ingress-controller-configmap.yaml

Then you will see the change is updated to nginx controller pod after mins

i.g.
kubectl -n test-namespace exec -it test-nginx-ingress-controller-584dd58494-d8fqr -- cat /etc/nginx/nginx.conf|grep large
    large_client_header_buffers     4 16k;

Thanks to the sharing by NeverEndingQueue in How to use ConfigMap configuration with Helm NginX Ingress controller - Kubernetes

Answer 5

Here's a neat way to do an in-place update from a script.

The idea is;

1. export the configmap to YAML (kubectl get cm -o yaml)
2. use sed to do a command-line replace of an old value with a new value (sed "s|from|to")
3. push it back to the cluster using kubectl apply

In this worked example, I'm updating a log level variable from 'info' level logging to 'warn' level logging.

So, step 1, read the current config;

$ kubectl get cm common-config -o yaml

apiVersion: v1
data:
  CR_COMMON_LOG_LEVEL: info
kind: ConfigMap

Step 2, you modify it locally with a regular expression search-and-replace, using sed:

$ kubectl get cm common-config -o yaml | \
  sed -e 's|CR_COMMON_LOG_LEVEL: info|CR_COMMON_LOG_LEVEL: warn|'

apiVersion: v1
data:
  CR_COMMON_LOG_LEVEL: warn
kind: ConfigMap

You can see the value has changed. Let's push it back up to the cluster;

Step 3; use kubectl apply -f -, which tells kubectl to read from stdin and apply it to the cluster;

$ kubectl get cm common-config -o yaml | \
  sed -e 's|CR_COMMON_LOG_LEVEL: info|CR_COMMON_LOG_LEVEL: warn|' | \
  kubectl apply -f -

configmap/common-config configured

Answer 6

kubectl edit configmap -n <namespace> <configMapName> -o yaml

This opens up a vim editor with the configmap in yaml format. Now simply edit it and save it.

Answer 7

Here is a complete shell script to add new file to configmap (or replace existing one) based on @Bruce S. answer https://stackoverflow.com/a/54876249/2862663

#!/bin/bash
# Requires jq to be installed
if [ -z "$1" ]
  then
    echo "usage: update-config-map.sh <config map name> <config file to add>"
    return
fi 
if [ -z "$2" ]
  then
    echo "usage: update-config-map.sh <config map name> <config file to add>"
    return
fi 

CM_FILE=$(mktemp -d)/config-map.json
kubectl get cm $1 -o json > $CM_FILE

DATA_FILES_DIR=$(mktemp -d)
files=$(cat $CM_FILE | jq '.data' | jq -r 'keys[]')
for k in $files; do
    name=".data[\"$k\"]"
    cat $CM_FILE | jq -r $name > $DATA_FILES_DIR/$k;
done

echo cunfigmap: $CM_FILE tempdir: $DATA_FILES_DIR

echo will add file $2 to config

cp $2 $DATA_FILES_DIR

kubectl create configmap $1 --from-file $DATA_FILES_DIR -o yaml --dry-run |  kubectl apply -f -
echo Done
echo removing temp dirs
rm -rf $CM_FILE
rm -rf $DATA_FILES_DIR

Answer 8

Now you can. Just throw: kubectl edit configmap <name of the configmap> on your command line. Then you can edit your configuration.

Answer 9

No, you can't.

Replace in kubernetes will simply replace everything in that configmap. You can't just update one file or one single property in it.

However, if you check with the client Api, you will find if you create a configmap with lots of files. Then, those files will be stored as a HashMap, where key is file name by default, value is the file content encoded as a string. So you can write your own function based on existing key-value pair in HashMap.

This is what I found so far, if you find there is already existing method to deal with this issue, please let me know :)

FYI, if you want to update just one or few properties, it is possible if you use patch. However, it is a little bit hard to implement.

this and this may help

Answer 10

Here is how you can add/modify/remove files in a configmap with some help from jq:

export configmap to a JSON file:

CM_FILE=$(mktemp -d)/config-map.json
oc get cm <configmap name> -o json > $CM_FILE

DATA_FILES_DIR=$(mktemp -d)
files=$(cat $CM_FILE | jq '.data' | jq -r 'keys[]')
for k in $files; do
    name=".data[\"$k\"]"
    cat $CM_FILE | jq -r $name > $DATA_FILES_DIR/$k;
done

add/modify a file:

echo '<paste file contents here>' > $DATA_FILES_DIR/<file name>.conf

remove a file:

rm <file name>.conf

when done, update the configmap:

kubectl create configmap <configmap name> --from-file $DATA_FILES_DIR -o yaml --dry-run | kubectl apply -f -

delete temporary files and folders:

rm -rf CM_FILE
rm -rf DATA_FILES_DIR