Apa itu ConfigMap di Kubernetes

ConfigMap adalah sebuah kamus pengaturan konfigurasi. Kamus ini dapat berisi pengaturan untuk satu pod, beberapa pod, atau bahkan seluruh cluster, tergantung pada tingkat di mana ConfigMap diterapkan. ConfigMap berguna untuk menyimpan dan berbagi data konfigurasi yang sederhana dan tidak sensitif.

Perbandingan dengan Definisi Variabel Lingkungan Secara Langsung

Meskipun memungkinkan untuk mendefinisikan variabel lingkungan secara langsung dalam manifest Pod atau Deployment, pendekatan ini memiliki keterbatasan. Misalnya, perubahan apa pun pada variabel tersebut akan memerlukan pengeditan file manifest dan mungkin perlu melakukan deploy ulang aplikasi. Selain itu, penggunaan ulang variabel ini di berbagai aplikasi atau lingkungan yang berbeda tidaklah langsung.

Manfaat Menggunakan ConfigMap

ConfigMap menawarkan beberapa manfaat dibandingkan dengan mendefinisikan variabel lingkungan secara langsung dalam manifest. Pertama, mereka memungkinkan Anda untuk mengelola konfigurasi aplikasi di luar templat Pod Anda, meningkatkan penggunaan ulang dan mengurangi kompleksitas. Kedua, ConfigMap bersifat dinamis, yang berarti Anda dapat memodifikasinya tanpa perlu me-restart Pod atau melakukan deploy ulang aplikasi yang menggunakannya. Terakhir, mereka memungkinkan pemisahan yang lebih baik antara konfigurasi dan kode aplikasi, mengikuti prinsip-prinsip aplikasi twelve-factor.

Meluncurkan Minikube

Minikube adalah alat yang berguna yang memungkinkan Anda menjalankan cluster Kubernetes satu node di mesin lokal Anda. Ini sangat berguna untuk tujuan pengujian dan pengembangan.

Untuk memulai Minikube, Anda hanya perlu menggunakan perintah minikube start:

$ minikube start

Perintah ini akan menginisialisasi mesin virtual baru di komputer Anda dan akan menginstal cluster Kubernetes satu node di dalam mesin virtual ini. Setelah menjalankan perintah ini, Anda dapat menggunakan alat baris perintah kubectl untuk berinteraksi dengan cluster.

Mendefinisikan Variabel Lingkungan tanpa ConfigMap

Sebelum memperkenalkan ConfigMap, penting untuk memahami bagaimana kita biasanya mendefinisikan variabel lingkungan dalam resource Kubernetes.

Perintah untuk Menghasilkan YAML dengan Variabel Lingkungan

Misalkan kita ingin membuat Pod baru dengan variabel lingkungan TEST_ENV diatur sebagai Hello_World. Biasanya, kita akan menjalankan perintah kubectl run dengan opsi --env untuk melakukan ini:

$ kubectl run \
    --env TEST_ENV=Hello_World \
    --port 8080 \
    --image bhargavshah86/kube-test:v0.1 \
    --restart Never \
    --dry-run \
    -o yaml \
    helloworld > pod_env.yaml

Perintah ini akan menghasilkan konfigurasi YAML untuk Pod dan menyimpannya ke file bernama pod_env.yaml.

Memahami Struktur YAML yang Dihasilkan

Jika Anda membuka file pod_env.yaml, Anda akan melihat bagian di mana variabel lingkungan TEST_ENV didefinisikan:

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: helloworld
  name: helloworld
spec:
  containers:
  - env:
    - name: TEST_ENV
      value: Hello_World
    image: bhargavshah86/kube-test:v0.1
    name: helloworld
    ports:
    - containerPort: 8080
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

Di bawah bidang spec.containers.env, Anda dapat melihat variabel lingkungan TEST_ENV dengan nilai Hello_World. Ini adalah bagaimana Kubernetes secara langsung mendefinisikan variabel lingkungan dalam sebuah Pod tanpa menggunakan ConfigMap.

Berpindah ke Penggunaan ConfigMap untuk Variabel Lingkungan

Meskipun variabel lingkungan dapat didefinisikan secara langsung dalam manifest Pod, lebih fleksibel dan dapat digunakan kembali untuk mengelolanya melalui ConfigMap.

Definisi ConfigMap dalam YAML

Langkah pertama dalam menggunakan ConfigMap adalah mendefinisikannya. Untuk ini, Anda dapat menggunakan perintah kubectl create configmap dengan opsi --from-literal untuk mendefinisikan ConfigMap dalam format YAML:

$ kubectl create configmap my-config \
    --from-literal=TEST_ENV=Hello_World \
    --dry-run \
    -o yaml > configmap.yaml

Perintah ini akan membuat ConfigMap bernama my-config dan menyimpan variabel lingkungan TEST_ENV dengan nilai Hello_World.

Memahami Struktur YAML ConfigMap

Jika Anda membuka file configmap.yaml, Anda akan melihat struktur ConfigMap:

apiVersion: v1
data:
  TEST_ENV: Hello_World
kind: ConfigMap
metadata:
  creationTimestamp: null
  name: my-config

Di sini, di bawah bidang data, pasangan kunci-nilai untuk TEST_ENV disimpan.

Membuat ConfigMap dari YAML

Setelah ConfigMap didefinisikan dalam file YAML, Anda dapat membuat ConfigMap di cluster Kubernetes Anda dengan perintah kubectl apply:

$ kubectl apply -f configmap.yaml

configmap/my-config created

Untuk memverifikasi pembuatan, daftar semua ConfigMap:

$ kubectl get configmap

NAME               DATA   AGE
kube-root-ca.crt   1      4m9s
my-config          1      5s

Memeriksa Detail ConfigMap

Anda dapat menjelaskan ConfigMap untuk melihat detailnya:

$ kubectl describe configmap my-config

Name:         my-config
Namespace:    default
Labels:       <none>
Annotations:  <none>

Data
====
TEST_ENV:
----
Hello_World

BinaryData
====

Events:  <none>

Mendefinisikan Variabel Lingkungan dalam Manifest Pod dengan Referensi ConfigMap

Dalam manifest Pod, Anda dapat merujuk ke ConfigMap untuk mendefinisikan variabel lingkungan:

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: helloworld-configmap-env
  name: helloworld-configmap-env
spec:
  containers:
  - env:
    - name: TEST_ENV
      valueFrom:
        configMapKeyRef:
          name: my-config
          key: TEST_ENV
    image: bhargavshah86/kube-test:v0.1
    name: helloworld-configmap-env
    ports:
    - containerPort: 8080
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

Setelah mendefinisikan manifest Pod dengan referensi ConfigMap, buat Pod:

$ kubectl apply -f pod_configmap_env.yaml

Anda dapat memverifikasi bahwa variabel lingkungan dalam Pod diatur dengan benar:

$ kubectl exec -it helloworld-configmap-env env

HOME=/root
PKG_RELEASE=1
NJS_VERSION=0.3.1
NGINX_VERSION=1.16.0
KUBERNETES_PORT_443_TCP_ADDR=10.96.0.1
KUBERNETES_PORT_443_TCP_PORT=443
KUBERNETES_PORT_443_TCP_PROTO=tcp
KUBERNETES_PORT_443_TCP=tcp://10.96.0.1:443
KUBERNETES_PORT=tcp://10.96.0.1:443
KUBERNETES_SERVICE_PORT_HTTPS=443
KUBERNETES_SERVICE_PORT=443
KUBERNETES_SERVICE_HOST=10.96.0.1
TEST_ENV=Hello_World
TERM=xterm
HOSTNAME=helloworld-configmap-env
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Perintah ini akan mencetak semua variabel lingkungan, dan Anda harus melihat TEST_ENV=Hello_World di antara keluaran.

Me-mount ConfigMap sebagai Volume di dalam Container

Selain digunakan untuk mengatur variabel lingkungan, ConfigMap juga dapat digunakan untuk menyimpan data yang kemudian di-mount sebagai volume dalam sebuah kontainer. Ini berguna untuk file konfigurasi, rahasia, dan data lain yang perlu diakses dalam sebuah kontainer.

Gambaran Umum Pemasangan Volume ConfigMap

Data yang disimpan dalam sebuah ConfigMap dapat ditulis ke dalam file dan kemudian di-mount sebagai volume di dalam sebuah Pod. Hal ini berguna ketika Anda perlu berbagi data non-sensitif antara kontainer-kontainer.

Mendefinisikan ConfigMap sebagai Volume dalam Manifest Pod

Untuk menggunakan ConfigMap sebagai volume, Anda perlu merujuk ke ConfigMap dalam bagian volumes dalam manifest Pod dan menentukan di mana me-mount volume tersebut dalam bagian volumeMounts:

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: helloworld-configmap-volume
  name: helloworld-configmap-volume
spec:
  containers:
  - image: bhargavshah86/kube-test:v0.1
    name: helloworld-configmap-volume
    ports:
    - containerPort: 8080
    resources: {}
    volumeMounts:
      - name: my-config-volume
        mountPath: /my-config/TEST_ENV
  volumes:
    - name: my-config-volume
      configMap:
        name: my-config
        items:
          - key: TEST_ENV
            path: keys
status: {}

Pada contoh ini, ConfigMap dengan nama my-config digunakan sebagai volume dengan nama my-config-volume dan di-mount pada path /my-config/TEST_ENV dalam kontainer.

Membuat dan Memverifikasi Pod dengan ConfigMap sebagai Volume

Setelah mendefinisikan manifest Pod dengan volume ConfigMap, buat Pod:

$ kubectl apply -f pod_configmap_volume.yaml

Anda dapat memverifikasi bahwa volume telah ter-mount dengan benar dengan menjalankan shell di dalam Pod dan memeriksa sistem file:

$ kubectl exec -it helloworld-configmap-volume sh

Setelah Anda masuk ke shell Pod, navigasikan ke direktori yang di-mount dan verifikasi bahwa kunci TEST_ENV dari ConfigMap telah ditulis ke sebuah file:

/usr/share/nginx/html # cat /my-config/TEST_ENV/keys

Hello_World

Ini akan menampilkan isi file kunci, yang seharusnya Hello_World, nilai yang terkait dengan kunci TEST_ENV dalam ConfigMap my-config.