Terapkan dan kelola layanan inferensi multi-model dengan ModelMesh - Alibaba Cloud Service Mesh

Saat perlu menjalankan beberapa model pembelajaran mesin untuk inferensi, gunakan ModelMesh untuk menerapkan dan mengelola layanan inferensi multi-model. Berdasarkan KServe ModelMesh, fitur ini dioptimalkan untuk kasus penggunaan model dengan volume tinggi, kerapatan tinggi, dan sering berubah. Fitur ini memuat model ke memori serta melepasnya secara cerdas untuk menyeimbangkan responsivitas dan sumber daya komputasi, sehingga menyederhanakan penerapan dan pengoperasian layanan inferensi multi-model sekaligus meningkatkan efisiensi dan kinerja inferensi.

Prasyarat

Anda telah menambahkan kluster ke instans ASM versi 1.18.0.134 atau yang lebih baru.
Anda telah membuat gerbang masuk (ingress gateway) untuk kluster tersebut. Untuk informasi selengkapnya, lihat Create an ingress gateway.

Catatan

Topik ini menggunakan gerbang masuk ASM sebagai gerbang kluster. Gerbang tersebut diberi nama ingressgateway secara default dan mengekspos port 8008 untuk traffic HTTP.

Fitur

ModelMesh menyediakan fitur-fitur berikut:

Fitur	Deskripsi
Cache management	Otomatis mengoptimalkan dan mengelola memori pod berdasarkan frekuensi dan kebaruan penggunaan. Memuat dan melepas replika model berdasarkan frekuensi penggunaan dan volume permintaan saat ini.
Intelligent placement and loading	Menyeimbangkan penempatan model di seluruh pod berdasarkan usia cache dan beban permintaan. Menggunakan antrian untuk menangani pemuatan model konkuren dan meminimalkan dampak terhadap traffic waktu proses.
Resilience	Otomatis mencoba ulang pemuatan model yang gagal pada pod yang berbeda.
Rolling updates	Otomatis dan lancar menangani pembaruan model secara bergulir.

Langkah 1: Aktifkan ModelMesh di ASM

Masuk ke Konsol ASM. Di panel navigasi kiri, pilih Service Mesh > Mesh Management.
Pada halaman Mesh Management, klik nama instans ASM target. Di panel navigasi kiri, pilih Ecosystem > KServe on ASM.
Pada halaman KServe on ASM, klik Install Model Service Mesh untuk mengaktifkan fitur ModelMesh.

Catatan: KServe bergantung pada CertManager. Menginstal KServe akan secara otomatis menginstal komponen CertManager. Jika Anda menggunakan CertManager yang dikelola sendiri, nonaktifkan Automatically install the CertManager component in the cluster.
Setelah beberapa menit, ketika komponen siap, jalankan perintah berikut menggunakan KubeConfig untuk kluster guna memverifikasi bahwa resource ServingRuntime telah siap.

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

ServingRuntime mendefinisikan templat pod untuk melayani satu atau beberapa format model tertentu. ModelMesh secara otomatis menyediakan pod yang sesuai berdasarkan framework dari model yang diterapkan.

Runtime default dan format model yang didukungnya tercantum dalam tabel berikut. Untuk informasi selengkapnya, lihat supported-model-formats. Jika server model ini tidak memenuhi kebutuhan Anda, Anda dapat membuat runtime pelayanan model kustom. Untuk informasi selengkapnya, lihat Customize a model serving runtime with ModelMesh.

Model serving runtime	Supported model frameworks
mlserver-1.x	sklearn, xgboost, lightgbm
ovms-1.x	openvino_ir, onnx
torchserve-0.x	pytorch-mar
triton-2.x	tensorflow, pytorch, onnx, tensorrt

Langkah 2: Konfigurasikan lingkungan ASM

Sinkronkan namespace dari kluster Kubernetes ke instans ASM. Untuk informasi selengkapnya, lihat Synchronize auto-injection labels from a data plane cluster to an ASM instance. Setelah sinkronisasi, pastikan namespace modelmesh-serving tersedia.

Buat aturan gerbang masuk (ingress gateway rule).

Buat file bernama grpc-gateway.yaml dengan konten berikut.

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

Menggunakan KubeConfig untuk kluster yang terkait dengan instans ASM Anda, jalankan perintah berikut untuk membuat aturan gerbang.
```
kubectl apply -f grpc-gateway.yaml
```

Buat layanan virtual (virtual service).

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

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

Menggunakan KubeConfig untuk kluster yang terkait dengan instans ASM Anda, jalankan perintah berikut untuk membuat layanan virtual.
```
kubectl apply -f vs-modelmesh-serving-service.yaml
```

Konfigurasikan transcoder gRPC-JSON.

Buat file bernama 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

Menggunakan KubeConfig untuk kluster yang terkait dengan instans ASM Anda, jalankan perintah berikut untuk menerapkan transcoder gRPC-JSON.
```
kubectl apply -f grpcjsontranscoder-for-kservepredictv2.yaml
```

Buat file bernama grpcjsontranscoder-increasebufferlimit.yaml dengan konten berikut. Konfigurasi ini meningkatkan batas ukuran respons dengan mengatur per_connection_buffer_limit_bytes.

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

Menggunakan KubeConfig untuk kluster yang terkait dengan instans ASM Anda, jalankan perintah berikut untuk menerapkan EnvoyFilter.
```
kubectl apply -f grpcjsontranscoder-increasebufferlimit.yaml
```

Langkah 3: Terapkan model contoh

Buat StorageClass. Untuk informasi selengkapnya, lihat Use dynamic NAS volumes.
1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
2. Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Volumes > StorageClasses.
3. Di pojok kanan atas halaman StorageClasses, klik Create, konfigurasikan parameter berikut, lalu klik Create.
  
  Atur Name menjadi alibabacloud-cnfs-nas. Atur Volume Type menjadi NAS dan Storage Driver menjadi CSI. Atur Reclaim Policy menjadi Delete. Di bagian Mount Options, tambahkan entri untuk nolock,tcp,noresvport dan vers=3. Pilih Mount Point Domain yang sesuai dan atur Path menjadi /.

Buat klaim volume persisten (persistent volume claim/PVC).

Buat file bernama 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

Menggunakan KubeConfig untuk kluster ACK, jalankan perintah berikut untuk membuat klaim volume persisten.
```
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, pasang sebagai volume di pod Kubernetes. Anda kemudian dapat menggunakan pod tersebut untuk mengunggah file model ke volume persisten.
1. Buat file bernama pvc-access.yaml dengan konten berikut.
  
  YAML berikut membuat pod bernama pvc-access yang meminta PVC yang sebelumnya dibuat dengan menentukan nama klaim "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. Menggunakan KubeConfig untuk kluster ACK, jalankan perintah berikut untuk membuat pod.
```
kubectl apply  -n modelmesh-serving  -f pvc-access.yaml
```
3. Pastikan pod pvc-access berada dalam status Running.
```
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 penyimpanan. Topik ini menggunakan model pengenalan digit tulisan tangan MNIST yang dilatih dengan scikit-learn. Anda dapat mengunduh salinan file model mnist-svm.joblib dari repositori kserve/modelmesh-minio-examples.
1. Menggunakan KubeConfig untuk kluster ACK, jalankan perintah berikut untuk menyalin file model mnist-svm.joblib ke folder /mnt/models pod pvc-access.
```
kubectl -n modelmesh-serving cp mnist-svm.joblib pvc-access:/mnt/models/
```
2. Jalankan perintah berikut untuk memastikan model berhasil diunggah.
```
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
```

Terapkan layanan inferensi.

Buat file bernama sklearn-mnist.yaml dengan konten berikut.

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

Menggunakan KubeConfig untuk kluster ACK, jalankan perintah berikut untuk menerapkan layanan inferensi sklearn-mnist.
```
kubectl apply -f sklearn-mnist.yaml
```
Setelah beberapa saat (waktu penerapan bervariasi tergantung kecepatan tarik gambar), jalankan perintah berikut untuk memverifikasi bahwa layanan inferensi sklearn-mnist telah siap.
```
kubectl get isvc -n modelmesh-serving
```
Status READY bernilai True menunjukkan penerapan berhasil.
```
NAME            URL                                               READY
sklearn-mnist   grpc://modelmesh-serving.modelmesh-serving:8033   True
```

Kirim permintaan inferensi.

Gunakan perintah curl untuk mengirim permintaan inferensi ke model sklearn-mnist. Array data merepresentasikan nilai skala abu-abu dari 64 piksel dari citra hasil pemindaian digit tulisan tangan.

MODEL_NAME="sklearn-mnist"
ASM_GW_IP="<asm_gateway_ip_address>"
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]}}]}'</asm_gateway_ip_address>

Tanggapan JSON berikut menunjukkan bahwa model mengenali digit sebagai 8.

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

Topik terkait

Untuk mengakomodasi kebutuhan lingkungan yang beragam, mengoptimalkan efisiensi inferensi, atau mengontrol alokasi sumber daya untuk penerapan multi-model Anda, sesuaikan runtime pelayanan model. Hal ini memungkinkan Anda menyesuaikan lingkungan secara detail dan memastikan setiap model dijalankan dalam kondisi optimal. Untuk informasi selengkapnya, lihat Customize a model serving runtime with ModelMesh.
Untuk memproses data bahasa alami dalam jumlah besar atau membangun sistem pemahaman bahasa yang kompleks, ubah model bahasa besar menjadi layanan inferensi. Untuk informasi selengkapnya, lihat Convert a large language model into an inference service.
Jika pod Anda mengalami pengecualian saat waktu proses, lihat Troubleshoot pod issues.