Implantar e gerenciar serviços de inferência multimodelo com ModelMesh - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

Para executar vários modelos de machine learning para inferência, use o ModelMesh para implantar e gerenciar serviços de inferência multimodelo. Baseado no KServe ModelMesh, este recurso é otimizado para casos de uso com alto volume, alta densidade e mudanças frequentes de modelos. Ele carrega e descarrega modelos da memória de forma inteligente para equilibrar a capacidade de resposta e os recursos computacionais. Isso simplifica a implantação e a operação de serviços de inferência multimodelo, além de melhorar a eficiência e o desempenho da inferência.

Pré-requisitos

Adicione um cluster a uma instância do ASM versão 1.18.0.134 ou posterior.
Crie um gateway de entrada para o cluster. Para mais informações, consulte Criar um gateway de entrada.

Nota

Este tópico usa um gateway de entrada do ASM como gateway do cluster. O gateway recebe o nome ingressgateway por padrão e expõe a porta 8008 para tráfego HTTP.

Recursos

O ModelMesh oferece os seguintes recursos:

Recurso	Descrição
Gerenciamento de cache	Otimiza e gerencia automaticamente a memória dos pods com base na frequência e recência de uso. Carrega e descarrega réplicas de modelos conforme a frequência de uso e o volume atual de solicitações.
Posicionamento e carregamento inteligentes	Equilibra o posicionamento dos modelos entre os pods considerando a idade do cache e a carga de solicitações. Usa filas para lidar com o carregamento simultâneo de modelos e minimizar o impacto no tráfego em tempo de execução.
Resiliência	Tenta novamente, de forma automática, carregar modelos que falharam em pods diferentes.
Atualizações contínuas	Gerencia atualizações contínuas de modelos de maneira automática e transparente.

Etapa 1: Ativar o ModelMesh no ASM

Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
Na página Mesh Management, clique em o nome da instância ASM desejada. No painel de navegação à esquerda, escolha Ecosystem > KServe on ASM.
Na página KServe on ASM, clique em Install Model Service Mesh para ative o recurso ModelMesh.

Nota: O KServe depende do CertManager. A instalação do KServe instala automaticamente o componente CertManager. Caso use um CertManager autogerenciado, desative a opção Automatically install the CertManager component in the cluster.
Após alguns minutos, quando os componentes estiverem prontos, execute o comando abaixo usando o KubeConfig do cluster para verifique se os recursos ServingRuntime estão disponíveis.

Saída esperada:

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

Um ServingRuntime define um modelo de pod para servir um ou mais formatos específicos de modelos. O ModelMesh provisiona automaticamente o pod correspondente com base no framework do modelo implantado.

A tabela a seguir lista os runtimes padrão e seus formatos de modelo suportados. Para mais informações, consulte formatos de modelo suportados. Se esses servidores de modelo não atenderem aos seus requisitos, crie um runtime de serviço de modelo personalizado. Para mais detalhes, veja Personalizar um runtime de serviço de modelo com ModelMesh.

Runtime de serviço de modelo	Frameworks de modelo suportados
mlserver-1.x	sklearn, xgboost, lightgbm
ovms-1.x	openvino_ir, onnx
torchserve-0.x	pytorch-mar
triton-2.x	tensorflow, pytorch, onnx, tensorrt

Etapa 2: Configure o ambiente do ASM

Sincronize os namespaces do cluster Kubernetes para a instância do ASM. Para mais informações, consulte Sincronizar rótulos de injeção automática de um cluster de plano de dados para uma instância do ASM. Após a sincronização, confirme que o namespace modelmesh-serving existe.

Crie uma regra de gateway de entrada.

Crie um arquivo chamado grpc-gateway.yaml com o seguinte conteúdo.

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

Com o KubeConfig do cluster associado à sua instância do ASM, execute o comando a seguir para crie a regra do gateway.
```
kubectl apply -f grpc-gateway.yaml
```

Crie um serviço virtual.

Crie um arquivo chamado vs-modelmesh-serving-service.yaml com o seguinte conteúdo.

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

Com o KubeConfig do cluster associado à sua instância do ASM, execute o comando a seguir para crie o serviço virtual.
```
kubectl apply -f vs-modelmesh-serving-service.yaml
```

Configure o transcodificador gRPC-JSON.

Crie um arquivo chamado grpcjsontranscoder-for-kservepredictv2.yaml com o seguinte conteúdo.

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

Com o KubeConfig do cluster associado à sua instância do ASM, execute o comando a seguir para implantar o transcodificador gRPC-JSON.
```
kubectl apply -f grpcjsontranscoder-for-kservepredictv2.yaml
```

Crie um arquivo chamado grpcjsontranscoder-increasebufferlimit.yaml com o seguinte conteúdo. Esta configuração aumenta o limite de tamanho da resposta definindo o parâmetro 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

Com o KubeConfig do cluster associado à sua instância do ASM, execute o comando a seguir para implantar o EnvoyFilter.
```
kubectl apply -f grpcjsontranscoder-increasebufferlimit.yaml
```

Etapa 3: Implantar um modelo de exemplo

Crie uma StorageClass. Para mais informações, consulte Usar volumes NAS dinâmicos.
1. Faça login no console do ACK. No painel de navegação à esquerda, clique em Clusters.
2. Na página Clusters, clique em o nome do seu cluster. No painel de navegação à esquerda, clique em Volumes > StorageClasses.
3. No canto superior direito da página StorageClasses, clique em Create, configure os parâmetros a seguir e clique em Create.
  
  Defina Name como alibabacloud-cnfs-nas. Defina Volume Type como NAS e Storage Driver como CSI. Defina Reclaim Policy como Delete. Na seção Mount Options, adicione entradas para nolock,tcp,noresvport e vers=3. Selecione o Mount Point Domain apropriado e defina Path como /.

Crie uma persistent volume claim (PVC).

Crie um arquivo chamado my-models-pvc.yaml com o seguinte conteúdo.

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

Com o KubeConfig do cluster ACK, execute o comando a seguir para crie a persistent volume claim.
```
kubectl apply -f my-models-pvc.yaml
```

Execute o comando a seguir para visualize as PVCs no namespace modelmesh-serving.

kubectl get pvc -n modelmesh-serving

Saída esperada:

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

Crie um pod para acessar a PVC.

Para usar a nova PVC, monte-a como um volume em um pod do Kubernetes. Em seguida, use esse pod para enviar arquivos de modelo para o volume persistente.
1. Crie um arquivo chamado pvc-access.yaml com o seguinte conteúdo.
  
  O YAML abaixo cria um pod chamado pvc-access que solicita a PVC criada anteriormente especificando o nome da claim "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. Com o KubeConfig do cluster ACK, execute o comando a seguir para crie o pod.
```
kubectl apply  -n modelmesh-serving  -f pvc-access.yaml
```
3. Confirme se o pod pvc-access está no estado Running.
```
kubectl get pods -n modelmesh-serving | grep pvc-access
```
  Saída esperada:
```
pvc-access             1/1     Running   0          51m
```
Armazene o modelo no volume persistente.

Adicione o modelo de IA ao volume de armazenamento. Este tópico usa um modelo de reconhecimento de dígitos manuscritos MNIST treinado com scikit-learn. Baixe uma cópia do arquivo de modelo mnist-svm.joblib do repositório kserve/modelmesh-minio-examples.
1. Com o KubeConfig do cluster ACK, execute o comando a seguir para copiar o arquivo de modelo mnist-svm.joblib para a pasta /mnt/models do pod pvc-access.
```
kubectl -n modelmesh-serving cp mnist-svm.joblib pvc-access:/mnt/models/
```
2. Execute o comando a seguir para confirme se o modelo foi enviado com sucesso.
```
kubectl -n modelmesh-serving exec -it pvc-access -- ls -alr /mnt/models/
```
  Saída esperada:
```
-rw-r--r-- 1  501 staff 344817 Oct 30 11:23 mnist-svm.joblib
```

Implante o serviço de inferência.

Crie um arquivo chamado sklearn-mnist.yaml com o seguinte conteúdo.

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

Com o KubeConfig do cluster ACK, execute o comando a seguir para implantar o serviço de inferência sklearn-mnist.
```
kubectl apply -f sklearn-mnist.yaml
```
Após alguns instantes (o tempo de implantação varia conforme a velocidade de download da imagem), execute o comando a seguir para verifique se o serviço de inferência sklearn-mnist está pronto.
```
kubectl get isvc -n modelmesh-serving
```
Um status READY com valor True indica uma implantação bem-sucedida.
```
NAME            URL                                               READY
sklearn-mnist   grpc://modelmesh-serving.modelmesh-serving:8033   True
```

Envie uma solicitação de inferência.

Use o comando curl para enviar uma solicitação de inferência ao modelo sklearn-mnist. O array de dados representa os valores de escala de cinza de 64 pixels de uma imagem digitalizada de um dígito manuscrito.

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]}}]}'

A resposta JSON a seguir indica que o modelo reconheceu o dígito como 8.

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

Tópicos relacionados

Para atender a diferentes necessidades de ambiente, otimizar a eficiência da inferência ou controlar a alocação de recursos em implantações multimodelo, personalize um runtime de serviço de modelo. Isso permite ajustar o ambiente e garantir que cada modelo seja executado nas condições ideais. Para mais informações, consulte Personalizar um runtime de serviço de modelo com ModelMesh.
Para processar grandes volumes de dados de linguagem natural ou construir sistemas complexos de compreensão de linguagem, converta um modelo de linguagem grande em um serviço de inferência. Para mais informações, consulte Converter um modelo de linguagem grande em um serviço de inferência.
Caso seus pods apresentem exceções durante a execução, consulte Solucionar problemas de pods.