Mengonfigurasi buffer kapasitas

Standard Autopilot

Pratinjau

Produk ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum di 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 dan status yang ditangguhkan dari kapasitas yang telah disediakan dan dikonfigurasi sebelumnya secara proaktif menggunakan Kubernetes CapacityBuffer CustomResourceDefinition (CRD). Dengan menggunakan buffer kapasitas, Anda dapat menentukan jumlah kapasitas node yang tidak digunakan secara eksplisit dalam cluster Anda. Kapasitas yang dicadangkan ini membantu mengurangi waktu penjadwalan Pod.

Saat workload berprioritas tinggi perlu ditingkatkan skalanya dengan cepat, workload baru dapat menggunakan kapasitas kosong segera tanpa menunggu penyediaan node. Pendekatan ini meminimalkan latensi dan menghindari pertentangan resource selama lonjakan permintaan yang tiba-tiba.

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

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Mengaktifkan 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. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menetapkan compute/region properti . Jika Anda menggunakan cluster zona terutama, tetapkan compute/zone sebagai gantinya. Dengan menetapkan 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.

• Buat, atau miliki akses ke, cluster GKE di versi 1.35.2-gke.1842000 untuk buffer aktif, dan versi 1.36.0-gke.2253000 atau yang lebih baru untuk buffer siaga.
• Aktifkan penyediaan otomatis node di cluster Standar Anda. Di cluster Autopilot, penyediaan otomatis node sudah diaktifkan. Penyediaan otomatis node bersifat opsional tetapi direkomendasikan untuk buffer aktif dan diperlukan untuk buffer siaga.

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 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 autoscaler cluster secara manual untuk membaca subresource skala. Lihat Error izin untuk resource kustom yang dapat diskalakan.

Bagian ini memberikan contoh objek ini. Jika Anda sudah memiliki workload yang ingin dikonfigurasi dengan buffer kapasitas, lanjutkan ke 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. Opsional: untuk menggunakan buffer kapasitas dengan ComputeClass kustom, simpan manifes berikut sebagai custom-compute-class.yaml:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: ccc-example
     namespace: capacity-buffer-example
   spec:
     # Buffers are also created according to these priorities
     priorities:
     - machineFamily: n4
     - machineFamily: n4d
     - machineFamily: c4
     - machineFamily: c4d
     nodePoolAutoCreation:
       enabled: true
   

   Manifes ini membuat ComputeClass kustom yang menentukan dan mengontrol prioritas komputasi untuk node yang disediakan GKE. Untuk mempelajari lebih lanjut, lihat ComputeClass kustom.

3. 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"
       # Optional: Using buffers with a custom ComputeClass /
       # controls the properties of the provisioned nodes.
       nodeSelector:
         cloud.google.com/compute-class: ccc-example
   

   Manifes ini membuat PodTemplate yang menentukan persyaratan resource untuk satu unit kapasitas buffer (1 CPU dan 1Gi Memori). 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 1Gi resource yang tersedia sebagai bagian dari buffer, jika cluster ditingkatkan skalanya.

4. 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
         # Optional: Using buffers with a custom ComputeClass /
         # controls the properties of the provisioned nodes.
         nodeSelector:
           cloud.google.com/compute-class: ccc-example
   

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

5. Terapkan manifes ke cluster Anda:

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

6. 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 ke workload 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 pasti unit buffer 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
     provisioningStrategy: "STRATEGY"
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda, misalnya capacity-buffer-example.
   • POD_TEMPLATE: PodTemplate yang menentukan persyaratan resource Anda, misalnya buffer-unit-template.
   • STRATEGY: strategi penyediaan, baik "buffer.x-k8s.io/active-capacity" (default) atau "buffer.gke.io/standby-capacity".

   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. Konfirmasi bahwa 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 buffer batas resource

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

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"
     provisioningStrategy: "STRATEGY"
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda, misalnya capacity-buffer-example.
   • POD_TEMPLATE: PodTemplate yang menentukan persyaratan resource Anda, misalnya buffer-unit-template.
   • STRATEGY: strategi penyediaan, baik "buffer.x-k8s.io/active-capacity" (default) atau "buffer.gke.io/standby-capacity".

   Manifes ini membuat resource CapacityBuffer dengan batas total 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. Konfirmasi bahwa 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 contoh PodTemplate dari bagian sebelumnya, Anda akan melihat 5 unit buffer karena ini adalah jumlah maksimum unit yang sesuai dengan batas yang ditentukan.

Mengonfigurasi buffer berbasis persentase

Mengonfigurasi buffer berbasis persentase akan mengubah ukuran buffer secara dinamis berdasarkan persentase workload yang dapat diskalakan. Buffer kapasitas berbasis persentase hanya didukung untuk objek Kubernetes yang dapat diskalakan yang mengimplementasikan subresource skala, seperti Deployment, StatefulSet, ReplicaSet, atau Tugas. Anda tidak dapat menentukan buffer berbasis persentase untuk template Pod karena tidak memiliki kolom replicas.

Sebaiknya mulai dengan strategi replika tetap atau batas resource, bukan buffer berbasis persentase. Buffer berbasis persentase kurang responsif terhadap peningkatan skala yang tiba-tiba jika workload diskalakan ke angka rendah atau nol, karena margin keamanan diskalakan secara proporsional dengan Pod aktif. Buffer ini terutama berguna untuk deployment besar yang tidak pernah diskalakan ke jumlah replika yang sangat rendah.

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
     provisioningStrategy: "STRATEGY"
   

   Ganti kode berikut:

   • NAMESPACE: nama namespace Anda.
   • SCALABLE_RESOURCE_NAME: nama resource yang dapat diskalakan, misalnya critical-workload-ref.
   • STRATEGY: strategi penyediaan, baik "buffer.x-k8s.io/active-capacity" (default) atau "buffer.gke.io/standby-capacity".

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

   Catatan: Anda dapat menetapkan nilai kolom percentage ke lebih besar dari 100 jika memerlukan buffer yang lebih besar dari ukuran workload yang direferensikan saat ini. Jumlah replika buffer yang bukan bilangan bulat, yang dihasilkan dari nilai kolom persentase yang lebih rendah dari 100, akan dibulatkan ke bawah.

2. Terapkan manifes:

   kubectl apply -f cb-percentage-based.yaml
   

3. Konfirmasi bahwa 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 2 unit buffer, 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 bereaksi dan otomatis menskalakan buffer menjadi 4 replika.

Menyesuaikan perilaku buffer siaga

Anda dapat menggunakan anotasi untuk menyesuaikan cara buffer siaga dimulai dan diperbarui. Tambahkan anotasi ini ke kolom metadata.annotations resource CapacityBuffer Anda:

• buffer.gke.io/standby-capacity-init-time: jumlah waktu node tetap aktif setelah dibuat sebelum ditangguhkan. Formatnya adalah string durasi (misalnya, 5m atau 1h). Defaultnya adalah 5m.
• buffer.gke.io/standby-capacity-refresh-frequency: seberapa sering node yang ditangguhkan diperbarui. Defaultnya adalah 1d.

Contoh berikut menunjukkan manifes dengan kolom opsional ini untuk menyesuaikan perilaku buffer siaga:

apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityBuffer
metadata:
  name: customized-standby-buffer
  namespace: my-namespace
  annotations:
    buffer.gke.io/standby-capacity-init-time: "15m"
    buffer.gke.io/standby-capacity-refresh-frequency: "12h"
spec:
  podTemplateRef:
    name: buffer-unit-template
  replicas: 3
  provisioningStrategy: "buffer.gke.io/standby-capacity"

Memuat gambar terlebih dahulu di buffer siaga

Untuk mempercepat waktu startup workload saat node siaga dilanjutkan, Anda dapat memuat image container terlebih dahulu menggunakan DaemonSet. DaemonSet berjalan selama periode startup sebelum node ditangguhkan.

Untuk memuat gambar terlebih dahulu menggunakan DaemonSet, selesaikan langkah-langkah berikut:

1. Simpan manifes berikut sebagai image-puller-daemonset.yaml:

   apiVersion: apps/v1
   kind: DaemonSet
   metadata:
     name: image-prefetch-daemonset
     namespace: NAMESPACE
   spec:
     selector:
       matchLabels:
         name: image-prefetch
     template:
       metadata:
         labels:
           name: image-prefetch
       spec:
         tolerations:
         - key: "buffer.gke.io/standby-node-suspended"
           operator: "Exists"
         initContainers:
         - name: image-puller
           image: IMAGE_NAME
           command: ["sh", "-c", "true"]
         containers:
         - name: pause
           image: registry.k8s.io/pause:3.9
   

   Ganti kode berikut:

   • NAMESPACE: namespace untuk DaemonSet, misalnya capacity-buffer-example.
   • IMAGE_NAME: nama image yang akan dimuat terlebih dahulu, misalnya your-app-image:latest.

2. Terapkan manifes DaemonSet ke cluster Anda:

   kubectl apply -f image-puller-daemonset.yaml
   

3. Pastikan DaemonSet dibuat:

   kubectl get daemonset image-prefetch-daemonset -n NAMESPACE
   

4. Pastikan buffer kapasitas Anda dibuat dan siap untuk penyediaan:

   kubectl get capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE
   

   Periksa statusnya. Kolom STATUS harus menampilkan ReadyForProvisioning.

Memantau status dan performa buffer kapasitas

Anda dapat memantau status dan kondisi buffer kapasitas menggunakan perintah kubectl dan metrik Cloud Monitoring.

Memverifikasi status resource CapacityBuffer

Untuk memeriksa kondisi buffer kapasitas dan memastikan bahwa buffer tersebut siap menerima workload, selesaikan langkah-langkah berikut:

1. Dapatkan status semua buffer kapasitas di seluruh cluster:

   kubectl get capacitybuffer -A
   

2. Periksa status, kondisi, dan log peristiwa mendetail dari buffer tertentu:

   kubectl describe capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE
   

Mengidentifikasi node buffer siaga yang ditangguhkan

VM buffer siaga telah disediakan sebelumnya, tetapi disimpan dalam status ditangguhkan untuk membantu mengurangi biaya. Anda dapat mengenali node yang ditangguhkan ini karena memiliki kondisi kustom. Untuk mengaudit instance node yang ditangguhkan, jalankan perintah berikut:

kubectl get nodes -o custom-columns='NAME:.metadata.name,SUSPENDED:.status.conditions[?(@.type=="Suspended")].status'

Status True menunjukkan bahwa VM siaga ditangguhkan. Status False atau <none> menunjukkan node yang aktif dan berjalan.

Memantau performa dengan Cloud Monitoring

Untuk membantu memantau performa buffer kapasitas, pantau resource berikut di Cloud Monitoring:

• Latensi reaksi (cluster_autoscaler/reaction_time_milliseconds): Melacak durasi Cluster Autoscaler untuk membuat keputusan penskalaan berdasarkan permintaan tertunda CapacityBuffer Anda.
• Log Cluster Autoscaler: Cari entri log seperti "Capacity pod processor injecting ..." untuk mengamati peristiwa penggantian Pod buffer aktif.

Menghapus buffer kapasitas

Jika Anda tidak lagi memerlukan buffer kapasitas untuk workload Anda, 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 mengatasi masalah umum terkait buffer kapasitas.

Buffer kapasitas tidak 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 kustom yang dapat diskalakan

Jika Anda mengonfigurasi CapacityBuffer untuk bekerja dengan objek kustom yang dapat diskalakan (menggunakan kolom scalableRef), autoscaler 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 buffer kapasitas.
• Lihat dokumentasi CRD CapacityBuffer.