Deploy and manage multi-model inference services with ModelMesh - Alibaba Cloud Service Mesh

Lorsque vous devez exécuter plusieurs modèles de machine learning pour l'inférence, utilisez ModelMesh pour déployer et gérer des services d'inférence multi-modèles. Basée sur KServe ModelMesh, cette fonctionnalité est optimisée pour les cas d'utilisation à fort volume, haute densité et modèles fréquemment modifiés. Elle charge et décharge intelligemment les modèles en mémoire afin d'équilibrer la réactivité et les ressources de calcul, simplifiant ainsi le déploiement et l'exploitation des services d'inférence multi-modèles tout en améliorant l'efficacité et les performances de l'inférence.

Prérequis

Vous avez ajouté un cluster à une instance ASM de version 1.18.0.134 ou ultérieure.
Vous avez créé une passerelle d'entrée pour le cluster. Pour plus d'informations, consultez la rubrique Créer une passerelle d'entrée.

Remarque

Cette rubrique utilise une passerelle d'entrée ASM comme passerelle de cluster. La passerelle est nommée ingressgateway par défaut et expose le port 8008 pour le trafic HTTP.

Fonctionnalités

ModelMesh offre les fonctionnalités suivantes :

Fonctionnalité	Description
Gestion du cache	Optimise et gère automatiquement la mémoire des pods en fonction de la fréquence et de la récence d'utilisation. Charge et décharge les réplicas de modèles selon la fréquence d'utilisation et le volume actuel des requêtes.
Placement et chargement intelligents	Équilibre le placement des modèles entre les pods en fonction de l'ancienneté du cache et de la charge des requêtes. Utilise des files d'attente pour gérer le chargement concurrent des modèles et minimiser l'impact sur le trafic d'exécution.
Résilience	Retente automatiquement le chargement des modèles ayant échoué sur d'autres pods.
Mises à jour progressives	Gère automatiquement et de manière transparente les mises à jour progressives des modèles.

Étape 1 : Activer ModelMesh dans ASM

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, choisissez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM cible. Dans le volet de navigation de gauche, choisissez Ecosystem > KServe on ASM.
Sur la page KServe on ASM, cliquez sur Install Model Service Mesh pour activer la fonctionnalité ModelMesh.

Remarque : KServe dépend de CertManager. L'installation de KServe installe automatiquement le composant CertManager. Si vous utilisez un CertManager géré manuellement, désactivez l'option Automatically install the CertManager component in the cluster.
Une fois les composants prêts (après quelques minutes), exécutez la commande suivante à l'aide du fichier KubeConfig du cluster pour vérifier que les ressources ServingRuntime sont prêtes.

Sortie attendue :

kubectl get servingruntimes -n modelmesh-serving

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

Un ServingRuntime définit un modèle de pod pour servir un ou plusieurs formats de modèles spécifiques. ModelMesh provisionne automatiquement le pod correspondant en fonction du framework du modèle déployé.

Le tableau suivant répertorie les runtimes par défaut et leurs formats de modèles pris en charge. Pour plus d'informations, consultez la documentation supported-model-formats. Si ces serveurs de modèles ne répondent pas à vos besoins, vous pouvez créer un runtime de service de modèle personnalisé. Pour plus d'informations, consultez la rubrique Personnaliser un runtime de service de modèle avec ModelMesh.

Runtime de service de modèle	Frameworks de modèles pris en charge
mlserver-1.x	sklearn, xgboost, lightgbm
ovms-1.x	openvino_ir, onnx
torchserve-0.x	pytorch-mar
triton-2.x	tensorflow, pytorch, onnx, tensorrt

Étape 2 : Configurer l'environnement ASM

Synchronisez les namespaces du cluster Kubernetes vers l'instance ASM. Pour plus d'informations, consultez la rubrique Synchroniser les libellés d'injection automatique d'un cluster de plan de données vers une instance ASM. Après la synchronisation, vérifiez que le namespace modelmesh-serving existe.

Créez une règle de passerelle d'entrée.

Créez un fichier nommé grpc-gateway.yaml avec le contenu suivant.

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

À l'aide du fichier KubeConfig du cluster associé à votre instance ASM, exécutez la commande suivante pour créer la règle de passerelle.
```
kubectl apply -f grpc-gateway.yaml
```

Créez un service virtuel.

Créez un fichier nommé vs-modelmesh-serving-service.yaml avec le contenu suivant.

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

À l'aide du fichier KubeConfig du cluster associé à votre instance ASM, exécutez la commande suivante pour créer le service virtuel.
```
kubectl apply -f vs-modelmesh-serving-service.yaml
```

Configurez le transcodeur gRPC-JSON.

Créez un fichier nommé grpcjsontranscoder-for-kservepredictv2.yaml avec le contenu suivant.

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

À l'aide du fichier KubeConfig du cluster associé à votre instance ASM, exécutez la commande suivante pour déployer le transcodeur gRPC-JSON.
```
kubectl apply -f grpcjsontranscoder-for-kservepredictv2.yaml
```

Créez un fichier nommé grpcjsontranscoder-increasebufferlimit.yaml avec le contenu suivant. Cette configuration augmente la limite de taille de réponse en définissant le paramètre 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

À l'aide du fichier KubeConfig du cluster associé à votre instance ASM, exécutez la commande suivante pour déployer l'EnvoyFilter.
```
kubectl apply -f grpcjsontranscoder-increasebufferlimit.yaml
```

Étape 3 : Déployer un exemple de modèle

Créez une StorageClass. Pour plus d'informations, consultez la rubrique Utiliser des volumes NAS dynamiques.
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Volumes > StorageClasses.
3. Dans le coin supérieur droit de la page StorageClasses, cliquez sur Create, configurez les paramètres suivants, puis cliquez sur Create.
  
  Définissez Name sur alibabacloud-cnfs-nas. Définissez Volume Type sur NAS et Storage Driver sur CSI. Définissez Reclaim Policy sur Delete. Dans la section Mount Options, ajoutez les entrées nolock,tcp,noresvport et vers=3. Sélectionnez le Mount Point Domain approprié et définissez Path sur /.

Créez une revendication de volume persistant (PVC).

Créez un fichier nommé my-models-pvc.yaml avec le contenu suivant.

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

À l'aide du fichier KubeConfig du cluster ACK, exécutez la commande suivante pour créer la revendication de volume persistant.
```
kubectl apply -f my-models-pvc.yaml
```

Exécutez la commande suivante pour afficher les PVC dans le namespace modelmesh-serving.

kubectl get pvc -n modelmesh-serving

Sortie attendue :

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

Créez un pod pour accéder au PVC.

Pour utiliser le nouveau PVC, montez-le en tant que volume dans un pod Kubernetes. Vous pourrez ensuite utiliser ce pod pour télécharger des fichiers de modèle sur le volume persistant.
1. Créez un fichier nommé pvc-access.yaml avec le contenu suivant.
  
  Le fichier YAML suivant crée un pod nommé pvc-access qui demande le PVC précédemment créé en spécifiant le nom de la revendication "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. À l'aide du fichier KubeConfig du cluster ACK, exécutez la commande suivante pour créer le pod.
```
kubectl apply  -n modelmesh-serving  -f pvc-access.yaml
```
3. Vérifiez que le pod pvc-access est dans l'état Running.
```
kubectl get pods -n modelmesh-serving | grep pvc-access
```
  Sortie attendue :
```
pvc-access             1/1     Running   0          51m
```
Stockez le modèle sur le volume persistant.

Ajoutez le modèle d'IA au volume de stockage. Cette rubrique utilise un modèle de reconnaissance de chiffres manuscrits MNIST entraîné avec scikit-learn. Vous pouvez télécharger une copie du fichier de modèle mnist-svm.joblib depuis le dépôt kserve/modelmesh-minio-examples.
1. À l'aide du fichier KubeConfig du cluster ACK, exécutez la commande suivante pour copier le fichier de modèle mnist-svm.joblib dans le dossier /mnt/models du pod pvc-access.
```
kubectl -n modelmesh-serving cp mnist-svm.joblib pvc-access:/mnt/models/
```
2. Exécutez la commande suivante pour confirmer que le modèle a été téléchargé avec succès.
```
kubectl -n modelmesh-serving exec -it pvc-access -- ls -alr /mnt/models/
```
  Sortie attendue :
```
-rw-r--r-- 1  501 staff 344817 Oct 30 11:23 mnist-svm.joblib
```

Déployez le service d'inférence.

Créez un fichier nommé sklearn-mnist.yaml avec le contenu suivant.

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

À l'aide du fichier KubeConfig du cluster ACK, exécutez la commande suivante pour déployer le service d'inférence sklearn-mnist.
```
kubectl apply -f sklearn-mnist.yaml
```
Après quelques instants (le temps de déploiement varie selon la vitesse de récupération de l'image), exécutez la commande suivante pour vérifier que le service d'inférence sklearn-mnist est prêt.
```
kubectl get isvc -n modelmesh-serving
```
Un statut READY indiquant True signifie que le déploiement a réussi.
```
NAME            URL                                               READY
sklearn-mnist   grpc://modelmesh-serving.modelmesh-serving:8033   True
```

Envoyez une requête d'inférence.

Utilisez la commande curl pour envoyer une requête d'inférence au modèle sklearn-mnist. Le tableau de données représente les valeurs de niveaux de gris de 64 pixels provenant d'une image numérisée d'un chiffre manuscrit.

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

La réponse JSON suivante indique que le modèle a reconnu le chiffre 8.

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

Rubriques connexes

Pour répondre aux besoins variés de l'environnement, optimiser l'efficacité de l'inférence ou contrôler l'allocation des ressources pour vos déploiements multi-modèles, personnalisez un runtime de service de modèle. Cela vous permet d'affiner l'environnement et de garantir que chaque modèle s'exécute dans des conditions optimales. Pour plus d'informations, consultez la rubrique Personnaliser un runtime de service de modèle avec ModelMesh.
Pour traiter de grandes quantités de données en langage naturel ou construire des systèmes complexes de compréhension du langage, convertissez un grand modèle de langage en service d'inférence. Pour plus d'informations, consultez la rubrique Convertir un grand modèle de langage en service d'inférence.
Si vos pods rencontrent des exceptions lors de l'exécution, consultez la rubrique Résoudre les problèmes liés aux pods.