Belajar Cloud Engineer - Containers on Cloud (EKS/GKE/AKS)

#Pendahuluan

Sejak episode 3 kalian sudah menjalankan container di cloud lewat layanan container dasar. Sekarang saatnya naik level ke orchestrator: Kubernetes. Kubernetes adalah sistem yang mengotomasi deployment, scaling, dan operasional container — tetapi mengelola Kubernetes sendiri di VM adalah pekerjaan besar yang menyita waktu (dan biaya).

Di sinilah managed Kubernetes berperan: AWS EKS, Google GKE, dan Azure AKS menyediakan control plane yang dikelola provider. Kalian fokus pada aplikasi; provider mengurus control plane, patching, dan high availability-nya. Episode 10 membahas konsep inti Kubernetes, node pools, workload & service, lalu praktik membuat cluster dan men-deploy aplikasi.

#Mengapa Kubernetes dan Managed K8s

#Masalah yang Dipecahkan Kubernetes

Menjalankan banyak container secara manual penuh masalah: ke mana request diarahkan? Bagaimana aplikasi tetap hidup saat satu node mati? Bagaimana scale otomatis? Kubernetes menjawab semuanya dengan declarative state: kalian menyatakan hasil akhir (10 replica, image v2.0), dan control plane bekerja agar kenyataan sesuai.

#Mengapa Managed, Bukan Self-Hosted

Aturan praktis 2026: self-hosted hanya untuk alasan spesifik (regulasi, kasus khusus). Untuk hampir semua organisasi, managed K8s adalah pilihan default.

#Konsep Inti Kubernetes yang Wajib Dipahami

#Cluster, Node Pool, dan Node

• Cluster — kesatuan control plane + worker nodes.
• Node pool — grup node dengan spesifikasi sama (instance type, autoscaling). Bisa punya beberapa pool: pool CPU kecil untuk web, pool GPU untuk ML (episode 23).
• Node — VM (atau Fargate) tempat pod berjalan.

Membuat cluster GKE:

gcloud container clusters create lab-cluster \
  --region=asia-southeast2 \
  --node-locations=asia-southeast2-a,asia-southeast2-b \
  --machine-type=e2-standard-2 \
  --num-nodes=2 \
  --enable-autoscaling --min-nodes=1 --max-nodes=5
gcloud container clusters get-credentials lab-cluster

Perhatikan --enable-autoscaling — node pool yang bisa scale otomatis sesuai beban (episode 21). Ini bukan fitur "bonus", melainkan bagian dari desain yang benar.

#Workload: Deployment dan Pod

Pod adalah unit terkecil (satu atau lebih container). Deployment mengelola pod: jumlah replica, image, rollout strategy.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
  labels:
    app: webapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
        - name: webapp
          image: nginx:1.27
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 200m
              memory: 256Mi

Dua hal yang wajib kalian biasakan di Kubernetes:

1. Resource requests & limits selalu didefinisikan — tanpa itu, satu pod bisa memakan semua CPU node dan mengganggu pod lain.
2. image: nginx:1.27 memakai tag versi spesifik, bukan latest — latest membuat rollout tidak reproducible.

#Service dan Ingress

Service memberikan alamat IP stabil ke sekumpulan pod (supaya load balancer tidak mengejar pod yang berpindah). Ingress mengatur routing HTTP eksternal ke service, lengkap dengan TLS.

apiVersion: v1
kind: Service
metadata:
  name: webapp
spec:
  selector:
    app: webapp
  ports:
    - port: 80
      targetPort: 80
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: webapp
spec:
  rules:
    - host: lab.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: webapp
                port:
                  number: 80

Di cloud, Ingress di-backing oleh cloud load balancer (ALB/NLB di EKS, HTTP LB di GKE, Application Gateway di AKS) — kalian cukup menulis manifest, provider yang memasang load balancer fisiknya.

#Deploy Aplikasi ke Cluster

Mari deploy aplikasi lengkap — deployment, service, dan ingress:

Deploy ke cluster

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl apply -f ingress.yaml
 
kubectl rollout status deployment/webapp
kubectl get pods
kubectl get svc
kubectl get ingress

Uji scaling manual — jumlah replica bisa diubah kapan saja, dan Kubernetes menyesuaikan:

Scale dan cek rollout

kubectl scale deployment webapp --replicas=5
kubectl get pods -o wide
kubectl scale deployment webapp --replicas=3

Perhatikan pola declarative: kalian tidak "membuat pod" atau "menghapus pod", kalian menyatakan jumlah yang diinginkan (--replicas=5), dan Kubernetes bekerja agar keadaan nyata sesuai. Semua perubahan lain — image, environment, config — mengikuti pola yang sama.

#Upgrade Aplikasi

Rolling update image

kubectl set image deployment/webapp webapp=nginx:1.29
kubectl rollout status deployment/webapp
kubectl rollout history deployment/webapp

Jika versi baru bermasalah, rollback semudah satu perintah:

Rollback ke versi sebelumnya

kubectl rollout undo deployment/webapp

Inilah kekuatan deployment strategy: aplikasi di-update dan di-rollback tanpa downtime, otomatis oleh Kubernetes.

#Perbandingan EKS vs GKE vs AKS

Pilihannya sering ditentukan oleh provider yang sudah dipakai organisasi. Kemampuan dasar — deployment, service, ingress — identik lintas provider karena semua Kubernetes. Yang membedakan hanya integrasi di sekitarnya.

#Kesalahan Umum (Common Pitfalls)

1. Tidak ada resource requests/limits — pod "senak" memakan semua node.
2. Tag latest — tidak reproducible; selalu pin versi.
3. Mengedit pod langsung, bukan deployment — perubahan hilang saat pod dibuat ulang; selalu edit workload (deployment).
4. Ingress tanpa TLS — traffic HTTP telanjang; pasang certificate (episode 15).
5. Node pool tanpa autoscaling — bayar node tetap padahal beban rendah; aktifkan cluster autoscaler.

#Penutup

Inti yang harus dibawa pulang:

• Kubernetes mengotomasi deployment & scaling container dengan pola declarative state.
• Managed K8s (EKS/GKE/AKS) adalah default 2026 — control plane, HA, dan patching diurus provider.
• Komponen inti: cluster, node pool, deployment, pod, service, ingress.
• Selalu definisikan resource requests/limits dan pin image version.
• Deployment & rollback aplikasi menjadi rutinitas satu perintah dengan kubectl rollout.

Di episode 11 selanjutnya kita akan membahas serverless architecture — API Gateway + Lambda/Cloud Functions, event-driven design, cold start trade-off, dan membangun serverless API yang lengkap. Sampai jumpa di episode 11!