CHAOS-ENGINEERING KUBERNETES DEVOPS RESILIENCE FAULT-TOLERANCE RELIABILITY TESTING CLOUD-NATIVE LITMUSCHAOS SYSTEM-DESIGN OBSERVABILITY

Chaos Engineering di Kubernetes: Menguji Ketahanan Sistem Anda dengan LitmusChaos

⏱️ 10 menit baca
👨‍💻

Chaos Engineering di Kubernetes: Menguji Ketahanan Sistem Anda dengan LitmusChaos

1. Pendahuluan

Di dunia pengembangan web modern, aplikasi kita semakin kompleks dan terdistribusi. Kubernetes telah menjadi tulang punggung bagi banyak aplikasi skala besar, memberikan fleksibilitas dan skalabilitas luar biasa. Namun, kompleksitas ini juga membawa tantangan baru: bagaimana kita bisa yakin aplikasi kita akan tetap berjalan lancar saat terjadi kegagalan tak terduga? Bagaimana jika sebuah pod mati mendadak, jaringan terputus, atau node server crash?

Di sinilah Chaos Engineering berperan. Chaos Engineering bukanlah tentang menciptakan kekacauan tanpa tujuan. Sebaliknya, ini adalah disiplin untuk secara sengaja dan terkontrol mengintroduksi kegagalan ke dalam sistem produksi (atau lingkungan yang mirip produksi) untuk menguji ketahanan dan kemampuan pemulihan sistem Anda. Tujuannya adalah untuk menemukan kelemahan sebelum pelanggan Anda menemukannya, sehingga Anda bisa memperbaikinya dan membangun sistem yang lebih tangguh.

Artikel ini akan membawa Anda menyelami bagaimana mengimplementasikan Chaos Engineering secara praktis di lingkungan Kubernetes, dengan fokus pada salah satu tool populer: LitmusChaos. Jika Anda seorang developer atau DevOps engineer yang bertanggung jawab atas aplikasi di Kubernetes, bersiaplah untuk memperkuat sistem Anda!

2. Mengapa Chaos Engineering Penting di Kubernetes?

Kubernetes dirancang untuk menjadi self-healing, tetapi ini tidak berarti aplikasi Anda akan secara otomatis tangguh terhadap semua jenis kegagalan. Faktanya, arsitektur terdistribusi Kubernetes justru memperkenalkan lapisan kompleksitas baru yang perlu diuji:

Tanpa Chaos Engineering, kita hanya bisa berharap sistem kita tangguh. Dengan Chaos Engineering, kita membuktikan ketangguhan itu.

3. Pengenalan LitmusChaos: Senjata Anda Melawan Kekacauan

LitmusChaos adalah framework Chaos Engineering yang open-source, cloud-native, dan dirancang khusus untuk Kubernetes. LitmusChaos memungkinkan Anda untuk:

📌 Konsep Utama LitmusChaos:

4. Instalasi LitmusChaos di Kubernetes

Mari kita mulai dengan menginstal LitmusChaos di cluster Kubernetes Anda. Kita akan menginstal komponen LitmusChaos ke dalam namespace litmus.

# Buat namespace untuk LitmusChaos
kubectl create namespace litmus

# Terapkan LitmusChaos Operator dan CRDs
kubectl apply -f https://raw.githubusercontent.com/litmuschaos/litmus/master/mkdocs/docs/litmus-operator-v3.25.0.yaml -n litmus

Tunggu beberapa saat hingga semua pod LitmusChaos berjalan. Anda bisa memantau statusnya:

kubectl get pods -n litmus

Anda akan melihat pod seperti litmus-controller-manager dan chaos-operator berjalan.

✅ Tips: Pastikan Anda memiliki akses kubectl ke cluster Kubernetes Anda. Untuk lingkungan development, minikube atau Kind sudah cukup.

5. Membuat Eksperimen Chaos Pertama Anda: Pod Delete Chaos

Salah satu eksperimen chaos paling dasar dan penting adalah pod-delete. Ini mensimulasikan kegagalan pod secara acak, menguji apakah aplikasi Anda bisa pulih dengan cepat dan tanpa downtime.

🎯 Skenario Target: Kita akan menjalankan eksperimen pod-delete pada sebuah aplikasi Nginx sederhana yang berjalan di Kubernetes.

a. Deploy Aplikasi Target (Nginx)

Pertama, mari kita deploy aplikasi Nginx sederhana.

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3 # Kita akan memastikan ada 3 replika
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer # Atau NodePort/ClusterIP

Terapkan deployment ini:

kubectl apply -f nginx-deployment.yaml

Verifikasi pod Nginx berjalan:

kubectl get pods -l app=nginx

Anda akan melihat 3 pod Nginx berstatus Running.

b. Mendefinisikan ChaosEngine dan ChaosExperiment

Sekarang, kita akan membuat ChaosEngine dan ChaosExperiment untuk menyerang deployment Nginx ini.

# nginx-pod-delete-chaos.yaml
---
apiVersion: litmuschaos.io/v1alpha1
kind: ChaosEngine
metadata:
  name: nginx-chaos
  namespace: default # Namespace aplikasi target
spec:
  engineState: active
  chaosServiceAccount: litmus-admin # Service Account yang akan digunakan Litmus
  experiments:
  - name: pod-delete # Nama eksperimen yang akan dijalankan
    spec:
      components:
        env:
        - name: TOTAL_CHAOS_DURATION # Durasi total eksperimen dalam detik
          value: '60'
        - name: CHAOS_INTERVAL # Interval antar injeksi chaos dalam detik
          value: '10'
        - name: FORCE # Apakah akan memaksa penghapusan pod
          value: 'true'
  appinfo:
    appns: default # Namespace aplikasi target
    applabel: app=nginx # Label selector untuk aplikasi target
    appkind: deployment # Jenis resource aplikasi target
---
apiVersion: litmuschaos.io/v1alpha1
kind: ChaosExperiment
metadata:
  name: pod-delete
  namespace: litmus # Namespace LitmusChaos
spec:
  definition:
    scope: Cluster
    targetContainers: []
    image: litmuschaos/go-runner:3.25.0 # Image runner eksperimen
    imagePullPolicy: IfNotPresent
    args:
    - -c
    - python3 /litmus/pod-delete.py
    command:
    - /bin/bash
    env:
    - name: TARGET_PODS
      value: '' # Biarkan kosong agar Litmus memilih secara acak
    - name: PODS_AFFECTED_PERC
      value: '' # Persentase pod yang akan terpengaruh
    labels:
      name: pod-delete
      app: pod-delete
    containerImage: ""
    # ... konfigurasi lain yang mungkin diperlukan

⚠️ Penting: Untuk chaosServiceAccount, Anda perlu membuat atau menggunakan Service Account yang memiliki izin untuk melakukan operasi chaos (misalnya, menghapus pod) di namespace target. LitmusChaos menyediakan litmus-admin sebagai contoh. Mari buat yang sederhana untuk tujuan demo:

# litmus-admin-sa.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: litmus-admin
  namespace: default # Di namespace target
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: litmus-admin
  namespace: default # Di namespace target
rules:
- apiGroups: [""]
  resources: ["pods", "deployments", "replicationcontrollers", "replicasets"]
  verbs: ["get", "list", "watch", "delete", "create", "update", "patch"]
- apiGroups: ["apps"]
  resources: ["deployments", "replicasets"]
  verbs: ["get", "list", "watch"]
- apiGroups: ["litmuschaos.io"]
  resources: ["chaosengines", "chaosexperiments", "chaosresults"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: litmus-admin
  namespace: default # Di namespace target
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: litmus-admin
subjects:
- kind: ServiceAccount
  name: litmus-admin
  namespace: default

Terapkan Service Account dan Role Binding ini:

kubectl apply -f litmus-admin-sa.yaml

Sekarang, terapkan ChaosEngine dan ChaosExperiment:

kubectl apply -f nginx-pod-delete-chaos.yaml

c. Memantau Eksperimen

Setelah ChaosEngine diterapkan, Chaos Operator akan mulai bekerja. Anda bisa memantau status ChaosEngine:

kubectl get chaosengine nginx-chaos -n default -o yaml

Anda akan melihat engineState berubah dari active menjadi running dan kemudian completed.

Selama eksperimen berjalan, LitmusChaos akan secara periodik menghapus pod Nginx Anda. Kubernetes Deployment Controller akan segera membuat pod baru untuk menjaga jumlah replika tetap 3.

Anda bisa melihat log pod eksperimen LitmusChaos:

kubectl logs -f <nama-pod-chaos-runner> -n default

(Ganti <nama-pod-chaos-runner> dengan nama pod yang dibuat oleh ChaosEngine, biasanya dimulai dengan nginx-chaos-runner-).

Dan yang terpenting, pantau pod Nginx Anda:

kubectl get pods -l app=nginx -w

Anda akan melihat pod-pod Nginx dihapus dan kemudian pod baru muncul.

d. Menganalisis Hasil

Setelah eksperimen selesai, LitmusChaos akan membuat ChaosResult.

kubectl get chaosresult nginx-chaos-pod-delete -n default -o yaml

Dalam ChaosResult, Anda akan menemukan detail tentang eksperimen, termasuk status pass atau fail. Untuk pod-delete, jika aplikasi Anda berhasil mempertahankan 3 replika dan service tetap tersedia, eksperimen akan pass. Jika ada downtime yang signifikan atau replika tidak kembali normal, itu mungkin fail, menandakan adanya area yang perlu diperbaiki.

💡 Wawasan: Tujuan utama di sini adalah memastikan bahwa, meskipun ada pod yang mati, service Anda tetap dapat diakses dan berfungsi dengan baik dari perspektif pengguna akhir. Ini bisa diverifikasi dengan memantau metrik service (misalnya, latensi, error rate) selama eksperimen.

6. Jenis-jenis Eksperimen Chaos Lainnya

LitmusChaos menyediakan berbagai eksperimen chaos siap pakai (atau “Chaos Hub”) yang bisa Anda gunakan:

Anda bisa menjelajahi Chaos Hub LitmusChaos untuk menemukan eksperimen yang relevan dengan aplikasi Anda.

7. Best Practices dan Integrasi

Untuk mendapatkan manfaat maksimal dari Chaos Engineering:

Kesimpulan

Chaos Engineering bukan lagi sekadar konsep mewah, melainkan keharusan bagi aplikasi modern yang berjalan di lingkungan terdistribusi seperti Kubernetes. Dengan LitmusChaos, Anda memiliki alat yang ampuh untuk secara proaktif menguji ketahanan sistem Anda, mengungkap kelemahan tersembunyi, dan membangun aplikasi yang benar-benar tangguh.

Mulai dengan eksperimen sederhana seperti pod-delete, pantau metrik Anda dengan cermat, dan secara bertahap tingkatkan cakupan chaos Anda. Ingat, tujuan akhirnya adalah membangun kepercayaan pada sistem Anda, memastikan bahwa bahkan di tengah kekacauan, aplikasi Anda tetap berdiri tegak. Mari berani menghadapi kekacauan untuk sistem yang lebih baik!

🔗 Baca Juga