Belajar Kubernetes - Episode 12 - Pengenalan dan Penjelasan ReplicaSet
#devops

Belajar Kubernetes - Episode 12 - Pengenalan dan Penjelasan ReplicaSet

Di episode ini kita akan coba bahas modern replacement untuk ReplicationController yaitu ReplicaSet. Kita akan mempelajari tentang set-based selector, matchLabels, matchExpressions, dan bagaimana ReplicaSet digunakan oleh Deployment.

Arman Dwi Pangestu
Arman Dwi PangestuMarch 15, 2026
0 views
7 min read

Pendahuluan

Catatan

Untuk kalian yang ingin membaca episode sebelumnya, bisa click thumbnail episode 11 di bawah ini

Episode 11Episode 11

Di episode sebelumnya kita sudah belajar tentang ReplicationController, legacy controller untuk mengelola Pod replica. Selanjutnya di episode 12 kali ini, kita akan coba bahas modern replacement nya yaitu ReplicaSet.

Catatan: Disini saya akan menggunakan Kubernetes Cluster yang di install melalui K3s.

ReplicaSet adalah next-generation ReplicationController dengan selector support yang lebih flexible. Sementara kalian bisa menggunakan ReplicaSet secara langsung, biasanya digunakan sebagai underlying mechanism untuk Deployment, yang menyediakan fitur tambahan seperti rolling update dan rollback capability.

Apa Itu ReplicaSet?

ReplicaSet memastikan bahwa jumlah Pod replica yang di-specify berjalan pada waktu tertentu. Ini adalah successor dari ReplicationController dan menyediakan core functionality yang sama dengan enhanced selector capability.

Fitur kunci ReplicaSet:

  • Set-based selector - Label selection yang lebih flexible menggunakan matchLabels dan matchExpressions
  • Maintain desired replica count - Memastikan jumlah Pod yang di-specify selalu berjalan
  • Self-healing - Otomatis replace failed Pod
  • Scaling - Mudah scale Pod up atau down
  • Digunakan oleh Deployment - Foundation untuk Deployment controller

ReplicaSet vs ReplicationController

Perbedaan utama antara ReplicaSet dan ReplicationController adalah selector support:

ReplicationController - Equality-based selector saja:

Kubernetesyml
selector:
    app: nginx
    tier: frontend

ReplicaSet - Set-based selector dengan lebih flexible:

Kubernetesyml
selector:
    matchLabels:
        app: nginx
    matchExpressions:
        - key: tier
          operator: In
          values:
              - frontend
              - backend

Kenapa Menggunakan ReplicaSet?

ReplicaSet menyediakan beberapa keuntungan dibanding ReplicationController:

  • Selector lebih flexible - Gunakan set-based operation (In, NotIn, Exists, DoesNotExist)
  • Modern API - Menggunakan apps/v1 API group
  • Integrasi lebih baik - Bekerja seamless dengan Deployment
  • Future-proof - Actively maintained dan direkomendasikan oleh Kubernetes
  • Backward compatible - Bisa melakukan semua yang ReplicationController lakukan, plus lebih

Important

Best Practice: Sementara kalian bisa menggunakan ReplicaSet secara langsung, direkomendasikan untuk menggunakan Deployment. Deployment mengelola ReplicaSet dan menyediakan fitur tambahan seperti rolling update, rollback, dan declarative update.

Komponen ReplicaSet

ReplicaSet terdiri dari tiga komponen utama:

1. Replica Count

Jumlah Pod replica yang ingin kalian jalankan:

Kubernetesyml
spec:
    replicas: 3

2. Selector

Label yang digunakan untuk mengidentifikasi Pod mana yang dikelola ReplicaSet. ReplicaSet support dua tipe:

matchLabels - Equality-based matching:

Kubernetesyml
selector:
    matchLabels:
        app: nginx
        environment: production

matchExpressions - Set-based matching:

Kubernetesyml
selector:
    matchExpressions:
        - key: tier
          operator: In
          values:
              - frontend
              - backend

3. Pod Template

Template yang digunakan untuk membuat Pod baru:

Kubernetesyml
template:
    metadata:
        labels:
            app: nginx
    spec:
        containers:
            - name: nginx
              image: nginx:1.25

Membuat ReplicaSet

Mari kita buat basic ReplicaSet:

Contoh 1: Basic ReplicaSet dengan matchLabels

Buat file bernama replicaset-basic.yml:

Kubernetesreplicaset-basic.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: nginx-replicaset
    labels:
        app: nginx
        tier: frontend
spec:
    replicas: 3
    selector:
        matchLabels:
            app: nginx
            tier: frontend
    template:
        metadata:
            labels:
                app: nginx
                tier: frontend
        spec:
            containers:
                - name: nginx
                  image: nginx:1.25
                  ports:
                      - containerPort: 80

Important

Penting: Label di Pod template harus match dengan selector. Jika tidak match, ReplicaSet akan gagal dibuat.

Apply konfigurasi:

Kubernetesbash
sudo kubectl apply -f replicaset-basic.yml

Verifikasi ReplicaSet dibuat:

Kubernetesbash
sudo kubectl get replicaset

Atau gunakan shorthand:

Kubernetesbash
sudo kubectl get rs

Output:

Kubernetesbash
NAME               DESIRED   CURRENT   READY   AGE
nginx-replicaset   3         3         3       30s

Cek Pod:

Kubernetesbash
sudo kubectl get pods

Output:

Kubernetesbash
NAME                     READY   STATUS    RESTARTS   AGE
nginx-replicaset-abc12   1/1     Running   0          30s
nginx-replicaset-def34   1/1     Running   0          30s
nginx-replicaset-ghi56   1/1     Running   0          30s

Set-Based Selector

Fitur paling powerful dari ReplicaSet adalah set-based selector menggunakan matchExpressions. Mari kita explore operator nya:

Operator: In

Memilih Pod dimana label value ada di set yang di-specify:

Kubernetesreplicaset-in-operator.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: web-app-rs
spec:
    replicas: 3
    selector:
        matchExpressions:
            - key: environment
              operator: In
              values:
                  - production
                  - staging
    template:
        metadata:
            labels:
                app: web-app
                environment: production
        spec:
            containers:
                - name: web-app
                  image: nginx:1.25

ReplicaSet ini mengelola Pod dengan environment: production ATAU environment: staging.

Operator: NotIn

Memilih Pod dimana label value TIDAK ada di set yang di-specify:

Kubernetesreplicaset-notin-operator.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: non-dev-rs
spec:
    replicas: 2
    selector:
        matchExpressions:
            - key: environment
              operator: NotIn
              values:
                  - development
    template:
        metadata:
            labels:
                app: myapp
                environment: production
        spec:
            containers:
                - name: myapp
                  image: nginx:1.25

ReplicaSet ini mengelola Pod dimana environment BUKAN development.

Operator: Exists

Memilih Pod yang punya label key yang di-specify (regardless of value):

Kubernetesreplicaset-exists-operator.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: labeled-rs
spec:
    replicas: 2
    selector:
        matchExpressions:
            - key: tier
              operator: Exists
    template:
        metadata:
            labels:
                app: myapp
                tier: frontend
        spec:
            containers:
                - name: myapp
                  image: nginx:1.25

ReplicaSet ini mengelola Pod yang punya label tier, regardless of value nya.

Operator: DoesNotExist

Memilih Pod yang TIDAK punya label key yang di-specify:

Kubernetesreplicaset-doesnotexist-operator.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: unlabeled-rs
spec:
    replicas: 2
    selector:
        matchExpressions:
            - key: deprecated
              operator: DoesNotExist
    template:
        metadata:
            labels:
                app: myapp
        spec:
            containers:
                - name: myapp
                  image: nginx:1.25

ReplicaSet ini mengelola Pod yang TIDAK punya label deprecated.

Menggabungkan matchLabels dan matchExpressions

Kalian bisa kombinasikan keduanya untuk selection yang lebih complex:

Kubernetesreplicaset-combined.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: complex-selector-rs
spec:
    replicas: 3
    selector:
        matchLabels:
            app: web-app
        matchExpressions:
            - key: environment
              operator: In
              values:
                  - production
                  - staging
            - key: tier
              operator: NotIn
              values:
                  - deprecated
    template:
        metadata:
            labels:
                app: web-app
                environment: production
                tier: frontend
        spec:
            containers:
                - name: web-app
                  image: nginx:1.25

ReplicaSet ini memilih Pod yang:

  • Punya app: web-app (matchLabels)
  • DAN punya environment sebagai production atau staging
  • DAN TIDAK punya tier: deprecated

Melihat Detail ReplicaSet

Untuk melihat informasi detail tentang ReplicaSet:

Kubernetesbash
sudo kubectl describe rs nginx-replicaset

Output:

Kubernetesbash
Name:         nginx-replicaset
Namespace:    default
Selector:     app=nginx,tier=frontend
Labels:       app=nginx
              tier=frontend
Annotations:  <none>
Replicas:     3 current / 3 desired
Pods Status:  3 Running / 0 Waiting / 0 Succeeded / 0 Failed
Pod Template:
  Labels:  app=nginx
           tier=frontend
  Containers:
   nginx:
    Image:        nginx:1.25
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Events:
  Type    Reason            Age   From                   Message
  ----    ------            ----  ----                   -------
  Normal  SuccessfulCreate  2m    replicaset-controller  Created pod: nginx-replicaset-abc12
  Normal  SuccessfulCreate  2m    replicaset-controller  Created pod: nginx-replicaset-def34
  Normal  SuccessfulCreate  2m    replicaset-controller  Created pod: nginx-replicaset-ghi56

Demonstrasi Self-Healing

ReplicaSet otomatis replace failed Pod, sama seperti ReplicationController:

Step 1: Cek Current Pod

Kubernetesbash
sudo kubectl get pods -l app=nginx

Step 2: Hapus Pod

Kubernetesbash
sudo kubectl delete pod nginx-replicaset-abc12

Step 3: Watch ReplicaSet Membuat Pod Baru

Kubernetesbash
sudo kubectl get pods -l app=nginx -w

Kalian akan melihat ReplicaSet segera membuat Pod baru untuk maintain desired count.

Scaling ReplicaSet

Scaling ReplicaSet bekerja sama seperti ReplicationController:

Cara 1: Menggunakan kubectl scale

Kubernetesbash
# Scale up ke 5 replica
sudo kubectl scale rs nginx-replicaset --replicas=5
 
# Scale down ke 2 replica
sudo kubectl scale rs nginx-replicaset --replicas=2

Cara 2: Edit ReplicaSet

Kubernetesbash
sudo kubectl edit rs nginx-replicaset

Ubah field replicas dan save.

Cara 3: Update File YAML

Update file YAML kalian dan apply:

Kubernetesbash
sudo kubectl apply -f replicaset-basic.yml

Contoh Praktis

Contoh 1: Web Application dengan Resource Limit

Kubernetesweb-app-replicaset.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: web-app-rs
    labels:
        app: web-app
        tier: frontend
spec:
    replicas: 5
    selector:
        matchLabels:
            app: web-app
            tier: frontend
    template:
        metadata:
            labels:
                app: web-app
                tier: frontend
        spec:
            containers:
                - name: web-app
                  image: nginx:1.25
                  ports:
                      - containerPort: 80
                  resources:
                      requests:
                          memory: "128Mi"
                          cpu: "100m"
                      limits:
                          memory: "256Mi"
                          cpu: "200m"
                  livenessProbe:
                      httpGet:
                          path: /
                          port: 80
                      initialDelaySeconds: 3
                      periodSeconds: 10
                  readinessProbe:
                      httpGet:
                          path: /
                          port: 80
                      initialDelaySeconds: 5
                      periodSeconds: 5

Contoh 2: Multi-Environment ReplicaSet

Kubernetesmulti-env-replicaset.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: multi-env-rs
spec:
    replicas: 4
    selector:
        matchLabels:
            app: myapp
        matchExpressions:
            - key: environment
              operator: In
              values:
                  - production
                  - staging
            - key: version
              operator: Exists
    template:
        metadata:
            labels:
                app: myapp
                environment: production
                version: v2.0
        spec:
            containers:
                - name: myapp
                  image: nginx:1.25
                  env:
                      - name: ENVIRONMENT
                        value: "production"
                      - name: VERSION
                        value: "v2.0"

Contoh 3: ReplicaSet dengan Node Affinity

Kubernetesreplicaset-affinity.yml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: affinity-rs
spec:
    replicas: 3
    selector:
        matchLabels:
            app: myapp
    template:
        metadata:
            labels:
                app: myapp
        spec:
            affinity:
                nodeAffinity:
                    requiredDuringSchedulingIgnoredDuringExecution:
                        nodeSelectorTerms:
                            - matchExpressions:
                                  - key: disktype
                                    operator: In
                                    values:
                                        - ssd
            containers:
                - name: myapp
                  image: nginx:1.25

ReplicaSet ini schedule Pod hanya di node dengan label disktype: ssd.

ReplicaSet dan Deployment

Dalam praktik, kalian jarang membuat ReplicaSet secara langsung. Sebaliknya, kalian membuat Deployment, yang mengelola ReplicaSet untuk kalian.

Bagaimana Deployment Menggunakan ReplicaSet

Saat kalian membuat Deployment:

  1. Deployment membuat ReplicaSet
  2. ReplicaSet membuat Pod
  3. Deployment mengelola ReplicaSet lifecycle (update, rollback)

Contoh Deployment:

Kubernetesdeployment-example.yml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: nginx-deployment
spec:
    replicas: 3
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
                - name: nginx
                  image: nginx:1.25

Saat kalian apply Deployment ini:

Kubernetesbash
sudo kubectl apply -f deployment-example.yml

Cek ReplicaSet yang dibuat oleh Deployment:

Kubernetesbash
sudo kubectl get rs

Output:

Kubernetesbash
NAME                          DESIRED   CURRENT   READY   AGE
nginx-deployment-5d59d67564   3         3         3       30s

Nama ReplicaSet include nama Deployment dan hash.

Kenapa Menggunakan Deployment Daripada ReplicaSet?

Deployment menyediakan fitur tambahan:

  • Rolling update - Gradually update Pod dengan zero downtime
  • Rollback - Mudah revert ke versi sebelumnya
  • Revision history - Track deployment history
  • Declarative update - Describe desired state, Kubernetes handle sisanya
  • Pause dan resume - Kontrol update process

Tip

Rekomendasi: Selalu gunakan Deployment untuk stateless application daripada membuat ReplicaSet secara langsung. Gunakan ReplicaSet hanya saat kalian butuh fine-grained control atau punya requirement spesifik yang Deployment tidak support.

Menghapus ReplicaSet

Cara 1: Hapus ReplicaSet dan Pod

Kubernetesbash
sudo kubectl delete rs nginx-replicaset

Ini menghapus ReplicaSet dan semua Pod nya.

Cara 2: Hapus ReplicaSet tapi Jaga Pod

Kubernetesbash
sudo kubectl delete rs nginx-replicaset --cascade=orphan

Ini hanya menghapus ReplicaSet, membiarkan Pod berjalan sebagai orphan.

Kesalahan Umum dan Pitfall

Kesalahan 1: Mismatched Label

Pod template label harus match dengan selector:

Salah:

Kubernetesyml
selector:
    matchLabels:
        app: nginx
template:
    metadata:
        labels:
            app: web  # Tidak match!

Benar:

Kubernetesyml
selector:
    matchLabels:
        app: nginx
template:
    metadata:
        labels:
            app: nginx  # Match!

Kesalahan 2: Menggunakan ReplicaSet Daripada Deployment

Membuat ReplicaSet secara langsung saat seharusnya menggunakan Deployment.

Solusi: Gunakan Deployment untuk most use case. Deployment mengelola ReplicaSet dan menyediakan rolling update.

Kesalahan 3: Complex Selector Tanpa Testing

Membuat selector yang terlalu complex yang tidak match Pod apapun.

Solusi: Mulai simple, test selector kalian, kemudian tambahkan complexity jika diperlukan.

Kesalahan 4: Tidak Set Resource Limit

Solusi: Selalu set resource request dan limit:

Kubernetesyml
resources:
    requests:
        memory: "128Mi"
        cpu: "100m"
    limits:
        memory: "256Mi"
        cpu: "200m"

Best Practice

Gunakan Deployment Daripada ReplicaSet

Untuk most use case, gunakan Deployment:

Kubernetesyml
apiVersion: apps/v1
kind: Deployment  # Gunakan Deployment, bukan ReplicaSet
metadata:
    name: nginx-deployment
spec:
    replicas: 3
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
                - name: nginx
                  image: nginx:1.25

Gunakan matchLabels untuk Simple Selector

Untuk simple equality-based selection, gunakan matchLabels:

Kubernetesyml
selector:
    matchLabels:
        app: nginx
        tier: frontend

Gunakan matchExpressions untuk Complex Logic

Untuk complex selection logic, gunakan matchExpressions:

Kubernetesyml
selector:
    matchExpressions:
        - key: environment
          operator: In
          values:
              - production
              - staging
        - key: deprecated
          operator: DoesNotExist

Tambahkan Meaningful Label

Gunakan descriptive label untuk organisasi yang lebih baik:

Kubernetesyml
labels:
    app: web-app
    tier: frontend
    environment: production
    version: v2.0
    team: platform

Implementasikan Health Check

Selalu tambahkan Probe:

Kubernetesyml
livenessProbe:
    httpGet:
        path: /healthz
        port: 8080
readinessProbe:
    httpGet:
        path: /ready
        port: 8080

Set Resource Limit

Selalu define resource request dan limit:

Kubernetesyml
resources:
    requests:
        memory: "128Mi"
        cpu: "100m"
    limits:
        memory: "256Mi"
        cpu: "200m"

Monitoring ReplicaSet

Cek Status ReplicaSet

Kubernetesbash
sudo kubectl get rs

Watch ReplicaSet Event

Kubernetesbash
sudo kubectl get events --sort-by='.lastTimestamp' | grep ReplicaSet

Monitor Status Pod

Kubernetesbash
sudo kubectl get pods -l app=nginx -w

Cek Resource Usage

Kubernetesbash
sudo kubectl top pods -l app=nginx

Penutup

Pada episode 12 ini, kita telah membahas ReplicaSet di Kubernetes secara mendalam. Kita sudah belajar apa itu ReplicaSet, bagaimana dia improve ReplicationController, dan cara menggunakan set-based selector untuk flexible Pod management.

Key takeaway:

  • ReplicaSet adalah modern replacement untuk ReplicationController
  • Support set-based selector dengan matchLabels dan matchExpressions
  • Empat operator: In, NotIn, Exists, DoesNotExist
  • Digunakan sebagai foundation untuk Deployment
  • Menyediakan self-healing dan scaling yang sama seperti ReplicationController
  • Best practice: Gunakan Deployment daripada ReplicaSet secara langsung
  • Label selection lebih flexible daripada ReplicationController
  • Menggunakan apps/v1 API group

Sementara ReplicaSet lebih powerful daripada ReplicationController, dalam praktik kalian harus menggunakan Deployment untuk mengelola stateless application. Deployment menyediakan semua benefit dari ReplicaSet plus rolling update, rollback capability, dan declarative update management.

Bagaimana, makin jelas kan tentang ReplicaSet di Kubernetes? Di episode 13 berikutnya, kita akan membahas DaemonSet, tipe controller yang berbeda yang memastikan Pod berjalan di setiap node di cluster kalian. Jadi, pastikan tetap semangat belajar dan nantikan episode selanjutnya!

Related Posts