Local Development Tools #

Salah satu tantangan terbesar developer yang bekerja dengan Kubernetes adalah inner development loop yang lambat — ubah kode, build image, push ke registry, update deployment, tunggu Pod ready, test. Satu siklus bisa makan 5-10 menit. Tools di artikel ini dirancang untuk mempersingkat loop ini secara drastis, baik dengan menjalankan cluster minimal di lokal maupun dengan cara yang lebih cerdas untuk connect kode lokal ke cluster yang sudah berjalan.

Opsi Local Cluster #

Minikube #

Minikube adalah tool paling lama dan paling dikenal untuk menjalankan cluster Kubernetes single-node di lokal.

# Install Minikube
brew install minikube   # macOS
# atau download dari https://minikube.sigs.k8s.io/

# Start cluster
minikube start
minikube start --cpus=4 --memory=8g --disk-size=40g

# Dengan driver tertentu
minikube start --driver=docker    # pakai Docker sebagai runtime
minikube start --driver=hyperkit  # macOS: lebih performa dari docker driver

# Load image lokal ke Minikube (tanpa push ke registry)
minikube image load my-api:dev

# Akses service
minikube service my-service --url

# Dashboard
minikube dashboard

# Addons (Ingress, metrics-server, dll)
minikube addons enable ingress
minikube addons enable metrics-server
minikube addons list

Kind (Kubernetes in Docker) #

Kind menjalankan node Kubernetes sebagai Docker container — lebih ringan dari Minikube dan sangat cocok untuk CI/CD pipeline.

# Install Kind
brew install kind   # macOS
# atau: go install sigs.k8s.io/kind@latest

# Buat cluster default (single node)
kind create cluster

# Buat cluster dengan konfigurasi
cat > kind-config.yaml << EOF
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF
kind create cluster --config kind-config.yaml --name local

# Load image lokal ke Kind (lebih cepat dari push ke registry)
kind load docker-image my-api:dev --name local

# Hapus cluster
kind delete cluster --name local

# Kind config untuk simulasi production lebih realistis
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"    
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
- role: worker
- role: worker

k3d (k3s in Docker) #

k3d adalah wrapper untuk k3s (Kubernetes ringan dari Rancher) yang berjalan di dalam Docker. Startup paling cepat dari semua opsi.

# Install k3d
brew install k3d   # macOS
# atau: curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash

# Buat cluster (sangat cepat, ~30 detik)
k3d cluster create local \
  --port "8080:80@loadbalancer" \
  --port "8443:443@loadbalancer" \
  --agents 2

# Load image lokal
k3d image import my-api:dev --cluster local

# List cluster
k3d cluster list

# Stop/start cluster (tidak perlu buat ulang)
k3d cluster stop local
k3d cluster start local

Perbandingan Local Cluster #

                  Minikube    Kind        k3d
─────────────────────────────────────────────────
Startup time      ~2 menit    ~1 menit    ~30 detik
Resource usage    Sedang      Ringan      Paling ringan
Multi-node        Ya          Ya          Ya
CI/CD friendly    Kurang      Sangat baik Sangat baik
Load image lokal  Ya          Ya          Ya
Addons bawaan     Banyak      Tidak ada   Terbatas
Windows support   Baik        Baik        Baik
macOS support     Baik        Baik        Baik

Skaffold: Inner Loop yang Cepat #

Skaffold mengotomasi siklus build-push-deploy saat kamu mengubah kode. Dengan file watching, setiap perubahan kode otomatis di-detect, image di-build, dan Pod di-update — tanpa perlu menjalankan perintah manual.

# skaffold.yaml
apiVersion: skaffold/v4beta6
kind: Config
metadata:
  name: my-api

build:
  artifacts:
  - image: my-registry.io/my-api
    # Dengan sync: tidak perlu rebuild image untuk perubahan kode Python/JS
    sync:
      infer:
      - "**/*.py"     # sync file Python langsung ke container (tanpa rebuild)
      - "**/*.js"

deploy:
  kubectl:
    manifests:
    - k8s/base/*.yaml
  # Atau Helm:
  # helm:
  #   releases:
  #   - name: my-api
  #     chartPath: ./chart
  #     valuesFiles:
  #     - values-dev.yaml

portForward:
- resourceType: service
  resourceName: api-service
  port: 80
  localPort: 8080

profiles:
- name: production
  deploy:
    kubectl:
      manifests:
      - k8s/overlays/production/*.yaml

# Development mode: watch + auto rebuild + auto deploy
skaffold dev

# Output:
# Watching for changes...
# [api] Syncing 1 files for my-registry.io/my-api:dev
# Port forwarding service/api-service in namespace default, remote port 80 -> http://127.0.0.1:8080
# [api] {"time":"...","level":"INFO","msg":"Server started"}

# Build dan deploy sekali saja (tanpa watch)
skaffold run

# Hanya build
skaffold build

# Cleanup (hapus semua yang di-deploy)
skaffold delete

Telepresence: Debug Service di Cluster Nyata #

Telepresence memungkinkan kamu menjalankan satu service secara lokal sementara terhubung ke cluster staging atau development yang nyata. Traffic yang seharusnya ke service tersebut dialihkan ke proses lokal kamu.

# Install Telepresence
brew install datawire/blackbird/telepresence  # macOS

# Connect ke cluster (setup traffic intercept)
telepresence connect

# Intercept traffic dari service di cluster ke proses lokal
# Semua request ke "api-service" di cluster → dikirim ke localhost:8080
telepresence intercept api \
  --port 8080:80 \
  --env-file .env.cluster    # export env vars dari Pod ke file lokal

# Setelah intercept aktif, jalankan service lokal:
python main.py  # atau: npm run dev

# Setiap request ke api-service di cluster sekarang datang ke proses lokal
# → Bisa debug dengan breakpoint, bisa lihat log lokal secara real-time

# Hentikan intercept
telepresence leave api

# Disconnect dari cluster
telepresence quit

Manfaat Telepresence:
  → Tidak perlu build image untuk setiap perubahan kecil
  → Service lokal bisa akses semua service lain di cluster (database, Redis, dll)
  → Bisa debug dengan IDE debugger (breakpoint, step-through)
  → Tidak perlu mock external dependencies — pakai yang nyata di cluster

DevSpace: Alternatif All-in-One #

DevSpace menggabungkan hot-reload, port-forwarding, dan log streaming dalam satu tool dengan konfigurasi yang lebih sederhana dari Skaffold untuk use case tertentu:

# devspace.yaml
version: v2beta1
name: my-api

images:
  api:
    image: my-registry.io/my-api
    dockerfile: ./Dockerfile

deployments:
  api:
    helm:
      chart:
        path: ./chart
      values:
        image:
          repository: my-registry.io/my-api

dev:
  api:
    imageSelector: my-registry.io/my-api
    devImage: my-registry.io/my-api:dev
    # Sync kode lokal ke container (hot reload)
    sync:
    - path: ./src:/app/src
    # Port forward
    ports:
    - port: "8080:8080"
    # Inject SSH dan buka terminal di container
    terminal:
      command: bash

Ringkasan #

Kind untuk CI/CD, k3d untuk development — Kind punya ekosistem integrasi CI yang lebih matang; k3d startup lebih cepat dan lebih ringan untuk penggunaan sehari-hari.
kind load dan k3d image import lebih cepat dari push ke registry — untuk development, langsung load image ke cluster lokal tanpa melalui registry; menghemat 1-2 menit per siklus.
Skaffold sync untuk hot-reload tanpa rebuild — definisikan pola file yang di-sync langsung ke container; perubahan Python/JavaScript tidak perlu rebuild image.
Telepresence untuk debug dengan dependency nyata — menjalankan service lokal dengan koneksi ke cluster staging memungkinkan debugging yang jauh lebih realistis dari mock.
Pilih tools yang sesuai workflow tim — tidak ada satu jawaban benar; tim yang deploy ke staging sering mungkin lebih cocok Telepresence, tim yang sering iterasi kode cocok Skaffold.
Pisahkan skaffold profile per environment — skaffold dev untuk lokal, skaffold run --profile staging untuk staging; satu konfigurasi untuk semua.

← Sebelumnya: kubectl Tips Berikutnya: Operator Pattern →