Mengonfigurasi load balancing berbasis pemanfaatan untuk Layanan GKE

Autopilot Standard

---

Pratinjau

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

Halaman ini menjelaskan cara mengonfigurasi load balancing berbasis pemanfaatan untuk Layanan GKE. Halaman ini ditujukan untuk tim infrastruktur dan aplikasi, serta administrator GKE yang bertanggung jawab untuk mengonfigurasi dan mengelola distribusi traffic untuk Layanan GKE mereka.

Anda dapat menggunakan load balancer berbasis pemakaian untuk mengoptimalkan performa dan ketersediaan aplikasi dengan mendistribusikan traffic secara cerdas berdasarkan penggunaan resource real-time Pod GKE Anda.

Sebelum membaca halaman ini, pastikan Anda memahami load balancing berbasis pemanfaatan untuk Layanan GKE dan cara kerja load balancing berbasis pemanfaatan.

Harga

Load balancing berbasis pemanfaatan adalah kemampuan GKE Gateway yang tersedia tanpa biaya tambahan. Harga Cloud Load Balancing dan GKE tetap berlaku.

Kuota

Load balancing berbasis pemanfaatan tidak memperkenalkan kuota baru, meskipun semua kuota dari Cloud Load Balancing dan layanan dependen lainnya tetap berlaku.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Aktifkan Google Kubernetes Engine API
• Jika ingin 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 gcloud components update.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan default yang Anda tetapkan.

• Tinjau persyaratan Gateway Controller.
• Tinjau batasan.

Persyaratan GKE Gateway Controller

Load balancing berbasis pemanfaatan untuk Layanan GKE memerlukan hal berikut:

• Google Cloud CLI versi 516.0.0 atau yang lebih baru.
• GKE versi 1.33.1-gke.1918000 atau yang lebih baru di saluran RAPID.
• Gateway API harus diaktifkan di cluster Anda.
• Profil HPA performa harus diaktifkan di cluster Anda.
• Autoscaling API harus diaktifkan di Google Cloud Project Anda.
• Akun layanan node harus dapat menulis ke Autoscaling API.

Load balancing berbasis pemanfaatan untuk Layanan GKE mendukung hal berikut:

• Layanan GKE cluster tunggal dan multi-cluster yang berfungsi sebagai backend untuk load balancer yang dikelola Google Cloud.
• Semua edisi GKE (Standard, Autopilot, dan Enterprise).
• Semua Load Balancer Aplikasi, kecuali Load Balancer Aplikasi klasik. Google Cloud

Batasan

Load balancing berbasis pemanfaatan untuk Layanan GKE memiliki batasan berikut.

• Satu-satunya metrik pemakaian resource yang didukung adalah CPU.
• Load Balancer Jaringan passthrough atau proxy tidak didukung.
• Hanya Gateway API yang didukung; Service dan Ingress API tidak didukung.
• Load balancing berbasis pemanfaatan tidak berfungsi dengan baik jika traffic Anda sangat tidak stabil. Penyeimbangan ulang traffic memerlukan waktu hingga 30 detik saat Pod mencapai pemanfaatan maksimumnya. Sinyal pemakaian diperkirakan akan meningkat seiring dengan traffic masuk, tetapi penundaan ini berarti load balancing berbasis pemakaian memerlukan waktu untuk menyesuaikan diri. Untuk performa optimal, load balancing berbasis pemanfaatan paling baik digunakan di lingkungan dengan alur traffic yang lancar dan dapat diprediksi.
• Cluster stack ganda (cluster dengan satu alamat IPv4 dan satu alamat IPv6) tidak didukung.
• Penyeimbangan beban berbasis pemanfaatan dapat memerlukan waktu hingga 30 detik untuk memperbarui dan menyesuaikan distribusi traffic setelah perubahan konfigurasi, seperti mengubah atau menghapus kolom dryRun di GCPBackendPolicy. Penundaan ini adalah perilaku di seluruh sistem yang diketahui. Oleh karena itu, fitur ini paling cocok untuk aplikasi dengan pola traffic yang relatif stabil yang dapat mentoleransi latensi update ini.

Secara default, load balancing berbasis pemanfaatan dinonaktifkan untuk Layanan GKE Anda. Anda harus mengaktifkannya secara eksplisit. Jika Anda tidak menetapkan nilai minimum penggunaan, sistem akan menggunakan nilai default 80% penggunaan per endpoint.

Tujuan Anda dalam mengonfigurasi load balancing berbasis pemanfaatan adalah mengoptimalkan distribusi traffic sehingga Pod backend dapat mengelola beban kerjanya secara efisien, yang akan meningkatkan performa aplikasi dan pemanfaatan resource.

Mengaktifkan load balancing berbasis pemanfaatan dan profil HPA Performa

Sebelum mengonfigurasi load balancing berbasis pemanfaatan, pastikan cluster GKE Anda mendukung fitur yang diperlukan. Load balancing berbasis pemanfaatan menggunakan metrik kustom, seperti CPU, untuk membuat keputusan perutean yang lebih cerdas. Keputusan ini bergantung pada hal berikut:

• Gateway API, yang memungkinkan kebijakan tingkat layanan melalui GCPBackendPolicy.
• Profil HPA Performa, yang memungkinkan workload diskalakan lebih cepat dan lebih agresif dengan menggunakan sinyal CPU.

Aktifkan Gateway API dan profil HPA Performa

Autopilot

Gateway API dan profil HPA Performa tersedia secara default di cluster Autopilot.

Standar

Untuk membuat cluster Standard baru dengan profil HPA Performa dan Gateway API diaktifkan, jalankan perintah berikut:

gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Ganti kode berikut:

• CLUSTER_NAME dengan nama cluster baru Anda.
• LOCATION dengan region atau zona Compute Engine untuk cluster Anda.
• PROJECT_ID dengan ID project Anda.
• CLUSTER_VERSION dengan versi GKE, yang harus 1.33.1-gke.1918000 atau yang lebih baru.

Untuk mengaktifkan profil HPA Performa dan Gateway API di cluster GKE Standard yang ada, gunakan perintah berikut:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Ganti kode berikut:

• CLUSTER_NAME dengan nama cluster baru Anda.
• LOCATION dengan region atau zona Compute Engine untuk cluster Anda.
• PROJECT_ID dengan ID project Anda.

Untuk mengetahui informasi selengkapnya tentang profil HPA Performa, lihat Mengonfigurasi profil HPA Performa.

Mengonfigurasi load balancing berbasis pemanfaatan

Setelah cluster Anda siap, tentukan kebijakan yang mengarahkan cara traffic dirutekan berdasarkan pemanfaatan backend. Anda harus menggunakan Kubernetes Gateway API melalui GCPBackendPolicy untuk konfigurasi.

Prasyarat

Sebelum mengonfigurasi load balancing berbasis pemanfaatan menggunakan Gateway API, pastikan cluster GKE Anda memenuhi persyaratan berikut:

1. Men-deploy aplikasi: pastikan Anda men-deploy aplikasi Kubernetes dengan menggunakan resource Deployment. Untuk mengetahui informasi selengkapnya, lihat Men-deploy aplikasi ke cluster GKE.

   Catatan: Agar load balancing berbasis pemanfaatan berfungsi dengan benar, Anda harus menentukan requests resource, terutama untuk CPU, dalam spesifikasi penampung Deployment Anda. Hal ini memungkinkan sistem menentukan secara akurat pemanfaatan resource dasar dan menyeimbangkan kembali traffic secara efektif. Tanpa requests yang ditentukan, mekanisme load balancing mungkin tidak berfungsi seperti yang diharapkan.

   Misalnya, manifes deployment umum dapat menyertakan bagian resource seperti ini:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-v1
   spec:
     # ... other deployment configurations ...
     template:
       # ... other template configurations ...
       spec:
         containers:
           - name: your-container-name
             image: your-image
             ports:
               - containerPort: 8080
             resources:
               limits:
                 cpu: 100m
                 memory: 45Mi
               requests:
                 cpu: 100m
                 memory: 45Mi
   

2. Mengekspos aplikasi menggunakan Service: Anda harus mengekspos aplikasi menggunakan Service Kubernetes. Untuk mengetahui informasi selengkapnya tentang cara kerja Layanan dan cara mengonfigurasinya, lihat Memahami Layanan Kubernetes.

3. Menggunakan Load Balancer Aplikasi berbasis Gateway API: ekspos Layanan dengan menggunakan Load Balancer Aplikasi yang dikelola GKE dan dikonfigurasi melalui Gateway API. Untuk mengetahui informasi selengkapnya, lihat Men-deploy Gateway.

Buat GCPBackendPolicy untuk load balancing berbasis CPU

Konfigurasi ini memungkinkan GKE mendistribusikan traffic secara dinamis berdasarkan pemakaian CPU real-time setiap Pod backend.

Untuk mengaktifkan load balancing berbasis pemanfaatan untuk Layanan GKE, gunakan resource kustom GCPBackendPolicy dari Kubernetes Gateway API.

Dengan resource kustom GCPBackendPolicy, Anda dapat menentukan perilaku load balancing secara deklaratif dalam cluster Kubernetes. Dengan menentukan metrik pemanfaatan CPU, Anda mengontrol cara traffic didistribusikan di seluruh backend berdasarkan penggunaan resource saat ini. Pendekatan ini membantu mempertahankan performa aplikasi, mencegah Pod individual menjadi kelebihan beban, serta meningkatkan keandalan dan pengalaman pengguna aplikasi.

1. Simpan manifes contoh berikut sebagai my-backend-policy.yaml:

   kind: GCPBackendPolicy
   apiVersion: networking.gke.io/v1
   metadata:
     name: my-backend-policy
     namespace: team-awesome
   spec:
     targetRef:
       group: ""
       kind: Service
       name: super-service
     default:
       balancingMode: CUSTOM_METRICS
       customMetrics:
       - name: gke.cpu
         dryRun: false
   

   Perhatikan hal berikut:

   • spec.targetRef.kind: Service: menargetkan Layanan Kubernetes standar dalam cluster yang sama.
   • spec.targetRef.kind: ServiceImport: menargetkan layanan dari cluster lain dalam penyiapan multi-cluster.
   • balancingMode: CUSTOM_METRICS: memungkinkan load balancing berbasis metrik kustom.
   • name: gke.cpu: menentukan penggunaan CPU sebagai metrik untuk distribusi traffic.

   Jika kolom maxUtilizationPercent tidak ditentukan, nilai default batas penggunaan adalah 80%. Traffic akan diseimbangkan kembali saat backend melebihi penggunaan CPU sebesar 80%.

2. Terapkan manifes sampel ke cluster Anda:

   kubectl apply -f my-backend-policy.yaml
   

Dengan mendasarkan distribusi traffic pada penggunaan CPU real-time, Anda dapat mengoptimalkan performa secara otomatis. Tindakan ini membantu mencegah kelebihan beban pada setiap Pod.

Pertimbangan penting untuk dryRun dan balancingMode

Saat mengonfigurasi GCPBackendPolicy dengan metrik kustom, pertimbangkan interaksi antara balancingMode dan kolom dryRun dalam definisi customMetrics Anda. Interaksi ini menentukan cara load balancer menggunakan metrik kustom Anda. Untuk mengetahui informasi selengkapnya tentang metrik kustom dan batasannya, termasuk yang terkait dengan mode penyeimbangan, lihat Metrik kustom Cloud Load Balancing.

• balancingMode: CUSTOM_METRICS

  • Untuk mendistribusikan traffic berdasarkan metrik kustom, setidaknya satu metrik kustom dalam daftar customMetrics harus memiliki dryRun yang ditetapkan ke false. Setelan ini memberi tahu load balancer untuk secara aktif menggunakan metrik tersebut untuk keputusan penyeimbangan ulang.
  • Anda dapat menyertakan metrik kustom lainnya dengan dryRun: true bersama metrik non-uji coba. Dengan begitu, Anda dapat menguji atau memantau metrik baru, seperti penggunaan GPU, tanpa memengaruhi traffic, sementara metrik lain, seperti penggunaan CPU dengan dryRun: false, mengontrol penyeimbangan.
  • Jika balancingMode adalah CUSTOM_METRICS dan semua metrik kustom memiliki dryRun yang ditetapkan ke true, Anda akan mendapatkan error. Misalnya: gceSync: generic::invalid_argument: Update: Invalid value for field 'resource.backends[0]': '...'. CUSTOM_METRICS BalancingMode requires at least one non-dry-run custom metric. Load balancer memerlukan metrik aktif untuk membuat keputusan.

• balancingMode adalah RATE atau mode metrik non-kustom lainnya

  • Jika load balancing didasarkan pada kriteria selain metrik kustom, seperti RATE untuk permintaan per detik, Anda dapat menetapkan dryRun: true untuk semua metrik kustom. Dengan demikian, Anda dapat memantau metrik kustom tanpa memengaruhi mekanisme penyeimbangan utama. Hal ini berguna untuk menguji metrik kustom baru sebelum mengalihkan balancingMode ke CUSTOM_METRICS.

• Memantau metrik kustom

  • Setelah Anda mengonfigurasi GCPBackendPolicy dan mulai mengirim traffic ke aplikasi, perlu waktu beberapa saat agar metrik kustom, seperti gke.cpu, muncul di Metrics Explorer.
  • Agar metrik kustom terlihat dan aktif di Metrics Explorer, harus ada traffic sebenarnya yang mengalir melalui backend yang dipantau kebijakan. Jika tidak ada traffic, metrik hanya dapat dilihat di bagian "Inactive Resources" di Metrics Explorer.

Menetapkan batas penggunaan CPU kustom

Secara default, GKE mendistribusikan traffic dari backend yang melebihi penggunaan CPU 80%. Namun, workload tertentu mungkin mentoleransi penggunaan CPU yang lebih tinggi atau lebih rendah sebelum memerlukan redistribusi traffic. Anda dapat menyesuaikan nilai minimum ini menggunakan kolom maxUtilizationPercent di GCPBackendPolicy resource.

1. Untuk mengonfigurasi Layanan GKE agar memungkinkan backend menggunakan CPU hingga 70% sebelum penyeimbangan ulang dipicu, simpan contoh manifes berikut sebagai my-backend-policy.yaml:

   kind: GCPBackendPolicy
   apiVersion: networking.gke.io/v1
   metadata:
     name: my-backend-policy
     namespace: team-awesome
   spec:
     targetRef:
       group: ""
       kind: Service
       name: super-service
     default:
       balancingMode: CUSTOM_METRICS
       customMetrics:
       - name: gke.cpu
         maxUtilizationPercent: 70
   

   Perhatikan hal berikut:

   • Kolom maxUtilizationPercent menerima nilai dari 0 hingga 100. Nilai 100 berarti backend dapat menggunakan kapasitas CPU penuhnya sebelum traffic diseimbangkan kembali.
   • Untuk beban kerja yang sensitif terhadap latensi yang memerlukan pelepasan awal, gunakan nilai minimum yang lebih rendah.
   • Untuk workload yang dirancang untuk berjalan mendekati kapasitas penuh, gunakan nilai minimum yang lebih tinggi.
   • Untuk layanan multi-cluster, spec.targetRef.kind harus berupa ServiceImport dan group harus berupa net.gke.io.

2. Terapkan manifes sampel ke cluster Anda:

   kubectl apply -f my-backend-policy.yaml
   

Dengan mengaktifkan nilai minimum penggunaan CPU kustom, Anda dapat mengontrol distribusi traffic berdasarkan penggunaan CPU backend.

(Opsional) Aktifkan mode uji coba

Mode uji coba memantau pemanfaatan resource Pod Anda tanpa mengubah distribusi traffic. Jika mode uji coba diaktifkan, metrik akan diekspor ke Cloud Monitoring, tetapi Cloud Load Balancing akan mengabaikan metrik ini dan menggunakan perilaku load balancing default.

1. Untuk mengaktifkan mode uji coba untuk Layanan GKE Anda, simpan manifes contoh berikut sebagai my-backend-policy.yaml:

   kind: GCPBackendPolicy
   apiVersion: networking.gke.io/v1
   metadata:
     name: my-backend-policy
   spec:
     targetRef:
       group: ""
       kind: Service
       name: store-v1
     default:
       balancingMode: RATE
       maxRatePerEndpoint: 10
       customMetrics:
       - name: gke.cpu
         dryRun: true
   

2. Terapkan manifes sampel ke cluster Anda:

   kubectl apply -f my-backend-policy.yaml
   

Saat Anda mengaktifkan mode uji coba, hal berikut akan terjadi:

• Cloud Load Balancing mengabaikan metrik pemakaian CPU dan menggunakan perilaku load balancing default.

• Metrik terus diekspor ke Cloud Monitoring di bagian network.googleapis.com/loadbalancer/backend/lb_custom_metrics.

Setelah meninjau metrik, hapus kolom dryRun dari GCPBackendPolicy dan terapkan kembali konfigurasi. Jika masalah terjadi setelah Anda menonaktifkan uji coba, aktifkan kembali dengan menambahkan dryRun: true kembali ke kebijakan.

Memverifikasi kebijakan

Untuk mengonfirmasi bahwa GCPBackendPolicy diterapkan ke Layanan GKE Anda dan untuk memverifikasi bahwa pengontrol GKE mengenali kebijakan, jalankan perintah berikut:

kubectl describe gcpbackendpolicy POLICY_NAME -n NAMESPACE

Outputnya mirip dengan hal berikut ini:

Name:         <your policy name>
Namespace:    <your namespace>
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPBackendPolicy
Metadata:
  Creation Timestamp:  ...
  Generation:          1
  Resource Version:    …
  UID:                 …
Spec:
  Default:
    Balancing Mode:  CUSTOM_METRICS
    Custom Metrics:
      Dry Run:  false
      Name:     gke.cpu
  Target Ref:
    Group:
    Kind:   Service
    Name:   super-service
Status:
  Conditions:
    Last Transition Time:  …
    Message:
    Reason:                Attached
    Status:                True
    Type:                  Attached
Events:
…

Mengonfigurasi load balancing berbasis pemanfaatan menggunakan Compute Engine API

Sebaiknya gunakan Kubernetes Gateway API untuk mengonfigurasi load balancing berbasis pemanfaatan untuk Layanan GKE Anda.

Namun, Anda mungkin lebih memilih menggunakan Compute Engine API atau Terraform untuk mengelola load balancer secara langsung. Jika memilih pendekatan ini, Anda harus mengaktifkan load balancing berbasis pemanfaatan di tingkat BackendService.

1. Untuk BackendService yang sudah ada, aktifkan load balancing berbasis pemanfaatan dan lampirkan Grup Endpoint Jaringan (NEG), my-lb-neg, dengan menjalankan perintah berikut:

   gcloud compute backend-services add-backend MY_BACKEND_SERVICE \
     --network-endpoint-group my-lb-neg \
     --network-endpoint-group-zone=asia-southeast1-a \
     --global \
     --balancing-mode=CUSTOM_METRICS \
     --custom-metrics 'name="gke.cpu",maxUtilization=0.8'
   

   Ganti kode berikut:

   • MY_BACKEND_SERVICE dengan nama BackendService Anda.
   • CUSTOM_METRICS dengan CUSTOM_METRICS.

2. Untuk memperbarui setelan load balancing berbasis pemanfaatan untuk entri backend yang ada di BackendService tempat NEG sudah terpasang, jalankan perintah berikut:

   gcloud compute backend-services update-backend MY_BACKEND_SERVICE \
     --network-endpoint-group my-lb-neg \
     --network-endpoint-group-zone=asia-southeast1-a \
     --global \
     --balancing-mode=CUSTOM_METRICS \
     --custom-metrics 'name="gke.cpu",maxUtilization=0.8'
   

   Ganti kode berikut:

   • MY_BACKEND_SERVICE dengan nama BackendService Anda.
   • CUSTOM_METRICS dengan CUSTOM_METRICS.

Catatan: Jika Anda menggunakan metrik kustom, pertahankan jumlah dimensi yang dikonfigurasi di bawah batas layanan. Jika melebihi batas, Anda tidak akan dapat menambahkan dimensi lainnya.

Menonaktifkan load balancing berbasis pemanfaatan untuk Layanan GKE

Untuk menonaktifkan load balancing berbasis pemanfaatan di Layanan GKE Anda, lakukan langkah-langkah berikut:

1. Jika Anda ingin mempertahankan kebijakan untuk setelan lain, hapus kolom balancingMode dan customMetrics dari GCPBackendPolicy Anda.
2. Jika tidak lagi memerlukan GCPBackendPolicy, Anda dapat menghapusnya.
3. Jika Anda menggunakan Compute Engine API, ubah kembali tanda --balancing-mode dan --custom-metrics dari layanan backend Anda.

Langkah berikutnya

• Ringkasan grup endpoint jaringan zona