Mengimplementasikan sistem antrean Tugas dengan berbagi kuota antar-namespace di GKE

Standard

---

Tutorial ini menggunakan Kueue untuk menunjukkan cara menerapkan sistem antrean Tugas, mengonfigurasi resource workload, dan pembagian kuota antar-namespace yang berbeda di Google Kubernetes Engine (GKE), serta untuk memaksimalkan pemanfaatan cluster Anda.

Latar belakang

Sebagai engineer infrastruktur atau administrator cluster, memaksimalkan pemanfaatan antar-namespace sangatlah penting. Batch Tugas dalam satu namespace mungkin tidak sepenuhnya menggunakan seluruh kuota yang ditetapkan ke namespace, sementara namespace lain mungkin memiliki beberapa Tugas yang tertunda. Untuk menggunakan resource cluster secara efisien di antara Tugas dalam berbagai namespace dan untuk meningkatkan fleksibilitas pengelolaan kuota, Anda dapat mengonfigurasi kelompok di Kueue. Kelompok adalah grup ClusterQueue yang dapat meminjam kuota yang tidak digunakan dari satu sama lain. ClusterQueue mengatur kumpulan resource seperti CPU, memori, dan akselerator hardware.

Anda dapat menemukan definisi yang lebih mendetail dari semua konsep ini di dokumentasi Kueue

Catatan: Kueue mengacu pada tugas yang ditentukan dengan API arbitrer sebagai Workload, untuk menghindari kebingungan dengan Kubernetes Job API tertentu.

Tujuan

Tutorial ini ditujukan untuk engineer infrastruktur atau administrator cluster yang ingin menerapkan sistem antrean Tugas di Kubernetes menggunakan Kueue dengan pembagian kuota.

Tutorial ini akan meniru dua tim dalam dua namespace berbeda, dan setiap tim memiliki resource khusus, tetapi dapat saling meminjam. Set ketiga dari resource dapat digunakan sebagai spillover ketika tugas terakumulasi.

Gunakan operator Prometheus untuk memantau Tugas dan alokasi resource di namespace yang berbeda.

Tutorial ini membahas langkah-langkah yang diperlukan berikut:

1. Membuat cluster GKE
2. Membuat ResourceFlavors
3. Untuk setiap tim, buat ClusterQueue dan LocalQueue
4. Membuat Job dan mengamati workload yang diterima
5. Meminjam kuota yang tidak digunakan dengan kelompok
6. Menambahkan spillover ClusterQueue yang mengatur Spot VM

Biaya

Tutorial ini menggunakan komponen Google Cloud yang dapat ditagih berikut:

• GKE

Gunakan Kalkulator Harga untuk membuat perkiraan biaya berdasarkan penggunaan yang Anda proyeksikan.

Setelah menyelesaikan tutorial ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk informasi selengkapnya, lihat Membersihkan.

Sebelum memulai

Menyiapkan project

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the GKE API.

   Enable the API

5. In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the GKE API.

   Enable the API

Menetapkan setelan default untuk Google Cloud CLI

1. Di konsol Google Cloud, mulai instance Cloud Shell:
   Buka Cloud Shell

2. Download kode sumber untuk aplikasi contoh ini:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

3. Tetapkan variabel lingkungan default:

   gcloud config set project PROJECT_ID
   gcloud config set compute/region COMPUTE_REGION
   

   Ganti nilai berikut:

   • PROJECT_ID: project ID Google Cloud Anda.
   • COMPUTE_REGION: region Compute Engine.

Membuat cluster GKE

1. Buat cluster GKE bernama kueue-cohort:

   Anda akan membuat cluster dengan 6 node (2 per zona) di kumpulan default tanpa penskalaan otomatis. Jumlah tersebut adalah seluruh resource yang tersedia untuk tim di awal, sehingga harus bersaing untuk mendapatkannya.

   Anda akan melihat nanti bagaimana Kueue mengelola workload yang akan dikirim oleh kedua tim ke antrean masing-masing.

     gcloud container clusters create kueue-cohort --region COMPUTE_REGION \
     --release-channel rapid --machine-type e2-standard-4 --num-nodes 2
   

   Catatan: Langkah ini dapat memerlukan waktu hingga lima menit.

   Setelah cluster dibuat, hasilnya tampak seperti berikut ini:

     kubeconfig entry generated for kueue-cohort.
     NAME: kueue-cohort
     LOCATION: us-central1
     MASTER_VERSION: 1.26.2-gke.1000
     MASTER_IP: 35.224.108.58
     MACHINE_TYPE: e2-medium
     NODE_VERSION: 1.26.2-gke.1000
     NUM_NODES: 6
     STATUS: RUNNING
   

   Dengan STATUS adalah RUNNING untuk kueue-cluster.

2. Buat node pool bernama spot.

   Node pool ini menggunakan Spot VM dan mengaktifkan penskalaan otomatis. Node pool dimulai dengan 0 node, tetapi kemudian Anda akan menyediakannya bagi tim untuk digunakan sebagai kapasitas overspill.

   gcloud container node-pools create spot --cluster=kueue-cohort --region COMPUTE_REGION  \
   --spot --enable-autoscaling --max-nodes 20 --num-nodes 0 \
   --machine-type e2-standard-4
   

3. Instal versi rilis Kueue ke cluster:

   VERSION=VERSION
   kubectl apply -f \
     https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
   

   Ganti VERSION dengan huruf v setelah versi terbaru Kueue, misalnya v0.4.0. Untuk informasi selengkapnya tentang versi Kueue, lihat rilis Kueue.

   Catatan: Contoh dalam repo memerlukan v0.3.0 atau yang lebih baru.

   Tunggu hingga pengontrol Kueue siap:

   watch kubectl -n kueue-system get pods
   

   Outputnya akan mirip dengan berikut ini sebelum Anda dapat melanjutkan:

   NAME                                        READY   STATUS    RESTARTS   AGE
   kueue-controller-manager-6cfcbb5dc5-rsf8k   2/2     Running   0          3m
   

4. Buat dua namespace baru bernama team-a dan team-b:

   kubectl create namespace team-a
   kubectl create namespace team-b
   

   Tugas akan dibuat untuk setiap namespace.

Membuat ResourceFlavors

ResourceFlavor mewakili variasi resource di node cluster Anda, seperti VM yang berbeda (misalnya spot versus on-demand), arsitektur (misalnya, CPU x86 vs ARM), merek, dan model (misalnya, GPU Nvidia A100 versus T4).

ResourceFlavors menggunakan label dan taint node agar cocok dengan set node dalam cluster.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: on-demand # This ResourceFlavor will be used for the CPU resource
spec:
  nodeLabels:
    cloud.google.com/gke-provisioning: standard # This label was applied automatically by GKE
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: spot # This ResourceFlavor will be used as added resource for the CPU resource
spec:
  nodeLabels:  
    cloud.google.com/gke-provisioning: spot # This label was applied automatically by GKE

Dalam manifes ini:

• on-demand ResourceFlavor memiliki label yang ditetapkan ke cloud.google.com/gke-provisioning: standard.
• spot ResourceFlavor memiliki label yang ditetapkan ke cloud.google.com/gke-provisioning: spot.

Catatan: Label ini memerlukan GKE 1.26 atau yang lebih baru

Saat workload diberi ResourceFlavor, Kueue menetapkan Pod workload ke node yang cocok dengan label node yang ditentukan untuk ResourceFlavor.

Men-deploy ResourceFlavor:

kubectl apply -f flavors.yaml

Membuat ClusterQueue dan LocalQueue

Membuat dua ClusterQueue cq-team-a dan cq-team-b, serta LocalQueues lq-team-a dan lq-team-b yang sesuai, dengan namespace masing-masing team-a dan team-b.

ClusterQueues adalah objek cakupan cluster yang mengatur kumpulan resource seperti CPU, memori, dan akselerator hardware. Administrator batch dapat membatasi visibilitas objek ini untuk pengguna batch.

LocalQueue adalah objek dengan namespace yang dapat dicantumkan oleh pengguna batch. Antrean mengarah ke CluterQueues, tempat resource dialokasikan untuk menjalankan workload LocalQueue.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: cq-team-a
spec:
  cohort: all-teams # cq-team-a and cq-team-b share the same cohort
  namespaceSelector:
    matchLabels:
      kubernetes.io/metadata.name: team-a #Only team-a can submit jobs direclty to this queue, but will be able to share it through the cohort
  resourceGroups:
  - coveredResources: ["cpu", "memory"]
    flavors:
    - name: on-demand
      resources:
      - name: "cpu"
        nominalQuota: 10
        borrowingLimit: 5
      - name: "memory"
        nominalQuota: 10Gi
        borrowingLimit: 15Gi
    - name: spot # This ClusterQueue doesn't have nominalQuota for spot, but it can borrow from others
      resources:
      - name: "cpu"
        nominalQuota: 0
      - name: "memory"
        nominalQuota: 0
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  namespace: team-a # LocalQueue under team-a namespace
  name: lq-team-a
spec:
  clusterQueue: cq-team-a # Point to the ClusterQueue team-a-cq

ClusterQueues memungkinkan resource memiliki beberapa ragam. Dalam hal ini, kedua ClusterQueues memiliki dua ragam, on-demand dan spot, masing-masing menyediakan resource cpu. Kuota spot ResourceFlavor ditetapkan ke 0, dan tidak akan digunakan untuk saat ini.

Kedua ClusterQueues memiliki kelompok yang sama bernama all-teams, yang ditentukan di .spec.cohort. Jika dua atau beberapa ClusterQueue berbagi kelompok yang sama, cluster tersebut dapat meminjam kuota yang tidak digunakan dari satu sama lain.

Anda dapat mempelajari lebih lanjut cara kerja kelompok dan semantik pinjaman di dokumentasi Kueue

Men-deploy ClusterQueues dan LocalQueues:

kubectl apply -f cq-team-a.yaml
kubectl apply -f cq-team-b.yaml

(Opsional) Memantau Workload menggunakan kube-prometheus

Anda dapat menggunakan Prometheus untuk memantau workload Kueue aktif dan tertunda. Untuk memantau workload yang ditampilkan dan mengamati beban di setiap ClusterQueue, deploy kube-prometheus ke cluster di bagian namespace monitoring:

1. Download kode sumber untuk operator Prometheus:

   cd
   git clone https://github.com/prometheus-operator/kube-prometheus.git
   

2. Buat CustomResourceDefinitions(CRD):

   kubectl create -f kube-prometheus/manifests/setup
   

3. Buat komponen pemantauan:

   kubectl create -f kube-prometheus/manifests
   

4. Izinkan prometheus-operator untuk mengambil metrik dari komponen Kueue:

   kubectl apply -f https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/prometheus.yaml
   

5. Ubah ke direktori kerja:

   cd kubernetes-engine-samples/batch/kueue-cohort
   

6. Siapkan penerusan port ke layanan Prometheus yang berjalan di cluster GKE Anda:

   kubectl --namespace monitoring port-forward svc/prometheus-k8s 9090
   

7. Buka UI web Prometheus di localhost:9090 pada browser.

   Di Cloud Shell:

   1. Klik Pratinjau Web.

   2. Klik Ubah port dan tetapkan nomor port ke 9090.

   3. Klik Ubah dan Lihat Pratinjau.

   UI web Prometheus berikut akan muncul.

   

8. Di kotak kueri Expression, masukkan kueri berikut untuk membuat panel pertama yang memantau beban kerja aktif untuk cq-team-a ClusterQueue:

   kueue_pending_workloads{cluster_queue="cq-team-a", status="active"} or kueue_admitted_active_workloads{cluster_queue="cq-team-a"}
   

9. Klik Tambahkan panel.

10. Di kotak kueri Expression, masukkan kueri berikut untuk membuat panel lain yang memantau beban kerja aktif untuk cq-team-b ClusterQueue:

    kueue_pending_workloads{cluster_queue="cq-team-b", status="active"} or kueue_admitted_active_workloads{cluster_queue="cq-team-b"}
    

11. Klik Tambahkan panel.

12. Di kotak kueri Expression, masukkan kueri berikut untuk membuat panel yang memantau jumlah node di cluster:

    count(kube_node_info)
    

(Opsional) Memantau Workload menggunakan Google Cloud Managed Service for Prometheus

Anda dapat menggunakan Google Cloud Managed Service for Prometheus untuk memantau workload Kueue yang aktif dan tertunda. Daftar lengkap metrik dapat ditemukan di dokumentasi Kueue.

1. Siapkan Identity dan RBAC untuk akses metrik:

   Konfigurasi berikut membuat 4 resource Kubernetes, yang memberikan akses metrik untuk kolektor Google Cloud Managed Service for Prometheus.

   • ServiceAccount bernama kueue-metrics-reader dalam namespace kueue-system akan digunakan untuk mengautentikasi saat mengakses metrik Kueue.

   • Secret yang terkait dengan akun layanan kueue-metrics-reader, menyimpan token autentikasi, yang digunakan oleh kolektor, untuk melakukan autentikasi dengan endpoint metrik yang ditampilkan oleh deployment Kueue.

   • Peran bernama kueue-secret-reader di namespace kueue-system, yang memungkinkan pembacaan secret yang berisi token akun layanan.

   • ClusterRoleBinding yang memberikan ClusterRole kueue-metrics-reader ke akun layanan kueue-metrics-reader.

   apiVersion: v1
   kind: ServiceAccount
   metadata:
    name: kueue-metrics-reader
    namespace: kueue-system
   ---
   apiVersion: v1
   kind: Secret
   metadata:
    name: kueue-metrics-reader-token
    namespace: kueue-system
    annotations:
      kubernetes.io/service-account.name: kueue-metrics-reader
   type: kubernetes.io/service-account-token
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
    name: kueue-secret-reader
    namespace: kueue-system
   rules:
   -   resources:
    -   secrets
    apiGroups: [""]
    verbs: ["get", "list", "watch"]
    resourceNames: ["kueue-metrics-reader-token"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
    name: kueue-metrics-reader
   subjects:
   -   kind: ServiceAccount
    name: kueue-metrics-reader
    namespace: kueue-system
   roleRef:
    kind: ClusterRole
    name: kueue-metrics-reader
    apiGroup: rbac.authorization.k8s.io
   

2. Konfigurasikan RoleBinding untuk Google Cloud Managed Service for Prometheus:

   Bergantung pada apakah Anda menggunakan cluster Autopilot atau Standard, Anda harus membuat RoleBinding di namespace gke-gmp-system atau gmp-system. Resource ini memungkinkan akun layanan kolektor mengakses secret kueue-metrics-reader-token untuk mengautentikasi dan meng-scrape metrik Kueue.

   Autopilot

     apiVersion: rbac.authorization.k8s.io/v1
     kind: RoleBinding
     metadata:
       name: gmp-system:collector:kueue-secret-reader
       namespace: kueue-system
     roleRef:
       name: kueue-secret-reader
       kind: Role
       apiGroup: rbac.authorization.k8s.io
     subjects:
     -   name: collector
       namespace: gke-gmp-system
       kind: ServiceAccount
   

   Standard

     apiVersion: rbac.authorization.k8s.io/v1
     kind: RoleBinding
     metadata:
       name: gmp-system:collector:kueue-secret-reader
       namespace: kueue-system
     roleRef:
       name: kueue-secret-reader
       kind: Role
       apiGroup: rbac.authorization.k8s.io
     subjects:
     -   name: collector
       namespace: gmp-system
       kind: ServiceAccount
   

3. Konfigurasi resource Pod Monitoring:

   Resource berikut mengonfigurasi pemantauan untuk deployment Kueue, yang menentukan bahwa metrik ditampilkan di jalur /metrics melalui HTTPS. Fungsi ini menggunakan secret kueue-metrics-reader-token untuk autentikasi saat mengambil metrik.

   apiVersion: monitoring.googleapis.com/v1
   kind: PodMonitoring
   metadata:
   name: kueue
   namespace: kueue-system
   spec:
   selector:
    matchLabels:
      control-plane: controller-manager
   endpoints:
   -   port: https
    interval: 30s
    path: /metrics
    scheme: https
    tls:
      insecureSkipVerify: true
    authorization:
      type: Bearer
      credentials:
        secret:
          name: kueue-metrics-reader-token
          key: token
   

Mengkueri metrik yang diekspor

• Mengkueri metrik yang diekspor dengan Cloud Monitoring
• Mengkueri metrik yang diekspor dengan Grafana

Contoh kueri PromQL untuk memantau sistem berbasis Kueue

Kueri PromQL ini memungkinkan Anda memantau metrik Kueue utama seperti throughput tugas, penggunaan resource menurut antrean, dan waktu tunggu beban kerja untuk memahami performa sistem dan mengidentifikasi potensi bottleneck.

Throughput Tugas

Ini menghitung rasio workload yang diizinkan per detik selama 5 menit untuk setiap cluster_queue. Metrik ini dapat membantu mengelompokkan menurut antrean untuk membantu menentukan bottleneck dan menjumlahkannya untuk memberikan throughput sistem secara keseluruhan.

Kueri:

sum(rate(kueue_admitted_workloads_total[5m])) by (cluster_queue)

Pemanfaatan Sumber Daya

Hal ini mengasumsikan bahwa metrics.enableClusterQueueResources diaktifkan. Fungsi ini menghitung rasio penggunaan CPU saat ini dengan kuota CPU nominal untuk setiap antrean. Nilai yang mendekati 1 menunjukkan penggunaan yang tinggi. Anda dapat menyesuaikannya untuk memori atau resource lainnya dengan mengubah label resource.

Untuk menginstal versi rilis Kueue yang dikonfigurasi secara kustom di cluster Anda, ikuti dokumentasi Kueue.

Kueri:

sum(kueue_cluster_queue_resource_usage{resource="cpu"}) by (cluster_queue) / sum(kueue_cluster_queue_nominal_quota{resource="cpu"}) by (cluster_queue)

Waktu Tunggu Antrean

Ini memberikan waktu tunggu persentil ke-90 untuk beban kerja dalam antrean tertentu. Anda dapat mengubah nilai kuartil (misalnya, 0,5 untuk median, 0,99 untuk persentil ke-99) untuk memahami distribusi waktu tunggu.

Kueri:

histogram_quantile(0.9, kueue_admission_wait_time_seconds_bucket{cluster_queue="QUEUE_NAME"})

Membuat Job dan mengamati workload yang diterima

Hasilkan Tugas ke kedua ClusterQueue yang akan tidur selama 10 detik, dengan tiga Tugas yang setara dan akan diselesaikan dengan tiga penyelesaian. Kemudian, data akan dibersihkan setelah 60 detik.

apiVersion: batch/v1
kind: Job
metadata:
  namespace: team-a # Job under team-a namespace
  generateName: sample-job-team-a-
  labels:
    kueue.x-k8s.io/queue-name: lq-team-a # Point to the LocalQueue
spec:
  ttlSecondsAfterFinished: 60 # Job will be deleted after 60 seconds
  parallelism: 3 # This Job will have 3 replicas running at the same time
  completions: 3 # This Job requires 3 completions
  suspend: true # Set to true to allow Kueue to control the Job when it starts
  template:
    spec:
      containers:
      - name: dummy-job
        image: gcr.io/k8s-staging-perf-tests/sleep:latest
        args: ["10s"] # Sleep for 10 seconds
        resources:
          requests:
            cpu: "500m"
            memory: "512Mi"
      restartPolicy: Never

job-team-a.yaml membuat Tugas pada namespace team-a dan mengarah ke LocalQueue lq-team-a dan ClusterQueue cq-team-a.

Demikian pula, job-team-b.yaml membuat Tugas pada namespace team-b, dan menunjuk ke LocalQueue lq-team-b dan ClusterQueue cq-team-b.

1. Mulai terminal baru dan jalankan skrip ini untuk menghasilkan Tugas setiap detik:

   ./create_jobs.sh job-team-a.yaml 1
   

2. Mulai terminal lain dan buat Tugas untuk namespace team-b:

   ./create_jobs.sh job-team-b.yaml 1
   

3. Amati Tugas yang mengantre di Prometheus. Atau dengan perintah ini:

   watch -n 2 kubectl get clusterqueues -o wide
   

Outputnya akan mirip dengan berikut ini:

    NAME        COHORT      STRATEGY         PENDING WORKLOADS   ADMITTED WORKLOADS
    cq-team-a   all-teams   BestEffortFIFO   0                   5
    cq-team-b   all-teams   BestEffortFIFO   0                   4

Meminjam kuota yang tidak digunakan dengan kelompok

ClusterQueues mungkin tidak selalu memiliki kapasitas penuh. Penggunaan kuota tidak akan dimaksimalkan saat workload tidak tersebar secara merata di antara ClusterQueue. Jika ClusterQueues berbagi kelompok yang sama satu sama lain, ClusterQueues dapat meminjam kuota dari ClusterQueues lain untuk memaksimalkan penggunaan kuota.

1. Setelah ada Tugas yang diantrekan untuk ClusterQueues cq-team-a dan cq-team-b, hentikan skrip untuk namespace team-b dengan menekan CTRL+c di terminal yang sesuai.

2. Setelah semua Tugas yang tertunda dari namespace team-b diproses, tugas dari namespace team-a dapat meminjam resource yang tersedia di cq-team-b:

   kubectl describe clusterqueue cq-team-a
   

   Karena cq-team-a dan cq-team-b memiliki kelompok yang sama yang disebut all-teams, ClusterQueues ini dapat berbagi resource yang tidak digunakan.

     Flavors Usage:
       Name:  on-demand
       Resources:
         Borrowed:  5
         Name:      cpu
         Total:     15
         Borrowed:  5Gi
         Name:      memory
         Total:     15Gi
   

3. Melanjutkan skrip untuk namespace team-b.

   ./create_jobs.sh job-team-b.yaml 3
   

   Amati bagaimana resource yang dipinjam dari cq-team-a kembali ke 0, sedangkan resource dari cq-team-b digunakan untuk workloadnya sendiri:

   kubectl describe clusterqueue cq-team-a
   

     Flavors Usage:
       Name:  on-demand
       Resources:
         Borrowed:  0
         Name:      cpu
         Total:     9
         Borrowed:  0
         Name:      memory
         Total:     9Gi
   

Meningkatkan kuota dengan Spot VM

Ketika kuota perlu ditingkatkan sementara, misalnya untuk memenuhi permintaan tinggi dalam workload yang tertunda, Anda dapat mengonfigurasi Kueue untuk mengakomodasi permintaan dengan menambahkan lebih banyak ClusterQueues ke kelompok. ClusterQueue dengan resource yang tidak digunakan dapat berbagi resource tersebut dengan ClusterQueues lain yang termasuk dalam kelompok yang sama.

Di awal tutorial, Anda telah membuat node pool bernama spot menggunakan Spot VM dan ResourceFlavor bernama spot dengan label yang ditetapkan ke cloud.google.com/gke-provisioning: spot. Buat ClusterQueue untuk menggunakan node pool ini dan ResourceFlavor yang mewakilinya:

1. Buat ClusterQueue baru bernama cq-spot dengan kelompok yang ditetapkan ke all-teams:

   apiVersion: kueue.x-k8s.io/v1beta1
   kind: ClusterQueue
   metadata:
     name: spot-cq
   spec:
     cohort: all-teams # Same cohort as cq-team-a and cq-team-b
     resourceGroups:
     - coveredResources: ["cpu", "memory"]
       flavors:
       - name: spot
         resources:
         - name: "cpu"
           nominalQuota: 40
         - name: "memory"
           nominalQuota: 144Gi

   Karena ClusterQueue ini berbagi kelompok yang sama dengan cq-team-a dan cq-team-b, ClusterQueue cq-team-a dan cq-team-b dapat meminjam resource hingga 15 permintaan CPU, dan 15 Gi memori.

   kubectl apply -f cq-spot.yaml
   

2. Di Prometheus, amati lonjakan workload yang diterima untuk cq-team-a dan cq-team-b berkat kuota tambahan oleh cq-spot yang berbagi kelompok yang sama. Atau dengan perintah ini:

   watch -n 2 kubectl get clusterqueues -o wide
   

3. Di Prometheus, amati jumlah node dalam cluster. Atau dengan perintah ini:

   watch -n 2 kubectl get nodes -o wide
   

4. Hentikan kedua skrip dengan menekan CTRL+c untuk namespace team-a dan team-b.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus project

Perhatian: Menghapus project memiliki efek berikut:
• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Menghapus resource satu per satu

1. Hapus sistem kuota Kueue:

   kubectl delete -n team-a localqueue lq-team-a
   kubectl delete -n team-b localqueue lq-team-b
   kubectl delete clusterqueue cq-team-a
   kubectl delete clusterqueue cq-team-b
   kubectl delete clusterqueue cq-spot
   kubectl delete resourceflavor default
   kubectl delete resourceflavor on-demand
   kubectl delete resourceflavor spot
   

2. Hapus manifes Kueue:

   VERSION=VERSION
   kubectl delete -f \
     https://github.com/kubernetes-sigs/kueue/releases/download/$VERSION/manifests.yaml
   

3. Hapus kluster:

   gcloud container clusters delete kueue-cohort --region=COMPUTE_REGION
   

Langkah berikutnya

• Pelajari cara Men-deploy sistem batch menggunakan Kueue lebih lanjut.

• Pelajari Tugas di GKE lebih lanjut.

• Pelajari Kueue lebih lanjut