Load Balancing Tingkat Lanjut pada Cluster GKE

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:

  • Terus arahkan traffic ke zona layanan hingga kapasitas lokal habis.
  • Kirim traffic ke layanan di lokasi "utama" dengan failover ke lokasi sekunder saat endpoint yang cukup di lokasi utama menjadi tidak berfungsi.
  • Mengontrol waktu terjadinya failover (berdasarkan persentase host yang responsif).

Batasan

  • Batasan umum terkait penggunaan load balancing lanjutan di Google Cloud apply.
  • 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

    Semua kolom yang tidak tercantum adalah kolom yang tidak didukung dan kebijakan dengan setidaknya satu kolom yang tidak didukung yang dikonfigurasi tidak akan berlaku di Cloud Service Mesh .

  • 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 di seluruh namespace/mesh tidak didukung.

  • Hanya kapasitas QPS yang didukung.

  • Hanya GKE versi >= 1.31.1 yang didukung.

  • Kebijakan load balancing lanjutan mesh layanan hanya boleh diterapkan ke layanan yang hanya melayani traffic mesh. Kebijakan ini tidak boleh diterapkan ke layanan yang berfungsi sebagai backend GKE Gateway. Perilaku traffic tidak ditentukan saat target traffic load balancing lanjutan adalah layanan Kubernetes yang melayani traffic mesh dan traffic dari GKE Gateway.

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 alat ini, Anda dapat:

Jika beberapa GCPTrafficDistributionPolicy menargetkan layanan yang sama, kebijakan yang paling lama akan diterapkan.

GCPBackendPolicy

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

Jika beberapa GCPBackendPolicy 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 di 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

Secara default, backend layanan diperlakukan seolah-olah memiliki kapasitas tak terbatas. Jika ada host yang responsif dalam jumlah yang memadai di zona lokal/terdekat, traffic tidak akan pernah didistribusikan di luar zona lokal/terdekat untuk lokalitas klien tertentu. Anda dapat secara opsional mengonfigurasi kapasitas backend layanan 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 responsif di backend utama cukup. Untuk mengetahui informasi selengkapnya tentang backend utama dan terminologi lainnya, lihat Ringkasan load balancing lanjutan. GCPTrafficDistributionPolicy memungkinkan Anda mengonfigurasi nilai persentase host 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 di mesh layanan multi-cluster.

Saat menargetkan layanan multi-cluster, GCPTrafficDistributionPolicy 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 service mesh, Anda dapat membuat GCPTrafficDistributionPolicy di cluster mana pun dalam fleet. Anda dapat memeriksa apakah suatu kebijakan bertentangan dengan kebijakan lain dengan memeriksa status kebijakannya.

Saat menargetkan layanan multi-cluster, GCPBackendPolicy menentukan setelan tingkat backend (misalnya, kapasitas per-pod) untuk pod backend yang dipilih oleh layanan penargetannya 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, sementara GCPBackendPolicy ada di setiap cluster. GCPBackendPolicy mengonfigurasi kapasitas 10qps 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 Layanan 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 akan 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.

Mesh layanan multi-cluster load balancing lanjutan

Di Istio, layanan Kubernetes reguler secara implisit menjadi "multi-cluster" jika ada beberapa cluster di mesh layanan dan layanan dibuat di seluruh batas cluster. Meskipun GCPTrafficDistributionPolicy berikut menargetkan layanan Kubernetes reguler foo, kebijakan ini berlaku untuk layanan multi-cluster foo 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