Load Balancing Lanjutan di Cluster GKE

Pratinjau

Produk atau fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum di Persyaratan Khusus Layanan. Produk dan fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Halaman ini menunjukkan cara mengonfigurasi load balancing lanjutan di cluster GKE untuk pengguna Cloud Service Mesh (TD) terkelola menggunakan Kubernetes API. Untuk panduan pengguna yang sesuai guna mengonfigurasi load balancing lanjutan menggunakan Google Cloud API, lihat Menyiapkan load balancing lanjutan.

Anda dapat menggunakan load balancing lanjutan untuk:

• Mempertahankan traffic ke zona layanan hingga kapasitas lokal habis.
• Kirim traffic ke layanan di lokasi "utama" dengan failover ke lokasi sekunder saat endpoint yang memadai di lokasi utama menjadi tidak sehat.
• Mengontrol kapan failover terjadi (berdasarkan persentase host yang sehat).

Batasan

• Batasan umum terkait penggunaan load balancing lanjutan di Google Cloud berlaku.
• Fitur ini hanya tersedia untuk pengguna Cloud Service Mesh terkelola yang menggunakan Traffic Director sebagai bidang kontrol dan memerlukan versi bidang data 1.19.10-asm.22 atau yang lebih baru.
• Tidak semua kolom di GCPTrafficDistributionPolicy dan GCPBackendPolicy didukung untuk managedCloud Service Mesh (TD). Kolom yang didukung adalah sebagai berikut:
  • GCPTrafficDistributionPolicy
    • ServiceLbAlgorithm
    • AutoCapacityDrain
    • FailoverConfig
  • GCPBackendPolicy
    • MaxRatePerEndpoint
    • BackendPreference
• Load balancing lanjutan hanya dapat diterapkan ke layanan Kubernetes yang didukung oleh workload yang berjalan di Google Cloud. Layanan atau beban kerja eksternal (seperti ServiceEntry) tidak didukung.
• Kebijakan load balancing hanya dapat diterapkan ke setiap layanan Kubernetes. Kebijakan load balancing seluruh namespace/seluruh mesh tidak didukung.
• Hanya kapasitas QPS yang didukung.
• Hanya versi GKE >= 1.31.1 yang didukung.
• Kebijakan load balancing lanjutan mesh layanan hanya boleh diterapkan ke layanan yang hanya menyalurkan traffic mesh. Ini tidak boleh diterapkan ke layanan yang berfungsi sebagai backend GKE Gateway. Perilaku traffic tidak ditentukan saat traffic load balancing lanjutan menargetkan layanan Kubernetes yang menyalurkan traffic mesh dan traffic dari Gateway GKE.

Mengonfigurasi load balancing lanjutan

Anda dapat menggunakan resource kustom berikut untuk mengonfigurasi load balancing lanjutan di GKE. Anda dapat menemukan definisi resource mendetail di repo gke-gateway-api.

GCPTrafficDistributionPolicy

GCPTrafficDistributionPolicy mengonfigurasi kebijakan load balancing tingkat layanan untuk layanan Kubernetes. Dengan fitur ini, Anda dapat:

• Pilih algoritma load balancing kustom. Algoritme yang didukung dijelaskan dalam tabel load balancing lanjutan.
• Aktifkan pengosongan kapasitas otomatis.
• Sesuaikan batas kesehatan failover.

Jika beberapa GCPTrafficDistributionPolicies menargetkan layanan yang sama, kebijakan terlama akan diterapkan.

GCPBackendPolicy

GCPBackendPolicy mengonfigurasi properti backend layanan yang memengaruhi perilaku load balancing, termasuk:

• Kapasitas backend layanan.
• Menetapkan backend pilihan.

Jika beberapa GCPBackendPolicies menargetkan layanan yang sama dalam cluster, kebijakan terlama akan diterapkan.

Status Kebijakan

GCPTrafficDistributionPolicy dan GCPBackendPolicy memiliki kolom status yang menunjukkan status lampiran kebijakan.

Misalnya, menjalankan kubectl describe gcpbackendpolicies example-policy -n example akan menghasilkan output yang mirip dengan:

...
Status:
  Ancestors:
    Ancestor Ref:
      Group:
      Kind:       Service
      Name:       example-svc
      Namespace:  example
    Conditions:
      Last Transition Time:  2024-10-13T01:15:03Z
      Message:
      Observed Generation:   1
      Reason:                Attached
      Status:                True
      Type:                  Attached
    Controller Name:         gsmconfig.gke.io/controller

Penyiapan awal

Sebelum dapat menyelesaikan panduan ini, Anda harus menyediakan Cloud Service Mesh di cluster GKE.

1. Periksa apakah CRD telah diinstal:

   kubectl get crd
   

   Outputnya mirip dengan:

   ...
   gcptrafficdistributionpolicies.networking.gke.io   2024-07-18T21:50:12Z
   gcpbackendpolicies.networking.gke.io               2024-07-18T21:50:12Z
   ...
   

2. Instal CRD GCPBackendPolicy jika belum diinstal:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcpbackendpolicies.yaml
   

3. Instal CRD GCPTrafficDistributionPolicy jika belum diinstal:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcptrafficdistributionpolicies.yaml
   

Contoh kebijakan dalam panduan pengguna ini menargetkan Service foo di namespace foo untuk tujuan demonstrasi. Anda dapat menjalankan perintah berikut untuk membuat layanan dan namespace pengujian, atau jika mau, Anda dapat menggunakan layanan dan namespace Anda sendiri:

kubectl apply -f - <<EOF
kind: Namespace
apiVersion: v1
metadata:
  name: foo
  labels:
    istio-injection: enabled
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: foo
  namespace: foo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-backend
  template:
    metadata:
      labels:
        app: test-backend
    spec:
      containers:
      - name: whereami
        image: gcr.io/google-samples/whereami:v1.2.23
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: foo
  namespace: foo
spec:
  selector:
    app: test-backend
  ports:
  - port: 8080
    targetPort: 8080
EOF

Mengonfigurasi algoritma load balancing

Secara default, traffic ke layanan didistribusikan secara merata ke setiap backend layanan yang sehat dalam mesh layanan Cloud Service Mesh. Anda dapat membuat GCPTrafficDistributionPolicy berikut sehingga traffic didistribusikan ke zona terdekat hingga kapasitas backend:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
  name: lb-policy
  namespace: foo
spec:
  targetRefs:
  - kind: Service
    group: ""
    name: foo-service
  default:
    serviceLbAlgorithm: WATERFALL_BY_ZONE
EOF

Catatan: Setelan di GCPTrafficDistributionPolicy lebih diutamakan daripada setelan di Kubernetes Service API inti.

Secara default, backend layanan diperlakukan seolah-olah memiliki kapasitas yang tidak terbatas. Jika ada cukup host yang sehat di zona lokal/terdekat, traffic tidak akan pernah didistribusikan di luar zona lokal/terdekat untuk lokalitas klien tertentu. Anda dapat mengonfigurasi kapasitas backend layanan secara opsional menggunakan GCPBackendPolicy sehingga satu zona tidak kelebihan beban.

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GCPBackendPolicy
metadata:
  name: backend-policy
  namespace: foo
spec:
  targetRef:
    kind: Service
    group: ""
    name: foo-backend
  default:
    maxRatePerEndpoint: 5
EOF

Menyesuaikan perilaku failover

Secara default, failover tidak akan dipicu selama persentase host yang memadai berfungsi dengan baik di backend utama. Untuk informasi selengkapnya tentang backend utama dan terminologi lainnya, lihat Ringkasan load balancing lanjutan. GCPTrafficDistributionPolicy memungkinkan Anda mengonfigurasi nilai minimum persentase host yang responsif hingga traffic dialihkan dari backend utama ke backend failover. Failover dipicu lebih cepat dengan nilai minimum yang lebih besar. Misalnya, jika Anda ingin failover dipicu segera setelah persentase host yang responsif turun di bawah 90% di backend utama, Anda dapat mengonfigurasi GCPTrafficDistributionPolicy berikut:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GCPTrafficDistributionPolicy
metadata:
  name: lb-policy
  namespace: foo
spec:
  targetRefs:
  - kind: Service
    group: ""
    name: foo-service
  default:
   failoverConfig:
     failoverHealthThreshold: 90
EOF

Mengonfigurasi load balancing lanjutan di mesh layanan multi-cluster

GCPTrafficDistributionPolicy dan GCPBackendPolicy diterapkan pada cakupan yang berbeda dalam mesh layanan multi-cluster.

Saat menargetkan layanan multi-cluster, GCPTrafficDistributionPolicy akan menentukan perilaku load balancing tingkat layanan di semua cluster. Hanya satu GCPTrafficDistributionPolicy yang perlu dibuat untuk layanan multi-cluster tertentu. Jika menggunakan Istio API untuk mengonfigurasi mesh layanan, Anda dapat membuat GCPTrafficDistributionPolicy di cluster mana pun dalam fleet. Anda dapat memeriksa apakah kebijakan bertentangan dengan kebijakan lain dengan memeriksa status kebijakan-nya.

Saat menargetkan layanan multi-cluster, GCPBackendPolicy menentukan setelan tingkat backend (misalnya, kapasitas per pod) untuk pod backend yang dipilih oleh layanan penargetan di cluster lokalnya. Untuk layanan multi-cluster yang sama, Anda dapat menentukan setelan tingkat backend yang berbeda di cluster yang berbeda.

Dalam contoh berikut, GCPTrafficDistributionPolicy dibuat di cluster A untuk menentukan algoritma load balancing yang akan digunakan di seluruh fleet, sedangkan GCPBackendPolicies ada di setiap cluster. Kedua GCPBackendPolicy mengonfigurasi kapasitas 10 qps per pod untuk pod backend di cluster lokalnya, sedangkan GCPBackendPolicy di cluster A mengonfigurasi pod backend di cluster A sebagai backend pilihan.

Bersama-sama, kebijakan ini mengonfigurasi perilaku load balancing untuk traffic dalam mesh yang dikirim ke Service foo:

• Traffic dari mana saja lebih memilih backend di cluster A hingga pod backend di cluster A perlu menangani 10 qps per pod.
  • Perilaku ini terutama ditentukan oleh GCPBackendPolicy yang menetapkan backendPreference ke PREFERRED di cluster A.
• Traffic yang melebihi kapasitas backend yang dikonfigurasi di cluster A dirutekan menggunakan algoritma WATERFALL_BY_ZONE ke cluster B. Untuk penjelasan yang lebih mendetail tentang backend pilihan, lihat Ringkasan load balancing lanjutan.
  • Perilaku ini terutama ditentukan oleh GCPTrafficDistributionPolicy, yang menentukan algoritma, di cluster A dan GCPBackendPolicy, yang menentukan kapasitas backend, di cluster A dan B.

Catatan: Bagian ini menunjukkan kemampuan Cloud Service Mesh untuk melakukan load balancing traffic di beberapa cluster. Untuk tujuan demonstrasi, deploy contoh Service foo dan pod backend-nya di kedua cluster.

Di Istio, layanan Kubernetes reguler secara implisit menjadi "multi-cluster" saat ada multi cluster di mesh layanan dan layanan dibuat di seluruh batas cluster. Meskipun GCPTrafficDistributionPolicy berikut menargetkan foo layanan Kubernetes reguler, kebijakan ini berlaku untuk foo layanan multi-cluster yang terdiri dari workload yang sesuai di dua cluster.

1. Buat GCPTrafficDistributionPolicy untuk cluster A:

   kubectl apply --context cluster-a-context -f - <<EOF
   kind: GCPTrafficDistributionPolicy
   apiVersion: networking.gke.io/v1
   metadata:
   name: foo-traffic-distribution-policy
   namespace: foo
   spec:
     targetRefs:
     - kind: Service
       group: ""
       name: foo-service
     default:
       serviceLbAlgorithm: WATERFALL_BY_ZONE
   
   EOF
   

2. Buat GCPBackendPolicy untuk cluster A:

   kubectl apply --context cluster-a-context -f - <<EOF
   kind: GCPBackendPolicy
   apiVersion: networking.gke.io/v1
   metadata:
   name: foo-backend-policy
   namespace: foo
   spec:
     default:
       maxRatePerEndpoint: 100
       backendPreference: PREFERRED
     targetRef:
       group: ""
       kind: Service
       name: foo-service
   EOF
   

3. Buat GCPBackendPolicy untuk cluster B:

   kubectl apply --context cluster-b-context -f - <<EOF
   kind: GCPBackendPolicy
   apiVersion: networking.gke.io/v1
   metadata:
   name: foo-backend-policy
   namespace: foo
   spec:
     default:
       maxRatePerEndpoint: 10
     targetRef:
       group: ""
       kind: Service
       name: foo-service
   EOF
   

Langkah Berikutnya

• Pelajari lebih lanjut Load balancing lanjutan