Kubernetes untuk Developer Solo: Panduan GKE Praktis Tanpa Kerumitan Berlebihan

Kubernetes punya reputasi sebagai overkill untuk developer solo dan tim kecil. Dalam banyak kasus, reputasi itu memang benar — mempertahankan control plane cluster sendiri, mengelola node pool, dan men-debug konflik CRD yang tidak jelas menghabiskan waktu yang lebih baik digunakan untuk membangun produk. Namun GKE Autopilot mengubah perhitungannya. Ia menghilangkan manajemen node sepenuhnya, hanya mengenakan biaya untuk resource request tingkat Pod (bukan kapasitas node yang menganggur), dan memberikan pengalaman Kubernetes sekelas produksi dengan biaya yang kompetitif dengan setup VPS terkelola setelah Anda memperhitungkan waktu operasional. Panduan ini berbagi apa yang saya pelajari men-deploy GKE Autopilot untuk proyek klien di Commsult Indonesia — apa yang berjalan baik, apa yang perlu diwaspadai, dan setup CI/CD yang bisa dioperasikan satu developer tanpa kelelahan.

GKE Autopilot vs Standard GKE vs Kubernetes DIY

Ada tiga cara menjalankan Kubernetes di Google Cloud: Standard GKE (Anda mengelola node, GKE mengelola control plane), Autopilot GKE (Google mengelola node dan control plane, Anda hanya mengelola Pod), dan Kubernetes self-managed di VM Compute Engine (Anda mengelola segalanya). Untuk developer solo, Autopilot hampir selalu pilihan yang tepat. Manajemen node pool Standard GKE — right-sizing, auto-scaling, upgrade window, node taint — adalah beban operasional yang signifikan. Autopilot menghapus semua itu. Anda mendefinisikan resource request dan limit Pod, dan Google menyediakan compute yang mendasarinya secara transparan. Jika sebuah node gagal, Pod Anda dijadwal ulang secara otomatis tanpa keterlibatan Anda.

Realita Harga Autopilot

Autopilot mengenakan biaya per Pod-detik CPU, memori, dan ephemeral storage yang diminta. Pod yang meminta 250m CPU dan 256Mi memori biayanya sekitar $0,016/jam — sekitar $11,50/bulan untuk Pod yang berjalan terus-menerus. Dua replika Pod tersebut biayanya $23/bulan. Bandingkan ini dengan Droplet DigitalOcean $12/bulan standar dengan 2 vCPU dan 2GB RAM yang menjalankan dua kontainer Docker — DigitalOcean jelas lebih murah untuk workload always-on sederhana. GKE Autopilot menjadi kompetitif ketika Anda membutuhkan fitur seperti HPA (Horizontal Pod Autoscaler), rolling update dengan readiness gate, isolasi namespace multi, atau CronJob dengan jaminan resource. Titik impas versus VPS terkelola kira-kira ada di 3-5 layanan yang berjalan terus-menerus.

Menyiapkan Cluster

Buat cluster GKE Autopilot di region terdekat dengan pengguna Anda — untuk proyek pasar Indonesia, asia-southeast1 (Singapura) atau asia-southeast2 (Jakarta). Aktifkan private node untuk menjaga alamat IP node worker dari internet publik, dan gunakan Cloud NAT untuk traffic keluar dari private node. Aktifkan Workload Identity untuk memungkinkan Pod mengakses layanan GCP (Cloud SQL, Cloud Storage) menggunakan IAM service account tanpa menyimpan kredensial sebagai Kubernetes secret. Pembuatan cluster awal membutuhkan 5-10 menit dan hanya memerlukan project ID dan region — tidak perlu konfigurasi node pool.

┌────────────────────────────────────────────────────────────────────┐
│          Solo Developer Kubernetes Stack (GKE Autopilot)           │
│                                                                    │
│  GitHub Actions CI/CD                                              │
│       │                                                            │
│       │  docker build + push to Artifact Registry                  │
│       │                                                            │
│       ▼                                                            │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │              GKE Autopilot Cluster                          │   │
│  │                                                             │   │
│  │  Namespace: production                                      │   │
│  │  ┌────────────────┐  ┌────────────────┐  ┌──────────────┐  │   │
│  │  │  Deployment    │  │  Deployment    │  │  CronJob     │  │   │
│  │  │  app (3 pods)  │  │  worker (2p)   │  │  scheduler   │  │   │
│  │  └───────┬────────┘  └───────┬────────┘  └──────────────┘  │   │
│  │          │                   │                              │   │
│  │  ┌───────▼───────────────────▼──────────────────────────┐  │   │
│  │  │  Service (ClusterIP) + Ingress (NGINX) + TLS cert    │  │   │
│  │  └──────────────────────────────────────────────────────┘  │   │
│  │                                                             │   │
│  │  Namespace: monitoring                                      │   │
│  │  Prometheus + Grafana (Helm charts)                         │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                          │                                         │
│                  Cloud SQL (PostgreSQL)                             │
│                  Cloud Storage (backups)                           │
└────────────────────────────────────────────────────────────────────┘

CI/CD Pipeline dengan GitHub Actions dan Artifact Registry

Workflow deployment untuk proyek GKE Autopilot menggunakan GitHub Actions untuk membangun image Docker, mendorongnya ke Artifact Registry di region GCP yang sama dengan cluster (untuk kecepatan pull tercepat), lalu menerapkan manifest Kubernetes yang diperbarui menggunakan `kubectl set image` atau dengan memperbarui tag image di file manifest dan menjalankan `kubectl apply`. Gunakan Workload Identity Federation untuk mengautentikasi GitHub Actions ke GCP — ini menggantikan kunci service account yang berumur panjang dengan token berumur pendek, menghilangkan kebutuhan menyimpan kredensial GCP di GitHub secrets.

Struktur Namespace dan RBAC untuk Proyek Solo

Bahkan sebagai developer solo, gunakan namespace untuk memisahkan kekhawatiran. Struktur namespace minimal: `production` untuk aplikasi live Anda, `staging` untuk pengujian pre-produksi, dan `monitoring` untuk Prometheus dan Grafana. Pemisahan ini memungkinkan Anda menerapkan ResourceQuota per namespace (mencegah namespace staging mengonsumsi semua resource cluster selama load test yang meledak) dan memudahkan penambahan anggota tim nanti dengan peran RBAC berbasis namespace. Install NGINX Ingress Controller di namespace `ingress-nginx` dan gunakan satu IP Cloud Load Balancer dengan name-based virtual hosting untuk merutekan traffic ke beberapa layanan.

# Create GKE Autopilot cluster (one-time)
gcloud container clusters create-auto myapp-cluster   --region asia-southeast1   --project my-project-id

# deployment.yaml — minimal production manifest
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: production
spec:
  replicas: 2
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: asia-southeast1-docker.pkg.dev/my-project/myapp:latest
          ports:
            - containerPort: 3000
          resources:
            requests:
              cpu: "250m"
              memory: "256Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 5
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: database-url
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
  namespace: production
spec:
  selector:
    app: myapp
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

# Apply and rollout
kubectl apply -f deployment.yaml
kubectl rollout status deployment/myapp -n production

# Rolling update with image change
kubectl set image deployment/myapp myapp=asia-southeast1-docker.pkg.dev/my-project/myapp:v2.0.0 -n production

Mengelola Secret dan Konfigurasi

Kubernetes Secret di-encode base64, bukan dienkripsi — siapa pun dengan akses kubectl ke namespace dapat men-decode-nya. Untuk produksi, gunakan External Secrets Operator dengan GCP Secret Manager sebagai backend. External Secrets menyinkronkan nilai GCP Secret Manager ke Kubernetes Secret secara otomatis, artinya nilai secret aktual Anda tidak pernah ada di repositori Git atau tidak terenkripsi di etcd. Di GCP Secret Manager, aktifkan rotasi otomatis untuk password database dan API key, dan konfigurasikan Secret Manager untuk memberi tahu aplikasi Anda melalui Pub/Sub ketika secret dirotasi agar dapat memuat ulang tanpa restart.

Taktik Optimasi Biaya

Beberapa taktik mengurangi biaya GKE Autopilot secara signifikan. Pertama, atur resource request dan limit yang akurat — meminta CPU dan memori secara berlebihan membuang uang karena Autopilot mengenakan biaya untuk yang Anda minta. Gunakan Vertical Pod Autoscaler (VPA) dalam mode rekomendasi selama satu minggu untuk mendapatkan saran resource berbasis data. Kedua, gunakan CronJob daripada Pod yang selalu berjalan untuk workload batch — Pod yang berjalan 30 menit sehari biayanya 48x lebih murah daripada yang berjalan terus-menerus. Ketiga, konfigurasi HPA untuk scale down ke 1 replika selama jam tidak sibuk untuk layanan tidak kritis. Keempat, gunakan `preemptible: true` di spesifikasi Pod untuk batch job yang toleran terhadap kegagalan — Autopilot mendiskon Pod preemptible sekitar 60%.

Kapan Sebaiknya Tetap Menggunakan VPS

Kubernetes tidak selalu jawabannya. Jika proyek Anda adalah satu kontainer Docker yang melayani traffic HTTP, DigitalOcean Droplet atau GCP Compute Engine instance dengan Docker dan NGINX adalah pilihan yang lebih sederhana dan murah. Tambahkan blue-green deployment via bash script (seperti dijelaskan di postingan lain) dan Anda mendapat deployment zero-downtime tanpa kompleksitas Kubernetes apa pun. Gunakan GKE Autopilot ketika Anda benar-benar membutuhkan: penskalaan otomatis berdasarkan beban (HPA), orkestrasi multi-layanan dengan rolling update berbasis health check, isolasi resource tingkat namespace, atau pekerjaan terjadwal dengan jaminan resource. Investasi operasional dalam Kubernetes mulai terbayar pada 4-6 layanan atau 3+ anggota tim.

Artikel Terkait

• Google Cloud vs DigitalOcean: Memilih Platform Anda
• Deployment Zero-Downtime dengan NGINX Blue-Green di VPS