Layanan Inferensi Multi-Model menggunakan Model Service Mesh - Alibaba Cloud Service Mesh

Untuk menjalankan beberapa model pembelajaran mesin dalam melakukan inferensi, Anda dapat menggunakan Model Service Mesh (ModelMesh) untuk meluncurkan dan mengelola layanan inferensi multi-model. ModelMesh diimplementasikan berdasarkan KServe ModelMesh dan dioptimalkan untuk kasus penggunaan model berskala tinggi, kepadatan tinggi, serta sering berubah. ModelMesh secara cerdas memuat dan membongkar model ke dan dari memori untuk menyeimbangkan responsivitas dan komputasi. Ini menyederhanakan penyebaran, operasi, dan pemeliharaan layanan inferensi multi-model, serta meningkatkan efisiensi dan kinerja inferensi.

Prasyarat

Sebuah kluster Container Service for Kubernetes (ACK) telah ditambahkan ke instance Service Mesh (ASM), dan instance ASM Anda adalah versi 1.18.0.134 atau lebih baru.
Sebuah gateway ingress telah dibuat untuk kluster tersebut. Untuk informasi lebih lanjut, lihat Buat Gateway Ingress.

Catatan

Dalam contoh ini, gateway ingress ASM digunakan sebagai gateway kluster. Nama gateway default adalah ingressgateway, port 8008 diaktifkan, dan protokol HTTP digunakan.

Fitur

ModelMesh menyediakan fitur-fitur berikut:

Fitur	Deskripsi
Manajemen cache	Pods dioptimalkan dan dikelola secara otomatis berdasarkan frekuensi penggunaan dan akses terbaru. Salinan model dimuat dan dibongkar berdasarkan frekuensi penggunaan dan volume permintaan saat ini.
Penempatan dan pemuatan cerdas	Penempatan model diseimbangkan oleh usia cache di seluruh pods dan beban permintaan. Antrian digunakan untuk menangani beban model konkuren dan meminimalkan dampak pada lalu lintas runtime.
Ketahanan	Pemuatan model yang gagal secara otomatis diulang di pods yang berbeda.
Kesederhanaan operasional	Pembaruan model bergulir ditangani secara otomatis dan mulus.

Langkah 1: Aktifkan fitur ModelMesh di ASM

Masuk ke Konsol ASM. Di panel navigasi sebelah kiri, pilih Service Mesh > Mesh Management.
Di halaman Mesh Management, klik nama instance ASM. Di panel navigasi sebelah kiri, pilih Ecosystem > KServe on ASM.
Di halaman KServe on ASM, klik Enable KServe on ASM.
Catatan
KServe bergantung pada CertManager, dan instalasi KServe akan otomatis menginstal komponen CertManager. Jika Anda ingin menggunakan CertManager yang dibangun sendiri, nonaktifkan Automatically install the CertManager component in the cluster.
Setelah KServe diaktifkan, gunakan kubectl untuk terhubung ke kluster ACK berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk memeriksa apakah sumber daya ServingRuntime tersedia:
```
kubectl get servingruntimes -n modelmesh-serving
```
Output yang Diharapkan:
```
NAME                DISABLED   MODELTYPE     CONTAINERS   AGE
mlserver-1.x                   sklearn       mlserver     1m
ovms-1.x                       openvino_ir   ovms         1m
torchserve-0.x                 pytorch-mar   torchserve   1m
triton-2.x                     keras         triton       1m
```
Sumber daya ServingRuntime mendefinisikan template untuk pods yang dapat melayani satu atau lebih format model tertentu. Pods disiapkan secara otomatis tergantung pada kerangka kerja model yang diterapkan.
Tabel berikut menjelaskan runtime dan format model yang didukung oleh ModelMesh. Untuk informasi lebih lanjut, lihat Format Model yang Didukung. Jika server model ini tidak dapat memenuhi semua persyaratan spesifik Anda, Anda dapat membuat runtime penyajian model kustom. Untuk informasi lebih lanjut, lihat Gunakan ModelMesh untuk Membuat Runtime Penyajian Model Kustom.
ServingRuntime
Kerangka kerja model yang didukung
mlserver-1.x
sklearn, xgboost, dan lightgbm
ovms-1.x
openvino_ir, onnx
torchserve-0.x
pytorch-mar
triton-2.x
tensorflow, pytorch, onnx, dan tensorrt

Langkah 2: Konfigurasikan lingkungan ASM

Sinkronkan namespace modelmesh-serving dari kluster ACK ke instance ASM. Untuk informasi lebih lanjut, lihat Sinkronkan Label Injeksi Proxy Sidecar Otomatis dari Kluster Kubernetes di Bidang Data ke Instance ASM. Setelah sinkronisasi, konfirmasikan bahwa namespace modelmesh-serving ada.

Buat gateway Istio untuk gateway ingress.

Buat file grpc-gateway.yaml dengan konten berikut:

Tampilkan File grpc-gateway.yaml

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: grpc-gateway
  namespace: modelmesh-serving
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - '*'
      port:
        name: grpc
        number: 8008
        protocol: GRPC

Gunakan kubectl untuk terhubung ke kluster ACK (atau instance ASM) berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk membuat gateway Istio:
```
kubectl apply -f grpc-gateway.yaml
```

Buat layanan virtual.

Buat file vs-modelmesh-serving-service.yaml dengan konten berikut:

Tampilkan File vs-modelmesh-serving-service.yaml

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: vs-modelmesh-serving-service
  namespace: modelmesh-serving
spec:
  gateways:
    - grpc-gateway
  hosts:
    - '*'
  http:
    - match:
        - port: 8008
      name: default
      route:
        - destination:
            host: modelmesh-serving
            port:
              number: 8033

Gunakan kubectl untuk terhubung ke kluster ACK (atau instance ASM) berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk membuat layanan virtual:
```
kubectl apply -f vs-modelmesh-serving-service.yaml
```

Konfigurasikan Google Remote Procedure Call (gRPC)-JSON transcoder.

Buat file grpcjsontranscoder-for-kservepredictv2.yaml dengan konten berikut:

apiVersion: istio.alibabacloud.com/v1beta1
kind: ASMGrpcJsonTranscoder
metadata:
  name: grpcjsontranscoder-for-kservepredictv2
  namespace: istio-system
spec:
  builtinProtoDescriptor: kserve_predict_v2
  isGateway: true
  portNumber: 8008
  workloadSelector:
    labels:
      istio: ingressgateway

Gunakan kubectl untuk terhubung ke kluster ACK (atau instance ASM) berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk menerapkan gRPC-JSON transcoder:
```
kubectl apply -f grpcjsontranscoder-for-kservepredictv2.yaml
```

Buat file grpcjsontranscoder-increasebufferlimit.yaml dengan konten berikut, dan atur parameter per_connection_buffer_limit_bytes untuk meningkatkan ukuran respons.

Tampilkan File grpcjsontranscoder-increasebufferlimit.yaml

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  labels:
    asm-system: "true"
    manager: asm-voyage
    provider: asm
  name: grpcjsontranscoder-increasebufferlimit
  namespace: istio-system
spec:
  configPatches:
  - applyTo: LISTENER
    match:
      context: GATEWAY
      listener:
        portNumber: 8008
      proxy:
        proxyVersion: ^1.*
    patch:
      operation: MERGE
      value:
        per_connection_buffer_limit_bytes: 100000000
  workloadSelector:
    labels:
      istio: ingressgateway

Gunakan kubectl untuk terhubung ke kluster ACK (atau instance ASM) berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk menerapkan filter Envoy:
```
kubectl apply -f grpcjsontranscoder-increasebufferlimit.yaml
```

Langkah 3: Sebarkan model sampel

Buat StorageClass. Untuk informasi lebih lanjut, lihat Mount Volume NAS yang Diproyeksikan Secara Dinamis.
1. Masuk ke Konsol ACK. Di panel navigasi sebelah kiri, klik Clusters.
2. Di halaman Clusters, temukan kluster yang Anda inginkan dan klik namanya. Di panel sebelah kiri, pilih Volumes > StorageClasses.
3. Di pojok kanan atas halaman StorageClasses, klik Create, atur parameter seperti yang ditunjukkan pada gambar berikut, lalu klik Create.

Buat Persistent Volume Claim (PVC).

Buat file my-models-pvc.yaml dengan konten berikut:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-models-pvc
  namespace: modelmesh-serving
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Gi
  storageClassName: alibabacloud-cnfs-nas
  volumeMode: Filesystem

Gunakan kubectl untuk terhubung ke kluster ACK berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk membuat PVC:
```
kubectl apply -f my-models-pvc.yaml
```

Jalankan perintah berikut untuk melihat PVC di namespace modelmesh-serving:

kubectl get pvc -n modelmesh-serving

Output yang Diharapkan:

NAME             STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS            AGE
my-models-pvc    Bound    nas-379c32e1-c0ef-43f3-8277-9eb4606b53f8   1Gi        RWX            alibabacloud-cnfs-nas   2h

Buat pod untuk mengakses PVC.
Untuk menggunakan PVC baru, Anda harus memasangnya sebagai volume ke pod Kubernetes, lalu gunakan pod tersebut untuk mengunggah file model ke volume persisten.
1. Buat file pvc-access.yaml dengan konten berikut.
  File YAML berikut menunjukkan bahwa pod pvc-access dibuat dan pengontrol Kubernetes diminta untuk mengklaim PVC yang sebelumnya diminta dengan menentukan "my-models-pvc".
```
apiVersion: v1
kind: Pod
metadata:
  name: "pvc-access"
spec:
  containers:
    - name: main
      image: ubuntu
      command: ["/bin/sh", "-ec", "sleep 10000"]
      volumeMounts:
        - name: "my-pvc"
          mountPath: "/mnt/models"
  volumes:
    - name: "my-pvc"
      persistentVolumeClaim:
        claimName: "my-models-pvc"
```
2. Gunakan kubectl untuk terhubung ke kluster ACK berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk membuat pod:
```
kubectl apply  -n modelmesh-serving  -f pvc-access.yaml
```
3. Verifikasi bahwa pod pvc-access sedang berjalan.
```
kubectl get pods -n modelmesh-serving | grep pvc-access
```
  Output yang Diharapkan:
```
pvc-access             1/1     Running   0          51m
```
Simpan model di volume persisten.
Tambahkan model AI ke volume persisten. Dalam contoh ini, model pengenalan karakter digit tulisan tangan MNIST yang dilatih dengan scikit-learn digunakan. Salinan file model mnist-svm.joblib dapat diunduh dari repositori kserve/modelmesh-minio-examples.
1. Gunakan kubectl untuk terhubung ke kluster ACK berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk menyalin file model mnist-svm.joblib ke folder /mnt/models di pod pvc-access:
```
kubectl -n modelmesh-serving cp mnist-svm.joblib pvc-access:/mnt/models/
```
2. Jalankan perintah berikut untuk memverifikasi bahwa model ada di volume persisten:
```
kubectl -n modelmesh-serving exec -it pvc-access -- ls -alr /mnt/models/
```
  Output yang Diharapkan:
```
-rw-r--r-- 1  501 staff 344817 Oct 30 11:23 mnist-svm.joblib
```

Sebarkan layanan inferensi.

Buat file sklearn-mnist.yaml dengan konten berikut:

Tampilkan File sklearn-mnist.yaml

apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: sklearn-mnist
  namespace: modelmesh-serving
  annotations:
    serving.kserve.io/deploymentMode: ModelMesh
spec:
  predictor:
    model:
      modelFormat:
        name: sklearn
      storage:
        parameters:
          type: pvc
          name: my-models-pvc
        path: mnist-svm.joblib

Gunakan kubectl untuk terhubung ke kluster ACK berdasarkan informasi dalam file kubeconfig, lalu jalankan perintah berikut untuk menerapkan layanan inferensi sklearn-mnist:
```
kubectl apply -f sklearn-mnist.yaml
```
Tunggu beberapa detik (lama waktu menunggu tergantung pada kecepatan penarikan gambar), lalu jalankan perintah berikut untuk memeriksa apakah layanan inferensi sklearn-mnist telah diterapkan:
```
kubectl get isvc -n modelmesh-serving
```
Output yang Diharapkan:
```
NAME            URL                                               READY
sklearn-mnist   grpc://modelmesh-serving.modelmesh-serving:8033   True
```

Lakukan inferensi.

Jalankan perintah curl untuk mengirim permintaan inferensi ke model sklearn-mnist. Array data menunjukkan nilai grayscale dari 64 piksel dalam pemindaian gambar digit yang akan diklasifikasikan.

MODEL_NAME="sklearn-mnist"
ASM_GW_IP="Alamat IP gateway ingress"
curl -X POST -k "http://${ASM_GW_IP}:8008/v2/models/${MODEL_NAME}/infer" -d '{"inputs": [{"name": "predict", "shape": [1, 64], "datatype": "FP32", "contents": {"fp32_contents": [0.0, 0.0, 1.0, 11.0, 14.0, 15.0, 3.0, 0.0, 0.0, 1.0, 13.0, 16.0, 12.0, 16.0, 8.0, 0.0, 0.0, 8.0, 16.0, 4.0, 6.0, 16.0, 5.0, 0.0, 0.0, 5.0, 15.0, 11.0, 13.0, 14.0, 0.0, 0.0, 0.0, 0.0, 2.0, 12.0, 16.0, 13.0, 0.0, 0.0, 0.0, 0.0, 0.0, 13.0, 16.0, 16.0, 6.0, 0.0, 0.0, 0.0, 0.0, 16.0, 16.0, 16.0, 7.0, 0.0, 0.0, 0.0, 0.0, 11.0, 13.0, 12.0, 1.0, 0.0]}}]}'

Blok kode berikut menunjukkan respons JSON. Dapat disimpulkan bahwa digit yang dipindai adalah 8.

{
 "modelName": "sklearn-mnist__isvc-3c10c62d34",
 "outputs": [
  {
   "name": "predict",
   "datatype": "INT64",
   "shape": [
    "1",
    "1"
   ],
   "contents": {
    "int64Contents": [
     "8"
    ]
   }
  }
 ]
}

Referensi

Ketika Anda menerapkan beberapa model yang memerlukan lingkungan runtime yang berbeda, atau ketika Anda perlu meningkatkan efisiensi inferensi model atau mengontrol alokasi sumber daya, Anda dapat menggunakan ModelMesh untuk membuat runtime penyajian model kustom. Konfigurasi yang disesuaikan dari runtime penyajian model kustom memastikan bahwa setiap model berjalan di lingkungan yang paling sesuai. Untuk informasi lebih lanjut, lihat Gunakan ModelMesh untuk Membuat Runtime Penyajian Model Kustom.
Ketika Anda perlu memproses sejumlah besar data bahasa alami atau ingin membangun sistem pemahaman bahasa kompleks, Anda dapat menggunakan model bahasa besar (LLM) sebagai layanan inferensi. Untuk informasi lebih lanjut, lihat Gunakan LLM sebagai Layanan Inferensi.
Ketika Anda mengalami kesalahan pod, Anda dapat menyelesaikannya dengan merujuk ke Pemecahan Masalah Pod.

ServingRuntime	Kerangka kerja model yang didukung
mlserver-1.x	sklearn, xgboost, dan lightgbm
ovms-1.x	openvino_ir, onnx
torchserve-0.x	pytorch-mar
triton-2.x	tensorflow, pytorch, onnx, dan tensorrt