Menggunakan load balancing Maglev di GKE Dataplane V2

Dokumen ini menunjukkan cara mengonfigurasi dan memverifikasi load balancing Maglev untuk Layanan di GKE Dataplane V2.

Maglev adalah algoritma hashing yang konsisten yang menyediakan load balancing ber-throughput tinggi dan berlatensi rendah. Maglev meminimalkan paket yang terputus dan gangguan koneksi saat Pod backend diskalakan, diperbarui, atau dijadwalkan ulang dengan membantu memastikan bahwa alur yang sama secara konsisten dipetakan ke backend yang sama.

Untuk mengetahui informasi selengkapnya, lihat makalah penelitian algoritma hashing yang konsisten Maglev.

Kami merekomendasikan fitur ini untuk beban kerja dengan koneksi yang berjalan lama atau aplikasi stateful yang perubahan backend-nya tidak boleh mengganggu alur yang ada.

Untuk mengetahui informasi tentang overhead resource dan pertimbangan skalabilitas, lihat Konsep GKE Dataplane V2.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Aktifkan Google Kubernetes Engine API
• Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.

Prasyarat dan batas

• Versi GKE: 1.36.0-gke.2882000 dan yang lebih baru
• GKE Dataplane V2: diaktifkan
• Mode cluster: Autopilot dan Standard

Buat cluster GKE dengan GKE Dataplane V2

Untuk menggunakan Maglev, Anda harus memiliki cluster GKE dengan GKE Dataplane V2 yang diaktifkan.

gcloud container clusters create-auto CLUSTER_NAME \
    --region=COMPUTE_REGION \
    --release-channel=rapid
gcloud container clusters get-credentials CLUSTER_NAME \
    --region=COMPUTE_REGION

gcloud container clusters create CLUSTER_NAME \
    --zone=COMPUTE_ZONE \
    --enable-dataplane-v2 \
    --cluster-version=1.36.0-gke.2882000
gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=COMPUTE_ZONE

Men-deploy aplikasi backend

Sebelum mengonfigurasi Service load balancing, deploy aplikasi backend untuk menangani traffic. Deployment ini menjalankan lima replika aplikasi contoh hello-app.

1. Simpan manifes berikut sebagai echo-backend.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echo-backend
   spec:
     replicas: 5
     selector:
       matchLabels:
         app: echo-backend
     template:
       metadata:
         labels:
           app: echo-backend
       spec:
         containers:
         - name: hello
           image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
           ports:
           - containerPort: 8080
   

2. Terapkan manifes:

   kubectl apply -f echo-backend.yaml
   

Mengonfigurasi Service load balancing

Anda dapat mengonfigurasi Layanan untuk menggunakan algoritma load balancing Maglev atau algoritma load balancing acak default. Kedua Service menargetkan Deployment echo-backend yang dibuat pada langkah sebelumnya.

Mengonfigurasi Layanan Maglev

Untuk mengaktifkan load balancing Maglev, tambahkan anotasi gke.networking.io/lb-algorithm: "maglev" ke metadata Service selama pembuatan.

1. Simpan manifes berikut sebagai maglev-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: maglev-service
     annotations:
       gke.networking.io/lb-algorithm: "maglev"
   spec:
     selector:
       app: echo-backend
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Terapkan manifes:

   kubectl apply -f maglev-service.yaml
   

Mengonfigurasi Layanan acak

Secara default, Service menggunakan algoritma load balancing acak. Anda tidak perlu menentukan anotasi untuk menggunakan algoritma default, tetapi contoh berikut secara eksplisit mengonfigurasinya untuk perbandingan.

1. Simpan manifes berikut sebagai random-service.yaml:

   apiVersion: v1
   kind: Service
   metadata:
     name: random-service
     annotations:
       gke.networking.io/lb-algorithm: "random"
   spec:
     selector:
       app: echo-backend
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Terapkan manifes:

   kubectl apply -f random-service.yaml
   

Memverifikasi konsistensi traffic

Anda dapat memverifikasi perbedaan konsistensi pemilihan rute antara Maglev dan load balancing acak dengan men-deploy Pod klien pengujian yang mengirim traffic dari port sumber tetap.

Memverifikasi konsistensi traffic Maglev

Maglev merutekan permintaan dari port sumber yang sama secara konsisten ke Pod backend yang sama.

1. Simpan manifes berikut sebagai client-maglev.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: client-maglev
   spec:
     restartPolicy: Never
     containers:
     - name: curl
       image: curlimages/curl:8.2.0
       command: ["/bin/sh", "-c"]
       args:
       - |
         while true; do
           curl -s -H "Connection: close" http://maglev-service:80 --local-port 54321 | grep Hostname
           sleep 0.5
         done
   

   Flag --local-port memaksa port sumber, dan header Connection: close membantu memastikan bahwa klien dapat segera menggunakan kembali port sumber untuk permintaan berikutnya.

2. Terapkan manifes:

   kubectl apply -f client-maglev.yaml
   

3. Saat Pod berjalan, periksa log:

   kubectl logs client-maglev
   

   Output yang diharapkan:

   Output menampilkan nama host yang sama yang dicetak berulang kali, yang menunjukkan bahwa semua traffic dari klien secara konsisten dirutekan ke Pod backend yang sama:

   Hostname: echo-backend-5c78f66dbf-abcde
   Hostname: echo-backend-5c78f66dbf-abcde
   

Memverifikasi distribusi traffic default (acak)

Service default mendistribusikan traffic dari port sumber yang sama ke berbagai Pod backend.

1. Simpan manifes berikut sebagai client-random.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: client-random
   spec:
     restartPolicy: Never
     containers:
     - name: curl
       image: curlimages/curl:8.2.0
       command: ["/bin/sh", "-c"]
       args:
       - |
         while true; do
           curl -s -H "Connection: close" http://random-service:80 --local-port 54321 | grep Hostname
           sleep 0.5
         done
   

2. Terapkan manifes:

   kubectl apply -f client-random.yaml
   

3. Saat Pod berjalan, periksa log:

   kubectl logs client-random
   

   Output yang diharapkan:

   Output menampilkan beberapa nama host yang berbeda, yang menunjukkan bahwa traffic didistribusikan ke berbagai Pod:

   Hostname: echo-backend-5c78f66dbf-abcde
   Hostname: echo-backend-5c78f66dbf-fghij
   Hostname: echo-backend-5c78f66dbf-klmno
   ...
   

Pembersihan

Untuk membersihkan resource yang digunakan dalam tutorial ini, jalankan perintah berikut:

1. Hapus Pod, Layanan, dan Deployment klien:

   kubectl delete service maglev-service random-service
   kubectl delete deployment echo-backend
   kubectl delete pod client-maglev client-random
   

2. Hapus cluster GKE:

gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION

gcloud container clusters delete CLUSTER_NAME --zone=COMPUTE_ZONE