Entrega un modelo con una sola GPU en GKE

En este instructivo, se muestra cómo implementar y entregar un modelo de lenguaje grande (LLM) con GPUs en Google Kubernetes Engine (GKE) con NVIDIA Triton Inference Server y TensorFlow Serving. Esto proporciona una base para comprender y explorar la implementación práctica de LLM para la inferencia en un entorno de Kubernetes administrado. Implementarás un contenedor compilado previamente en un clúster de GKE con una sola GPU de núcleo de tensor L4 y prepararás la infraestructura de GKE para realizar inferencias en línea.

Este instructivo está dirigido a ingenieros de aprendizaje automático (AA), administradores y operadores de plataformas, y especialistas en IA y datos que deseen alojar un modelo de aprendizaje automático (AA) previamente entrenado en un clúster de GKE. Para obtener más información sobre los roles comunes y las tareas de ejemplo a los que se hace referencia en el contenido de Google Cloud, consulta Roles y tareas comunes de los usuarios de GKE.

Antes de leer esta página, asegúrate de estar familiarizado con lo siguiente:

• Disponibilidad actual de la versión de GPU
• GPUs en GKE

Cree un bucket de Cloud Storage

Crea un bucket de Cloud Storage para almacenar el modelo previamente entrenado que se entregará

En Cloud Shell, ejecuta lo siguiente:

gcloud storage buckets create gs://$GSBUCKET

Configura tu clúster a fin de acceder al bucket mediante la federación de identidades para cargas de trabajo para GKE

Para permitir que tu clúster acceda al bucket de Cloud Storage, haz lo siguiente:

1. Crea una cuenta de servicio Google Cloud .
2. Crea una ServiceAccount de Kubernetes en tu clúster.
3. Vincula la ServiceAccount de Kubernetes a la cuenta de servicio de Google Cloud .

Crea una cuenta de servicio Google Cloud

1. En la consola de Google Cloud , ve a la página Crear cuenta de servicio:

   Ve a Crear cuenta de servicio

2. En el campo ID de cuenta de servicio, ingresa gke-ai-sa.

3. Haz clic en Crear y continuar.

4. En la lista Rol, selecciona el rol Cloud Storage > Servicio de recopilador de Storage Insights.

5. Haz clic en Agregar otro rol.

6. En la lista Seleccionar un rol, selecciona el rol Cloud Storage > Administrador de objetos de almacenamiento.

7. Haz clic en Continuar y, luego, en Listo.

Crea una ServiceAccount de Kubernetes en tu clúster

En Cloud Shell, haz lo siguiente:

1. Crea un espacio de nombres de Kubernetes:

   kubectl create namespace gke-ai-namespace
   

2. Crea una ServiceAccount de Kubernetes en el espacio de nombres:

   kubectl create serviceaccount gpu-k8s-sa --namespace=gke-ai-namespace
   

Vincula la ServiceAccount de Kubernetes a la cuenta de servicio Google Cloud

En Cloud Shell, ejecuta los siguientes comandos:

1. Agrega una vinculación de IAM a la cuenta de servicio Google Cloud :

   gcloud iam service-accounts add-iam-policy-binding gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[gke-ai-namespace/gpu-k8s-sa]"
   

   La marca --member proporciona la identidad completa de la ServiceAccount de Kubernetes en Google Cloud.

2. Anota la ServiceAccount de Kubernetes:

   kubectl annotate serviceaccount gpu-k8s-sa \
       --namespace gke-ai-namespace \
       iam.gke.io/gcp-service-account=gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com
   

Implementa el servidor de inferencia en línea

Cada framework de inferencia en línea espera encontrar el modelo de AA previamente entrenado en un formato específico. En la siguiente sección, se muestra cómo implementar el servidor de inferencia según el framework que desees usar:

Triton

1. En Cloud Shell, copia el modelo de AA previamente entrenado en el bucket de Cloud Storage:

   gcloud storage cp src/triton-model-repository gs://$GSBUCKET --recursive
   

2. Implementa el framework con un objeto Deployment. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster:

   envsubst < src/gke-config/deployment-triton.yaml | kubectl --namespace=gke-ai-namespace apply -f -
   

3. Valida que GKE haya implementado el framework:

   kubectl get deployments --namespace=gke-ai-namespace
   

   Cuando el framework está listo, el resultado es similar al siguiente:

   NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
   triton-deployment    1/1     1            1           5m29s
   

4. Implementa los servicios para acceder a la Deployment:

   kubectl apply --namespace=gke-ai-namespace -f src/gke-config/service-triton.yaml
   

5. Comprueba que la IP externa esté asignada:

   kubectl get services --namespace=gke-ai-namespace
   

   El resultado es similar al siguiente:

   NAME            TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                                        AGE
   kubernetes      ClusterIP      34.118.224.1     <none>          443/TCP                                        60m
   triton-server   LoadBalancer   34.118.227.176   35.239.54.228   8000:30866/TCP,8001:31035/TCP,8002:30516/TCP   5m14s
   

   Toma nota de la dirección IP de triton-server en la columna EXTERNAL-IP.

6. Comprueba que el servicio y la implementación funcionen de forma correcta:

   curl -v EXTERNAL_IP:8000/v2/health/ready
   

   El resultado es similar al siguiente:

   ...
   < HTTP/1.1 200 OK
   < Content-Length: 0
   < Content-Type: text/plain
   ...
   

TF Serving

1. En Cloud Shell, copia el modelo de AA previamente entrenado en el bucket de Cloud Storage:

   gcloud storage cp src/tfserve-model-repository gs://$GSBUCKET --recursive
   

2. Implementa el framework con un objeto Deployment. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster:

   envsubst < src/gke-config/deployment-tfserve.yaml | kubectl --namespace=gke-ai-namespace apply -f -
   

3. Valida que GKE haya implementado el framework:

   kubectl get deployments --namespace=gke-ai-namespace
   

   Cuando el framework está listo, el resultado es similar al siguiente:

   NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
   tfserve-deployment   1/1     1            1           5m29s
   

4. Implementa los servicios para acceder a la Deployment:

   kubectl apply --namespace=gke-ai-namespace -f src/gke-config/service-tfserve.yaml
   

5. Comprueba que la IP externa esté asignada:

   kubectl get services --namespace=gke-ai-namespace
   

   El resultado es similar al siguiente:

   NAME            TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                                        AGE
   kubernetes      ClusterIP      34.118.224.1     <none>          443/TCP                                        60m
   tfserve-server  LoadBalancer   34.118.227.176   35.239.54.228   8500:30003/TCP,8000:32194/TCP                  5m14s
   

   Toma nota de la dirección IP de tfserve-server en la columna EXTERNAL-IP.

6. Comprueba que el servicio y la Deployment funcionen de forma correcta:

   curl -v EXTERNAL_IP:8000/v1/models/mnist
   

   Reemplaza EXTERNAL_IP por tu dirección IP externa.

   El resultado es similar al siguiente:

   ...
   < HTTP/1.1 200 OK
   < Content-Type: application/json
   < Date: Thu, 12 Oct 2023 19:01:19 GMT
   < Content-Length: 154
   <
   {
     "model_version_status": [
           {
           "version": "1",
           "state": "AVAILABLE",
           "status": {
             "error_code": "OK",
             "error_message": ""
           }
         }
       ]
   }
   

Entrega el modelo

Triton

1. Crea un entorno virtual de Python en Cloud Shell.

   python -m venv ./mnist_client
   source ./mnist_client/bin/activate
   

2. Instala los paquetes de Python necesarios:

   pip install -r src/client/triton-requirements.txt
   

3. Prueba el servidor de inferencia de Triton con la carga de una imagen:

   cd src/client
   python triton_mnist_client.py -i EXTERNAL_IP -m mnist -p ./images/TEST_IMAGE.png
   

   Reemplaza lo siguiente:

   • EXTERNAL_IP: Es la dirección IP externa.
   • TEST_IMAGE: Es el nombre del archivo que corresponde a la imagen que deseas probar. Puedes usar las imágenes almacenadas en src/client/images.

   Según la imagen que uses, el resultado es similar al siguiente:

   Calling Triton HTTP Service      ->      Prediction result: 7
   

Nota: Puedes escribir clientes que ejecuten inferencias en el servidor de inferencia de Triton. Para obtener más información, consulta los ejemplos y bibliotecas de NVIDIA.

TF Serving

1. Crea un entorno virtual de Python en Cloud Shell.

   python -m venv ./mnist_client
   source ./mnist_client/bin/activate
   

2. Instala los paquetes de Python necesarios:

   pip install -r src/client/tfserve-requirements.txt
   

3. Prueba TensorFlow Serving con algunas imágenes.

   cd src/client
   python tfserve_mnist_client.py -i EXTERNAL_IP -m mnist -p ./images/TEST_IMAGE.png
   

Reemplaza lo siguiente:

• EXTERNAL_IP: Es la dirección IP externa.
• TEST_IMAGE: Un valor de 0 a 9. Puedes usar las imágenes almacenadas en src/client/images.

Según la imagen que uses, obtendrás un resultado similar al siguiente:

  Calling TensorFlow Serve HTTP Service    ->      Prediction result: 5

Nota: Puedes escribir clientes que ejecuten inferencias en el servidor de TensorFlow. Para obtener más información, consulta API de TensorFlow.

Éxito: Implementaste con éxito un marco de trabajo de entrega en línea para un modelo de AA previamente entrenado.

Observa el rendimiento del modelo

Triton

Para observar el rendimiento del modelo, puedes usar la integración del panel de Triton en Cloud Monitoring. Con este panel, puedes ver métricas de rendimiento críticas, como el rendimiento de tokens, la latencia de solicitudes y las tasas de error.

Para usar el panel de Triton, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de Triton, en tu clúster de GKE. Triton expone las métricas en formato Prometheus de forma predeterminada. No es necesario que instales un exportador adicional.

Luego, puedes ver las métricas con el panel de Triton. Para obtener información sobre cómo usar Google Cloud Managed Service para Prometheus para recopilar métricas de tu modelo, consulta la guía de observabilidad de Triton en la documentación de Cloud Monitoring.

TF Serving

Para observar el rendimiento del modelo, puedes usar la integración del panel de TF Serving en Cloud Monitoring. Con este panel, puedes ver métricas de rendimiento críticas, como el rendimiento de tokens, la latencia de solicitudes y las tasas de error.

Para usar el panel de TF Serving, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de TF Serving, en tu clúster de GKE.

Luego, puedes ver las métricas con el panel de TF Serving. Si deseas obtener información para usar Google Cloud Managed Service para Prometheus y recopilar métricas de tu modelo, consulta la guía de observabilidad de TF Serving en la documentación de Cloud Monitoring.