Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Mengonfigurasi buffer kapasitas

Standard Autopilot

Buffer kapasitas meningkatkan responsivitas dan keandalan workload penting dengan mengelola kapasitas cluster cadangan secara proaktif dan status ditangguhkan dari kapasitas yang telah disediakan sebelumnya dan telah dikonfigurasi sebelumnya menggunakan CustomResourceDefinition (CRD) 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 mengurangi waktu penjadwalan Pod.

Saat workload berprioritas tinggi perlu peningkatan skala dengan cepat, workload baru dapat menggunakan kapasitas kosong dengan 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.

Aktifkan Google Kubernetes Engine API

Untuk 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 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.

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 standby.
Aktifkan node auto-provisioning di cluster Standar Anda. Di cluster Autopilot, node auto-provisioning sudah diaktifkan. Node auto-provisioning 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 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 dan versi GKE yang lebih lama dari 1.36.0-gke.2459000, Anda mungkin perlu memberikan izin secara manual kepada autoscaler cluster untuk membaca subresource skala. Lihat Error izin untuk resource yang dapat diskalakan kustom.

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

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

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.

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.

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 (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.

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 contoh Deployment dengan 10 replika, yang merupakan objek referensi untuk contoh buffer berbasis persentase di bagian berikutnya.

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

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.

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:

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, "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.

Terapkan manifes:

kubectl apply -f cb-fixed-replicas.yaml

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 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:

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, "buffer.x-k8s.io/active-capacity" (default) atau "buffer.gke.io/standby-capacity".
Manifes ini membuat resource CapacityBuffer dengan batas total 5 CPU dan Memori 5 GiB. Jika Anda menggunakan contoh PodTemplate dari langkah sebelumnya, Anda menentukan setiap unit sebagai CPU 1 dan Memori 1Gi, yang akan menghasilkan 5 unit buffer.

Terapkan manifes:

kubectl apply -f cb-resource-limits.yaml

Pastikan GKE menerapkan buffer kapasitas:
```
kubectl get capacitybuffer resource-limit-buffer -n NAMESPACE
```
Periksa status CapacityBuffer. Kolom replicas akan menampilkan nilai yang berasal dari batas yang Anda tentukan. Jika menggunakan contoh PodTemplate dari bagian sebelumnya, Anda akan melihat 5 unit buffer karena ini adalah jumlah maksimum unit yang sesuai dalam batas yang ditentukan.

Mengonfigurasi penyanggaan berbasis persentase

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

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

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

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, "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 dirujuk. 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 Anda memerlukan buffer yang lebih besar daripada ukuran workload yang dirujuk saat ini. Jumlah replika buffer non-bilangan bulat, yang dihasilkan dari nilai kolom persentase yang lebih rendah dari 100, dibulatkan ke bawah.

Terapkan manifes:

kubectl apply -f cb-percentage-based.yaml

Pastikan GKE menerapkan buffer kapasitas:
```
kubectl get capacitybuffer percentage-buffer -n NAMESPACE
```
Periksa status CapacityBuffer. Kolom replicas akan 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.
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.

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: durasi 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 24h.

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 mulai beban kerja saat node standby dilanjutkan, Anda dapat memuat image container terlebih dahulu menggunakan DaemonSet. DaemonSet berjalan selama periode sistem dimulai sebelum node ditangguhkan.

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

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 di-preload, misalnya your-app-image:latest.

Terapkan manifes DaemonSet ke cluster Anda:

kubectl apply -f image-puller-daemonset.yaml

Pastikan DaemonSet dibuat:

kubectl get daemonset image-prefetch-daemonset -n NAMESPACE

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 Anda dan memverifikasi bahwa buffer tersebut siap menerima beban kerja, selesaikan langkah-langkah berikut:

Dapatkan status semua buffer kapasitas di seluruh cluster:
```
kubectl get capacitybuffer -A
```

Periksa status mendetail, kondisi, dan log peristiwa buffer tertentu:

kubectl describe capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE

Mengidentifikasi node buffer siaga yang ditangguhkan

VM buffer standby telah diprovisi sebelumnya, tetapi tetap 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 standby 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: Telusuri 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, hapus objek CapacityBuffer. Tindakan ini akan menghapus Pod placeholder dan memungkinkan autoscaler cluster memperkecil 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 kustom yang skalabel

Jika Anda mengonfigurasi CapacityBuffer untuk berfungsi dengan objek yang dapat diskalakan kustom (menggunakan kolom scalableRef), penskalaan otomatis cluster mungkin gagal menskalakan buffer jika tidak memiliki izin yang diperlukan. Masalah ini hanya terjadi di GKE versi yang lebih lama dari 1.36.0-gke.2459000.

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.

Pod Buffer tidak dijadwalkan di node yang disediakan oleh ComputeClass kustom

Jika dependensi konfigurasi CapacityBuffer Anda (misalnya, PodTemplate) memilih ComputeClass kustom, Anda mungkin mengalami masalah saat Pod buffer tidak dijadwalkan di node yang baru disediakan. Masalah ini menyebabkan autoscaler cluster berulang kali membuat node pool dan node yang berlebihan saat node dalam kondisi tidak ada aktivitas dihapus.

Masalah ini terjadi jika ComputeClass kustom menyediakan node dengan taint atau persyaratan runtime tertentu, dan Pod buffer Anda (atau PodTemplate yang diandalkannya) tidak memiliki toleransi atau setelan yang cocok.

Untuk mengatasi masalah ini, perbarui konfigurasi CapacityBuffer Anda untuk menentukan toleransi, pemilih node, atau class runtime yang diperlukan. Misalnya, jika dependensi Anda memilih ComputeClass kustom yang dikonfigurasi dengan GKE Sandbox, perbarui dependensi untuk melakukan salah satu hal berikut:

Tentukan kolom spec.runtimeClassName: gvisor.
Sertakan toleransi eksplisit untuk taint sandbox.gke.io/runtime=gvisor:NoSchedule.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi ComputeClass kustom.

Langkah berikutnya

Pelajari lebih lanjut penyangga kapasitas.
Lihat dokumentasi CRD CapacityBuffer.

Mengonfigurasi buffer kapasitas Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Sebelum memulai

Membuat objek Kubernetes prasyarat

Menerapkan buffer kapasitas

Mengonfigurasi buffer replika tetap

Mengonfigurasi buffer batas resource

Mengonfigurasi penyanggaan berbasis persentase

Menyesuaikan perilaku buffer siaga

Memuat gambar terlebih dahulu di buffer siaga

Memantau status dan performa buffer kapasitas

Memverifikasi status resource CapacityBuffer

Mengidentifikasi node buffer siaga yang ditangguhkan

Memantau performa dengan Cloud Monitoring

Menghapus buffer kapasitas

Pemecahan masalah

Buffer kapasitas belum siap karena model penagihan

Error izin untuk resource kustom yang skalabel

Pod Buffer tidak dijadwalkan di node yang disediakan oleh ComputeClass kustom

Langkah berikutnya

Mengonfigurasi buffer kapasitas