Operator Pattern #

Kubernetes sudah tahu cara mengelola aplikasi stateless dengan baik — rolling update, scaling, self-healing. Tapi untuk stateful application seperti database, message broker, atau monitoring stack, operasi seperti backup, failover, atau rolling upgrade memerlukan pengetahuan domain yang dalam. Operator Pattern adalah cara mengkodekan pengetahuan operasional tersebut ke dalam Kubernetes controller, sehingga kompleksitas operasional bisa dikelola secara otomatis oleh software.

Masalah yang Diselesaikan Operator #

Mengelola PostgreSQL di Kubernetes tanpa Operator:
  → Buat StatefulSet, Service, PVC secara manual
  → Konfigurasi primary-replica secara manual
  → Backup scheduled via CronJob yang di-maintain sendiri
  → Failover: deteksi manual, intervensi manual
  → Upgrade versi: prosedur panjang yang rentan error
  → Scale up replica: konfigurasi ulang replication secara manual

Mengelola PostgreSQL dengan CloudNativePG Operator:
  kubectl apply -f postgres-cluster.yaml
  → Operator handle provisioning, replication, backup, failover, upgrade
  → Operator "tahu" cara mengelola PostgreSQL dengan benar

Komponen Operator: CRD dan Controller #

Operator terdiri dari dua bagian:

Custom Resource Definition (CRD) — mendefinisikan resource type baru di Kubernetes API. Setelah CRD terdaftar, kamu bisa buat resource dengan kind yang sebelumnya tidak ada.

Custom Controller — program yang watch resource tersebut dan mengambil tindakan untuk memastikan actual state sesuai desired state.

# CRD mendefinisikan resource baru: PostgresCluster
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: postgresclusters.postgresql.cnpg.io
spec:
  group: postgresql.cnpg.io
  versions:
  - name: v1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        type: object
        properties:
          spec:
            type: object
            properties:
              instances:
                type: integer
              imageName:
                type: string
  scope: Namespaced
  names:
    plural: postgresclusters
    singular: postgrescluster
    kind: PostgresCluster

# Setelah CRD terdaftar, resource baru bisa dibuat
apiVersion: postgresql.cnpg.io/v1
kind: PostgresCluster       # ← custom resource, bukan resource bawaan
metadata:
  name: db-cluster
spec:
  instances: 3
  imageName: ghcr.io/cloudnative-pg/postgresql:16.1
  storage:
    size: 100Gi
  backup:
    barmanObjectStore:
      destinationPath: s3://my-backup-bucket/postgres
      s3Credentials:
        accessKeyId:
          name: aws-creds
          key: ACCESS_KEY_ID

Reconciliation Loop #

Inti dari setiap Controller (dan Operator) adalah reconciliation loop:

Reconciliation Loop:

  1. Watch: controller subscribe ke perubahan resource (CRD, Deployment, dll)

  2. Event masuk:
     → Resource dibuat/diupdate/dihapus
     → Related resource berubah (misalnya Pod yang dimiliki mati)
     → Periodic re-sync (untuk mendeteksi drift)

  3. Reconcile dipanggil:
     → Baca desired state (dari spec resource)
     → Baca actual state (dari cluster dan external system)
     → Hitung perbedaan (diff)
     → Ambil tindakan untuk membuat actual = desired
     → Update status resource

  4. Kembali ke langkah 1

Prinsip: reconcile harus idempotent
  → Memanggil reconcile berkali-kali dengan input yang sama
    harus menghasilkan state yang sama
  → Tidak ada "create once" logic yang akan break jika dipanggil ulang

Contoh Operator Populer #

Prometheus Operator #

Memungkinkan konfigurasi Prometheus dan Alertmanager via CRD Kubernetes-native:

# Prometheus — didefinisikan sebagai custom resource
apiVersion: monitoring.coreos.com/v1
kind: Prometheus
metadata:
  name: main
  namespace: monitoring
spec:
  replicas: 2
  serviceMonitorSelector:         # pilih ServiceMonitor yang di-scrape
    matchLabels:
      release: prometheus
  ruleSelector:
    matchLabels:
      role: alert-rules
  retention: 15d
  storage:
    volumeClaimTemplate:
      spec:
        resources:
          requests:
            storage: 50Gi

Cert-Manager #

Otomasi provisioning dan renewal TLS certificate dari Let’s Encrypt atau CA internal:

# Certificate — didefinisikan sebagai custom resource
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: api-tls
  namespace: production
spec:
  secretName: api-tls-secret
  issuerRef:
    name: letsencrypt-prod
    kind: ClusterIssuer
  dnsNames:
  - api.example.com
  - www.api.example.com
  # Cert-Manager otomatis: request certificate, simpan ke Secret,
  # dan renew sebelum expired (biasanya 30 hari sebelum expiry)

Strimzi (Kafka Operator) #

Mengelola seluruh lifecycle cluster Apache Kafka:

apiVersion: kafka.strimzi.io/v1beta2
kind: Kafka
metadata:
  name: my-cluster
spec:
  kafka:
    version: 3.6.0
    replicas: 3
    listeners:
    - name: plain
      port: 9092
      type: internal
    config:
      offsets.topic.replication.factor: 3
    storage:
      type: persistent-claim
      size: 100Gi
  zookeeper:
    replicas: 3
    storage:
      type: persistent-claim
      size: 10Gi

Menemukan Operator yang Ada #

# OperatorHub.io — katalog Operator komunitas
# https://operatorhub.io/

# ArtifactHub — termasuk Helm charts dan Operator
# https://artifacthub.io/

# Install Operator via OLM (Operator Lifecycle Manager)
kubectl apply -f https://github.com/operator-framework/operator-lifecycle-manager/releases/download/v0.27.0/crds.yaml
kubectl apply -f https://github.com/operator-framework/operator-lifecycle-manager/releases/download/v0.27.0/olm.yaml

# Atau install langsung via manifest/Helm
helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set installCRDs=true

Kapan Menulis Operator Sendiri? #

Tulis Operator sendiri jika:
  ✓ Punya stateful application internal yang operasinya kompleks
  ✓ Ada operasi yang harus dilakukan secara reaktif terhadap perubahan state
  ✓ Tim harus mengelola lifecycle aplikasi ini di banyak cluster/namespace
  ✓ Ada kebutuhan spesifik yang tidak dipenuhi Operator yang sudah ada

Jangan tulis Operator jika:
  ✗ Cukup dengan Helm + CronJob + dokumentasi operasional
  ✗ Ada Operator yang sudah matang untuk use case kamu
  ✗ Tim tidak punya kapasitas untuk maintain custom controller
  ✗ Kebutuhan masih bisa diselesaikan dengan resource Kubernetes standar

Tools untuk menulis Operator:
  Kubebuilder  — Go, paling banyak digunakan, scaffolding yang lengkap
  Operator SDK — Go/Ansible/Helm, dari Red Hat, punya OLM integration
  kopf         — Python, lebih mudah untuk yang tidak familiar Go
  controller-runtime — library Go dasar yang digunakan Kubebuilder

Ringkasan #

  • Operator = CRD + Controller — CRD mendefinisikan resource baru (PostgresCluster, Kafka, Certificate); Controller watch resource tersebut dan reconcile actual state ke desired state.
  • Reconciliation loop harus idempotent — memanggil reconcile berkali-kali harus aman; tidak ada operasi “sekali jalan” yang tidak bisa di-ulangi.
  • Operator cocok untuk stateful application — database, message broker, monitoring stack punya operasional yang kompleks (backup, failover, upgrade); Operator mengkodekan pengetahuan ini.
  • Cari di OperatorHub sebelum tulis sendiri — komunitas sudah membangun Operator untuk sebagian besar use case umum (PostgreSQL, MySQL, Kafka, Redis, Prometheus, Cert-Manager).
  • Cert-Manager adalah Operator yang hampir universal — provisioning dan renewal TLS certificate otomatis; hampir semua cluster production seharusnya menggunakannya.
  • Kubebuilder untuk Go, kopf untuk Python — jika perlu menulis Operator sendiri, pilih SDK sesuai kemampuan tim; Kubebuilder paling populer dan punya scaffolding terlengkap.

← Sebelumnya: Local Development Tools   Berikutnya: Managed Kubernetes →

About | Author | Content Scope | Editorial Policy | Privacy Policy | Disclaimer | Contact