Mempercepat pemuatan model di GKE dengan Run:ai Model Streamer

Dokumen ini menunjukkan cara mempercepat pemuatan bobot model AI besar dari Cloud Storage menggunakan Run:ai Model Streamer dengan server inferensi vLLM di Google Kubernetes Engine (GKE).

Solusi dalam dokumen ini mengasumsikan bahwa Anda telah memuat model dan bobot AI dalam format safetensors ke dalam bucket Cloud Storage.

Dengan menambahkan flag --load-format=runai_streamer ke deployment vLLM, Anda dapat menggunakan Run:ai Model Streamer untuk meningkatkan efisiensi download model untuk workload AI di GKE.

Dokumen ini ditujukan untuk pengguna berikut:

  • Engineer machine learning (ML) yang perlu memuat model AI besar dari penyimpanan objek ke node GPU/TPU secepat mungkin.
  • Admin dan operator platform yang mengotomatiskan dan mengoptimalkan infrastruktur penyajian model di GKE.
  • Arsitek cloud yang mengevaluasi alat pemuatan data khusus untuk workload AI/ML.

Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang dirujuk dalam Cloud de Confiance by S3NS konten, lihat Peran dan tugas pengguna GKE umum.

Ringkasan

Solusi yang dijelaskan dalam dokumen ini menggunakan tiga komponen inti—Run:ai Model Streamer, vLLM, dan format file safetensors—untuk mempercepat proses pemuatan bobot model dari Cloud Storage ke node GPU atau TPU.

Run:ai Model Streamer

Run:ai Model Streamer adalah Python SDK open source yang mempercepat pemuatan model AI besar ke akselerator. SDK ini melakukan streaming bobot model langsung dari penyimpanan, seperti bucket Cloud Storage, ke memori GPU atau TPU Anda. Streamer model sangat cocok untuk mengakses file safetensors yang berada di Cloud Storage.

safetensors

safetensors adalah format file untuk menyimpan tensor, struktur data inti dalam model AI, dengan cara yang meningkatkan keamanan dan kecepatan. safetensors dirancang sebagai alternatif untuk format pickle Python, dan memungkinkan waktu pemuatan yang cepat melalui pendekatan tanpa salinan. Pendekatan ini memungkinkan tensor dapat diakses langsung dari sumber tanpa perlu memuat seluruh file ke memori lokal terlebih dahulu.

vLLM

vLLM adalah library open source untuk inferensi dan penyajian LLM. Ini adalah server inferensi berperforma tinggi yang dioptimalkan untuk memuat model AI besar dengan cepat. Dalam dokumen ini, vLLM adalah mesin inti yang menjalankan model AI Anda di GKE dan menangani permintaan inferensi yang masuk. Dukungan autentikasi bawaan Run:ai Model Streamer untuk Cloud Storage memerlukan vLLM versi 0.11.1 atau yang lebih baru untuk GPU, dan 0.18.0 atau yang lebih baru untuk TPU.

Cara Run:ai Model Streamer mempercepat pemuatan model

Saat Anda memulai aplikasi AI berbasis LLM untuk inferensi, sering kali terjadi penundaan yang signifikan sebelum model siap digunakan. Penundaan ini, yang dikenal sebagai cold start, terjadi karena seluruh file model multi-gigabyte harus didownload dari lokasi penyimpanan, seperti bucket Cloud Storage, ke disk lokal mesin Anda. File tersebut kemudian dimuat ke dalam memori akselerator Anda. Selama periode pemuatan ini, akselerator yang mahal akan tidak digunakan, yang tidak efisien dan mahal.

Daripada proses download lalu muat, streamer model melakukan streaming model langsung dari Cloud Storage ke memori GPU atau TPU. Streamer menggunakan backend berperforma tinggi untuk membaca beberapa bagian model, yang disebut tensor, secara paralel. Membaca tensor secara bersamaan jauh lebih cepat daripada memuat file secara berurutan.

Ringkasan arsitektur

Run:ai Model Streamer terintegrasi dengan vLLM di GKE untuk mempercepat pemuatan model dengan melakukan streaming bobot model langsung dari Cloud Storage ke memori akselerator, tanpa menggunakan disk lokal.

Diagram berikut menampilkan arsitektur ini:

Arsitektur Run:ai Model Streamer yang memuat bobot model dari Cloud Storage ke vLLM di GKE.
Arsitektur Run:ai Model Streamer dengan vLLM dan Cloud Storage.

Arsitektur ini mencakup komponen dan alur kerja berikut:

  • Bucket Cloud Storage: menyimpan bobot model AI dalam format safetensors.
  • Pod GKE dengan GPU atau TPU: menjalankan server inferensi vLLM.
  • Server inferensi vLLM: dikonfigurasi dengan flag --load-format=runai_streamer, yang mengaktifkan fungsi streamer model.
  • Run:ai Model Streamer: saat vLLM dimulai, streamer model membaca bobot model dari jalur gs:// yang ditentukan di bucket Cloud Storage. Daripada mendownload file ke disk, streamer model melakukan streaming data tensor langsung ke memori akselerator Pod GKE, tempat data tersebut langsung tersedia untuk vLLM untuk inferensi.
  • Cache Cepat Cloud Storage (Opsional): jika diaktifkan, Cache Cepat akan meng-cache data bucket di zona yang sama dengan node GKE, sehingga lebih mempercepat akses data untuk streamer.

Manfaat

  • Waktu cold start yang lebih singkat: streamer model secara signifikan mengurangi waktu yang diperlukan model untuk memulai. Streamer model memuat bobot model hingga enam kali lebih cepat dibandingkan metode konvensional. Untuk mengetahui informasi selengkapnya, lihat Benchmark Run:ai Model Streamer
  • Peningkatan penggunaan akselerator: dengan meminimalkan penundaan pemuatan model, akselerator seperti GPU dan TPU dapat mengalokasikan lebih banyak waktu untuk tugas inferensi yang sebenarnya, sehingga meningkatkan efisiensi dan kapasitas pemrosesan secara keseluruhan.
  • Alur kerja yang disederhanakan: solusi yang dijelaskan dalam dokumen ini terintegrasi dengan GKE, sehingga server inferensi seperti vLLM atau SGLang dapat langsung mengakses model di bucket Cloud Storage.

Sebelum memulai

Pastikan untuk menyelesaikan prasyarat berikut.

Memilih atau membuat project dan mengaktifkan API

  • In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  • Verify that billing is enabled for your Cloud de Confiance project.

  • Enable the Kubernetes Engine, Cloud Storage, Compute Engine, IAM APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    • Menyiapkan Cloud Shell

    Dokumen ini menggunakan Google Cloud CLI dan perintah kubectl untuk membuat dan mengelola resource yang diperlukan untuk solusi ini. Anda dapat menjalankan perintah ini di Cloud Shell dengan mengklik Activate Cloud Shell di bagian atas konsol. Cloud de Confiance

    Di konsol, aktifkan Cloud Shell. Cloud de Confiance

    Aktifkan Cloud Shell

    Atau, Anda dapat menginstal dan melakukan inisialisasi gcloud CLI di lingkungan shell lokal untuk menjalankan perintah. Jika ingin menggunakan terminal shell lokal, jalankan perintah gcloud auth login untuk melakukan autentikasi dengan Cloud de Confiance by S3NS.

    Memberikan peran IAM

    Pastikanakun Anda memiliki peran IAM berikut di project Anda sehingga Anda dapat membuat cluster GKE dan mengelola Cloud Storage: Cloud de Confiance

    • roles/container.admin
    • roles/storage.admin

    Untuk memberikan peran ini, jalankan perintah berikut:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="user:$(gcloud config get-value account)" \
    --role="roles/container.admin"
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="user:$(gcloud config get-value account)" \
    --role="roles/storage.admin"

    Ganti PROJECT_ID dengan project ID Anda.

    Menyiapkan lingkungan Anda

    Bagian ini memandu Anda menyiapkan cluster GKE dan mengonfigurasi izin untuk mengakses model di Cloud Storage.

    Membuat cluster GKE

    Run:ai Model Streamer dapat digunakan dengan cluster GKE Autopilot dan Standar. Pilih mode cluster yang paling sesuai dengan kebutuhan Anda.

    1. Tetapkan variabel untuk project dan nama cluster Anda:

      export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME

      Ganti kode berikut:

      • PROJECT_ID: Project ID Cloud de Confiance by S3NS Anda. Anda dapat menemukan project ID dengan menjalankan perintah gcloud config get-value project.
      • CLUSTER_NAME: Nama cluster Anda. Contoh, run-ai-test.

    2. Buat cluster Autopilot atau Standar:

      Autopilot

      Ikuti langkah-langkah berikut untuk membuat cluster GKE Autopilot:

      1. Tetapkan region untuk cluster Anda:

        export REGION=REGION

        Ganti REGION dengan region tempat Anda ingin membuat cluster. Untuk performa optimal, gunakan region yang sama dengan bucket Cloud Storage Anda.

      2. Buat cluster:

        gcloud container clusters create-auto $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --location=$REGION

      Cluster Autopilot otomatis menyediakan node berdasarkan persyaratan workload. Saat Anda men-deploy server vLLM pada langkah berikutnya, Autopilot akan menyediakan node GPU atau TPU jika diperlukan. Untuk mengetahui informasi selengkapnya, lihat Tentang pembuatan otomatis node pool.

      Standar

      Ikuti langkah-langkah berikut untuk membuat cluster GKE Standar:

      1. Tetapkan zona untuk cluster Anda:

        export ZONE=ZONE

        Ganti ZONE dengan zona tempat Anda ingin membuat cluster. Untuk performa optimal, gunakan zona di region yang sama dengan bucket Cloud Storage Anda.

      2. Buat cluster:

        gcloud container clusters create $CLUSTER_NAME \
    --project=$PROJECT_ID \
    --zone=$ZONE \
    --workload-pool=$PROJECT_ID.s3ns.svc.id.goog \
    --num-nodes=1

    Membuat node pool

    Jika Anda membuat cluster Standar, Anda harus membuat node pool dengan GPU atau TPU. Cluster Autopilot otomatis menyediakan node berdasarkan persyaratan workload. Buat node pool berdasarkan akselerator yang ingin Anda gunakan:

    *   {GPU}

    Create a node pool with one G2 machine (NVIDIA L4 GPU):

    ```sh
    gcloud container node-pools create g2-gpu-pool \
        --cluster=$CLUSTER_NAME \
        --zone=$ZONE \
        --machine-type=g2-standard-16 \
        --num-nodes=1 \
        --accelerator=type=nvidia-l4
    ```

*   {TPU}

    Create a node pool with TPU v7x nodes:

    ```sh
    gcloud container node-pools create tpu7x-pool \
        --cluster=$CLUSTER_NAME \
        --zone=$ZONE \
        --machine-type=tpu7x-standard-4t \
        --num-nodes=1
    ```

    Mengonfigurasi Workload Identity Federation for GKE

    Konfigurasikan Workload Identity Federation for GKE agar workload GKE Anda dapat mengakses model di bucket Cloud Storage dengan aman.

    1. Tetapkan variabel untuk akun layanan dan namespace Kubernetes Anda:

      export KSA_NAME=KSA_NAME
export NAMESPACE=NAMESPACE

      Ganti kode berikut:

      • NAMESPACE: namespace tempat Anda ingin menjalankan workload. Pastikan untuk menggunakan namespace yang sama untuk membuat semua resource dalam dokumen ini.
      • KSA_NAME: nama akun layanan Kubernetes yang dapat digunakan Pod Anda untuk melakukan autentikasi ke Cloud de Confiance by S3NS API.

    2. Buat namespace Kubernetes:

      kubectl create namespace $NAMESPACE

    3. Buat akun layanan Kubernetes (KSA):

      kubectl create serviceaccount $KSA_NAME \
    --namespace=$NAMESPACE

    4. Berikan izin yang diperlukan ke KSA Anda:

      1. Tetapkan variabel lingkungan:

        export BUCKET_NAME=BUCKET_NAME
export PROJECT_ID=PROJECT_ID
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format 'get(projectNumber)')

        Ganti kode berikut:

        • BUCKET_NAME: nama bucket Cloud Storage Anda yang berisi file safetensors.
        • PROJECT_ID: Project ID Cloud de Confiance by S3NS Anda.

        PROJECT_NUMBER, PROJECT_ID, NAMESPACE, dan KSA_NAME akan digunakan untuk membuat ID utama Workload Identity Federation for GKE untuk project Anda pada langkah-langkah berikut.

      2. Berikan peran roles/storage.bucketViewer ke KSA Anda untuk melihat objek di bucket Cloud Storage Anda:

        gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.s3ns.svc.id.goog/subject/ns/$NAMESPACE/sa/$KSA_NAME" \
    --role="roles/storage.bucketViewer"

      3. Berikan peran roles/storage.objectUser ke KSA Anda untuk membaca, menulis, dan menghapus objek di bucket Cloud Storage Anda:

        gcloud storage buckets add-iam-policy-binding gs://$BUCKET_NAME \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.s3ns.svc.id.goog/subject/ns/$NAMESPACE/sa/$KSA_NAME" \
    --role="roles/storage.objectUser"

    Anda kini telah menyiapkan cluster GKE dengan GPU atau TPU dan mengonfigurasi Workload Identity Federation for GKE, sehingga memberikan Akun Layanan Kubernetes izin yang diperlukan untuk mengakses model AI Anda di Cloud Storage. Dengan cluster dan izin yang sudah ada, Anda siap men-deploy server inferensi vLLM, yang akan menggunakan akun layanan ini untuk melakukan streaming bobot model dengan Run:ai Model Streamer.

    Men-deploy vLLM dengan Run:ai Model Streamer

    Deploy Pod yang menjalankan server yang kompatibel dengan vLLM OpenAI, dan dikonfigurasi dengan flag --load-format=runai_streamer untuk menggunakan Run:ai Model Streamer. Versi vLLM harus 0.11.1 atau yang lebih baru untuk GPU, dan 0.18.0 atau yang lebih baru untuk TPU.

    Contoh manifes berikut menunjukkan cara mengonfigurasi vLLM dengan streamer model yang diaktifkan untuk model berukuran kecil, seperti gemma-2-9b-it.

    Flag --model-loader-extra-config={"distributed":true} memungkinkan pemuatan bobot model terdistribusi dan merupakan setelan yang direkomendasikan untuk meningkatkan performa pemuatan model dari penyimpanan objek.

    Untuk mengetahui informasi selengkapnya, lihat Paralelisme tensor dan Parameter yang dapat disesuaikan.

    1. Pilih contoh manifes berdasarkan akselerator yang ingin Anda gunakan:

      GPU

      Contoh manifes berikut menggunakan satu GPU NVIDIA L4. Jika Anda menggunakan model besar yang memerlukan beberapa GPU, tingkatkan nilai --tensor-parallel-size ke jumlah GPU yang diperlukan.

      Simpan manifes berikut sebagai vllm-deployment.yaml. Manifes ini dirancang untuk fleksibilitas di seluruh cluster Autopilot dan Standar.

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-streamer-deployment
  namespace: NAMESPACE
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm-streamer
  template:
    metadata:
      labels:
        app: vllm-streamer
    spec:
      serviceAccountName: KSA_NAME
      containers:
        - name: vllm-container
          image: vllm/vllm-openai:v0.11.1
          command:
            - python3
            - -m
            - vllm.entrypoints.openai.api_server
          args:
            - --model=gs://BUCKET_NAME/PATH_TO_MODEL
            - --load-format=runai_streamer
            - --model-loader-extra-config={"distributed":true}
            - --host=0.0.0.0
            - --port=8000
            - --disable-log-requests
            - --tensor-parallel-size=1
          ports:
            - containerPort: 8000
              name: api
          # startupProbe allows for longer startup times for large models
          startupProbe:
            httpGet:
              path: /health
              port: 8000
            failureThreshold: 60  # 60 * 10s = 10 minutes timeout
            periodSeconds: 10
            initialDelaySeconds: 30
          readinessProbe:
            httpGet:
              path: /health
              port: 8000
            failureThreshold: 3
            periodSeconds: 10
          resources:
            limits:
              nvidia.com/gpu: "1"
            requests:
              nvidia.com/gpu: "1"
          volumeMounts:
          - mountPath: /dev/shm
            name: dshm
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      volumes:
      - emptyDir:
          medium: Memory
        name: dshm

      Ganti kode berikut:

      • NAMESPACE: namespace Kubernetes Anda.
      • KSA_NAME: nama akun layanan Kubernetes Anda.
      • BUCKET_NAME: nama bucket Cloud Storage Anda.
      • PATH_TO_MODEL: jalur ke direktori model Anda dalam bucket, misalnya, models/my-llama.

      TPU

      Contoh manifes berikut menggunakan node TPU v7x.

      Simpan manifes berikut sebagai vllm-deployment.yaml.

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-vllm
  namespace: NAMESPACE
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tpu-vllm
  template:
    metadata:
      labels:
        app: tpu-vllm
    spec:
      serviceAccountName: KSA_NAME
      containers:
      - name: vllm-container
        image: vllm/vllm-tpu:v0.18.0
        resources:
          limits:
            google.com/tpu: "4"
        command: ["sh", "-c"]
        args:
        - >-
          python3 -m vllm.entrypoints.openai.api_server
          --model=gs://BUCKET_NAME/PATH_TO_MODEL
          --load-format=runai_streamer
          --tensor-parallel-size=8
          --port=8000
        ports:
        - containerPort: 8000
        env:
        - name: VLLM_XLA_CACHE_PATH
          value: "gs://BUCKET_NAME/PATH_TO_CACHE"
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu7x
        cloud.google.com/gke-tpu-topology: 2x2x1

      Ganti kode berikut:

      • NAMESPACE: namespace Kubernetes Anda.
      • KSA_NAME: nama akun layanan Kubernetes Anda.
      • BUCKET_NAME: nama bucket Cloud Storage Anda.
      • PATH_TO_MODEL: jalur ke direktori model Anda dalam bucket, misalnya, models/my-llama.
      • PATH_TO_CACHE: jalur ke direktori cache kompilasi XLA Anda dalam bucket, misalnya, models/xla-cache.

    2. Terapkan manifes untuk membuat Deployment:

      kubectl create -f vllm-deployment.yaml

    Anda dapat membuat lebih banyak manifes vLLM menggunakan alat Panduan Memulai Inferensi GKE.

    Memverifikasi Deployment

    1. Periksa status Deployment:

      kubectl get deployments -n NAMESPACE

    2. Dapatkan nama Pod:

      kubectl get pods -n NAMESPACE | grep vllm-streamer

      Perhatikan nama Pod yang dimulai dengan vllm-streamer-deployment.

    3. Untuk memeriksa apakah streamer model mendownload model dan bobot, lihat log Pod:

      kubectl logs -f POD_NAME -n NAMESPACE

      Ganti POD_NAME dengan nama Pod dari langkah sebelumnya. Log streaming yang berhasil akan terlihat seperti berikut:

      [RunAI Streamer] Overall time to stream 15.0 GiB of all files: 13.4s, 1.1 GiB/s

    Opsional: Meningkatkan performa dengan Cache Cepat

    Cache Cepat Cloud Storage dapat lebih mempercepat pemuatan model dengan meng-cache data lebih dekat ke node GKE Anda. Caching sangat bermanfaat saat melakukan penskalaan beberapa node di zona yang sama.

    Anda mengaktifkan Cache Cepat untuk bucket Cloud Storage tertentu di zona tertentu Cloud de Confiance by S3NS . Untuk meningkatkan performa, zona cache harus cocok dengan zona tempat Pod inferensi GKE Anda berjalan. Pendekatan Anda bergantung pada apakah Pod Anda berjalan di zona yang dapat diprediksi.

    • Untuk cluster zona GKE Standar, tempat Anda mengetahui zona tempat Pod akan berjalan, aktifkan Cache Cepat untuk zona tertentu tersebut.

    • Untuk cluster GKE regional (Autopilot dan Standar), tempat Pod dapat dijadwalkan di beberapa zona, Anda memiliki opsi berikut:

      • Mengaktifkan caching di semua zona: Aktifkan Cache Cepat di setiap zona dalam region cluster. Hal ini memastikan cache tersedia, terlepas dari tempat GKE menjadwalkan Pod Anda. Perhatikan bahwa Anda akan dikenai biaya untuk setiap zona tempat caching diaktifkan. Untuk mengetahui informasi selengkapnya, lihat Harga Cache Cepat.
      • Menempatkan Pod ke zona tertentu: Gunakan aturan nodeSelector atau nodeAffinity dalam manifes workload Anda untuk membatasi Pod ke satu zona. Kemudian, Anda dapat mengaktifkan Cache Cepat hanya di zona tersebut. Ini adalah pendekatan yang lebih hemat biaya jika workload Anda dapat dibatasi ke satu zona.

    Untuk mengaktifkan Cache Cepat untuk zona tempat cluster GKE Anda berada, jalankan perintah berikut:

    # Enable the cache
gcloud storage buckets anywhere-caches create gs://$BUCKET_NAME $ZONE

# Check the status of the cache
gcloud storage buckets anywhere-caches describe $BUCKET_NAME/$ZONE

    Pembersihan

    Agar tidak menimbulkan biaya pada Cloud de Confiance by S3NS akun Anda untuk resource yang digunakan dalam dokumen ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus masing-masing resource.

    Untuk menghapus masing-masing resource, ikuti langkah-langkah berikut:

    1. Hapus cluster GKE. Tindakan ini akan menghapus semua node dan workload.

      gcloud container clusters delete CLUSTER_NAME --location=ZONE_OR_REGION

      Ganti kode berikut:

      • CLUSTER_NAME: nama cluster Anda.
      • ZONE_OR_REGION: zona atau region cluster Anda.

    2. Nonaktifkan Cache Cepat, jika Anda mengaktifkannya, untuk menghindari biaya berkelanjutan. Untuk mengetahui informasi selengkapnya, lihat Menonaktifkan cache.

    Langkah berikutnya