# Zero-Downtime Deployment dengan Service Mesh dan Canary Routing

> Diterbitkan oleh Literally Web ID pada 20 Oct 2026
> Sumber: https://literally.web.id/articles/zero-downtime-deployment-dengan-service-mesh-dan-canary-routing

---

## 1. Menu Kita Hari Ini & Alat yang Perlu Disiapkan

Pernahkah Anda merilis kode baru ke production, hanya untuk melihat tingkat error melonjak tajam karena ada edge case yang lolos dari uji unit lokal? Jantung berdegup kencang, tombol rollback ditekan, dan Anda berharap punya cara yang lebih elegan untuk menguji fitur tanpa harus mengorbankan pengalaman seluruh pengguna.

Dalam 15 menit ke depan, kita akan merakit resep infrastruktur kelas berat langsung dari ruang kendali produksi: **Zero-Downtime Deployment menggunakan Istio Service Mesh dan Canary Routing**. Kita tidak akan membahas teori abstrak dari buku tebal. Kita akan langsung meracik kontrol lalu lintas berbasis persentase, membelokkan 5% trafik pengguna ke versi v2 aplikasi Go atau Node.js kita, memantau metrik via Prometheus, dan memastikan semuanya berjalan mulus tanpa satu pun *dropped packet*.

> [!TIP]
> Siapkan terminal Anda, pastikan cluster Kubernetes (Minikube, Kind, atau EKS) sudah aktif, dan pastikan `istioctl` serta `kubectl` sudah terpasang rapi di mesin kerja Anda.

Mari kita mulai perjalanan ini dengan melihat peta besar dari apa yang akan kita bangun di dapur infrastruktur kita.

## 2. Peta Jalan Singkat: Apa yang Sedang Kita Rakit

Sebelum kita menyentuh baris kode konfigurasi pertama, mari kita bayangkan sebuah restoran cepat saji yang sangat sibuk. Alih-alih mengganti seluruh menu di semua cabang secara bersamaan—yang bisa berakibat fatal jika resep baru ternyata asin—kita mengirimkan menu baru tersebut hanya ke satu meja pojok (Canary). Kita amati reaksi pelanggan, apakah mereka tersenyum atau mengerutkan dahi, baru kemudian kita ratakan ke seluruh restoran.

Di dunia cloud native, kita akan melakukan hal serupa:
1. **Fondasi Service Mesh**: Kita injeksikan *sidecar proxy* (Envoy) ke dalam pod aplikasi kita untuk memegang kendali penuh atas lalu lintas masuk dan keluar.
2. **VirtualService & DestinationRule**: Kita pasang pengalih arah cerdas di pintu gerbang mesh, membagi trafik secara presisi (misal: 95% ke v1, 5% ke v2).
3. **Observability**: Kita intip kesehatan aplikasi secara real-time menggunakan metrik tracing agar kita tahu kapan harus menaikkan persentase canary atau langsung melakukan abort deployment.

Dari peta jalan ini, mari kita langsung terjun ke langkah pertama untuk menyiapkan bahan-bahannya.

## 3. Langkah 1: Mempersiapkan Fondasi & Environment

Kita butuh namespace khusus yang siap disuntikkan kemampuan mesh secara otomatis. Bayangkan ini seperti memasang pipa ledeng cerdas di gedung baru sebelum penghuninya masuk.

Buka terminal Anda dan buat namespace bernama `production-mesh`, lalu aktifkan injeksi otomatis Istio:

```bash
# Membuat namespace untuk aplikasi kita
kubectl create namespace production-mesh

# Mengaktifkan automatic sidecar injection dari Istio
kubectl label namespace production-mesh istio-injection=enabled --overwrite

# Verifikasi bahwa label sudah terpasang
kubectl get namespace production-mesh --show-labels
```

> [!IMPORTANT]
> Pastikan Anda sudah menginstal Istio di cluster Kubernetes Anda menggunakan profil `demo` atau `minimal` sebelum menjalankan perintah di atas. Jika `istioctl version` mengembalikan error, pastikan CLI sudah terhubung ke cluster yang benar.

Sekarang, mari kita siapkan dua versi aplikasi backend kita (misalnya sebuah layanan web sederhana berbasis Go) yang akan kita sebut sebagai `web-api`. Versi 1 adalah yang stabil saat ini, dan Versi 2 adalah fitur baru yang ingin kita uji.

## 4. Langkah 2: Meracik Konfigurasi Inti Tanpa Basa-basi

Kita akan mendeploy dua deployment Kubernetes (`web-api-v1` dan `web-api-v2`) ke dalam namespace `production-mesh`. Setelah itu, kita racik bumbu utamanya: `VirtualService` dan `DestinationRule`.

Simpan konfigurasi berikut ke dalam file bernama `deployment-and-mesh.yaml`:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-api-v1
  namespace: production-mesh
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-api
      version: v1
  template:
    metadata:
      labels:
        app: web-api
        version: v1
    spec:
      containers:
      - name: web
        image: gcr.io/kanary-demo/web-api:1.0.0
        ports:
        - containerPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-api-v2
  namespace: production-mesh
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-api
      version: v2
  template:
    metadata:
      labels:
        app: web-api
        version: v2
    spec:
      containers:
      - name: web
        image: gcr.io/kanary-demo/web-api:2.0.0
        ports:
        - containerPort: 8080
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: web-api-destination
  namespace: production-mesh
spec:
  host: web-api
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: web-api-route
  namespace: production-mesh
spec:
  hosts:
  - "web-api"
  http:
  - route:
    - destination:
        host: web-api
        subset: v1
      weight: 95
    - destination:
        host: web-api
        subset: v2
      weight: 5
```

Terapkan konfigurasi ini langsung ke cluster Anda:

```bash
kubectl apply -f deployment-and-mesh.yaml
```

Perhatikan bagaimana `VirtualService` membagi beban: 95% lari ke subset `v1` dan hanya 5% yang mendarat di subset `v2`. Inilah inti dari canary routing. Namun, infrastruktur yang hebat tidak lengkap tanpa lapisan pengamanan dan optimasi performa.

## 5. Langkah 3: Sentuhan Akhir Keamanan & Optimasi

Di lingkungan production nyata, Anda tidak ingin trafik canary jebol karena serangan DDoS atau koneksi lambat dari bot jahat. Kita perlu memastikan bahwa komunikasi antar pod di dalam mesh dienkripsi dengan mTLS (Mutual TLS) secara ketat.

Buat file konfigurasi `security-mesh.yaml`:

```yaml
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: production-mesh
spec:
  mtls:
    mode: STRICT
```

Terapkan aturan keamanan ini:

```bash
kubectl apply -f security-mesh.yaml
```

Dengan mode `STRICT`, setiap byte data yang melintasi Envoy proxy dijamin terenkripsi menggunakan sertifikat TLS yang dirotasi otomatis oleh Istio. Tidak ada lagi celah bagi *packet sniffing* di dalam cluster internal Anda.

## 6. Tes Rasa: Memastikan Semuanya Berjalan Sempurna

Sekarang saatnya kita cicipi hasil masakan kita. Mari kita buat pod tester sementara untuk menghantam endpoint `web-api` secara berulang-ulang, lalu lihat apakah pembagian trafik 95:5 benar-benar terjadi.

Jalankan perintah curl interaktif ini di terminal:

```bash
# Jalankan pod temporary untuk melakukan test request
kubectl run curl-tester --image=curlimages/curl -it --rm --namespace=production-mesh -- sh

# Di dalam terminal pod tester, jalankan loop berikut:
while true; do curl -s http://web-api:8080/version; echo ""; sleep 0.2; done
```

> [!TIP]
> Anda akan melihat sebagian besar respons mencetak `v1.0.0`, dan sesekali (sekitar 1 dari 20 permintaan) akan muncul `v2.0.0`. Itu adalah tanda visual yang sangat memuaskan bahwa sistem Canary Routing kita bekerja dengan presisi tinggi!

Keluar dari pod tester dengan mengetik `exit`. Tapi tunggu, bagaimana jika tiba-tiba lonjakan error terjadi pada v2? Mari kita bahas penanganannya.

## 7. Pertolongan Pertama: Jika Terjadi Kendala Kecil

* **Masalah 1**: Trafik sama sekali tidak masuk ke v2 (0%).
  * *Solusi*: Cek kembali label pada selector deployment Anda. Pastikan label `version: v2` di DestinationRule benar-benar cocok dengan label di pod Kubernetes Anda.
* **Masalah 2**: Muncul error `503 Service Unavailable` saat mengakses mesh.
  * *Solusi*: Seringkali ini terjadi karena sidecar Envoy belum sepenuhnya siap saat aplikasi mulai menerima trafik. Tambahkan *readiness probe* pada aplikasi Anda atau jalankan ulang pod dengan `kubectl rollout restart deployment/web-api-v1 -n production-mesh`.

Selamat! Anda baru saja merakit sistem Zero-Downtime Deployment kelas enterprise dalam waktu kurang dari 15 menit. Simpan resep ini di lali catatan harian infrastruktur Anda, dan nikmati tidur yang lebih nyenyak saat malam deployment tiba.