Menjalankan workload berskala besar dengan mulai fleksibel dengan penyediaan dalam antrean

Halaman ini menunjukkan cara mengoptimalkan fleksibilitas, efisiensi, dan ketersediaan kapasitas komputasi GPU untuk workload AI dan batch berskala besar dengan GPU menggunakan flex-start dengan penyediaan dalam antrean yang didukung oleh Dynamic Workload Scheduler.

Sebelum membaca halaman ini, pastikan Anda memahami hal-hal berikut:

Panduan ini ditujukan untuk Engineer machine learning (ML), Admin dan operator platform, serta untuk Spesialis Data dan AI yang tertarik menggunakan kemampuan orkestrasi container Kubernetes untuk menjalankan workload batch. Untuk mengetahui informasi selengkapnya tentang peran umum dan contoh tugas yang kami referensikan dalam konten Google Cloud , lihat Peran dan tugas pengguna GKE umum.

Cara kerja flex-start dengan penyediaan dalam antrean

Dengan flex-start dengan penyediaan dalam antrean, GKE mengalokasikan semua resource yang diminta secara bersamaan. Flex-start dengan penyediaan dalam antrean menggunakan alat berikut:

  • Flex-start dengan penyediaan dalam antrean didasarkan pada Dynamic Workload Scheduler yang digabungkan dengan definisi resource kustom (CRD) Provisioning Request. Alat ini mengelola kapasitas yang dialokasikan berdasarkan resource yang tersedia dan persyaratan workload Anda.
  • (Opsional) Kueue mengotomatiskan siklus proses flex-start dengan permintaan penyediaan dalam antrean. Kueue mengimplementasikan antrean Tugas dan secara otomatis menangani siklus proses Permintaan Penyediaan.

Untuk menggunakan flex-start dengan penyediaan dalam antrean, Anda harus menambahkan flag --flex-start dan --enable-queued-provisioning saat membuat node pool.

Praktik terbaik:

Gunakan flex-start dengan penyediaan dalam antrean untuk workload AI dan batch berskala besar jika workload Anda memenuhi kriteria berikut:

  • Workload Anda memiliki waktu mulai yang fleksibel.
  • Workload Anda harus dijalankan di beberapa node secara bersamaan.

Untuk workload yang lebih kecil yang dapat berjalan di satu node, gunakan Flex-start VM. Untuk mengetahui informasi selengkapnya tentang penyediaan GPU di GKE, lihat Mendapatkan akselerator untuk workload AI.

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.

Menggunakan node pool dengan flex-start dengan penyediaan dalam antrean

Bagian ini hanya berlaku untuk cluster Standard.

Anda dapat menggunakan salah satu metode berikut untuk menetapkan bahwa flex-start dengan penyediaan dalam antrean dapat berfungsi dengan node pool tertentu di cluster Anda:

Membuat node pool

Buat node pool yang memiliki flex-start dengan penyediaan dalam antrean yang diaktifkan menggunakan gcloud CLI:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=LOCATION \
    --enable-queued-provisioning \
    --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
    --machine-type=MACHINE_TYPE \
    --flex-start \
    --enable-autoscaling  \
    --num-nodes=0   \
    --total-max-nodes TOTAL_MAX_NODES  \
    --location-policy=ANY  \
    --no-enable-autorepair

Ganti kode berikut:

  • NODEPOOL_NAME: Nama yang Anda pilih untuk node pool.
  • CLUSTER_NAME: Nama cluster.
  • LOCATION: Region Compute Engine cluster, seperti us-central1.
  • GPU_TYPE: Jenis GPU.
  • AMOUNT: Jumlah GPU yang akan dipasang ke node di node pool.
  • DRIVER_VERSION: versi driver NVIDIA yang akan diinstal. Dapat berupa salah satu dari hal berikut:
    • default: Menginstal versi driver default untuk versi GKE Anda.
    • latest: Instal versi driver terbaru yang tersedia untuk versi GKE Anda. Hanya tersedia untuk node yang menggunakan Container-Optimized OS.
  • TOTAL_MAX_NODES: jumlah maksimum node yang akan diskalakan secara otomatis untuk seluruh node pool.

  • MACHINE_TYPE: Jenis mesin Compute Engine untuk node Anda.

    Praktik terbaik:

    Gunakan jenis mesin yang dioptimalkan untuk akselerator guna meningkatkan performa dan efisiensi untuk workload AI/ML.

Secara opsional, Anda dapat menggunakan flag berikut:

  • --node-locations=COMPUTE_ZONES: Daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node GPU. Zona harus berada di region yang sama dengan cluster. Pilih zona yang memiliki GPU yang tersedia.
  • --enable-gvnic: Flag ini mengaktifkan gVNIC di kumpulan node GPU untuk meningkatkan kecepatan traffic jaringan.
  • --request-valid-for-duration: Flag ini menginstruksikan GKE untuk menunggu permintaan GPU dipenuhi tanpa batas waktu. Jika flag ini tidak ditentukan, waktu tunggu default untuk GPU adalah maksimum 14 hari. Sebaliknya, workload TPU dapat menunggu dalam jangka waktu yang tidak ditentukan.

Perintah ini membuat node pool dengan konfigurasi berikut:

  • Flag --flex-start yang dikombinasikan dengan flag --enable-queued-provisioning menginstruksikan GKE untuk membuat node pool dengan flex-start dengan penyediaan dalam antrean diaktifkan dan menambahkan taint cloud.google.com/gke-queued ke node pool.
  • GKE memungkinkan penyediaan dalam antrean dan penskalaan otomatis cluster.
  • Node pool awalnya memiliki nol node.
  • Flag --no-enable-autorepair menonaktifkan perbaikan otomatis, yang dapat mengganggu workload yang berjalan di node yang diperbaiki.

Mengaktifkan node auto-provisioning untuk membuat node pool untuk flex-start dengan penyediaan dalam antrean

Anda dapat menggunakan node auto-provisioning untuk mengelola node pool untuk flex-start dengan penyediaan dalam antrean untuk cluster yang menjalankan versi 1.29.2-gke.1553000 atau yang lebih baru. Saat Anda mengaktifkan node auto-provisioning, GKE akan membuat node pool dengan resource yang diperlukan untuk workload terkait.

Untuk mengaktifkan node auto-provisioning, pertimbangkan setelan berikut dan selesaikan langkah-langkah di bagian Mengonfigurasi batas GPU:

  • Tentukan resource yang diperlukan untuk flex-start dengan penyediaan dalam antrean saat Anda mengaktifkan fitur ini. Untuk mencantumkan resourceTypes yang tersedia, jalankan perintah gcloud compute accelerator-types list.
  • Gunakan tanda --no-enable-autoprovisioning-autorepair untuk menonaktifkan perbaikan otomatis node node.
  • Izinkan GKE menginstal driver GPU secara otomatis di node GPU yang disediakan secara otomatis. Untuk mengetahui informasi selengkapnya, lihat Menginstal driver menggunakan node auto-provisioning dengan GPU.

Jalankan workload batch dan AI dengan flex-start dengan penyediaan dalam antrean

Untuk menjalankan workload batch dengan flex-start dengan penyediaan dalam antrean, gunakan salah satu konfigurasi berikut:

Praktik terbaik:

Gunakan Kueue untuk menjalankan workload batch dan AI dengan flex-start dengan penyediaan dalam antrean.

Flex-start dengan penyediaan dalam antrean untuk Tugas dengan Kueue

Bagian berikut menunjukkan cara mengonfigurasi flex-start dengan penyediaan dalam antrean untuk Tugas dengan Kueue:

  • Flex-start dengan penyiapan node pool penyediaan dalam antrean.
  • Pemesanan dan flex-start dengan penyiapan node pool penyediaan dalam antrean.

Bagian ini menggunakan contoh di direktori dws-examples dari repositori ai-on-gke. Kami telah memublikasikan contoh dalam direktori dws-examples berdasarkan lisensi Apache2.

Anda harus memiliki izin administrator untuk menginstal Kueue. Untuk mendapatkannya, pastikan Anda diberi peran IAM roles/container.admin. Untuk mengetahui lebih lanjut peran IAM GKE, lihat Panduan membuat kebijakan izin IAM.

Menyiapkan lingkungan Anda

  1. Jalankan perintah berikut di Cloud Shell:

    git clone https://github.com/GoogleCloudPlatform/ai-on-gke
cd ai-on-gke/tutorials-and-examples/workflow-orchestration/dws-examples

  2. Instal versi Kueue terbaru di cluster Anda:

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

    Ganti KUEUE_VERSION dengan Kueue versi terbaru.

Jika Anda menggunakan Kueue dalam versi yang lebih lama dari 0.7.0, ubah konfigurasi feature gate Kueue dengan menetapkan feature gate ProvisioningACC ke true. Lihat feature gate Kueue untuk mengetahui penjelasan yang lebih mendetail dan nilai gerbang default. Untuk mengetahui informasi selengkapnya tentang penginstalan Kueue, lihat Penginstalan.

Memecahkan masalah penginstalan Kueue: Jika Anda mengalami error izin selama penginstalan, pastikan pengguna Anda memiliki peran cluster-admin. Jika Anda mengalami error koneksi webhook ditolak saat membuat antrean nanti dalam tutorial ini, pastikan hal berikut:

  • Pod kueue-controller-manager berjalan sepenuhnya di namespace kueue-system.
  • Aturan firewall cluster Anda mengizinkan komunikasi dari panel kontrol ke node pada port 8443.

Buat resource Kueue untuk penyiapan hanya kumpulan node Dynamic Workload Scheduler

Dengan manifes berikut, Anda membuat antrean level cluster bernama dws-cluster-queue dan namespace LocalQueue bernama dws-local-queue. Tugas yang merujuk ke antrean dws-cluster-queue di namespace ini menggunakan flex-start dengan penyediaan dalam antrean untuk mendapatkan resource GPU.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: "default-flavor"
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: AdmissionCheck
metadata:
  name: dws-prov
spec:
  controllerName: kueue.x-k8s.io/provisioning-request
  parameters:
    apiGroup: kueue.x-k8s.io
    kind: ProvisioningRequestConfig
    name: dws-config
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ProvisioningRequestConfig
metadata:
  name: dws-config
spec:
  provisioningClassName: queued-provisioning.gke.io
  managedResources:
    - nvidia.com/gpu
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: "dws-cluster-queue"
spec:
  namespaceSelector: {}
  resourceGroups:
    - coveredResources: ["cpu", "memory", "nvidia.com/gpu", "ephemeral-storage"]
      flavors:
        - name: "default-flavor"
          resources:
            - name: "cpu"
              nominalQuota: 1000000000 # "Infinite" quota
            - name: "memory"
              nominalQuota: 1000000000Gi # "Infinite" quota
            - name: "nvidia.com/gpu"
              nominalQuota: 1000000000 # "Infinite" quota
            - name: "ephemeral-storage"
              nominalQuota: 1000000000Ti # "Infinite" quota
  admissionChecks:
    - dws-prov
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  namespace: "default"
  name: "dws-local-queue"
spec:
  clusterQueue: "dws-cluster-queue"
---
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  labels:
    control-plane: controller-manager
  name: controller-manager-metrics-monitor
  namespace: kueue-system
spec:
  endpoints:
    - path: /metrics
      port: 8080
      scheme: http
      interval: 30s
  selector:
    matchLabels:
      control-plane: controller-manager
---

Antrean cluster ini memiliki batas kuota yang tinggi dan hanya integrasi penyediaan dalam antrean dengan flex-start yang diaktifkan. Untuk mengetahui informasi selengkapnya tentang Kueue API dan cara menyiapkan batas, lihat Konsep Kueue.

Deploy LocalQueue:

kubectl create -f ./dws-queues.yaml

Outputnya mirip dengan hal berikut ini:

resourceflavor.kueue.x-k8s.io/default-flavor created
admissioncheck.kueue.x-k8s.io/dws-prov created
provisioningrequestconfig.kueue.x-k8s.io/dws-config created
clusterqueue.kueue.x-k8s.io/dws-cluster-queue created
localqueue.kueue.x-k8s.io/dws-local-queue created

Jika ingin menjalankan Tugas yang menggunakan flex-start dengan penyediaan dalam antrean di namespace lain, Anda dapat membuat LocalQueues tambahan menggunakan template sebelumnya.

Menjalankan Tugas

Dalam manifes berikut, contoh Tugas menggunakan flex-start dengan penyediaan dalam antrean:

apiVersion: batch/v1
kind: Job
metadata:
  name: sample-job
  namespace: default
  labels:
    kueue.x-k8s.io/queue-name: dws-local-queue
  annotations:
    provreq.kueue.x-k8s.io/maxRunDurationSeconds: "600"
spec:
  parallelism: 1
  completions: 1
  suspend: true
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-nodepool: NODEPOOL_NAME
      tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
      containers:
        - name: dummy-job
          image: gcr.io/k8s-staging-perf-tests/sleep:v0.0.3
          args: ["120s"]
          resources:
            requests:
              cpu: "100m"
              memory: "100Mi"
              nvidia.com/gpu: 1
            limits:
              cpu: "100m"
              memory: "100Mi"
              nvidia.com/gpu: 1
      restartPolicy: Never

Manifes ini mencakup kolom berikut yang relevan untuk konfigurasi flex-start dengan penyediaan dalam antrean:

  • Label kueue.x-k8s.io/queue-name: dws-local-queue memberi tahu GKE bahwa Kueue bertanggung jawab untuk mengorkestrasi Job tersebut. Label ini juga menentukan antrean tempat Tugas diantrekan.
  • Flag suspend: true memberi tahu GKE untuk membuat resource Tugas, tetapi belum menjadwalkan Pod. Kueue mengubah flag tersebut menjadi false saat node siap untuk eksekusi Tugas.
  • nodeSelector memberi tahu GKE untuk menjadwalkan Job hanya pada node pool yang ditentukan. Nilai harus cocok dengan NODEPOOL_NAME, nama node pool dengan penyediaan dalam antrean yang diaktifkan.

  1. Jalankan Tugas Anda:

    kubectl create -f ./job.yaml

    Outputnya mirip dengan hal berikut ini:

    job.batch/sample-job created

  2. Periksa status Tugas Anda:

    kubectl describe job sample-job

    Outputnya mirip dengan hal berikut ini:

    Events:
  Type    Reason            Age    From                        Message
  ----    ------            ----   ----                        -------
  Normal  Suspended         5m17s  job-controller              Job suspended
  Normal  CreatedWorkload   5m17s  batch/job-kueue-controller  Created Workload: default/job-sample-job-7f173
  Normal  Started           3m27s  batch/job-kueue-controller  Admitted by clusterQueue dws-cluster-queue
  Normal  SuccessfulCreate  3m27s  job-controller              Created pod: sample-job-9qsfd
  Normal  Resumed           3m27s  job-controller              Job resumed
  Normal  Completed         12s    job-controller              Job completed

Flex-start dengan penyediaan dalam antrean dengan integrasi Kueue juga mendukung jenis workload lain yang tersedia di ekosistem open source, seperti berikut:

  • RayJob
  • JobSet v0.5.2 atau yang lebih baru
  • Kubeflow MPIJob, TFJob, PyTorchJob.
  • Pod Kubernetes yang sering digunakan oleh orchestrator alur kerja
  • Cluster mini Flux

Untuk mengetahui informasi selengkapnya tentang dukungan ini, lihat Pengguna batch Kueue.

Buat resource Kueue untuk penyiapan node pool Reservation dan Dynamic Workload Scheduler

Dengan manifes berikut, Anda membuat dua ResourceFlavors yang terkait dengan dua node pool yang berbeda: reservation-nodepool dan dws-nodepool. Nama node pool ini hanyalah contoh nama. Ubah nama ini sesuai dengan konfigurasi node pool Anda. Selain itu, dengan konfigurasi ClusterQueue, Job yang masuk akan mencoba menggunakan reservation-nodepool, dan jika tidak ada kapasitas, Job ini akan menggunakan Dynamic Workload Scheduler untuk mendapatkan resource GPU.

apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: "reservation"
spec:
  nodeLabels:
    cloud.google.com/gke-nodepool: "reservation-nodepool" # placeholder value
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: "dws"
spec:
  nodeLabels:
    cloud.google.com/gke-nodepool: "dws-nodepool" # placeholder value
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: "cluster-queue"
spec:
  namespaceSelector: {} # match all.
  resourceGroups:
    - coveredResources: ["cpu", "memory", "nvidia.com/gpu"]
      flavors:
        - name: "reservation" # first we try reservation
          resources:
            - name: "cpu"
              nominalQuota: 9
            - name: "memory"
              nominalQuota: 36Gi
            - name: "nvidia.com/gpu"
              nominalQuota: 9
        - name: "dws" # if reservation is saturated we try dws
          resources:
            - name: "cpu"
              nominalQuota: 1000000000 # "Infinite" quota
            - name: "memory"
              nominalQuota: 1000000000Gi # "Infinite" quota
            - name: "nvidia.com/gpu"
              nominalQuota: 1000000000 # "Infinite" quota
  admissionChecksStrategy:
    admissionChecks:
      - name: "dws-prov"
        onFlavors: [dws]
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  namespace: "default"
  name: "user-queue"
spec:
  clusterQueue: "cluster-queue"
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: AdmissionCheck
metadata:
  name: dws-prov
spec:
  controllerName: kueue.x-k8s.io/provisioning-request
  parameters:
    apiGroup: kueue.x-k8s.io
    kind: ProvisioningRequestConfig
    name: dws-config
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ProvisioningRequestConfig
metadata:
  name: dws-config
spec:
  provisioningClassName: queued-provisioning.gke.io
  managedResources:
    - nvidia.com/gpu

Antrean cluster ini memiliki batas kuota yang tinggi dan hanya integrasi flex-start dengan penyediaan dalam antrean yang diaktifkan. Untuk mengetahui informasi selengkapnya tentang API Kueue dan cara menyiapkan batas, lihat Konsep Kueue.

Deploy manifes menggunakan perintah berikut:

kubectl create -f ./dws_and_reservation.yaml

Outputnya mirip dengan hal berikut ini:

resourceflavor.kueue.x-k8s.io/reservation created
resourceflavor.kueue.x-k8s.io/dws created
clusterqueue.kueue.x-k8s.io/cluster-queue created
localqueue.kueue.x-k8s.io/user-queue created
admissioncheck.kueue.x-k8s.io/dws-prov created
provisioningrequestconfig.kueue.x-k8s.io/dws-config created

Menjalankan Tugas

Berbeda dengan penyiapan sebelumnya, manifes ini tidak menyertakan kolom nodeSelector karena diisi oleh Kueue, bergantung pada kapasitas gratis di ClusterQueue.

apiVersion: batch/v1
kind: Job
metadata:
  generateName: sample-job-
  namespace: default
  labels:
    kueue.x-k8s.io/queue-name: user-queue
  annotations:
    provreq.kueue.x-k8s.io/maxRunDurationSeconds: "600"
spec:
  parallelism: 1
  completions: 1
  suspend: true
  template:
    spec:
      tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
      containers:
        - name: dummy-job
          image: gcr.io/k8s-staging-perf-tests/sleep:v0.0.3
          args: ["120s"]
          resources:
            requests:
              cpu: "100m"
              memory: "100Mi"
              nvidia.com/gpu: 1
            limits:
              cpu: "100m"
              memory: "100Mi"
              nvidia.com/gpu: 1
      restartPolicy: Never

  1. Menjalankan Tugas Anda:

    kubectl create -f ./job-without-node-selector.yaml

    Outputnya mirip dengan hal berikut ini:

    job.batch/sample-job-v8xwm created

Untuk mengidentifikasi node pool yang digunakan Tugas, Anda perlu mencari tahu ResourceFlavor yang digunakan Tugas Anda.

Pemecahan masalah

Untuk mengetahui informasi selengkapnya tentang pemecahan masalah Kueue, lihat Memecahkan Masalah Permintaan Penyediaan di Kueue.

Flex-start dengan penyediaan dalam antrean untuk Tugas tanpa Kueue

Menentukan objek ProvisioningRequest

Buat permintaan melalui Provisioning Request untuk setiap Tugas. Flex-start dengan penyediaan dalam antrean tidak memulai Pod, melainkan hanya menyediakan node.

  1. Buat manifes provisioning-request.yaml berikut:

    Standar 

    apiVersion: v1
kind: PodTemplate
metadata:
  name: POD_TEMPLATE_NAME
  namespace: NAMESPACE_NAME
  labels:
    cloud.google.com/apply-warden-policies: "true"
template:
  spec:
    nodeSelector:
      cloud.google.com/gke-nodepool: NODEPOOL_NAME
      cloud.google.com/gke-flex-start: "true"
    tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"
    containers:
      - name: pi
        image: perl
        command: ["/bin/sh"]
        resources:
          limits:
            cpu: "700m"
            nvidia.com/gpu: 1
          requests:
            cpu: "700m"
            nvidia.com/gpu: 1
    restartPolicy: Never
---
apiVersion: autoscaling.x-k8s.io/API_VERSION
kind: ProvisioningRequest
metadata:
  name: PROVISIONING_REQUEST_NAME
  namespace: NAMESPACE_NAME
spec:
  provisioningClassName: queued-provisioning.gke.io
  parameters:
    maxRunDurationSeconds: "MAX_RUN_DURATION_SECONDS"
  podSets:
  - count: COUNT
    podTemplateRef:
      name: POD_TEMPLATE_NAME

    Ganti kode berikut:

    • API_VERSION: Versi API, baik v1 maupun v1beta1. Sebaiknya gunakan v1 untuk stabilitas dan akses ke fitur terbaru.
    • NAMESPACE_NAME: Nama namespace Kubernetes Anda. Namespace harus sama dengan namespace Pod.
    • PROVISIONING_REQUEST_NAME: Nama ProvisioningRequest. Anda akan merujuk ke nama ini dalam anotasi Pod.
    • MAX_RUN_DURATION_SECONDS: Secara opsional, runtime maksimum node dalam detik, hingga default tujuh hari. Untuk mempelajari lebih lanjut, lihat Cara kerja mulai fleksibel dengan penyediaan dalam antrean. Anda tidak dapat mengubah nilai ini setelah pembuatan permintaan. Kolom ini tersedia di GKE versi 1.28.5-gke.1355000 atau yang lebih baru.
    • COUNT: Jumlah Pod yang diminta. Node dijadwalkan secara atomik dalam satu zona.
    • POD_TEMPLATE_NAME: Nama PodTemplate.
    • NODEPOOL_NAME: Nama yang Anda pilih untuk node pool. Hapus jika Anda ingin menggunakan node pool yang disediakan secara otomatis.

    GKE dapat menerapkan validasi dan mutasi ke Pod selama pembuatannya. Label cloud.google.com/apply-warden-policies memungkinkan GKE menerapkan validasi dan mutasi yang sama ke objek PodTemplate. Label ini diperlukan agar GKE dapat menghitung persyaratan resource node untuk Pod Anda.

    node auto-provisioning 

    apiVersion: v1
kind: PodTemplate
metadata:
  name: POD_TEMPLATE_NAME
  namespace: NAMESPACE_NAME
  labels:
    cloud.google.com/apply-warden-policies: "true"
template:
  spec:
    nodeSelector:
      cloud.google.com/gke-accelerator: GPU_TYPE
      cloud.google.com/gke-flex-start: "true"
    tolerations:
      - key: "nvidia.com/gpu"
        operator: "Exists"
        effect: "NoSchedule"
    containers:
      - name: pi
        image: perl
        command: ["/bin/sh"]
        resources:
          limits:
            cpu: "700m"
            nvidia.com/gpu: 1
          requests:
            cpu: "700m"
            nvidia.com/gpu: 1
    restartPolicy: Never
---
apiVersion: autoscaling.x-k8s.io/API_VERSION
kind: ProvisioningRequest
metadata:
  name: PROVISIONING_REQUEST_NAME
  namespace: NAMESPACE_NAME
spec:
  provisioningClassName: queued-provisioning.gke.io
  parameters:
    maxRunDurationSeconds: "MAX_RUN_DURATION_SECONDS"
  podSets:
  - count: COUNT
    podTemplateRef:
      name: POD_TEMPLATE_NAME

    Ganti kode berikut:

    • API_VERSION: Versi API, baik v1 maupun v1beta1. Sebaiknya gunakan v1 untuk stabilitas dan akses ke fitur terbaru.
    • NAMESPACE_NAME: Nama namespace Kubernetes Anda. Namespace harus sama dengan namespace Pod.
    • PROVISIONING_REQUEST_NAME: Nama ProvisioningRequest. Anda akan merujuk ke nama ini dalam anotasi Pod.
    • MAX_RUN_DURATION_SECONDS: Opsional, runtime maksimum node dalam detik, hingga default tujuh hari. Untuk mempelajari lebih lanjut, lihat Cara kerja mulai fleksibel dengan penyediaan dalam antrean. Anda tidak dapat mengubah nilai ini setelah pembuatan permintaan. Kolom ini tersedia di GKE versi 1.28.5-gke.1355000 atau yang lebih baru.
    • COUNT: Jumlah Pod yang diminta. Node dijadwalkan secara atomik dalam satu zona.
    • POD_TEMPLATE_NAME: Nama PodTemplate.
    • GPU_TYPE: jenis hardware GPU.

    GKE dapat menerapkan validasi dan mutasi ke Pod selama pembuatannya. Label cloud.google.com/apply-warden-policies memungkinkan GKE menerapkan validasi dan mutasi yang sama ke objek PodTemplate. Label ini diperlukan agar GKE dapat menghitung persyaratan resource node untuk Pod Anda.

  2. Terapkan manifes:

    kubectl apply -f provisioning-request.yaml

Mengonfigurasi Pod

Bagian ini menggunakan Kubernetes Jobs untuk mengonfigurasi Pod. Namun, Anda juga dapat menggunakan JobSet Kubernetes atau framework lain seperti Kubeflow, Ray, atau pengontrol kustom. Dalam spesifikasi Job, tautkan Pod ke ProvisioningRequest menggunakan anotasi berikut:

apiVersion: batch/v1
kind: Job
spec:
  template:
    metadata:
      annotations:
        autoscaling.x-k8s.io/consume-provisioning-request: PROVISIONING_REQUEST_NAME
        autoscaling.x-k8s.io/provisioning-class-name: "queued-provisioning.gke.io"
    spec:
      ...

Kunci anotasi Pod consume-provisioning-request menentukan ProvisioningRequest mana yang akan digunakan. GKE menggunakan anotasi consume-provisioning-request dan provisioning-class-name untuk melakukan hal berikut:

  • Untuk menjadwalkan Pod hanya di node yang disediakan oleh flex-start dengan penyediaan dalam antrean.
  • Untuk menghindari penghitungan ganda permintaan resource antara Pod dan flex-start dengan penyediaan dalam antrean di autoscaler cluster.
  • Untuk memasukkan anotasi safe-to-evict: false, guna mencegah autoscaler cluster memindahkan Pod antar-node dan mengganggu komputasi batch. Anda dapat mengubah perilaku ini dengan menentukan safe-to-evict: true dalam anotasi Pod.

Mengamati status Permintaan Penyediaan

Status Permintaan Penyediaan menentukan apakah Pod dapat dijadwalkan atau tidak. Anda dapat menggunakan watch Kubernetes untuk mengamati perubahan secara efisien atau alat lain yang sudah Anda gunakan untuk melacak status objek Kubernetes. Tabel berikut menjelaskan kemungkinan status permintaan Penyediaan dan setiap kemungkinan hasilnya:

Status Permintaan Penyediaan Deskripsi Kemungkinan hasil
Tertunda Permintaan belum dilihat dan diproses. Setelah diproses, permintaan akan beralih ke status Accepted atau Failed.
Accepted=true Permintaan diterima dan menunggu ketersediaan resource.

Permintaan harus beralih ke status Provisioned, jika resource ditemukan dan node disediakan atau ke status Failed jika hal tersebut tidak memungkinkan.

Secara default, GKE menunggu hingga 14 hari untuk permintaan GPU dan waktu yang tidak ditentukan untuk permintaan TPU. Jika permintaan tidak dipenuhi dalam waktu ini, permintaan akan beralih ke status Failed.
Provisioned=true Node sudah siap. Anda memiliki waktu 10 menit untuk memulai Pod agar dapat menggunakan resource yang disediakan. Setelah waktu ini, autoscaler cluster menganggap node tidak diperlukan dan menghapusnya.
Failed=true Node tidak dapat disediakan karena terjadi error. Failed=true adalah status terminal. Pecahkan masalah kondisi berdasarkan informasi di kolom Reason dan Message kondisi. Buat dan coba lagi permintaan Provisioning Request baru.
Provisioned=false Node belum disediakan.

Jika Reason=NotProvisioned, ini adalah status sementara sebelum semua resource tersedia.

Jika Reason=QuotaExceeded, pecahkan masalah kondisi berdasarkan alasan ini dan informasi di kolom Message kondisi. Anda mungkin perlu meminta lebih banyak kuota. Untuk mengetahui detail selengkapnya, lihat bagian Memeriksa apakah Permintaan Penyediaan dibatasi oleh kuota. Reason ini hanya tersedia dengan GKE versi 1.29.2-gke.1181000 atau yang lebih baru.

Jika Reason=ResourcePoolExhausted, dan Message berisi Expected time is indefinite, pilih zona atau region lain, atau sesuaikan resource yang diminta.

Mulai Pod

Saat permintaan Penyediaan mencapai status Provisioned=true, Anda dapat menjalankan Job untuk memulai Pod. Hal ini menghindari proliferasi Pod yang tidak dapat dijadwalkan untuk permintaan yang tertunda atau gagal, yang dapat memengaruhi performa kube-scheduler dan autoscaler cluster.

Atau, jika Anda tidak mempermasalahkan adanya Pod yang tidak dapat dijadwalkan, Anda dapat membuat Pod secara paralel dengan permintaan Provisioning Request.

Membatalkan permintaan Permintaan Penyediaan

Untuk membatalkan permintaan sebelum disediakan, Anda dapat menghapus ProvisioningRequest:

kubectl delete provreq PROVISIONING_REQUEST_NAME -n NAMESPACE

Dalam sebagian besar kasus, menghapus ProvisioningRequest akan menghentikan pembuatan node. Namun, bergantung pada waktunya, misalnya jika node sudah disediakan, node tersebut mungkin tetap dibuat. Dalam kasus ini, autoscaler cluster akan menghapus node setelah 10 menit jika tidak ada Pod yang dibuat.

Memecahkan masalah kuota

Semua VM yang disediakan oleh permintaan Permintaan Penyediaan menggunakan kuota preemptible.

Jumlah ProvisioningRequests yang berada dalam status Accepted dibatasi oleh kuota khusus. Anda mengonfigurasi kuota untuk setiap project, satu konfigurasi kuota per region.

Memeriksa kuota di konsol Google Cloud

Untuk memeriksa nama batas kuota dan penggunaan saat ini di konsolGoogle Cloud , ikuti langkah-langkah berikut:

  1. Buka halaman Quotas di konsol Google Cloud :

    Buka Quotas

  2. Di kotak Filter, pilih properti Metrik, masukkan active_resize_requests, lalu tekan Enter.

Nilai defaultnya adalah 100. Untuk meningkatkan kuota, ikuti langkah-langkah yang tercantum dalam artikel Meminta penyesuaian kuota.

Memeriksa apakah Permintaan Penyediaan dibatasi oleh kuota

Jika permintaan Penyediaan Anda membutuhkan waktu lebih lama dari yang diperkirakan untuk dipenuhi, periksa apakah permintaan tersebut tidak dibatasi oleh kuota. Anda mungkin perlu meminta lebih banyak kuota.

Untuk cluster yang menjalankan versi 1.29.2-gke.1181000 atau yang lebih baru, periksa apakah batasan kuota tertentu mencegah permintaan Anda dipenuhi:

kubectl describe provreq PROVISIONING_REQUEST_NAME \
    --namespace NAMESPACE

Outputnya mirip dengan yang berikut ini:

…
Last Transition Time:  2024-01-03T13:56:08Z
    Message:               Quota 'NVIDIA_P4_GPUS' exceeded. Limit: 1.0 in region europe-west4.
    Observed Generation:   1
    Reason:                QuotaExceeded
    Status:                False
    Type:                  Provisioned
…

Dalam contoh ini, GKE tidak dapat men-deploy node karena tidak ada cukup kuota di region europe-west4.

Memigrasikan node pool dari penyediaan dalam antrean ke flex-start

Opsi pemakaian flex-start membuat Flex-start VM. Untuk memigrasikan node pool yang ada yang dibuat menggunakan flag --enable-queued-provisioning agar menggunakan flex-start, lakukan langkah-langkah berikut:

  1. Pastikan node pool kosong:

    kubectl get nodes -l cloud.google.com/gke-nodepool=NODEPOOL_NAME

    • Jika perintah tidak menampilkan node apa pun, Anda dapat memperbarui node pool untuk menggunakan VM mulai fleksibel.

    • Jika perintah menampilkan daftar node, Anda harus memigrasikan workload ke node pool lain terlebih dahulu.

  2. Perbarui node pool ke VM Flex-start:

    gcloud container node-pools update NODEPOOL_NAME \
  --cluster=CLUSTER_NAME --flex-start

Operasi ini melakukan hal berikut:

  • Update node pool ke node pool VM Flex-start.
  • Terapkan harga node yang menggunakan Flex-start VM.

Semua node pada cluster yang berjalan di 1.32.2-gke.1652000 atau yang lebih baru, versi minimum untuk node yang menggunakan Flex-start VM, menggunakan upgrade berumur singkat.

Langkah berikutnya