Container Service for Kubernetes:Despliegue de un servicio de inference para modelos TensorFlow

Requisitos previos

• Use the default Kubernetes GPU schedulingYou have created a GPU cluster.

• Cluster nodes can access the public network.

• You have configured the Arena client.

• You have completed standalone TensorFlow training.

Procedimiento

1. Ejecute el siguiente comando para consultar los recursos de GPU disponibles en el clúster.

   arena top node

   Salida esperada:

   NAME                      IPADDRESS      ROLE    STATUS  GPU(Total)  GPU(Allocated)
   cn-beijing.192.168.0.100  192.168.0.100  <none>  Ready   1           0
   cn-beijing.192.168.0.101  192.168.0.101  <none>  Ready   1           0
   cn-beijing.192.168.0.99   192.168.0.99   <none>  Ready   1           0
   ---------------------------------------------------------------------------------------------------
   Allocated/Total GPUs of nodes which own resource nvidia.com/gpu In Cluster:
   0/3 (0.0%)

   La salida indica que hay tres nodos con GPU disponibles para el despliegue del modelo.

2. Cargue el modelo en un bucket de Object Storage Service (OSS).

   Importante

   Los siguientes pasos para cargar el modelo en OSS corresponden a un sistema Linux. Para obtener instrucciones de carga en otros sistemas operativos, consulte Quick start for the ossutil command-line tool.

   1. Install ossutil.

   2. Cree un bucket llamado examplebucket.

      • Ejecute el siguiente comando para crear examplebucket.

        ossutil64 mb oss://examplebucket

      • La siguiente salida indica que examplebucket se creó correctamente.

        0.668238(s) elapsed

   3. Cargue el modelo en el bucket examplebucket.

      ossutil64 cp model.savedmodel oss://examplebucket

3. Cree un volumen persistente (PV) y una solicitud de volumen persistente (PVC).

   1. Cree un archivo Tensorflow.yaml basado en la siguiente plantilla.

      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: model-csi-pv
      spec:
        capacity:
          storage: 5Gi
        accessModes:
          - ReadWriteMany
        persistentVolumeReclaimPolicy: Retain
        csi:
          driver: ossplugin.csi.alibabacloud.com
          volumeHandle: model-csi-pv   # Must be the same as the PV name.
          volumeAttributes:
            bucket: "Your Bucket"
            url: "Your oss url"
            akId: "Your AccessKey ID"
            akSecret: "Your AccessKey Secret"
            otherOpts: "-o max_stat_cache_size=0 -o allow_other"
      ---
      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: model-pvc
      spec:
        accessModes:
        - ReadWriteMany
        resources:
          requests:
            storage: 5Gi

      Parámetro	Descripción
      bucket	Nombre del bucket de OSS. Debe ser único a nivel global dentro de OSS. Para más información, consulte Bucket naming conventions.
      url	URL utilizada para acceder a los archivos de OSS. Para más información, consulte Obtain URLs of a single file or multiple files.
      akId	AccessKey ID y AccessKey Secret utilizados para acceder a OSS. Se recomienda usar un usuario de RAM para el acceso. Para más información, consulte Create an AccessKey pair.
      akSecret
      otherOpts	Parámetros personalizados para montar OSS. La opción -o max_stat_cache_size=0 deshabilita la caché de atributos. Cada vez que se accede a un archivo, se recupera la información de atributos más reciente desde OSS. La opción -o allow_other permite que otros usuarios accedan al sistema de archivos montado. Para más información sobre la configuración de parámetros, consulte ossfs-supported setting options.

   2. Ejecute el siguiente comando para crear el PV y la PVC.

      kubectl apply -f Tensorflow.yaml

4. Ejecute el siguiente comando para iniciar una instancia de tensorflow serving llamada bert-tfserving.

   arena serve tensorflow \
     --name=bert-tfserving \
     --model-name=chnsenticorp  \
     --gpus=1  \
     --image=tensorflow/serving:1.15.0-gpu \
     --data=model-pvc:/models \
     --model-path=/models/tensorflow \
     --version-policy=specific:1623831335

   Salida esperada:

   configmap/bert-tfserving-202106251556-tf-serving created
   configmap/bert-tfserving-202106251556-tf-serving labeled
   configmap/bert-tfserving-202106251556-tensorflow-serving-cm created
   service/bert-tfserving-202106251556-tensorflow-serving created
   deployment.apps/bert-tfserving-202106251556-tensorflow-serving created
   INFO[0003] The Job bert-tfserving has been submitted successfully
   INFO[0003] You can run `arena get bert-tfserving --type tf-serving` to check the job status

5. Ejecute el siguiente comando para listar los servicios que se están ejecutando actualmente.

   arena serve list

   Solo el servicio bert-tfserving se encuentra en ejecución:

   NAME            TYPE        VERSION       DESIRED  AVAILABLE  ADDRESS        PORTS
   bert-tfserving  Tensorflow  202106251556  1        1          172.16.95.171  GRPC:8500,RESTFUL:8501

6. Ejecute el siguiente comando para consultar los detalles del servicio de inference bert-tfserving.

   arena serve get bert-tfserving

   Salida esperada:

   Name:       bert-tfserving
   Namespace:  inference
   Type:       Tensorflow
   Version:    202106251556
   Desired:    1
   Available:  1
   Age:        4m
   Address:    172.16.95.171
   Port:       GRPC:8500,RESTFUL:8501
   Instances:
     NAME                                                             STATUS   AGE  READY  RESTARTS  NODE
     ----                                                             ------   ---  -----  --------  ----
     bert-tfserving-202106251556-tensorflow-serving-8554d58d67-jd2z9  Running  4m   1/1    0         cn-beijing.192.168.0.88

   La salida muestra que el modelo se desplegó correctamente mediante tensorflow serving y expone dos puertos de API: 8500 (gRPC) y 8501 (HTTP).

7. De forma predeterminada, arena serve tensorflow expone el servicio de inference a través de una ClusterIP. Es necesario configurar un Ingress de red pública para el acceso directo.

   1. En la página Clusters, haga clic en el nombre del clúster destino. En el panel de navegación izquierdo, seleccione Network > Ingresses.

   2. En la lista desplegable Namespace situada en la parte superior de la página, seleccione el namespace inference, que contiene el servicio de inference creado en el paso 6.

   3. En la esquina superior derecha de la página, haga clic en Create Ingress. Para más información sobre los parámetros, consulte Create and use an NGINX Ingress to expose a service.

      • Name: En este ejemplo, establezca el nombre como Tensorflow.

      • Rule:

        • Host: Un nombre de dominio personalizado, por ejemplo, test.example.com.

        • Mappings:

          • Path: Deje este campo vacío para usar la ruta raíz /.

          • Match Rule: El valor predeterminado (ImplementationSpecific).

          • Service: Obtenga el nombre ejecutando el comando kubectl get service.

          • Port: En este ejemplo, establezca el puerto en 8501.

8. Una vez creado el Ingress, obtenga su dirección desde la columna Ingresses en la página Rules.

9. Ejecute el siguiente comando para invocar la API del servicio de inference. Para más información sobre tensorflow serving, consulte la documentación de la API en Tensorflow Serving API.

   curl "http://<Ingress address>"

   Salida esperada:

   {
    "model_version_status": [
     {
      "version": "1623831335",
      "state": "AVAILABLE",
      "status": {
       "error_code": "OK",
       "error_message": ""
      }
     }
    ]
   }