Belajar Kubernetes - Episode 26 - Pengenalan dan Penjelasan Deployment
#devops

Belajar Kubernetes - Episode 26 - Pengenalan dan Penjelasan Deployment

Di episode ini kita akan coba bahas Kubernetes Deployment untuk managing application rollout. Kita akan mempelajari rolling update, rollback, scaling strategy, dan best practice untuk production deployment.

Arman Dwi Pangestu
Arman Dwi PangestuApril 1, 2026
View CodeSponsor this project
0 views
7 min read

Pendahuluan

Catatan

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

Episode 25Episode 25

Di episode sebelumnya kita sudah belajar tentang managing Kubernetes object menggunakan imperative dan declarative approach. Selanjutnya di episode 26 kali ini, kita akan coba bahas Deployment, salah satu Kubernetes resource paling penting untuk managing application rollout dan update.

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

Deployment menyediakan declarative update untuk Pod dan ReplicaSet. Dia manage entire lifecycle application kalian, dari initial deployment ke update dan rollback, ensuring zero-downtime deployment.

Apa Itu Deployment?

Deployment adalah Kubernetes resource yang manage set identical Pod, ensuring desired number Pod running dan handling update gracefully.

Bayangkan Deployment seperti production manager - dia ensure right number worker (Pod) selalu available, replace worker ketika fail, dan coordinate smooth transition ketika kalian need update workforce.

Karakteristik kunci Deployment:

  • Declarative update - Describe desired state, Kubernetes handle the rest
  • Rolling update - Update Pod gradually tanpa downtime
  • Rollback capability - Revert ke previous version easily
  • Scaling - Adjust number replica up atau down
  • Self-healing - Automatically replace failed Pod
  • Version history - Maintain revision history
  • Health check - Ensure Pod ready sebelum routing traffic

Kenapa Gunakan Deployment?

Deployment solve beberapa critical challenge:

  • Zero-downtime update - Update application tanpa service interruption
  • Easy rollback - Quickly revert problematic update
  • Automated scaling - Adjust capacity based on demand
  • Self-healing - Replace failed Pod automatically
  • Version control - Track deployment history
  • Gradual rollout - Control update pace dan strategy
  • Production-ready - Battle-tested untuk production workload

Tanpa Deployment, kalian harus manually manage Pod, handle update carefully untuk avoid downtime, dan implement rollback mechanism sendiri.

Membuat Deployment

Mari kita buat basic Deployment.

Basic Deployment

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

Apply Deployment:

Kubernetesbash
sudo kubectl apply -f nginx-deployment.yml

Check Deployment status:

Kubernetesbash
sudo kubectl get deployments

Output:

Kubernetesbash
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           30s

Check Pod created oleh Deployment:

Kubernetesbash
sudo kubectl get pods -l app=nginx

Deployment dengan Resource Limit

Kubernetesapp-deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-deployment
    labels:
        app: myapp
spec:
    replicas: 5
    selector:
        matchLabels:
            app: myapp
    template:
        metadata:
            labels:
                app: myapp
                version: v1.0
        spec:
            containers:
                - name: app
                  image: myapp:1.0
                  ports:
                      - containerPort: 8080
                  resources:
                      requests:
                          memory: "256Mi"
                          cpu: "250m"
                      limits:
                          memory: "512Mi"
                          cpu: "500m"
                  livenessProbe:
                      httpGet:
                          path: /health
                          port: 8080
                      initialDelaySeconds: 30
                      periodSeconds: 10
                  readinessProbe:
                      httpGet:
                          path: /ready
                          port: 8080
                      initialDelaySeconds: 5
                      periodSeconds: 5

Scaling Deployment

Adjust number replica.

Manual Scaling

Menggunakan kubectl scale:

Kubernetesbash
sudo kubectl scale deployment nginx-deployment --replicas=5

Menggunakan kubectl apply:

Kubernetesnginx-deployment.yml
spec:
    replicas: 5  # Changed dari 3 ke 5
Kubernetesbash
sudo kubectl apply -f nginx-deployment.yml

Autoscaling

Gunakan HorizontalPodAutoscaler untuk automatic scaling:

Kuberneteshpa.yml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
    name: nginx-hpa
spec:
    scaleTargetRef:
        apiVersion: apps/v1
        kind: Deployment
        name: nginx-deployment
    minReplicas: 3
    maxReplicas: 10
    metrics:
        - type: Resource
          resource:
              name: cpu
              target:
                  type: Utilization
                  averageUtilization: 70

Apply HPA:

Kubernetesbash
sudo kubectl apply -f hpa.yml

Check HPA status:

Kubernetesbash
sudo kubectl get hpa

Rolling Update

Update Deployment tanpa downtime.

Update Strategy

Deployment support dua update strategy:

RollingUpdate (default):

  • Update Pod gradually
  • Maintain availability during update
  • Configurable dengan maxSurge dan maxUnavailable

Recreate:

  • Terminate semua Pod sebelum create new one
  • Cause downtime
  • Useful untuk application yang tidak bisa run multiple version

Rolling Update Configuration

Kubernetesdeployment-strategy.yml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-deployment
spec:
    replicas: 10
    strategy:
        type: RollingUpdate
        rollingUpdate:
            maxSurge: 2        # Max 2 extra Pod during update
            maxUnavailable: 1  # Max 1 Pod unavailable during update
    selector:
        matchLabels:
            app: myapp
    template:
        metadata:
            labels:
                app: myapp
        spec:
            containers:
                - name: app
                  image: myapp:1.0
                  ports:
                      - containerPort: 8080

maxSurge: Maximum number Pod yang bisa created above desired replica maxUnavailable: Maximum number Pod yang bisa unavailable during update

Melakukan Rolling Update

Update image menggunakan kubectl set:

Kubernetesbash
sudo kubectl set image deployment/nginx-deployment nginx=nginx:1.26

Update menggunakan kubectl apply:

Kubernetesnginx-deployment.yml
# Change image version
containers:
    - name: nginx
      image: nginx:1.26  # Updated dari 1.25
Kubernetesbash
sudo kubectl apply -f nginx-deployment.yml

Watch rollout progress:

Kubernetesbash
sudo kubectl rollout status deployment/nginx-deployment

Output:

Kubernetesbash
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out

Rollback

Revert ke previous version.

View Rollout History

Kubernetesbash
sudo kubectl rollout history deployment/nginx-deployment

Output:

Kubernetesbash
deployment.apps/nginx-deployment
REVISION  CHANGE-CAUSE
1         <none>
2         <none>
3         kubectl set image deployment/nginx-deployment nginx=nginx:1.26

View Specific Revision

Kubernetesbash
sudo kubectl rollout history deployment/nginx-deployment --revision=2

Rollback ke Previous Version

Kubernetesbash
sudo kubectl rollout undo deployment/nginx-deployment

Rollback ke Specific Revision

Kubernetesbash
sudo kubectl rollout undo deployment/nginx-deployment --to-revision=2

Pause dan Resume Rollout

Pause rollout:

Kubernetesbash
sudo kubectl rollout pause deployment/nginx-deployment

Make multiple change:

Kubernetesbash
sudo kubectl set image deployment/nginx-deployment nginx=nginx:1.26
sudo kubectl set resources deployment/nginx-deployment -c=nginx --limits=cpu=500m,memory=512Mi

Resume rollout:

Kubernetesbash
sudo kubectl rollout resume deployment/nginx-deployment

Deployment Strategy

Different approach untuk updating application.

Rolling Update (Default)

Gradually replace old Pod dengan new one:

Kubernetesrolling-update.yml
spec:
    strategy:
        type: RollingUpdate
        rollingUpdate:
            maxSurge: 25%
            maxUnavailable: 25%

Keuntungan:

  • Zero downtime
  • Gradual rollout
  • Easy rollback

Kekurangan:

  • Both version run simultaneously
  • Slower daripada Recreate

Recreate

Terminate semua Pod sebelum create new one:

Kubernetesrecreate-strategy.yml
spec:
    strategy:
        type: Recreate

Keuntungan:

  • Simple dan fast
  • Hanya satu version run at a time

Kekurangan:

  • Cause downtime
  • Not suitable untuk production

Blue-Green Deployment

Run dua identical environment, switch traffic:

Kubernetesblue-green.yml
# Blue deployment (current)
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-blue
spec:
    replicas: 3
    selector:
        matchLabels:
            app: myapp
            version: blue
    template:
        metadata:
            labels:
                app: myapp
                version: blue
        spec:
            containers:
                - name: app
                  image: myapp:1.0
---
# Green deployment (new)
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-green
spec:
    replicas: 3
    selector:
        matchLabels:
            app: myapp
            version: green
    template:
        metadata:
            labels:
                app: myapp
                version: green
        spec:
            containers:
                - name: app
                  image: myapp:2.0
---
# Service (switch antara blue dan green)
apiVersion: v1
kind: Service
metadata:
    name: app-service
spec:
    selector:
        app: myapp
        version: blue  # Change ke 'green' untuk switch
    ports:
        - port: 80
          targetPort: 8080

Canary Deployment

Gradually shift traffic ke new version:

Kubernetescanary.yml
# Stable deployment (90% traffic)
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-stable
spec:
    replicas: 9
    selector:
        matchLabels:
            app: myapp
            track: stable
    template:
        metadata:
            labels:
                app: myapp
                track: stable
        spec:
            containers:
                - name: app
                  image: myapp:1.0
---
# Canary deployment (10% traffic)
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-canary
spec:
    replicas: 1
    selector:
        matchLabels:
            app: myapp
            track: canary
    template:
        metadata:
            labels:
                app: myapp
                track: canary
        spec:
            containers:
                - name: app
                  image: myapp:2.0
---
# Service (route ke both)
apiVersion: v1
kind: Service
metadata:
    name: app-service
spec:
    selector:
        app: myapp  # Match both stable dan canary
    ports:
        - port: 80
          targetPort: 8080

Contoh Praktis

Contoh 1: Production Web Application

Kubernetesweb-app-deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: web-app
    labels:
        app: web
        tier: frontend
spec:
    replicas: 5
    strategy:
        type: RollingUpdate
        rollingUpdate:
            maxSurge: 2
            maxUnavailable: 1
    selector:
        matchLabels:
            app: web
    template:
        metadata:
            labels:
                app: web
                version: v1.0
        spec:
            containers:
                - name: nginx
                  image: nginx:1.25
                  ports:
                      - containerPort: 80
                        name: http
                  resources:
                      requests:
                          memory: "128Mi"
                          cpu: "100m"
                      limits:
                          memory: "256Mi"
                          cpu: "200m"
                  livenessProbe:
                      httpGet:
                          path: /health
                          port: 80
                      initialDelaySeconds: 30
                      periodSeconds: 10
                      timeoutSeconds: 5
                      failureThreshold: 3
                  readinessProbe:
                      httpGet:
                          path: /ready
                          port: 80
                      initialDelaySeconds: 5
                      periodSeconds: 5
                      timeoutSeconds: 3
                      failureThreshold: 3
            affinity:
                podAntiAffinity:
                    preferredDuringSchedulingIgnoredDuringExecution:
                        - weight: 100
                          podAffinityTerm:
                              labelSelector:
                                  matchExpressions:
                                      - key: app
                                        operator: In
                                        values:
                                            - web
                              topologyKey: kubernetes.io/hostname

Contoh 2: Microservice dengan ConfigMap dan Secret

Kubernetesmicroservice-deployment.yml
apiVersion: v1
kind: ConfigMap
metadata:
    name: api-config
data:
    LOG_LEVEL: "info"
    API_TIMEOUT: "30"
---
apiVersion: v1
kind: Secret
metadata:
    name: api-secrets
type: Opaque
stringData:
    DATABASE_PASSWORD: "secretpassword"
    API_KEY: "abc123xyz789"
---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: api-service
spec:
    replicas: 3
    selector:
        matchLabels:
            app: api
    template:
        metadata:
            labels:
                app: api
        spec:
            containers:
                - name: api
                  image: myapi:latest
                  ports:
                      - containerPort: 8080
                  envFrom:
                      - configMapRef:
                            name: api-config
                      - secretRef:
                            name: api-secrets
                  resources:
                      requests:
                          memory: "256Mi"
                          cpu: "250m"
                      limits:
                          memory: "512Mi"
                          cpu: "500m"

Contoh 3: Multi-Container Deployment

Kubernetesmulti-container-deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
    name: app-with-sidecar
spec:
    replicas: 3
    selector:
        matchLabels:
            app: myapp
    template:
        metadata:
            labels:
                app: myapp
        spec:
            containers:
                # Main application
                - name: app
                  image: myapp:latest
                  ports:
                      - containerPort: 8080
                  volumeMounts:
                      - name: logs
                        mountPath: /var/log/app
                # Log shipper sidecar
                - name: log-shipper
                  image: fluent/fluentd:v1.16
                  volumeMounts:
                      - name: logs
                        mountPath: /var/log/app
                        readOnly: true
            volumes:
                - name: logs
                  emptyDir: {}

Melihat Detail Deployment

Get Deployment

Kubernetesbash
sudo kubectl get deployments
sudo kubectl get deployments -o wide

Describe Deployment

Kubernetesbash
sudo kubectl describe deployment nginx-deployment

View Deployment YAML

Kubernetesbash
sudo kubectl get deployment nginx-deployment -o yaml

Watch Deployment

Kubernetesbash
sudo kubectl get deployments --watch

Get ReplicaSet

Kubernetesbash
sudo kubectl get replicasets

Get Pod by Deployment

Kubernetesbash
sudo kubectl get pods -l app=nginx

Kesalahan Umum dan Pitfall

Kesalahan 1: No Resource Limit

Problem: Pod bisa consume unlimited resource.

Solusi: Selalu set resource limit:

Kubernetesyml
resources:
    requests:
        memory: "256Mi"
        cpu: "250m"
    limits:
        memory: "512Mi"
        cpu: "500m"

Kesalahan 2: Missing Health Check

Problem: Kubernetes route traffic ke unhealthy Pod.

Solusi: Add liveness dan readiness probe:

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

Kesalahan 3: Too Aggressive Rolling Update

Problem: Update happen terlalu fast, causing issue.

Solusi: Configure appropriate maxSurge dan maxUnavailable:

Kubernetesyml
rollingUpdate:
    maxSurge: 1
    maxUnavailable: 0  # Ensure no downtime

Kesalahan 4: Tidak Test Update

Problem: Deploy untested change ke production.

Solusi: Test di staging dulu:

Kubernetesbash
# Test di staging
sudo kubectl apply -f deployment.yml --namespace=staging
 
# Setelah validation, deploy ke production
sudo kubectl apply -f deployment.yml --namespace=production

Kesalahan 5: Ignore Rollout Status

Problem: Tidak monitor deployment progress.

Solusi: Selalu check rollout status:

Kubernetesbash
sudo kubectl rollout status deployment/nginx-deployment

Best Practice

Gunakan Declarative Configuration

Selalu gunakan YAML file:

Kubernetesbash
# Bagus: Declarative
sudo kubectl apply -f deployment.yml
 
# Hindari: Imperative
sudo kubectl create deployment nginx --image=nginx:1.25

Set Appropriate Replica Count

Pilih based on load dan availability requirement:

Kubernetesyml
# Development: 1-2 replica
replicas: 1
 
# Production: 3+ replica untuk high availability
replicas: 5

Gunakan Label Effectively

Organize dan select resource:

Kubernetesyml
metadata:
    labels:
        app: myapp
        version: v1.0
        environment: production
        tier: backend

Configure Update Strategy

Control rollout behavior:

Kubernetesyml
strategy:
    type: RollingUpdate
    rollingUpdate:
        maxSurge: 25%
        maxUnavailable: 25%

Add Annotation

Document deployment detail:

Kubernetesyml
metadata:
    annotations:
        kubernetes.io/change-cause: "Update to version 1.26"
        description: "Production web server"
        owner: "platform-team"

Gunakan Namespace

Isolate environment:

Kubernetesyml
metadata:
    name: app-deployment
    namespace: production

Monitor Deployment

Set up monitoring dan alert:

Kubernetesbash
sudo kubectl get deployments --watch
sudo kubectl rollout status deployment/app

Troubleshooting Deployment

Check Deployment Status

Kubernetesbash
sudo kubectl get deployment nginx-deployment
sudo kubectl describe deployment nginx-deployment

Check ReplicaSet

Kubernetesbash
sudo kubectl get replicasets
sudo kubectl describe replicaset <replicaset-name>

Check Pod

Kubernetesbash
sudo kubectl get pods -l app=nginx
sudo kubectl describe pod <pod-name>
sudo kubectl logs <pod-name>

Check Event

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

Rollback jika Needed

Kubernetesbash
sudo kubectl rollout undo deployment/nginx-deployment

Penutup

Pada episode 26 ini, kita telah membahas Deployment di Kubernetes secara mendalam. Kita sudah belajar cara create Deployment, perform rolling update, rollback change, dan implement different deployment strategy.

Key takeaway:

  • Deployment manage Pod dan ReplicaSet declaratively
  • Menyediakan zero-downtime update dengan rolling update
  • Easy rollback ke previous version
  • Scaling adjust replica count up atau down
  • Self-healing replace failed Pod automatically
  • Dua update strategy: RollingUpdate dan Recreate
  • maxSurge dan maxUnavailable control update pace
  • Rollout history track deployment revision
  • Health check ensure Pod ready
  • Resource limit prevent resource exhaustion
  • Blue-green dan canary strategy untuk advanced deployment
  • Selalu gunakan declarative configuration file
  • Monitor rollout status during update
  • Test di staging sebelum production
  • Gunakan label untuk organization dan selection

Deployment adalah cornerstone application management di Kubernetes. Dengan memahami Deployment, kalian bisa confidently deploy, update, dan manage application di production dengan zero downtime dan easy rollback capability.

Bagaimana, makin jelas kan tentang Deployment di Kubernetes? Jadi, pastikan tetap semangat belajar dan nantikan episode selanjutnya!

Catatan

Untuk kalian yang ingin melanjutkan ke episode selanjutnya, bisa click thumbnail episode 27 di bawah ini

Episode 27Episode 27

Related Posts