Percepat penarikan data untuk model dengan menggunakan Fluid di KServe - Container Service for Kubernetes

Seiring perkembangan teknologi, ukuran file yang digunakan oleh model aplikasi AI semakin besar. Namun, masalah latensi tinggi dan cold start dapat terjadi ketika file besar ditarik dari layanan penyimpanan seperti Object Storage Service (OSS) dan File Storage NAS (NAS). Anda dapat menggunakan Fluid untuk mempercepat penarikan file model dan mengoptimalkan kinerja layanan inferensi, terutama layanan inferensi yang diterapkan menggunakan KServe. Topik ini menjelaskan cara mempercepat model dengan menggunakan Fluid di KServe. Contoh ini menggunakan model Qwen-7B-Chat-Int8 dengan GPU NVIDIA V100.

Prasyarat

Klaster Container Service for Kubernetes (ACK) Pro telah dibuat dan tidak menjalankan sistem operasi ContainerOS. Klaster ACK Pro harus menjalankan Kubernetes versi 1.22 atau lebih baru dan memiliki setidaknya tiga node, masing-masing dengan minimal 3 GB memori bebas. Untuk informasi lebih lanjut, lihat Buat Klaster ACK Pro.
Suite AI cloud-native telah diinstal, termasuk komponen ack-fluid. Untuk informasi lebih lanjut, lihat Terapkan Suite AI Cloud-Native.
Klien Arena versi 0.9.15 atau lebih baru telah diinstal. Untuk informasi lebih lanjut, lihat Konfigurasikan Klien Arena.
Komponen ack-kserve telah diinstal. Untuk informasi lebih lanjut, lihat Instal ack-kserve.
OSS telah diaktifkan. Untuk informasi lebih lanjut, lihat Aktifkan OSS.

Langkah 1: Siapkan data model dan unggah data model ke bucket OSS

Unduh model. Contoh ini menggunakan model Qwen-7B-Chat-Int8.
1. Jalankan perintah berikut untuk menginstal Git:
```
sudo yum install git
```
2. Jalankan perintah berikut untuk menginstal plug-in Large File Support (LFS):
```
sudo yum install git-lfs
```
3. Jalankan perintah berikut untuk mengkloning repositori Qwen-7B-Chat-Int8 dari komunitas ModelScope ke host lokal Anda:
```
GIT_LFS_SKIP_SMUDGE=1 git clone https://www.modelscope.cn/qwen/Qwen-7B-Chat-Int8.git
```
4. Jalankan perintah berikut untuk masuk ke direktori tempat repositori Qwen-7B-Chat-Int8 disimpan:
```
cd Qwen-7B-Chat-Int8
```
5. Jalankan perintah berikut untuk mengunduh file besar yang dikelola oleh LFS dari direktori tempat repositori Qwen-7B-Chat-Int8 disimpan:
```
git lfs pull
```
Unggah file Qwen-7B-Chat-Int8 yang telah diunduh ke bucket OSS.
1. Masuk ke konsol OSS dan catat nama bucket OSS yang telah Anda buat.
  Untuk informasi lebih lanjut tentang cara membuat bucket OSS, lihat Buat Bucket.
2. Instal dan konfigurasikan ossutil. Untuk informasi lebih lanjut, lihat Instal ossutil.
3. Jalankan perintah berikut untuk membuat direktori bernama Qwen-7B-Chat-Int8 di bucket OSS:
```
ossutil mkdir oss://<your-bucket-name>/Qwen-7B-Chat-Int8
```
4. Jalankan perintah berikut untuk mengunggah file model ke bucket OSS:
```
ossutil cp -r ./Qwen-7B-Chat-Int8 oss://<Your-Bucket-Name>/Qwen-7B-Chat-Int8
```

Langkah 2: Buat dataset dan JindoRuntime

Dataset digunakan untuk mengorganisir dan memproses data secara efisien. JindoRuntime meningkatkan akses data melalui kebijakan cache. Keduanya dapat digunakan bersama untuk meningkatkan kinerja pemrosesan data dan model.

Jalankan perintah berikut untuk membuat Secret guna menyimpan pasangan AccessKey yang digunakan untuk mengakses bucket OSS:
```
kubectl apply -f-<<EOF                                            
apiVersion: v1
kind: Secret
metadata:
  name: oss-secret
stringData:
  fs.oss.accessKeyId: <YourAccessKey ID>
  fs.oss.accessKeySecret: <YourAccessKey Secret>
EOF
```
Pada kode sebelumnya, parameter fs.oss.accessKeyId menentukan ID AccessKey dan parameter fs.oss.accessKeySecret menentukan rahasia AccessKey. Untuk informasi lebih lanjut tentang cara mendapatkan pasangan AccessKey, lihat Dapatkan Pasangan AccessKey.
Output yang diharapkan:
```
secret/oss-secret created
```

Buat file bernama resource.yaml dan salin konten berikut untuk membuat dataset dan JindoRuntime. Untuk informasi lebih lanjut tentang konfigurasi dataset dan JindoRuntime, lihat Gunakan JindoFS untuk Mempercepat Akses ke OSS.

Dataset digunakan untuk menentukan informasi tentang dataset di penyimpanan jarak jauh dan sistem file dasar (UFS).
JindoRuntime digunakan untuk memulai klaster JindoFS untuk caching data.

Lihat Konten di File resource.yaml

apiVersion: data.fluid.io/v1alpha1
kind: Dataset
metadata:
  name: qwen-7b-chat-int8
spec:
  mounts:
    - mountPoint: oss://<oss_bucket>/Qwen-7b-chat-Int8 # Ganti nilai dengan alamat penyimpanan aktual model. 
      options:
        fs.oss.endpoint: <oss_endpoint> # Ganti nilai dengan endpoint aktual bucket OSS. 
      name: models
      path: "/"
      encryptOptions:
        - name: fs.oss.accessKeyId
          valueFrom:
            secretKeyRef:
              name: oss-secret
              key: fs.oss.accessKeyId
        - name: fs.oss.accessKeySecret
          valueFrom:
            secretKeyRef:
              name: oss-secret
              key: fs.oss.accessKeySecret
---
apiVersion: data.fluid.io/v1alpha1
kind: JindoRuntime
metadata:
  name: qwen-7b-chat-int8 # Nama harus sama dengan dataset. 
spec:
  replicas: 3
  tieredstore:
    levels:
      - mediumtype: MEM # Gunakan memori untuk menyimpan cache data. 
        volumeType: emptyDir
        path: /dev/shm
        quota: 3Gi # Kapasitas cache yang dapat disediakan oleh replika worker. 
        high: "0.95"
        low: "0.7"
  fuse:
    resources:
      requests:
        memory: 2Gi
    properties:
      fs.oss.download.thread.concurrency: "200"
      fs.oss.read.buffer.size: "8388608"
      fs.oss.read.readahead.max.buffer.count: "200"
      fs.oss.read.sequence.ambiguity.range: "2147483647"

Jalankan perintah berikut untuk membuat dataset dan JindoRuntime:

kubectl apply -f resource.yaml

Output yang diharapkan:

dataset.data.fluid.io/qwen-7b-chat-int8 created
jindoruntime.data.fluid.io/qwen-7b-chat-int8 created

Langkah 3: Terapkan model vLLM sebagai layanan inferensi

Jalankan perintah berikut untuk menerapkan layanan inferensi berbasis KServe:

Kode sampel berikut menerapkan model Qwen-7B-Chat-Int8 sebagai layanan inferensi menggunakan Vetorized Large Language Model (vLLM) dan KServe:

arena serve kserve \
    --name=qwen-fluid \
    --image=kube-ai-registry.cn-shanghai.cr.aliyuncs.com/kube-ai/vllm:0.4.1 \
    --gpus=1 \
    --cpu=4 \
    --memory=12Gi \
    --data="qwen-7b-chat-int8:/mnt/models/Qwen-7B-Chat-Int8" \
    "python3 -m vllm.entrypoints.openai.api_server --port 8080 --trust-remote-code --served-model-name qwen --model /mnt/models/Qwen-7B-Chat-Int8 --gpu-memory-utilization 0.95 --quantization gptq --max-model-len=6144"

Output yang diharapkan:

inferenceservice.serving.kserve.io/qwen-fluid created
INFO[0002] Job qwen-fluid telah dikirimkan dengan sukses 
INFO[0002] Anda dapat menjalankan `arena serve get qwen-fluid --type kserve -n default` untuk memeriksa status job

Output menunjukkan bahwa layanan inferensi telah berhasil diterapkan.

Langkah 4: Periksa hasil percepatan penarikan data

Jalankan perintah berikut untuk melihat informasi tentang dataset:

kubectl get dataset qwen-7b-chat-int8

Output yang diharapkan:

NAME                UFS TOTAL SIZE   CACHED     CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
qwen-7b-chat-int8   17.01GiB         10.46MiB   18.00GiB         0.1%                Bound   23h

Jalankan perintah berikut untuk memeriksa waktu yang dikonsumsi hingga server aplikasi siap:
```
# Filter pod yang namanya mengandung qwen-fluid dari semua pod, ekstrak nama pod, dan tetapkan nama pod yang diekstrak ke variabel POD_NAME. 
POD_NAME=$(kubectl get po |grep qwen-fluid|awk -F " " '{print $1}')
Periksa jumlah waktu yang dikonsumsi hingga server aplikasi siap.
kubectl logs $POD_NAME |grep -i "server ready takes"
```
Output yang diharapkan:
```
server ready takes 25.875763 s
```
Output menunjukkan bahwa 25,875763 detik dikonsumsi hingga server aplikasi siap setelah menggunakan Fluid untuk mempercepat penarikan data. Efek percepatan bervariasi berdasarkan aplikasi, ukuran dataset, dan konfigurasi lingkungan. Data dalam topik ini hanya untuk referensi.
Untuk informasi lebih lanjut tentang efek percepatan berdasarkan JindoRuntime, lihat bagian Langkah 3: Buat Aplikasi untuk Menguji Percepatan Data dari topik "Gunakan JindoFS untuk Mempercepat Akses ke OSS".

Referensi

Untuk informasi lebih lanjut tentang Fluid, lihat Dataset Elastis.