> For the complete documentation index, see [llms.txt](https://bagus-cahyono.gitbook.io/programming-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://bagus-cahyono.gitbook.io/programming-notes/cka/04_configmap.md).

# ConfigMap

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

A ConfigMap allows you to decouple environment-specific configuration from your container images, so that your applications are easily portable.

## App: Get Config From ENV

We already have and app that will return a JSON response `{"message":"Success"}`. Let's make it configurable so our apps will check the environment variable `DEFAULT_MESSAGE` and use the value as message in our response.

```go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
)

type Response struct {
    Message string `json:"message,omitempty"`
}

func main() {
    // get default message from env
    message := os.Getenv("DEFAULT_MESSAGE")
    if message == "" {
        // fallback message
        message = "Success"
    }

    srv := http.NewServeMux()
    srv.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        res := Response{
            Message: message,
        }

        err := json.NewEncoder(w).Encode(res)
        if err != nil {
            log.Fatal(err)
        }
    })

    fmt.Println("Server is running on port 8080...")
    err := http.ListenAndServe(":8080", srv)
    if err != nil {
        log.Fatal(err)
    }
}
```

Try to run it with additional environment variable like this `DEFAULT_MESSAGE="k8s" go run main.go` and it should return `k8s` as the message when we access it.

```bash
➜ curl http://127.0.0.1:8080
{"message":"k8s"}
```

Build our apps again using command `docker build --tag simple-go .` so the new image will available in kubernetes docker images.

## Define ConfigMap

Let's create a new file called `configmap.yaml` and define our ConfigMap object in there.

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: simple-go-config
data:
  DEFAULT_MESSAGE: "Everything is fine!"
```

This will create a ConfigMap object with name `simple-go-config`. The `data` section is key value pair for our config. In here we have config data with key `DEFAULT_MESSAGE` and value `"Everything is fine!"`.

Lets apply it using command `kubectl apply -f configmap.yaml`. And check it using `kubectl get configmaps`. We should see `simple-go-config` in the list there.

```bash
➜ kubectl get configmaps 
NAME               DATA   AGE
kube-root-ca.crt   1      20d
simple-go-config   1      3s
```

We can also get the details of it using command `kubectl describe configmaps simple-go-config`.

```bash
➜ kubectl describe configmaps simple-go-config 
Name:         simple-go-config
Namespace:    default
Labels:       <none>
Annotations:  <none>

Data
====
DEFAULT_MESSAGE:
----
Everything is fine!


BinaryData
====

Events:  <none>
```

## Bind ConfigMap in Deployment

Now that we already setup a ConfigMap we need to update our deployment config to set environment variable with name `DEFAULT_MESSAGE` and get the value from ConfigMap named `simple-go-config` and key `DEFAULT_MESSAGE`.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-go
  labels:
    app: simple-go
spec:
  replicas: 3
  selector:
    matchLabels:
      app: simple-go
  template:
    metadata:
      labels:
        app: simple-go
    spec:
      containers:
      - name: server
        image: simple-go:latest
        imagePullPolicy: Never
        ports:
        - containerPort: 8080
        env:
        - name: DEFAULT_MESSAGE
          valueFrom:
            configMapKeyRef:
              name: simple-go-config
              key: DEFAULT_MESSAGE
```

Apply the deployment and we should see a new sets of pods created replacing the old pods.

```bash
➜ kubectl apply -f deployment.yaml 
deployment.apps/simple-go configured
```

```bash
➜ kubectl get pods
NAME                         READY   STATUS    RESTARTS   AGE
simple-go-77b89f5cf8-6ldx9   1/1     Running   0          8s
simple-go-77b89f5cf8-bpsgq   1/1     Running   0          9s
simple-go-77b89f5cf8-jcfc7   1/1     Running   0          7s
```

Now let's do a port-forward to one of the pods and access our apps with curl.

```bash
➜ kubectl port-forward simple-go-77b89f5cf8-6ldx9 8080:8080
Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080
```

Our app now should return response message `"Everything is fine!"` like this.

```bash
➜ curl http://127.0.0.1:8080
{"message":"Everything is fine!"}
```

Whenever we update a ConfigMap we also need to restart our pods so it will get the latest config available.

## References

* <https://kubernetes.io/docs/concepts/configuration/configmap/>