Mengonfigurasi buffer kapasitas

Standard Autopilot

Pratinjau

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

Buffer kapasitas meningkatkan responsivitas dan keandalan workload penting dengan mengelola kapasitas cluster cadangan secara proaktif menggunakan definisi resource kustom CapacityBuffer Kubernetes. Dengan menggunakan buffer kapasitas, Anda dapat menentukan secara eksplisit jumlah kapasitas node yang tidak digunakan dalam cluster Anda. Kapasitas yang dicadangkan ini membantu memastikan GKE menyediakan node lebih awal.

Saat workload berprioritas tinggi perlu di-scale up dengan cepat, workload baru dapat menggunakan kapasitas kosong secara langsung tanpa menunggu penyediaan node. Tindakan ini meminimalkan latensi dan menghindari perebutan resource selama lonjakan permintaan yang tiba-tiba.

Halaman ini menyediakan tiga metode untuk mengonfigurasi buffer kapasitas: buffer replika tetap, buffer berbasis persentase, dan buffer batas resource.

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 perintah gcloud components update. gcloud CLI versi sebelumnya mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
  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 lokasi default yang Anda tetapkan.

• Buat, atau miliki akses ke cluster GKE di versi 1.35.2-gke.1842000 atau yang lebih baru.
• (Opsional, tetapi direkomendasikan) Aktifkan penyediaan otomatis node di cluster Anda.

Membuat objek Kubernetes prasyarat

Untuk mengonfigurasi CapacityBuffer, Anda memerlukan namespace yang menyimpan semua objek yang diperlukan (CapacityBuffer itu sendiri, dan resource tambahan seperti PodTemplate atau workload). PodTemplate dan CapacityBuffer harus berada di namespace yang sama. Anda dapat membuat namespace atau menggunakan namespace yang sudah ada, termasuk namespace default.

Bergantung pada jenis CapacityBuffer yang Anda konfigurasi, Anda juga memerlukan salah satu hal berikut:

• PodTemplate: menentukan persyaratan resource untuk satu unit kapasitas buffer. Konfigurasi yang ditentukan dalam objek CapacityBuffer mereferensikan template Pod.

• Workload: workload yang ada yang Anda referensikan dalam objek CapacityBuffer. Panduan ini menggunakan objek Deployment sebagai contoh workload, tetapi buffer kapasitas mendukung salah satu jenis resource berikut:

  • Deployment
  • ReplicaSet
  • StatefulSet
  • ReplicationController
  • Tugas

  • CustomResourceDefinitions (CRD) yang mengimplementasikan subresource scale.

    Catatan: Jika Anda menggunakan CRD kustom, Anda mungkin perlu memberikan izin secara manual kepada autoscaler cluster untuk membaca subresource skala. Lihat Error izin untuk resource kustom yang dapat diskalakan.

Bagian ini memberikan contoh objek tersebut. Jika Anda sudah memiliki workload yang ingin dikonfigurasi dengan buffer kapasitas, lanjutkan ke bagian Menerapkan buffer kapasitas.

Untuk membuat contoh workload Kubernetes, selesaikan langkah-langkah berikut:

1. Simpan manifes berikut sebagai namespace.yaml:

   apiVersion: v1
   kind: Namespace
   metadata:
     name: capacity-buffer-example
     labels:
       name: capacity-buffer-example
   

   Manifes ini membuat namespace bernama capacity-buffer-example.

2. Simpan manifes berikut sebagai buffer-pod-template.yaml:

   apiVersion: v1
   kind: PodTemplate
   metadata:
     name: buffer-unit-template
     namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
   template:
     spec:
       terminationGracePeriodSeconds: 0
       containers:
       - name: buffer-container
         image: registry.k8s.io/pause:3.9
         resources:
           requests:
             cpu: "1"
             memory: "1Gi"
           limits:
             cpu: "1"
             memory: "1Gi"
   

   Manifes ini membuat PodTemplate yang menentukan persyaratan resource untuk satu unit kapasitas buffer (CPU 1 dan Memori 1Gi). Konfigurasi ini menentukan ukuran unit kapasitas yang disediakan GKE untuk buffer. Misalnya, dengan PodTemplate ini, GKE tidak akan menganggap node dengan kurang dari 1 CPU dan 1 GiB resource yang tersedia sebagai bagian dari buffer, jika cluster di-scale up.

3. Simpan manifes berikut sebagai sample-workload-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: critical-workload-ref
     namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
   spec:
     replicas: 10
     selector:
       matchLabels:
         app: critical-workload
     template:
       metadata:
         labels:
           app: critical-workload
       spec:
         containers:
         - name: busybox
           image: busybox
           command: ["sleep", "3600"]
           resources:
             requests:
               cpu: 100m
   

   Manifes ini membuat contoh Deployment dengan 10 replika, yang merupakan objek referensi untuk contoh buffer berbasis persentase di bagian berikutnya.

4. Terapkan manifes ke cluster Anda:

   kubectl apply -f namespace.yaml -f buffer-pod-template.yaml -f sample-workload-deployment.yaml
   

5. Pastikan GKE membuat objek:

   kubectl get podtemplate -n capacity-buffer-example
   kubectl get deployment critical-workload-ref -n capacity-buffer-example
   

   Outputnya mirip dengan hal berikut ini:

   NAME                   AGE
   buffer-unit-template   1m
   
   NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
   critical-workload-ref   10/10   10           10          1m
   

Menerapkan buffer kapasitas

Bagian ini memberikan contoh berbagai jenis buffer kapasitas yang dapat Anda terapkan pada beban kerja Anda.

Catatan: Mungkin perlu waktu hingga 5 menit agar buffer kapasitas bereaksi terhadap perubahan.

Mengonfigurasi buffer replika tetap

Mengonfigurasi CapacityBuffer dengan replika tetap menentukan jumlah unit buffer yang tepat yang Anda inginkan berdasarkan PodTemplate.

Untuk membuat buffer dengan replika tetap, selesaikan langkah-langkah berikut:

1. Simpan manifes berikut sebagai cb-fixed-replicas.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: fixed-replica-buffer
     namespace: NAMESPACE
   spec:
     podTemplateRef:
       name: POD_TEMPLATE
     replicas: 3
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda, misalnya capacity-buffer-example.
   • POD_TEMPLATE: PodTemplate yang menentukan persyaratan resource Anda, misalnya buffer-unit-template.

   Manifes ini membuat resource CapacityBuffer yang mereferensikan PodTemplate untuk meminta sejumlah unit buffer tertentu.

2. Terapkan manifes:

   kubectl apply -f cb-fixed-replicas.yaml
   

3. Pastikan GKE menerapkan buffer kapasitas:

   kubectl get capacitybuffer fixed-replica-buffer -n NAMESPACE
   

   Kolom replicas dalam status harus menampilkan 3, yang mencerminkan jumlah replika yang Anda tentukan dalam manifes. Kolom STATUS harus menampilkan ReadyForProvisioning.

Mengonfigurasi penyanggaan berbasis persentase

Mengonfigurasi buffer berbasis persentase secara dinamis akan menentukan ukuran buffer berdasarkan persentase workload yang dapat diskalakan yang ada.

Untuk membuat buffer berbasis persentase, selesaikan langkah-langkah berikut:

1. Simpan manifes berikut sebagai cb-percentage-based.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: percentage-buffer
     namespace: NAMESPACE
   spec:
     scalableRef:
       apiGroup: apps
       kind: Deployment
       name: SCALABLE_RESOURCE_NAME
     percentage: 20
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda.
   • SCALABLE_RESOURCE_NAME: nama resource yang dapat diskalakan, misalnya critical-workload-ref.

   Manifes ini membuat resource CapacityBuffer yang meminta ukuran buffer yang setara dengan 20% replika resource yang dirujuk. Jika Anda menggunakan contoh Deployment dari bagian sebelumnya, nilai replika ditetapkan ke 10.

   Catatan: Anda dapat menetapkan nilai kolom percentage lebih besar dari 100 jika Anda memerlukan buffer yang lebih besar daripada ukuran beban kerja yang dirujuk saat ini.

2. Terapkan manifes:

   kubectl apply -f cb-percentage-based.yaml
   

3. Pastikan GKE menerapkan buffer kapasitas:

   kubectl get capacitybuffer percentage-buffer -n NAMESPACE
   

   Periksa status CapacityBuffer. Kolom replicas harus menampilkan nilai dari perhitungan persentase. Jika Anda menggunakan contoh Deployment dari bagian sebelumnya, Anda akan melihat unit buffer 2, yaitu 20% dari 10 replika yang ditentukan dalam Deployment.

4. Uji penskalaan dinamis dengan menskalakan Deployment secara manual hingga 20 replika:

   kubectl scale deployment critical-workload-ref -n NAMESPACE --replicas=20
   

   Pengontrol CapacityBuffer akan bereaksi dan otomatis menskalakan buffer menjadi 4 replika.

Mengonfigurasi buffer batas resource

Anda dapat menggunakan kolom limits untuk menentukan jumlah maksimum resource yang harus digunakan buffer, yang dihitung berdasarkan ukuran PodTemplate.

Untuk membuat buffer batas resource, selesaikan langkah-langkah berikut:

1. Simpan manifes berikut sebagai cb-resource-limits.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: resource-limit-buffer
     namespace: NAMESPACE
   spec:
     podTemplateRef:
       name: POD_TEMPLATE
     limits:
       cpu: "5"
       memory: "5Gi"
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda, misalnya capacity-buffer-example.
   • POD_TEMPLATE: PodTemplate yang menentukan persyaratan resource Anda, misalnya buffer-unit-template.

   Manifes ini membuat resource CapacityBuffer dengan total batas 5 CPU dan 5 GiB Memori. Jika Anda menggunakan contoh PodTemplate dari langkah sebelumnya, Anda menentukan setiap unit sebagai 1 CPU dan 1Gi Memori, yang akan menghasilkan 5 unit buffer.

2. Terapkan manifes:

   kubectl apply -f cb-resource-limits.yaml
   

3. Pastikan GKE menerapkan buffer kapasitas:

   kubectl get capacitybuffer resource-limit-buffer -n NAMESPACE
   

   Periksa status CapacityBuffer. Kolom replicas harus menampilkan nilai yang berasal dari batas yang Anda tentukan. Jika Anda menggunakan PodTemplate contoh dari bagian sebelumnya, Anda akan melihat 5 unit buffer karena ini adalah jumlah maksimum unit yang sesuai dalam batas yang ditentukan.

Menghapus buffer kapasitas

Jika Anda tidak lagi memerlukan buffer kapasitas untuk workload, hapus objek CapacityBuffer. Tindakan ini akan menghapus Pod placeholder dan memungkinkan autoscaler cluster menurunkan skala node.

kubectl delete capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE

Ganti CAPACITY_BUFFER_NAME dengan nama CapacityBuffer yang ingin Anda hapus.

Pemecahan masalah

Bagian berikut berisi informasi tentang cara menyelesaikan masalah umum terkait buffer kapasitas.

Buffer kapasitas belum siap karena model penagihan

Jika Anda membuat CapacityBuffer untuk workload yang menggunakan model penagihan berbasis Pod (bayar per Pod), buffer kapasitas tidak akan siap untuk penyediaan.

Untuk mengidentifikasi masalah ini, periksa status CapacityBuffer:

kubectl describe capacitybuffer BUFFER_NAME -n NAMESPACE

Cari kondisi jenis ReadyForProvisioning dengan status False.

Untuk mengatasi masalah ini, pastikan CapacityBuffer Anda mereferensikan workload atau PodTemplate yang kompatibel dengan penagihan berbasis node.

Error izin untuk resource yang dapat diskalakan kustom

Jika Anda mengonfigurasi CapacityBuffer untuk bekerja dengan objek yang dapat diskalakan kustom (menggunakan kolom scalableRef), penskalaan otomatis cluster mungkin gagal menskalakan buffer jika tidak memiliki izin yang diperlukan.

Untuk mengatasi masalah ini, berikan izin yang diperlukan secara manual dengan membuat ClusterRole dan ClusterRoleBinding, seperti dalam contoh berikut:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: custom-scale-getter
rules:
- apiGroups: ["api.example.com"]
  resources: ["customreplicatedresources/scale"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ca-custom-scale-getter
subjects:
- kind: User
  name: "system:cluster-autoscaler"
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: custom-scale-getter

Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi RBAC, lihat dokumentasi RBAC Kubernetes.

Langkah berikutnya

• Pelajari lebih lanjut penyangga kapasitas.
• Lihat dokumentasi CRD CapacityBuffer.