ConfigMap - Tempat Konfigurasimu Disimpan

Pada artikel sebelumnya, kita telah membahas tentang Service yang berfungsi sebagai gerbang penghubung antar aplikasi di Kubernetes. Kita sudah bisa membuat aplikasi kita berjalan di dalam klaster Kubernetes dan mengeksposnya baik di dalam maupun di luar klaster. Namun, bagaimana cara mengelola konfigurasi aplikasi kita? Bagaimana jika kita ingin mengubah konfigurasi tanpa harus membangun ulang image container? Di sinilah peran ConfigMap menjadi sangat penting.

Apa itu ConfigMap?

ConfigMap adalah objek API Kubernetes yang digunakan untuk menyimpan data non-rahasia dalam bentuk pasangan key-value. Pod dapat menggunakan ConfigMap sebagai variabel lingkungan, argumen command line, atau sebagai file konfigurasi dalam volume.

ConfigMap memungkinkan kita untuk memisahkan konfigurasi dari image container, sehingga aplikasi kita menjadi lebih portable. Dengan ConfigMap, kita bisa mengubah konfigurasi aplikasi tanpa harus membangun ulang image container.

Mengapa Kita Membutuhkan ConfigMap?

Ada beberapa alasan mengapa ConfigMap sangat penting dalam ekosistem Kubernetes:

Pemisahan konfigurasi dari kode: Mengikuti prinsip 12-Factor App , konfigurasi seharusnya terpisah dari kode.
Portabilitas: Aplikasi yang sama bisa dijalankan di lingkungan yang berbeda dengan konfigurasi yang berbeda.
Kemudahan perubahan: Konfigurasi bisa diubah tanpa harus membangun ulang image container.
Konsistensi: Memastikan semua Pod menggunakan konfigurasi yang sama.

Cara Membuat ConfigMap

Ada beberapa cara untuk membuat ConfigMap di Kubernetes:

1. Dari File YAML

Cara paling umum adalah dengan mendefinisikan ConfigMap dalam file YAML:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_host: "mysql"
  database_port: "3306"
  database_name: "myapp"
  log_level: "info"

Simpan file di atas sebagai app-config.yaml dan terapkan ke klaster:

kubectl apply -f app-config.yaml

2. Dari Command Line

Kita juga bisa membuat ConfigMap langsung dari command line:

kubectl create configmap app-config --from-literal=database_host=mysql --from-literal=database_port=3306 --from-literal=database_name=myapp --from-literal=log_level=info

3. Dari File

Jika kita memiliki file konfigurasi, kita bisa membuat ConfigMap dari file tersebut:

kubectl create configmap app-config --from-file=config.properties

Atau dari beberapa file:

kubectl create configmap app-config --from-file=config.properties --from-file=settings.xml

4. Dari Directory

Kita juga bisa membuat ConfigMap dari semua file dalam suatu directory:

kubectl create configmap app-config --from-file=config-dir/

Cara Menggunakan ConfigMap

Ada tiga cara utama untuk menggunakan ConfigMap dalam Pod:

1. Sebagai Environment Variables

Kita bisa menggunakan ConfigMap sebagai environment variables dalam Pod:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
    - name: app
      image: myapp:latest
      env:
        - name: DB_HOST
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: database_host
        - name: DB_PORT
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: database_port

Atau kita bisa menggunakan semua key dalam ConfigMap sebagai environment variables:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
    - name: app
      image: myapp:latest
      envFrom:
        - configMapRef:
            name: app-config

2. Sebagai Command Line Arguments

Kita bisa menggunakan ConfigMap sebagai command line arguments:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
    - name: app
      image: myapp:latest
      command: ["/bin/sh", "-c"]
      args: ["echo $(DB_HOST)"]
      env:
        - name: DB_HOST
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: database_host

3. Sebagai Volume

Kita juga bisa menggunakan ConfigMap sebagai volume:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
    - name: app
      image: myapp:latest
      volumeMounts:
        - name: config-volume
          mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: app-config

Dengan konfigurasi di atas, setiap key dalam ConfigMap akan menjadi file di directory /etc/config. Misalnya, key database_host akan menjadi file /etc/config/database_host dengan isi “mysql”.

Kita juga bisa memilih key tertentu untuk dimount:

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
    - name: app
      image: myapp:latest
      volumeMounts:
        - name: config-volume
          mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: app-config
        items:
          - key: database_host
            path: db/host
          - key: database_port
            path: db/port

Dengan konfigurasi di atas, key database_host akan menjadi file /etc/config/db/host dan key database_port akan menjadi file /etc/config/db/port.

Contoh Lengkap

Mari kita lihat contoh lengkap penggunaan ConfigMap dalam aplikasi web sederhana:

Pertama, kita buat ConfigMap untuk konfigurasi aplikasi:

apiVersion: v1
kind: ConfigMap
metadata:
  name: web-config
data:
  nginx.conf: |
    server {
      listen 80;
      server_name localhost;
      
      location / {
        root /usr/share/nginx/html;
        index index.html;
      }
    }
  index.html: |
    <!DOCTYPE html>
    <html>
    <head>
      <title>Welcome to Kubernetes!</title>
    </head>
    <body>
      <h1>Hello from ConfigMap!</h1>
      <p>This page is served from a ConfigMap.</p>
    </body>
    </html>

Kemudian, kita buat Deployment yang menggunakan ConfigMap tersebut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
        volumeMounts:
        - name: config-volume
          mountPath: /usr/share/nginx/html/index.html
          subPath: index.html
        - name: config-volume
          mountPath: /etc/nginx/conf.d/default.conf
          subPath: nginx.conf
      volumes:
      - name: config-volume
        configMap:
          name: web-config

Terakhir, kita buat Service untuk mengekspos aplikasi:

apiVersion: v1
kind: Service
metadata:
  name: web-service
spec:
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 80
  type: ClusterIP

Simpan ketiga file YAML di atas dan terapkan ke klaster:

kubectl apply -f web-config.yaml
kubectl apply -f web-deployment.yaml
kubectl apply -f web-service.yaml

Verifikasi bahwa aplikasi berjalan dengan baik:

kubectl port-forward service/web-service 8080:80

Sekarang kita bisa mengakses aplikasi di http://localhost:8080 dan melihat halaman HTML yang kita definisikan dalam ConfigMap.

Update ConfigMap

Salah satu keuntungan menggunakan ConfigMap adalah kita bisa mengubah konfigurasi tanpa harus membangun ulang image container. Namun, perlu diingat bahwa perubahan pada ConfigMap tidak secara otomatis diaplikasikan ke Pod yang sedang berjalan.

Untuk mengaplikasikan perubahan pada ConfigMap, kita perlu:

Update ConfigMap:

kubectl edit configmap web-config

Restart Pod untuk mengaplikasikan perubahan:

kubectl rollout restart deployment web-app

Untuk ConfigMap yang dimount sebagai volume, Kubernetes akan memperbarui file yang dimount dalam beberapa detik atau menit setelah ConfigMap diupdate. Namun, aplikasi mungkin perlu di-restart untuk membaca konfigurasi baru.

Batasan ConfigMap

Ada beberapa batasan yang perlu diperhatikan saat menggunakan ConfigMap:

Ukuran maksimum: ConfigMap memiliki batasan ukuran 1MB.
Tidak cocok untuk data rahasia: ConfigMap tidak dienkripsi dan tidak cocok untuk menyimpan data rahasia seperti password atau token. Untuk data rahasia, gunakan Secret.
Namespace-specific: ConfigMap hanya bisa digunakan oleh Pod dalam namespace yang sama.

Kesimpulan

ConfigMap adalah komponen penting dalam Kubernetes yang memungkinkan kita untuk memisahkan konfigurasi dari image container. Dengan ConfigMap, kita bisa mengubah konfigurasi aplikasi tanpa harus membangun ulang image container, membuat aplikasi kita lebih portable dan mudah dikelola.

Pada artikel berikutnya, kita akan membahas tentang Secret - yang menjaga konfigurasi rahasia di Kubernetes. Jangan lupa untuk mencoba contoh-contoh di atas di klaster Minikube Anda!

Cappy Hoding! 🖖🏾

Apa itu ConfigMap?#

Mengapa Kita Membutuhkan ConfigMap?#

Cara Membuat ConfigMap#

1. Dari File YAML#

2. Dari Command Line#

3. Dari File#

4. Dari Directory#

Cara Menggunakan ConfigMap#

1. Sebagai Environment Variables#

2. Sebagai Command Line Arguments#

3. Sebagai Volume#

Contoh Lengkap#

Update ConfigMap#

Batasan ConfigMap#

Kesimpulan#