Mempercepat pemuatan data AI/ML dengan Hyperdisk ML

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

Ringkasan

Hyperdisk ML adalah solusi penyimpanan berperforma tinggi yang dapat digunakan untuk mengembangkan skala aplikasi Anda. Layanan ini memberikan throughput agregat yang tinggi untuk banyak virtual machine secara serentak, sehingga ideal jika Anda ingin menjalankan AI/ML yang membutuhkan akses ke data dalam jumlah besar.

Jika diaktifkan dalam mode hanya baca, Anda dapat menggunakan Hyperdisk ML untuk pemuatan bobot model hingga 11,9X relatif terhadap pemuatan langsung dari registry model. Akselerasi ini dimungkinkan oleh Google Cloud Hyperdisk arsitektur yang memungkinkan penskalaan menjadi 2.500 node serentak dengan kecepatan 1,2 TB/dtk. Hal ini memungkinkan Anda meningkatkan waktu muat dan mengurangi penyediaan Pod yang berlebihan untuk workload inferensi AI/ML Anda.

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

  1. Lakukan pra-cache atau hidrasi data di disk image Persistent Disk: Memuat volume ML Hyperdisk dengan data dari sumber data eksternal (untuk (misalnya, bobot Gemma yang dimuat dari Cloud Storage) yang dapat yang digunakan untuk inferensi. Persistent Disk untuk disk image harus kompatibel dengan Google Cloud Hyperdisk.
  2. Membuat volume Hyperdisk ML menggunakan volume yang sudah ada Google Cloud Hyperdisk: Membuat volume Kubernetes yang merujuk pada volume {i> Hyperdisk ML<i} yang dimuat dengan data. Secara opsional, Anda dapat buat kelas penyimpanan multi-zona untuk memastikan data Anda tersedia di semua yang akan dijalankan Pod.
  3. Buat Deployment Kubernetes untuk menggunakan volume Hyperdisk ML: Referensikan volume ML Hyperdisk dengan status akselerasi pemuatan data yang akan digunakan aplikasi Anda.

Volume Hyperdisk Multi-zona

Disk Hyperdisk ML hanya tersedia dalam satu zona. Secara opsional, Anda dapat menggunakan fitur multi-zona Hyperdisk ML untuk menghubungkan beberapa {i>disk<i} zona yang berisi konten yang sama dalam satu PersistentVolumeKlaim dan PersistentVolume. Disk zona yang direferensikan oleh fitur multi-zona harus ditempatkan di region yang sama. Misalnya, jika cluster regional dibuat di us-central1, disk multi-zona harus ditemukan di region yang sama (misalnya, us-central1-a, us-central1-b).

Kasus penggunaan yang umum untuk inferensi AI/ML adalah menjalankan Pod di seluruh zona untuk peningkatan ketersediaan akselerator dan efisiensi biaya dengan Spot VM. Karena Hyperdisk ML berdasarkan zona, jika server inferensi Anda menjalankan banyak Pod di berbagai zona, mengkloning {i>disk<i} di seluruh zona secara otomatis untuk memastikan data Anda mengikuti aplikasi.

Hidrasi Hyperdisk ML dari sumber data eksternal dan pembuatan PV multi-zona untuk mengakses data di seluruh zona.

Volume Hyperdisk ML Multi-zona memiliki batasan berikut:

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

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

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

  • Aktifkan Google Kubernetes Engine API.
    • Mengaktifkan Google Kubernetes Engine API
  • Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.
  • Tetapkan region dan zona default ke salah satu nilai yang didukung.
  • Pastikan project Google Cloud Anda memiliki kuota yang memadai untuk membuat node yang diperlukan dalam panduan ini. Kode contoh untuk cluster GKE dan pembuatan resource Kubernetes memerlukan kuota minimum berikut dalam 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 nanti. Jika Anda menggunakan saluran rilis, memastikan bahwa saluran tersebut memiliki versi GKE minimum atau lebih baru yang yang diperlukan untuk {i>driver<i} ini.
  • Pastikan driver CSI Persistent Disk Compute Engine diaktifkan. Driver Persistent Disk Compute Engine diaktifkan oleh pada cluster Autopilot dan Standar baru, dan tidak dapat dinonaktifkan atau diedit saat menggunakan {i>Autopilot<i}. Jika Anda perlu mengaktifkan driver Compute Engine Persistent Disk CSI dari cluster Anda, lihat Mengaktifkan Compute Engine Persistent Disk CSI Driver di cluster yang ada.
  • Jika Anda ingin menyesuaikan nilai readahead, gunakan versi GKE 1.29.2-gke.1217000 atau yang lebih baru.
  • Jika Anda ingin menggunakan fitur multi-zona yang disediakan secara dinamis, gunakan GKE versi 1.30.2-gke.1394000 atau yang lebih baru.
  • Hyperdisk ML hanya didukung pada jenis dan zona node tertentu. Kepada pelajari lebih lanjut, lihat Tentang Google Cloud Hyperdisk di dokumentasi Compute Engine.

Mendapatkan akses ke model

Guna mendapatkan akses ke model Gemma untuk di-deploy ke GKE, Anda harus menandatangani perjanjian izin lisensi terlebih dahulu, lalu membuat Token akses Wajah memeluk.

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

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

Membuat token akses

Untuk mengakses model melalui Wajah Memeluk, Anda memerlukan Wajah Memeluk token tersebut.

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

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

Membuat cluster GKE

Anda dapat menyajikan LLM pada GPU di GKE Autopilot atau Cluster standar. Sebaiknya gunakan Autopilot untuk pengalaman Kubernetes yang terkelola sepenuhnya. Untuk memilih Mode operasi GKE yang paling cocok 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 \
  --region=REGION \
  --release-channel=rapid \
  --cluster-version=1.30.2-gke.1394000

    Ganti nilai berikut:

    • PROJECT: ID project Google Cloud.
    • REGION: region yang mendukung akselerator yang ingin Anda gunakan, misalnya, us-east4 untuk GPU L4.

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

  2. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

    gcloud container clusters get-credentials hdml-gpu-l4 \
  --region=REGION

Standard

  1. Di Cloud Shell, jalankan perintah berikut untuk membuat Kumpulan cluster dan node standar:

    gcloud container clusters create hdml-gpu-l4 \
    --location=REGION \
    --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=REGION \
    --project=PROJECT \
    --node-locations=ZONES \
    --cluster=hdml-gpu-l4 \
    --machine-type=g2-standard-24 \
    --num-nodes=2

    Ganti nilai berikut:

    • CLUSTER_VERSION: versi GKE (misalnya, 1.30.2-gke.1394000).
    • REGION: region komputasi untuk bidang kontrol cluster. Region harus mendukung akselerator yang Anda ingin Anda gunakan, misalnya us-east4, untuk GPU L4. Periksa region yang menyediakan GPU L4.
    • 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 --zone. Untuk cluster zona, --node-locations harus berisi zona utama cluster.
    • PROJECT: ID project Google Cloud.

    Pembuatan cluster 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-cache data di disk image, dan membuat Volume ML Hyperdisk untuk akses baca berdasarkan workload Anda di GKE. Pendekatan ini (juga disebut hidrasi data) memastikan bahwa data tersedia saat workload Anda membutuhkannya.

Untuk menyalin data dari Cloud Storage guna melakukan pra-cache image disk Persistent Disk, ikuti langkah-langkah 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
provisioner: pd.csi.storage.gke.io
allowVolumeExpansion: false
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer

  2. Buat StorageClass dengan menjalankan perintah ini:

    kubectl create -f hyperdisk-ml.yaml

Membuat PersistentVolumeKlaim ReadWriteOnce (RWO)

  1. Simpan manifes PersistentVolumeKlaim berikut dalam file bernama producer-pvc.yaml. Anda akan menggunakan StorageClass yang dibuat sebelumnya. Pastikan bahwa {i>disk<i} 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 PersistentVolumeKlaim dengan menjalankan perintah ini:

    kubectl create -f producer-pvc.yaml

Membuat Tugas Kubernetes untuk mengisi volume Google Cloud Hyperdisk yang terpasang

Bagian ini menunjukkan contoh pembuatan Tugas Kubernetes yang menyediakan dan mengunduh model yang disesuaikan instruksi Gemma 7B dari Hugging Face ke volume Google Cloud Hyperdisk yang terpasang.

  1. Untuk mengakses LLM Gemma yang digunakan contoh dalam panduan ini, buat Rahasia Kubernetes yang berisi token Wajah Memeluk:

    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 Wajah Memeluk yang Anda buat sebelumnya.

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

    apiVersion: batch/v1
kind: Job
metadata:
  name: producer-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"
            - matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                - "ZONE"
      containers:
      - name: copy
        resources:
          requests:
            cpu: "32"
          limits:
            cpu: "32"
        image: huggingface/downloader:0.17.3
        command: [ "huggingface-cli" ]
        args:
        - download
        - google/gemma-1.1-7b-it
        - --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:
          - mountPath: "/data"
            name: volume
      restartPolicy: Never
      volumes:
        - name: volume
          persistentVolumeClaim:
            claimName: producer-pvc
  parallelism: 1         # Run 1 Pods concurrently
  completions: 1         # Once 1 Pods complete successfully, the Job is done
  backoffLimit: 4        # Max retries on failure

    Ganti ZONE dengan zona komputasi tempat Anda ingin {i>Hyperdisk<i} yang akan dibuat. Jika Anda menggunakannya dengan Misalnya, pastikan itu adalah zona yang memiliki kapasitas mesin G2.

  3. Buat Tugas dengan menjalankan perintah ini:

    kubectl apply -f producer-job.yaml

    Mungkin diperlukan waktu beberapa menit agar Tugas menyelesaikan penyalinan data ke Volume Persistent Disk. Saat Tugas menyelesaikan penyediaan, statusnya adalah bertanda "Selesai".

  4. Untuk memeriksa kemajuan status Pekerjaan Anda, jalankan perintah berikut berikut:

    kubectl get job producer-job

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

    kubectl delete job producer-job

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

Bagian ini membahas langkah-langkah untuk membuat PersistentVolume ReadOnlyMany (ROM) dan Sambungan PersistentVolumeKlaim dari volume Google Cloud Hyperdisk yang sudah ada sebelumnya. Untuk mempelajari lebih lanjut, lihat Menggunakan persistent disk yang sudah ada sebagai PersistentVolume.

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

    Jika Anda menggunakan volume Google Cloud Hyperdisk yang sudah ada sebelumnya versi GKE, Anda harus memodifikasi 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 Google Cloud Hyperdisk yang sudah ada dibuat.

  2. Buat pasangan PersistentVolume dan PersistentVolumeKlaim, dengan merujuk pada {i>disk<i} 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
  accessModes:
    - ReadOnlyMany
  claimRef:
    namespace: default
    name: hdml-static-pvc
  csi:
    driver: pd.csi.storage.gke.io
    volumeHandle: projects/PROJECT/zones/ZONE/disks/DISK_NAME
    fsType: ext4
    readOnly: true
  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 Google Cloud Hyperdisk yang sudah ada dibuat.
      • DISK_NAME: nama volume Google Cloud Hyperdisk yang sudah ada sebelumnya.

    2. Membuat resource PersistentVolume dan PersistentVolumeKlaim dengan menjalankan perintah ini:

      kubectl apply -f hdml-static-pv.yaml

Membuat volume ReadOnlyOnly Hyperdisk multi-zona dari VolumeSnapshot

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

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

Membuat 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
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 ke PersistentVolumeKlaim yang Anda buat sebelumnya Membuat PersistentVolumeKlaim ReadWriteOnce (RWO).

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

  4. Buat VolumeSnapshot dengan menjalankan perintah berikut:

    kubectl apply -f my-snapshot.yaml

  5. Saat VolumeSnapshot ditandai "Ready", jalankan perintah berikut untuk buat 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, 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: "2400Mi"
  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

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

    Contoh ini menetapkan volumeBindingMode ke Immediate, yang memungkinkan GKE untuk menyediakan PersistentVolumeKlaim sebelum konsumen yang mereferensikannya.

  2. Buat StorageClass dengan menjalankan perintah berikut:

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

Membuat PersistentVolumeKlaim yang menggunakan StorageClass multi-zona

Langkah berikutnya adalah membuat PersistentVolumeKlaim yang mereferensikan StorageClass.

GKE menggunakan konten disk image yang ditentukan untuk menyediakan volume Hyperdisk ML di setiap zona yang ditentukan dalam tanpa harus membuat snapshot.

Untuk membuat PersistentVolumeKlaim, 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:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  accessModes:
  - ReadOnlyMany
  storageClassName: hyperdisk-ml-multi-zone
  resources:
    requests:
      storage: 300Gi

  2. Buat PersistentVolumeKlaim 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 workload pengontrol (seperti Deployment atau StatefulSet).

Jika Anda ingin menggunakan PersistentVolume yang sudah ada sebelumnya dalam mode ReadOnly Many dengan Penerapan, lihat Menggunakan persistent disk dengan beberapa 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:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b
        ai.gke.io/inference-server: vllm
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: security
                  operator: In
                  values:
                  - S2
              topologyKey: topology.kubernetes.io/zone
      containers:
      - name: 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: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=2
        env:
        - name: MODEL_ID
          value: /models/gemma-7b
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
        - mountPath: /models
          name: gemma-7b
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      - name: gemma-7b
        persistentVolumeClaim:
          claimName: CLAIM_NAME
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  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 disk image 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 dapat memperoleh manfaat dari nilai readahead. Hal ini biasanya berlaku untuk beban kerja inferensi atau pelatihan yang perlu dimuat bobot model AI/ML ke dalam memori. Sebagian besar workload dengan I/O berurutan biasanya melihat peningkatan performa dengan nilai readahead 1024 KB atau lebih tinggi.

Anda dapat menentukan opsi ini melalui opsi pasangan read_ahead_kb saat Anda menyediakan PersistentVolume baru secara statis atau saat Anda mengubah PersistentVolume yang disediakan secara dinamis.

Contoh berikut menunjukkan cara menyesuaikan nilai readahead ke 4.096 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
    volumeHandle: projects/PROJECT/zones/ZONE/disks/DISK_NAME
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: topology.gke.io/zone
          operator: In
          values:
          - ZONE
  storageClassName: hyperdisk-ml
  mountOptions:
  - read_ahead_kb=4096

Ganti nilai berikut:

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

Menguji dan mengukur performa volume Hyperdisk ML Anda

Bagian ini menunjukkan cara menggunakan Fleksibel I/O Tester (FIO) untuk mengukur performa volume Hyperdisk ML Anda membaca data yang sudah ada sebelumnya . 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
        - --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
        - --direct=1
        - --rw=read
        - --readonly
        - --bs=4096k
        - --ioengine=libaio
        - --iodepth=8
        - --runtime=60
        - --numjobs=1
        - --name=read_benchmark
        volumeMounts:
        - mountPath: "/models"
          name: volume
      restartPolicy: Never
      volumes:
      - name: volume
        persistentVolumeClaim:
          claimName: hdml-static-pvc
  parallelism: 1         # Run 1 Pods concurrently
  completions: 1         # Once 1 Pods complete successfully, the Job is done
  backoffLimit: 1        # Max retries on failure

    Ganti CLAIM_NAME dengan nama Anda PersistentVolumeKlaim (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 ML Hyperdisk

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

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

Pemecahan masalah

Bagian ini memberikan panduan pemecahan masalah untuk menyelesaikan masalah terkait Volume Hyperdisk ML di GKE.

Mode akses disk tidak dapat diperbarui

Error berikut terjadi jika volume Hyperdisk ML sudah digunakan oleh 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 mengupdate accessMode volume Hyperdisk ML dari READ_WRITE_SINGLE hingga READ_ONLY_MANY, saat digunakan oleh Mode akses ReadOnly Many PersistentVolume. Pembaruan ini dilakukan ketika {i>disk<i} yang dilampirkan ke node baru.

Untuk mengatasi masalah ini, hapus semua Pod yang mereferensikan disk menggunakan PersistentVolume dalam mode ReadWriteOnce. Tunggu sampai {i>disk<i} terlepas, dan kemudian membuat ulang beban kerja yang menggunakan PersistentVolume dalam mode ReadOnlyOnly.

Disk tidak dapat dipasang dengan mode READ_WRITE

Error berikut menunjukkan bahwa GKE mencoba melampirkan Volume Hyperdisk ML dalam mode akses READ_ONLY_MANY ke 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 mengupdate accessMode volume Hyperdisk ML dari READ_WRITE_SINGLE hingga READ_ONLY_MANY, saat digunakan oleh Mode akses ReadOnly Many PersistentVolume. Namun, GKE tidak akan memperbarui mode akses secara otomatis dari READ_ONLY_MANY menjadi READ_WRITE_SINGLE. Ini adalah mekanisme keamanan untuk memastikan bahwa disk multi-zona telah bukan secara tidak sengaja, karena dapat mengakibatkan perbedaan konten antara multi-zona.

Untuk mengatasi masalah ini, sebaiknya ikuti Melakukan pra-cache data ke alur kerja disk image Persistent Disk jika Anda membutuhkan konten yang diperbarui. Jika Anda membutuhkan kontrol lebih besar atas Mode akses volume Hyperdisk ML dan setelan lainnya, lihat Ubah setelan volume Google Cloud Hyperdisk.

Kuota terlampaui - Kuota throughput tidak memadai

Error berikut menunjukkan bahwa Hyperdisk ML yang tidak memadai kuota throughput 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 pelajari kuota Hyperdisk lebih lanjut dan cara menambah disk kuota dalam project Anda.

Untuk panduan pemecahan masalah lainnya, lihat Tingkatkan performa penyimpanan Anda dengan Google Cloud Hyperdisk.

Langkah selanjutnya