Mempercepat pemuatan data AI/ML dengan Hyperdisk ML

Autopilot Standard

Panduan ini membahas cara menyederhanakan dan mempercepat pemuatan bobot model AI/ML di Google Kubernetes Engine (GKE) menggunakan Hyperdisk ML. Driver CSI Persistent Disk Compute Engine adalah cara utama untuk mengakses Penyimpanan ML Hyperdisk dengan cluster GKE.

Ringkasan

Hyperdisk ML adalah solusi penyimpanan berperforma tinggi yang dapat digunakan untuk menskalakan aplikasi Anda. Layanan ini menyediakan throughput gabungan yang tinggi ke banyak mesin virtual secara bersamaan, sehingga ideal jika Anda ingin menjalankan workload AI/ML yang memerlukan akses ke data dalam jumlah besar.

Jika diaktifkan dalam mode hanya baca banyak, Anda dapat menggunakan Hyperdisk ML untuk mempercepat pemuatan bobot model hingga 11,9X lebih cepat dibandingkan pemuatan langsung dari registry model. Percepatan ini dimungkinkan oleh arsitektur Google Cloud Hyperdisk yang memungkinkan penskalaan hingga 2.500 node serentak pada 1,2 TiB/dtk. Hal ini memungkinkan Anda meningkatkan waktu pemuatan dan mengurangi penyediaan berlebih Pod untuk workload inferensi AI/ML.

Langkah-langkah tingkat tinggi untuk membuat dan menggunakan Hyperdisk ML adalah sebagai berikut:

1. Melakukan pra-cache atau menggabungkan data dalam image disk Persistent Disk: Memuat volume ML Hyperdisk dengan data dari sumber data eksternal (misalnya, bobot Gemma yang dimuat dari Cloud Storage) yang dapat digunakan untuk penayangan. Persistent Disk untuk image disk harus kompatibel dengan Google Cloud Hyperdisk.
2. Buat volume Hyperdisk ML menggunakan Hyperdisk Google Cloud yang sudah ada: Buat volume Kubernetes yang mereferensikan volume Hyperdisk ML yang dimuat dengan data. Jika ingin, Anda dapat membuat class penyimpanan multi-zona untuk memastikan data Anda tersedia di semua zona tempat Pod Anda akan berjalan.
3. Buat Deployment Kubernetes untuk menggunakan volume Hyperdisk ML: Referensikan volume Hyperdisk ML dengan pemuatan data yang dipercepat agar dapat digunakan oleh aplikasi Anda.

Catatan: Saat Anda membuat PersistentVolumeClaim yang terkait dengan StorageClass yang mendukung Hyperdisk ML, GKE otomatis membuat penyimpanan pendukung Hyperdisk ML dasar dan melampirkan penyimpanan tersebut ke sebuah node. Untuk volume yang disediakan secara dinamis, Anda tidak perlu membuat dan melampirkan penyimpanan Hyperdisk ML secara terpisah ke node Anda.

Volume Hyperdisk ML multi-zona

Disk Hyperdisk ML hanya tersedia di satu zona. Secara opsional, Anda dapat menggunakan fitur multi-zona Hyperdisk ML untuk menautkan beberapa disk zonal secara dinamis yang berisi konten yang sama dalam satu PersistentVolumeClaim dan PersistentVolume logis. Disk zona yang dirujuk oleh fitur multi-zona harus berada di region yang sama. Misalnya, jika cluster regional Anda dibuat di us-central1, disk multi-zona harus berada di region yang sama (misalnya, us-central1-a, us-central1-b).

Kasus penggunaan umum untuk inferensi AI/ML adalah menjalankan Pod di seluruh zona untuk meningkatkan ketersediaan akselerator dan efisiensi biaya dengan Spot VM. Karena Hyperdisk ML bersifat zonal, jika server inferensi Anda menjalankan banyak Pod di seluruh zona, GKE akan otomatis meng-clone disk di seluruh zona untuk memastikan data Anda mengikuti aplikasi Anda.

Volume Hyperdisk ML multi-zona memiliki batasan berikut:

• Operasi pengubahan ukuran volume dan snapshot volume tidak didukung.
• Volume Hyperdisk ML multi-zona hanya didukung dalam mode hanya baca.
• Saat menggunakan disk yang sudah ada dengan volume ML Hyperdisk multi-zona, GKE tidak melakukan pemeriksaan untuk memvalidasi bahwa konten disk di seluruh zona sama. Jika ada disk yang berisi konten yang berbeda, pastikan aplikasi Anda mempertimbangkan potensi inkonsistensi antar-zona.

Untuk mempelajari lebih lanjut, lihat Membuat volume Hyperdisk ML ReadOnlyMany multi-zona dari VolumeSnapshot.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

• Aktifkan Google Kubernetes Engine API.
Aktifkan Google Kubernetes Engine API
• Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

• Tetapkan region dan zona default ke salah satu nilai yang didukung.
• Pastikan Google Cloud project Anda memiliki kuota yang cukup untuk membuat node yang diperlukan dalam panduan ini. Contoh kode untuk pembuatan cluster GKE dan resource Kubernetes memerlukan kuota minimum berikut di region pilihan Anda: 88 CPU C3, 8 GPU NVIDIA L4.

Persyaratan

Untuk menggunakan volume Hyperdisk ML di GKE, cluster Anda harus memenuhi persyaratan berikut:

• Gunakan cluster Linux yang menjalankan GKE versi 1.30.2-gke.1394000 atau yang lebih baru. Jika Anda menggunakan saluran rilis, pastikan saluran tersebut memiliki versi GKE minimum atau yang lebih baru yang diperlukan untuk driver ini.
• Pastikan driver CSI Persistent Disk Compute Engine diaktifkan. Driver Persistent Disk Compute Engine diaktifkan secara default pada cluster Autopilot dan Standard baru dan tidak dapat dinonaktifkan atau diedit saat menggunakan Autopilot. Jika Anda perlu mengaktifkan driver CSI Persistent Disk Compute Engine dari cluster, lihat artikel Mengaktifkan Driver CSI Persistent Disk Compute Engine di cluster yang ada.
• Jika Anda ingin menyesuaikan nilai baca-depan, gunakan GKE versi 1.29.2-gke.1217000 atau yang lebih baru.
• Jika Anda ingin menggunakan fitur yang disediakan secara dinamis multi-zona, gunakan GKE versi 1.30.2-gke.1394000 atau yang lebih baru.
• Hyperdisk ML hanya didukung pada jenis node dan zona tertentu. Untuk mempelajari lebih lanjut, lihat Tentang Hyperdisk ML dalam dokumentasi Compute Engine.

Mendapatkan akses ke model

Untuk mendapatkan akses ke model Gemma untuk deployment ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu, lalu membuat token akses Hugging Face.

Menandatangani perjanjian izin lisensi

Anda harus menandatangani perjanjian izin untuk menggunakan Gemma. Ikuti petunjuk berikut:

1. Akses halaman izin model di Kaggle.com.
2. Verifikasi izin menggunakan akun Hugging Face Anda.
3. Setujui persyaratan model.

Membuat token akses

Untuk mengakses model melalui Hugging Face, Anda memerlukan token Hugging Face.

Ikuti langkah-langkah berikut untuk membuat token baru jika Anda belum memilikinya:

1. Klik Profil Anda > Setelan > Token Akses.
2. Pilih New Token.
3. Tentukan Nama pilihan Anda dan Peran minimal Read.
4. Pilih Generate a token.
5. Salin token yang dihasilkan ke papan klip Anda.

Membuat cluster GKE

Anda dapat menayangkan LLM di GPU dalam cluster GKE Autopilot atau Standard. Sebaiknya gunakan cluster Autopilot untuk mendapatkan pengalaman Kubernetes yang terkelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai untuk workload Anda, lihat Memilih mode operasi GKE.

Autopilot

1. Jalankan perintah berikut di Cloud Shell:

   gcloud container clusters create-auto hdml-gpu-l4 \
     --project=PROJECT \
     --location=CONTROL_PLANE_LOCATION \
     --release-channel=rapid \
     --cluster-version=1.30.2-gke.1394000
   

   Ganti nilai berikut:

   • PROJECT: Google Cloud project ID.
   • CONTROL_PLANE_LOCATION: region Compute Engine dari bidang kontrol cluster Anda. Berikan region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-east4 untuk GPU L4.

   GKE membuat cluster Autopilot dengan node CPU dan GPU seperti yang diminta oleh beban kerja yang di-deploy.

2. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

   gcloud container clusters get-credentials hdml-gpu-l4 \
     --location=CONTROL_PLANE_LOCATION
   

Standar

1. Di Cloud Shell, jalankan perintah berikut untuk membuat cluster Standard dan node pool:

   gcloud container clusters create hdml-gpu-l4 \
       --location=CONTROL_PLANE_LOCATION \
       --num-nodes=1 \
       --machine-type=c3-standard-44 \
       --release-channel=rapid \
       --cluster-version=CLUSTER_VERSION \
       --node-locations=ZONES \
       --project=PROJECT
   
   gcloud container node-pools create gpupool \
       --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
       --location=CONTROL_PLANE_LOCATION \
       --project=PROJECT \
       --node-locations=ZONES \
       --cluster=hdml-gpu-l4 \
       --machine-type=g2-standard-24 \
       --num-nodes=2
   

   Ganti nilai berikut:

   • CLUSTER_VERSION: versi cluster GKE Anda (misalnya, 1.30.2-gke.1394000).
   • CONTROL_PLANE_LOCATION: lokasi Compute Engine bidang kontrol cluster Anda. Untuk cluster regional, berikan region dengan zona yang mendukung akselerator yang ingin Anda gunakan. Untuk cluster zona, berikan zona yang mendukung akselerator yang ingin Anda gunakan. Untuk memeriksa ketersediaan akselerator tertentu, lihat Ketersediaan GPU menurut region dan zona.
   • ZONES: zona tempat node dibuat. Anda dapat menentukan zona sebanyak yang diperlukan untuk cluster Anda. Semua zona harus berada di region yang sama dengan bidang kontrol cluster, yang ditentukan oleh flag --location. Untuk cluster zona, --node-locations harus berisi zona utama cluster.
   • PROJECT: Google Cloud project ID.

   Pembuatan cluster mungkin memerlukan waktu beberapa menit.

2. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

   gcloud container clusters get-credentials hdml-gpu-l4
   

Melakukan pra-cache data ke image disk Persistent Disk

Untuk menggunakan Hyperdisk ML, Anda melakukan pra-peng-cache-an data dalam image disk, dan membuat volume Hyperdisk ML untuk akses baca oleh beban kerja Anda di GKE. Pendekatan ini (juga disebut penyediaan data) memastikan bahwa data Anda tersedia saat workload Anda membutuhkannya.

Langkah-langkah berikut menjelaskan cara menyalin data secara manual dari sumber, seperti repositori Hugging Face, langsung ke volume Hyperdisk ML menggunakan Job Kubernetes.

Jika data Anda sudah ada di bucket Cloud Storage, Anda dapat menggunakan Hyperdisk ML untuk mengotomatiskan transfer data dari Cloud Storage ke Hyperdisk ML. Dengan begitu, Anda tidak perlu melakukan langkah-langkah pembuatan Job secara manual yang dijelaskan di bagian berikut.

Membuat StorageClass yang mendukung Hyperdisk ML

1. Simpan manifes StorageClass berikut dalam file bernama hyperdisk-ml.yaml.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
       name: hyperdisk-ml
   parameters:
       type: hyperdisk-ml
       provisioned-throughput-on-create: "2400Mi"
   provisioner: pd.csi.storage.gke.io
   allowVolumeExpansion: false
   reclaimPolicy: Delete
   volumeBindingMode: WaitForFirstConsumer
   mountOptions:
     - read_ahead_kb=4096
   

   Tips: Jika Anda ingin menyesuaikan nilai baca-lebih-dulu, tambahkan parameter read_ahead_kb ke kolom mountOptions.

2. Buat StorageClass dengan menjalankan perintah ini:

   kubectl create -f hyperdisk-ml.yaml
   

Membuat PersistentVolumeClaim ReadWriteOnce (RWO)

1. Simpan manifes PersistentVolumeClaim berikut dalam file bernama producer-pvc.yaml. Anda akan menggunakan StorageClass yang Anda buat sebelumnya. PVC ini menggunakan mode akses ReadWriteOnce karena digunakan oleh Job Kubernetes untuk mendownload data model ke disk persisten, yang memerlukan akses tulis. Mode akses ReadWriteMany tidak didukung oleh Google Cloud Hyperdisk. Pastikan disk Anda memiliki kapasitas yang cukup untuk menyimpan data Anda.

   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata:
     name: producer-pvc
   spec:
     storageClassName: hyperdisk-ml
     accessModes:
     - ReadWriteOnce
     resources:
       requests:
         storage: 300Gi
   

2. Buat PersistentVolumeClaim dengan menjalankan perintah ini:

   kubectl create -f producer-pvc.yaml
   

Buat Tugas Kubernetes untuk mengisi volume Google Cloud Hyperdisk yang di-mount

Bagian ini menunjukkan contoh pembuatan Job Kubernetes yang menyediakan disk dan mendownload model yang disesuaikan untuk perintah Gemma 7B dari Hugging Face ke volume Google Cloud Hyperdisk yang di-mount.

1. Untuk mengakses LLM Gemma yang digunakan dalam contoh di panduan ini, buat Secret Kubernetes yang berisi token Hugging Face:

   kubectl create secret generic hf-secret \
       --from-literal=hf_api_token=HF_TOKEN\
       --dry-run=client -o yaml | kubectl apply -f -
   

   Ganti HF_TOKEN dengan token Hugging Face yang Anda buat sebelumnya.

2. Simpan contoh manifes berikut sebagai producer-job.yaml:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: producer-job
   spec:
     template:
       spec:
         affinity:
           # Node affinity ensures that Pods are scheduled on the nodes that support Hyperdisk ML.
           nodeAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
               nodeSelectorTerms:
               - matchExpressions:
                 # Specifies the Performance compute class. For more information,
                 # see https://cloud.google.com/kubernetes-engine/docs/concepts/autopilot-compute-classes#when-to-use.
                 - key: cloud.google.com/compute-class
                   operator: In
                   values:
                   - "Performance"
               - matchExpressions:
                 - key: cloud.google.com/machine-family
                   operator: In
                   values:
                   - "c3"
               - matchExpressions:
                 # Restricts Pod scheduling to a specific zone because Hyperdisk ML disks
                 # are a zonal resource.
                 - key: topology.kubernetes.io/zone
                   operator: In
                   values:
                   - "ZONE"
         containers:
         - name: copy
           resources:
             requests:
               cpu: "32"
             limits:
               cpu: "32"
            # The image used to download models from Hugging Face.
           image: huggingface/downloader:0.17.3
           command: [ "huggingface-cli" ]
           args:
           - download
           # The Hugging Face model to download.
           - google/gemma-1.1-7b-it
           # Destination directory within the container.
           - --local-dir=/data/gemma-7b
           - --local-dir-use-symlinks=False
           env:
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: hf-secret
                 key: hf_api_token
           volumeMounts:
             # Mount path for the PersistentVolume.
             - mountPath: "/data"
               name: volume
         # Prevents Pod restarts on scheduling failures. The Job will create new Pods
         # for retries, up to the specified "backoffLimit".
         restartPolicy: Never
         volumes:
           - name: volume
             persistentVolumeClaim:
               # References the Hyperdisk ML PVC created earlier.
               claimName: producer-pvc
     # Runs only one Pod at any given time.
     parallelism: 1
     # After the Pod runs successfully, the Job is complete.
     completions: 1
     # Max retries on Pod failure.
     backoffLimit: 4
   

   Ganti ZONE dengan zona komputasi tempat Anda ingin membuat Hyperdisk. Jika Anda menggunakannya dengan contoh Deployment, pastikan zona tersebut memiliki kapasitas mesin G2.

3. Buat Job dengan menjalankan perintah ini:

   kubectl apply -f producer-job.yaml
   

   Mungkin perlu waktu beberapa menit hingga Tugas selesai menyalin data ke volume Persistent Disk. Setelah Tugas selesai melakukan penyediaan, statusnya akan ditandai "Selesai".

4. Untuk memeriksa progres status Job Anda, jalankan perintah berikut:

   kubectl get job producer-job
   

5. Setelah Tugas selesai, Anda dapat membersihkan Tugas dengan menjalankan perintah ini:

   kubectl delete job producer-job
   

Membuat volume Hyperdisk ML ReadOnlyMany dari Hyperdisk Google Cloud yang sudah ada

Bagian ini mencakup langkah-langkah untuk membuat pasangan PersistentVolume dan PersistentVolumeClaim ReadOnlyMany (ROM) dari volume Hyperdisk Google Cloud yang sudah ada. Untuk mempelajari lebih lanjut, lihat Menggunakan persistent disk yang sudah ada sebagai PersistentVolumes.

1. Di GKE versi 1.30.2-gke.1394000 dan yang lebih baru, GKE secara otomatis mengonversi mode akses volume READ_WRITE_SINGLE Google Cloud Hyperdisk menjadi READ_ONLY_MANY.

   Jika Anda menggunakan volume Google Cloud Hyperdisk yang sudah ada sebelumnya di GKE versi sebelumnya, Anda harus mengubah mode akses secara manual dengan menjalankan perintah berikut:

   gcloud compute disks update HDML_DISK_NAME \
       --zone=ZONE \
       --access-mode=READ_ONLY_MANY
   

   Ganti nilai berikut:

   • HDML_DISK_NAME: nama volume Hyperdisk ML Anda.
   • ZONE: zona komputasi tempat volume Hyperdisk Google Cloud yang sudah ada dibuat.

2. Buat pasangan PersistentVolume dan PersistentVolumeClaim, dengan merujuk ke disk yang sebelumnya Anda isi.

   1. Simpan manifes berikut sebagai hdml-static-pv.yaml:

      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: hdml-static-pv
      spec:
        storageClassName: "hyperdisk-ml"
        capacity:
          storage: 300Gi
        # The "ReadOnlyMany" access mode allows the volume to be mounted by multiple
        # nodes for read-only access.
        accessModes:
          - ReadOnlyMany
        # ClaimRef links this PersistentVolume to a PersistentVolumeClaim.
        claimRef:
          namespace: default
          name: hdml-static-pvc
        csi:
          driver: pd.csi.storage.gke.io
          # The unique identifier of the Compute Engine disk resource backing
          # this volume.
          volumeHandle: projects/PROJECT/zones/ZONE/disks/DISK_NAME
          fsType: ext4
          readOnly: true
        # Node affinity ensures that Pod is scheduled in a zone where the volume
        # is replicated.
        nodeAffinity:
          required:
            nodeSelectorTerms:
            - matchExpressions:
              - key: topology.gke.io/zone
                operator: In
                values:
                - ZONE
      ---
      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        namespace: default
        name: hdml-static-pvc
      spec:
        storageClassName: "hyperdisk-ml"
        volumeName: hdml-static-pv
        accessModes:
        - ReadOnlyMany
        resources:
          requests:
            storage: 300Gi
      

      Ganti nilai berikut:

      • PROJECT: project tempat cluster GKE Anda dibuat.
      • ZONE: zona tempat volume Hyperdisk Google Cloud yang sudah ada dibuat.
      • DISK_NAME: nama volume Google Cloud Hyperdisk yang sudah ada.

   2. Buat resource PersistentVolume dan PersistentVolumeClaim dengan menjalankan perintah ini:

      kubectl apply -f hdml-static-pv.yaml
      

Membuat volume Hyperdisk ML ReadOnlyMany multi-zona dari VolumeSnapshot

Bagian ini membahas langkah-langkah untuk membuat volume ML Hyperdisk multi-zona dalam mode akses ReadOnlyMany. Anda menggunakan VolumeSnapshot untuk image disk Persistent Disk yang sudah ada. Untuk mempelajari lebih lanjut, lihat Mencadangkan penyimpanan Persistent Disk menggunakan snapshot volume.

Untuk membuat volume Hyperdisk ML multi-zona, ikuti langkah-langkah berikut:

Buat VolumeSnapshot disk Anda

1. Simpan manifes berikut sebagai file bernama disk-image-vsc.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: disk-image-vsc
   driver: pd.csi.storage.gke.io
   # The snapshot will be deleted when the "VolumeSnapshot" object is deleted.
   deletionPolicy: Delete
   parameters:
     snapshot-type: images
   

2. Buat VolumeSnapshotClass dengan menjalankan perintah berikut:

   kubectl apply -f disk-image-vsc.yaml
   

3. Simpan manifes berikut sebagai file bernama my-snapshot.yaml. Anda akan merujuk PersistentVolumeClaim yang Anda buat sebelumnya di Membuat PersistentVolumeClaim ReadWriteOnce (RWO).

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: my-snapshot
   spec:
     volumeSnapshotClassName: disk-image-vsc
     source:
       # The name of the PersistentVolumeClaim to snapshot.
       persistentVolumeClaimName: producer-pvc
   

4. Buat VolumeSnapshot dengan menjalankan perintah berikut:

   kubectl apply -f my-snapshot.yaml
   

5. Setelah VolumeSnapshot ditandai "Siap", jalankan perintah berikut untuk membuat volume Hyperdisk ML:

   kubectl wait --for=jsonpath='{.status.readyToUse}'=true \
       --timeout=300s volumesnapshot my-snapshot
   

Membuat StorageClass multi-zona

Jika Anda ingin salinan data Anda dapat diakses di lebih dari satu zona, tentukan parameter enable-multi-zone-provisioning di StorageClass Anda, yang membuat disk di zona yang Anda tentukan di kolom allowedTopologies.

Untuk membuat StorageClass, ikuti langkah-langkah berikut:

1. Simpan manifes berikut sebagai file bernama hyperdisk-ml-multi-zone.yaml.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: hyperdisk-ml-multi-zone
   parameters:
     type: hyperdisk-ml
     provisioned-throughput-on-create: "4800Mi"
     enable-multi-zone-provisioning: "true"
   provisioner: pd.csi.storage.gke.io
   allowVolumeExpansion: false
   reclaimPolicy: Delete
   volumeBindingMode: Immediate
   allowedTopologies:
   - matchLabelExpressions:
     - key: topology.gke.io/zone
       values:
       - ZONE_1
       - ZONE_2
   mountOptions:
     - read_ahead_kb=8192
   

   Ganti ZONE_1, ZONE_2, ..., ZONE_N dengan zona tempat penyimpanan Anda dapat diakses.

   Contoh ini menetapkan volumeBindingMode ke Immediate, sehingga GKE dapat menyediakan PersistentVolumeClaim sebelum konsumen mana pun mereferensikannya.

2. Buat StorageClass dengan menjalankan perintah berikut:

   kubectl apply -f hyperdisk-ml-multi-zone.yaml
   

Buat PersistentVolumeClaim yang menggunakan StorageClass multi-zona

Langkah selanjutnya adalah membuat PersistentVolumeClaim yang mereferensikan StorageClass.

GKE menggunakan konten image disk yang ditentukan untuk otomatis menyediakan volume ML Hyperdisk di setiap zona yang ditentukan dalam snapshot Anda.

Untuk membuat PersistentVolumeClaim, ikuti langkah-langkah berikut:

1. Simpan manifes berikut sebagai file bernama hdml-consumer-pvc.yaml.

   kind: PersistentVolumeClaim
   apiVersion: v1
   metadata:
     name: hdml-consumer-pvc
   spec:
     # Specifies that the new PersistentVolumeClaim should be provisioned from the
     # contents of the volume snapshot named "my-snapshot".
     dataSource:
       name: my-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     accessModes:
     - ReadOnlyMany
     storageClassName: hyperdisk-ml-multi-zone
     resources:
       requests:
         storage: 300Gi
   

2. Buat PersistentVolumeClaim dengan menjalankan perintah berikut:

   kubectl apply -f hdml-consumer-pvc.yaml
   

Membuat Deployment untuk menggunakan volume Hyperdisk ML

Saat menggunakan Pod dengan PersistentVolumes, sebaiknya gunakan pengontrol workload (seperti Deployment atau StatefulSet).

Jika Anda ingin menggunakan PersistentVolume yang sudah ada dalam mode ReadOnlyMany dengan Deployment, lihat Menggunakan persistent disk dengan banyak pembaca.

Untuk membuat dan menguji Deployment, ikuti langkah-langkah berikut:

1. Simpan contoh manifes berikut sebagai vllm-gemma-deployment.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: vllm-gemma-deployment
   spec:
     replicas: 2
     selector:
       # Labels used to select the Pods managed by this Deployment.
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           # Labels for AI/GKE integration.
           ai.gke.io/model: gemma-7b
           ai.gke.io/inference-server: vllm
       spec:
         affinity:
           # Node affinity ensures Pods run on nodes with L4 GPUs.
           nodeAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
               nodeSelectorTerms:
               - matchExpressions:
                 - key: cloud.google.com/gke-accelerator
                   operator: In
                   values:
                   - nvidia-l4
           # Pod anti-affinity prefers scheduling Pods in different zones for
           # higher availability.
           podAntiAffinity:
             preferredDuringSchedulingIgnoredDuringExecution:
             - weight: 100
               podAffinityTerm:
                 labelSelector:
                   matchExpressions:
                   - key: app
                     operator: In
                     values:
                     - gemma-server
                 topologyKey: topology.kubernetes.io/zone
         containers:
         - name: inference-server
           # The container image for the vLLM inference server.
           image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:latest
           resources:
             requests:
               cpu: "2"
               memory: "25Gi"
               ephemeral-storage: "25Gi"
               nvidia.com/gpu: 2
             limits:
               cpu: "2"
               memory: "25Gi"
               ephemeral-storage: "25Gi"
               nvidia.com/gpu: 2
           # Command to run the vLLM API server.
           command: ["python3", "-m", "vllm.entrypoints.api_server"]
           args:
           # Specifies the model to load, using an environment variable.
           - --model=$(MODEL_ID)
           - --tensor-parallel-size=2
           env:
           # Environment variable to define the model path.
           - name: MODEL_ID
             value: /models/gemma-7b
           volumeMounts:
           - mountPath: /dev/shm
             name: dshm
           # Mount point for the Hyperdisk ML volume containing the model.
           - mountPath: /models
             name: gemma-7b
         volumes:
         - name: dshm
           emptyDir:
               medium: Memory
         - name: gemma-7b
           # References the PersistentVolumeClaim for the Hyperdisk ML volume.
           persistentVolumeClaim:
             claimName: CLAIM_NAME
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     # Selects Pods with the label "app: gemma-server".
     selector:
       app: gemma-server
     # The "ClusterIP" field makes the Service reachable only within the cluster.
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 8000
         targetPort: 8000
   

   Ganti CLAIM_NAME dengan salah satu nilai berikut:

   • hdml-static-pvc: jika Anda menggunakan volume Hyperdisk ML dari Google Cloud Hyperdisk yang ada.
   • hdml-consumer-pvc: jika Anda menggunakan volume Hyperdisk ML dari image disk VolumeSnapshot.

2. Jalankan perintah berikut untuk menunggu server inferensi tersedia:

   kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment
   

3. Untuk menguji apakah server vLLM Anda sudah aktif dan berjalan, ikuti langkah-langkah berikut:

   1. Jalankan perintah berikut untuk menyiapkan penerusan port ke model:

      kubectl port-forward service/llm-service 8000:8000
      

   2. Jalankan perintah curl untuk mengirim permintaan ke model:

      USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"
      
      curl -X POST http://localhost:8000/generate \
      -H "Content-Type: application/json" \
      -d @- <<EOF
      {
          "prompt": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
          "temperature": 0.90,
          "top_p": 1.0,
          "max_tokens": 128
      }
      EOF
      

   Output berikut menunjukkan contoh respons model:

   {"predictions":["Prompt:\n<start_of_turn>user\nI'm new to coding. If you could only recommend one programming language to start with, what would it be and why?<end_of_turn>\nOutput:\nPython is often recommended for beginners due to its clear, readable syntax, simple data types, and extensive libraries.\n\n**Reasons why Python is a great language for beginners:**\n\n* **Easy to read:** Python's syntax is straightforward and uses natural language conventions, making it easier for beginners to understand the code.\n* **Simple data types:** Python has basic data types like integers, strings, and lists that are easy to grasp and manipulate.\n* **Extensive libraries:** Python has a vast collection of well-documented libraries covering various tasks, allowing beginners to build projects without reinventing the wheel.\n* **Large supportive community:**"]}
   

Menyesuaikan nilai readahead

Jika Anda memiliki workload yang melakukan I/O berurutan, workload tersebut mungkin akan mendapatkan manfaat dari penyesuaian nilai baca-tuntas. Hal ini biasanya berlaku untuk workload inferensi atau pelatihan yang perlu memuat bobot model AI/ML ke dalam memori. Sebagian besar beban kerja dengan I/O berurutan biasanya melihat peningkatan performa dengan nilai baca-lebih-dahulu sebesar 1024 KB atau lebih tinggi.

Menyesuaikan nilai readahead untuk volume baru

Anda dapat menentukan opsi ini dengan menambahkan read_ahead_kb ke kolom mountOptions di StorageClass Anda. Contoh berikut menunjukkan cara menyesuaikan nilai baca-lebih-dahulu menjadi 4096 KB. Tindakan ini akan berlaku untuk PersistentVolume yang baru disediakan secara dinamis yang dibuat menggunakan hyperdisk-ml StorageClass.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
    name: hyperdisk-ml
parameters:
    type: hyperdisk-ml
provisioner: pd.csi.storage.gke.io
allowVolumeExpansion: false
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
mountOptions:
  - read_ahead_kb=4096

Catatan: mountOptions StorageClass disalin ke PersistentVolume saat dibuat. Untuk menerapkan opsi pemasangan ke PersistentVolume yang ada, Anda harus menghapus dan membuat ulang PersistentVolume, atau mengubah kolom mountOptions PersistentVolume secara langsung.

Menyesuaikan nilai readahead untuk volume yang ada

Untuk volume yang disediakan secara statis, atau PersistentVolume yang sudah ada, Anda dapat menentukan opsi ini dengan menambahkan read_ahead_kb ke kolom spec.mountOptions. Contoh berikut menunjukkan cara menyesuaikan nilai baca-lebih-dahulu menjadi 4096 KB.

apiVersion: v1
kind: PersistentVolume
  name: DISK_NAME
spec:
  accessModes:
  - ReadOnlyMany
  capacity:
    storage: 300Gi
  csi:
    driver: pd.csi.storage.gke.io
    fsType: ext4
    readOnly: true
    # The unique identifier of the Compute Engine disk resource backing this volume.
    volumeHandle: projects/PROJECT/zones/ZONE/disks/DISK_NAME
  # Node affinity ensures that Pods are scheduled in the zone where the volume exists.
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: topology.gke.io/zone
          operator: In
          values:
          - ZONE
  storageClassName: hyperdisk-ml
  mountOptions:
  - read_ahead_kb=4096

Catatan: mountOptions hanya diterapkan pada saat pemasangan volume, setelah Pod terikat ke node. Untuk menerapkan opsi pemasangan ke workload yang sudah berjalan, Anda harus menghapus dan membuat ulang semua pod konsumen.

Ganti nilai berikut:

• DISK_NAME: nama volume Google Cloud Hyperdisk yang sudah ada.
• ZONE: zona tempat volume Hyperdisk Google Cloud yang sudah ada dibuat.

Menguji dan menetapkan tolok ukur performa volume Hyperdisk ML

Bagian ini menunjukkan cara menggunakan Flexible I/O Tester (FIO) untuk mengukur performa volume ML Hyperdisk Anda untuk membaca data yang sudah ada . Anda dapat menggunakan metrik ini untuk mengevaluasi performa volume untuk workload dan konfigurasi tertentu.

1. Simpan contoh manifes berikut sebagai benchmark-job.yaml:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: benchmark-job
   spec:
     template:  # Template for the Pods the Job will create.
       spec:
         affinity:
           nodeAffinity:
             requiredDuringSchedulingIgnoredDuringExecution:
               nodeSelectorTerms:
               - matchExpressions:
                 - key: cloud.google.com/compute-class
                   operator: In
                   values:
                   - "Performance"
               - matchExpressions:
                 - key: cloud.google.com/machine-family
                   operator: In
                   values:
                   - "c3"
   
         containers:
         - name: fio
           resources:
             requests:
               cpu: "32"
           image: litmuschaos/fio
           args:
           - fio
           # Specifies the files to use for the benchmark. Multiple files can be separated by colons.
           - --filename
           - /models/gemma-7b/model-00001-of-00004.safetensors:/models/gemma-7b/model-00002-of-00004.safetensors:/models/gemma-7b/model-00003-of-00004.safetensors:/models/gemma-7b/model-00004-of-00004.safetensors:/models/gemma-7b/model-00004-of-00004.safetensors
           # Use non-buffered I/O.
           - --direct=1
           # Set the I/O pattern to read.
           - --rw=read
           # Open files in read-only mode.
           - --readonly
           # Block size for I/O operations.
           - --bs=4096k
           # I/O engine to use.
           - --ioengine=libaio
           # Number of I/O units to keep in flight against each file.
           - --iodepth=8
           # Duration of the test in seconds.
           - --runtime=60
           # Number of jobs to run.
           - --numjobs=1
           # Name of the job.
           - --name=read_benchmark
           volumeMounts:
           - mountPath: "/models"
             name: volume
         restartPolicy: Never
         volumes:
         - name: volume
           persistentVolumeClaim:
             claimName: hdml-static-pvc
     parallelism: 1
     completions: 1
     backoffLimit: 1
   

   Ganti CLAIM_NAME dengan nama PersistentVolumeClaim Anda (misalnya, hdml-static-pvc).

2. Buat Tugas dengan menjalankan perintah berikut:

   kubectl apply -f benchmark-job.yaml.
   

3. Gunakan log kubectl untuk melihat output alat fio:

   kubectl logs benchmark-job-nrk88 -f
   

   Outputnya terlihat mirip dengan yang berikut ini:

   read_benchmark: (g=0): rw=read, bs=4M-4M/4M-4M/4M-4M, ioengine=libaio, iodepth=8
   fio-2.2.10
   Starting 1 process
   
   read_benchmark: (groupid=0, jobs=1): err= 0: pid=32: Fri Jul 12 21:29:32 2024
   read : io=18300MB, bw=2407.3MB/s, iops=601, runt=  7602msec
       slat (usec): min=86, max=1614, avg=111.17, stdev=64.46
       clat (msec): min=2, max=33, avg=13.17, stdev= 1.08
       lat (msec): min=2, max=33, avg=13.28, stdev= 1.06
       clat percentiles (usec):
       |  1.00th=[11072],  5.00th=[12352], 10.00th=[12608], 20.00th=[12736],
       | 30.00th=[12992], 40.00th=[13120], 50.00th=[13248], 60.00th=[13376],
       | 70.00th=[13504], 80.00th=[13632], 90.00th=[13888], 95.00th=[14016],
       | 99.00th=[14400], 99.50th=[15296], 99.90th=[22144], 99.95th=[25728],
       | 99.99th=[33024]
       bw (MB  /s): min= 2395, max= 2514, per=100.00%, avg=2409.79, stdev=29.34
       lat (msec) : 4=0.39%, 10=0.31%, 20=99.15%, 50=0.15%
   cpu          : usr=0.28%, sys=8.08%, ctx=4555, majf=0, minf=8203
   IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=99.8%, 16=0.0%, 32=0.0%, >=64=0.0%
       submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
       complete  : 0=0.0%, 4=100.0%, 8=0.1%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
       issued    : total=r=4575/w=0/d=0, short=r=0/w=0/d=0, drop=r=0/w=0/d=0
       latency   : target=0, window=0, percentile=100.00%, depth=8
   
   Run status group 0 (all jobs):
   READ: io=18300MB, aggrb=2407.3MB/s, minb=2407.3MB/s, maxb=2407.3MB/s, mint=7602msec, maxt=7602msec
   
   Disk stats (read/write):
   nvme0n2: ios=71239/0, merge=0/0, ticks=868737/0, in_queue=868737, util=98.72%
   

Memantau throughput atau IOPS pada volume Hyperdisk ML

Untuk memantau performa yang disediakan untuk volume Hyperdisk ML Anda, lihat Menganalisis IOPS dan throughput yang disediakan dalam dokumentasi Compute Engine.

Untuk memperbarui throughput atau IOPS yang disediakan untuk volume Hyperdisk ML yang ada, atau untuk mempelajari parameter Google Cloud Hyperdisk tambahan yang dapat Anda tentukan di StorageClass, lihat Menskalakan performa penyimpanan menggunakan Google Cloud Hyperdisk.

Pemecahan masalah

Bagian ini berisi panduan pemecahan masalah untuk menyelesaikan masalah volume ML Hyperdisk di GKE.

Mode akses disk tidak dapat diperbarui

Error berikut terjadi saat volume ML Hyperdisk sudah digunakan dan dilampirkan oleh node dalam mode akses ReadWriteOnce.

AttachVolume.Attach failed for volume ... Failed to update access mode:
failed to set access mode for zonal volume ...
'Access mode cannot be updated when the disk is attached to instance(s).'., invalidResourceUsage

GKE otomatis memperbarui accessMode volume Hyperdisk ML dari READ_WRITE_SINGLE ke READ_ONLY_MANY, saat digunakan oleh PersistentVolume mode akses ReadOnlyMany. Update ini dilakukan saat disk terpasang ke node baru.

Untuk mengatasi masalah ini, hapus semua Pod yang mereferensikan disk menggunakan PersistentVolume dalam mode ReadWriteOnce. Tunggu hingga disk dilepas, lalu buat ulang beban kerja yang menggunakan PersistentVolume dalam mode ReadOnlyMany.

Disk tidak dapat dilampirkan dengan mode READ_WRITE

Error berikut menunjukkan bahwa GKE mencoba melampirkan volume Hyperdisk ML dalam mode akses READ_ONLY_MANY ke node GKE menggunakan mode akses ReadWriteOnce.

AttachVolume.Attach failed for volume ...
Failed to Attach: failed cloud service attach disk call ...
The disk cannot be attached with READ_WRITE mode., badRequest

GKE otomatis memperbarui accessMode volume Hyperdisk ML dari READ_WRITE_SINGLE ke READ_ONLY_MANY, saat digunakan oleh PersistentVolume mode akses ReadOnlyMany. Namun, GKE tidak akan memperbarui mode akses secara otomatis dari READ_ONLY_MANY ke READ_WRITE_SINGLE. Ini adalah mekanisme keamanan untuk memastikan bahwa disk multi-zona tidak ditulis secara tidak sengaja, karena hal ini dapat menyebabkan konten yang berbeda di antara disk multi-zona.

Untuk mengatasi masalah ini, sebaiknya ikuti alur kerja Data pra-cache ke image disk Persistent Disk jika Anda memerlukan konten yang diperbarui. Jika Anda memerlukan kontrol yang lebih besar atas mode akses dan setelan lainnya untuk volume Hyperdisk ML, lihat Mengubah setelan untuk volume Hyperdisk. Google Cloud

Kuota terlampaui - Kuota throughput tidak mencukupi

Error berikut menunjukkan bahwa kuota throughput Hyperdisk ML tidak mencukupi pada saat penyediaan disk.

failed to provision volume with StorageClass ... failed (QUOTA_EXCEEDED): Quota 'HDML_TOTAL_THROUGHPUT' exceeded

Untuk mengatasi masalah ini, lihat Kuota Disk untuk mempelajari lebih lanjut kuota Hyperdisk dan cara meningkatkan kuota disk di project Anda.

Untuk panduan pemecahan masalah tambahan, lihat Menskalakan performa penyimpanan dengan Google Cloud Hyperdisk.

Langkah berikutnya

• Pelajari cara mengotomatiskan transfer data dari Cloud Storage ke volume Hyperdisk menggunakan GKE Volume Populator.
• Pelajari cara memigrasikan volume Persistent Disk ke Hyperdisk.
• Baca selengkapnya tentang driver CSI Persistent Disk di GitHub.