Servir LLMs escalables en GKE con TorchServe

Preparar el entorno

Clona el repositorio de ejemplo y abre el directorio del tutorial:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Crear el clúster

Ejecuta el siguiente comando:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Haz los cambios siguientes:

• RELEASE_CHANNEL: el canal de lanzamiento de tu clúster. Debe ser rapid, regular o stable. Elige un canal que tenga la versión 1.28.3-gke.1203000 de GKE o una posterior para usar las GPUs L4. Para ver las versiones disponibles en un canal específico, consulta Ver las versiones predeterminadas y disponibles de los canales de lanzamiento.
• CLUSTER_VERSION: la versión de GKE que se va a usar. Debe ser 1.28.3-gke.1203000 o posterior.

Esta operación tarda varios minutos en completarse.

Crear un repositorio de Artifact Registry

1. Crea un repositorio estándar de Artifact Registry con el formato Docker en la misma región que tu clúster:

   gcloud artifacts repositories create models \
       --repository-format=docker \
       --location=us-central1 \
       --description="Repo for T5 serving image"
   

2. Verifica el nombre del repositorio:

   gcloud artifacts repositories describe models \
       --location=us-central1
   

   El resultado debería ser similar al siguiente:

   Encryption: Google-managed key
   Repository Size: 0.000MB
   createTime: '2023-06-14T15:48:35.267196Z'
   description: Repo for T5 serving image
   format: DOCKER
   mode: STANDARD_REPOSITORY
   name: projects/PROJECT_ID/locations/us-central1/repositories/models
   updateTime: '2023-06-14T15:48:35.267196Z'
   

Empaquetar el modelo

En esta sección, empaquetarás el modelo y el framework de servicio en una sola imagen de contenedor con Cloud Build y enviarás la imagen resultante al repositorio de Artifact Registry.

1. Revisa el Dockerfile de la imagen de contenedor:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ARG BASE_IMAGE=pytorch/torchserve:0.12.0-cpu
   
   FROM alpine/git
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   RUN git clone "${MODEL_REPO}" /model
   
   FROM ${BASE_IMAGE}
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_VERSION=1.0
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   COPY --from=0 /model/. /home/model-server/
   COPY handler.py \
        model.py \
        requirements.txt \
        setup_config.json /home/model-server/
   
   RUN  torch-model-archiver \
        --model-name="${MODEL_NAME}" \
        --version="${MODEL_VERSION}" \
        --model-file="model.py" \
        --serialized-file="pytorch_model.bin" \
        --handler="handler.py" \
        --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
        --runtime="python" \
        --export-path="model-store" \
        --requirements-file="requirements.txt"
   
   FROM ${BASE_IMAGE}
   
   ENV PATH /home/model-server/.local/bin:$PATH
   ENV TS_CONFIG_FILE /home/model-server/config.properties
   # CPU inference will throw a warning cuda warning (not error)
   # Could not load dynamic library 'libnvinfer_plugin.so.7'
   # This is expected behaviour. see: https://stackoverflow.com/a/61137388
   ENV TF_CPP_MIN_LOG_LEVEL 2
   
   COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
   COPY config.properties /home/model-server/
   

   Este archivo Dockerfile define el siguiente proceso de compilación de varias fases:

   1. Descarga los artefactos del modelo del repositorio de Hugging Face.
   2. Empaqueta el modelo con la herramienta PyTorch Serving Archive. De este modo, se crea un archivo de modelo (.mar) que el servidor de inferencia usa para cargar el modelo.
   3. Crea la imagen final con PyTorch Serve.

2. Crea y envía la imagen con Cloud Build:

   gcloud builds submit model/ \
       --region=us-central1 \
       --config=model/cloudbuild.yaml \
       --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0
   

   El proceso de compilación tarda varios minutos en completarse. Si usas un tamaño de modelo mayor que t5-small, el proceso de compilación puede tardar mucho más.

3. Comprueba que la imagen esté en el repositorio:

   gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models
   

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

   El resultado debería ser similar al siguiente:

   IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
   us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38
   

Desplegar el modelo empaquetado en GKE

Para desplegar la imagen, en este tutorial se usan los desplegues de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de pods distribuidas entre los nodos de un clúster.

Modifica el manifiesto de Kubernetes del repositorio de ejemplo para que se ajuste a tu entorno.

1. Revisa el archivo de manifiesto de la carga de trabajo de inferencia:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     replicas: 1
     selector:
       matchLabels:
         model: t5
         version: v1.0
         machine: gpu
     template:
       metadata:
         labels:
           model: t5
           version: v1.0
           machine: gpu
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         securityContext:
           fsGroup: 1000
           runAsUser: 1000
           runAsGroup: 1000
         containers:
           - name: inference
             image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
             imagePullPolicy: IfNotPresent
             args: ["torchserve", "--start", "--foreground"]
             resources:
               limits:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
               requests:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
             ports:
               - containerPort: 8080
                 name: http
               - containerPort: 8081
                 name: management
               - containerPort: 8082
                 name: metrics
             readinessProbe:
               httpGet:
                 path: /ping
                 port: http
               initialDelaySeconds: 120
               failureThreshold: 10
             livenessProbe:
               httpGet:
                 path: /models/t5-small
                 port: management
               initialDelaySeconds: 150
               periodSeconds: 5
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     type: ClusterIP
     selector:
       model: t5
       version: v1.0
       machine: gpu
     ports:
       - port: 8080
         name: http
         targetPort: http
       - port: 8081
         name: management
         targetPort: management
       - port: 8082
         name: metrics
         targetPort: metrics
   

2. Sustituye PROJECT_ID por el ID de tu proyecto: Google Cloud

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"
   

   De esta forma, se asegura de que la ruta de la imagen de contenedor en la especificación de Deployment coincida con la ruta de la imagen del modelo T5 en Artifact Registry.

3. Crea los recursos de Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Para comprobar que el modelo se ha implementado correctamente, sigue estos pasos:

1. Obtén el estado del despliegue y del servicio:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Espera hasta que el resultado muestre pods listos, como en el siguiente ejemplo. En función del tamaño de la imagen, la primera extracción de la imagen puede tardar varios minutos.

   NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
   deployment.apps/t5-inference    1/1     1             0           66s
   
   NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
   service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s
   

2. Abre un puerto local para el t5-inference servicio:

   kubectl port-forward svc/t5-inference 8080
   

3. Abre una nueva ventana de terminal y envía una solicitud de prueba al servicio:

   curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"
   

   Si la solicitud de prueba falla y la conexión del pod se cierra, comprueba los registros:

   kubectl logs deployments/t5-inference
   

   Si el resultado es similar al siguiente, significa que no se han podido instalar algunas dependencias del modelo de TorchServe:

   org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small
   

   Para solucionar este problema, reinicia la implementación:

   kubectl rollout restart deployment t5-inference
   

   El controlador de la implementación crea un nuevo pod. Repite los pasos anteriores para abrir un puerto en el nuevo Pod.

Acceder al modelo desplegado mediante la aplicación web

Para acceder al modelo implementado con la aplicación web Fast Dash, sigue estos pasos:

1. Crea y envía la aplicación web Fast Dash como una imagen de contenedor en Artifact Registry:

   gcloud builds submit client-app/ \
       --region=us-central1 \
       --config=client-app/cloudbuild.yaml
   

2. Abre kubernetes/application.yaml en un editor de texto y sustituye PROJECT_ID en el campo image: por el ID de tu proyecto. También puedes ejecutar el siguiente comando:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"
   

3. Crea los recursos de Kubernetes:

   kubectl create -f kubernetes/application.yaml
   

   El despliegue y el servicio pueden tardar un tiempo en aprovisionarse por completo.

4. Para comprobar el estado, ejecuta el siguiente comando:

   kubectl get -f kubernetes/application.yaml
   

   Espera hasta que el resultado muestre pods listos, como en el siguiente ejemplo:

   NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/fastdash   1/1     1            0           1m
   
   NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m
   

5. La aplicación web ya se está ejecutando, aunque no se expone en una dirección IP externa. Para acceder a la aplicación web, abre un puerto local:

   kubectl port-forward service/fastdash 8050
   

6. En un navegador, abre la interfaz web:

   • Si usas un shell local, abre un navegador y ve a http://127.0.0.1:8050.
   • Si usas Cloud Shell, haz clic en Vista previa web y, a continuación, en Cambiar puerto. Especifica el puerto 8050.

7. Para enviar una solicitud al modelo T5, especifica los valores en los campos TEXT (TEXTO), FROM LANG (LENGUAJE DE ORIGEN) y TO LANG (LENGUAJE DE DESTINO) de la interfaz web y haz clic en Submit (Enviar). Para ver una lista de los idiomas disponibles, consulta la documentación de T5.

Habilitar el autoescalado del modelo

En esta sección se muestra cómo habilitar el escalado automático del modelo en función de las métricas de Google Cloud Managed Service para Prometheus. Para ello, sigue estos pasos:

1. Instalar el adaptador de Stackdriver de métricas personalizadas
2. Aplicar configuraciones de PodMonitoring y HorizontalPodAutoscaling

Google Cloud Managed Service para Prometheus está habilitado de forma predeterminada en los clústeres Autopilot que ejecutan la versión 1.25 y posteriores.

Instalar el adaptador de Stackdriver de métricas personalizadas

Este adaptador permite que tu clúster use métricas de Prometheus para tomar decisiones de escalado automático de Kubernetes.

1. Implementa el adaptador:

   kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
   

2. Crea una cuenta de servicio de IAM para que la use el adaptador:

   gcloud iam service-accounts create monitoring-viewer
   

3. Asigna a la cuenta de servicio de gestión de identidades y accesos el rol monitoring.viewer en el proyecto y el rol iam.workloadIdentityUser:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
       --role roles/monitoring.viewer
   gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

4. Anota la cuenta de servicio de Kubernetes del adaptador para que pueda suplantar la identidad de la cuenta de servicio de gestión de identidades y accesos:

   kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
       --namespace custom-metrics \
       iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com
   

5. Reinicia el adaptador para propagar los cambios:

   kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
       --namespace=custom-metrics
   

Aplicar configuraciones de PodMonitoring y HorizontalPodAutoscaling

PodMonitoring es un recurso personalizado de Google Cloud Managed Service para Prometheus que permite la ingestión de métricas y el raspado de destinos en un espacio de nombres específico.

1. Despliega el recurso PodMonitoring en el mismo espacio de nombres que el Deployment de TorchServe:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Revisa el manifiesto de HorizontalPodAutoscaler:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: t5-inference
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: t5-inference
     minReplicas: 1
     maxReplicas: 5
     metrics:
     - type: Pods
       pods:
         metric:
           name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
         target:
           type: AverageValue
           averageValue: "30000"
   

   HorizontalPodAutoscaler escala la cantidad de pods del modelo T5 en función de la duración acumulada de la cola de solicitudes. El autoescalado se basa en la métrica ts_queue_latency_microseconds, que muestra la duración acumulada de la cola en microsegundos.

3. Crea el objeto HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Verificar el autoescalado con un generador de carga

Para probar la configuración del autoescalado, genera carga para la aplicación de servicio. En este tutorial se usa un generador de carga de Locust para enviar solicitudes al endpoint de predicción del modelo.

1. Crea el generador de carga:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Espera a que los pods del generador de carga estén listos.

2. Expón la interfaz web del generador de carga de forma local:

   kubectl port-forward svc/loadgenerator 8080
   

   Si aparece un mensaje de error, vuelve a intentarlo cuando el Pod esté en funcionamiento.

3. En un navegador, abre la interfaz web del generador de carga:

   • Si usas una shell local, abre un navegador y ve a http://127.0.0.1:8080.
   • Si usas Cloud Shell, haz clic en Vista previa web y, a continuación, en Cambiar puerto. Introduce el puerto 8080.

4. Haga clic en la pestaña Gráficos para observar el rendimiento a lo largo del tiempo.

5. Abre una nueva ventana de terminal y observa el número de réplicas de tus escaladores automáticos de pods horizontales:

   kubectl get hpa -w
   

   El número de réplicas aumenta a medida que lo hace la carga. El escalado puede tardar unos diez minutos. A medida que se inician nuevas réplicas, aumenta el número de solicitudes correctas en el gráfico de Locust.

   NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
   t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s
   

Recomendaciones

• Crea tu modelo con la misma versión de la imagen Docker base que usarás para el servicio.
• Si tu modelo tiene dependencias de paquetes especiales o si el tamaño de tus dependencias es grande, crea una versión personalizada de tu imagen base de Docker.
• Consulta la versión de árbol de los paquetes de dependencia de tu modelo. Asegúrate de que las dependencias de tu paquete sean compatibles entre sí. Por ejemplo, la versión 2.0.3 de Pandas es compatible con la versión 1.20.3 de NumPy y versiones posteriores.
• Ejecuta modelos que requieran mucha GPU en nodos de GPU y modelos que requieran mucha CPU en CPUs. Esto podría mejorar la estabilidad del servicio de modelos y asegurar que consumas los recursos de los nodos de forma eficiente.

Observar el rendimiento del modelo

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

Para usar el panel de control de TorchServe, debes habilitar Google Cloud Managed Service para Prometheus, que recoge las métricas de TorchServe, en tu clúster de GKE. TorchServe expone las métricas en formato Prometheus de forma predeterminada, por lo que no es necesario instalar ningún exportador adicional.