Esta página se ha traducido con Cloud Translation API.

Servir LLMs escalables en GKE con TorchServe

En este tutorial se muestra cómo desplegar y servir un modelo de aprendizaje automático (ML) escalable en un clúster de Google Kubernetes Engine (GKE) mediante el framework TorchServe. Sirves un modelo de PyTorch preentrenado que genera predicciones basadas en las solicitudes de los usuarios. Una vez que hayas desplegado el modelo, obtendrás una URL de predicción que tu aplicación usará para enviar solicitudes de predicción. Este método te permite escalar el modelo y la aplicación web de forma independiente. Cuando despliegas la carga de trabajo y la aplicación de aprendizaje automático en Autopilot, GKE elige el tipo y el tamaño de máquina subyacentes más eficientes para ejecutar las cargas de trabajo.

Este tutorial está dirigido a ingenieros de aprendizaje automático, administradores y operadores de plataformas, y especialistas en datos e IA que estén interesados en usar GKE Autopilot para reducir la carga administrativa de la configuración, el escalado y las actualizaciones de los nodos. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas de usuario habituales de GKE.

Antes de leer esta página, asegúrate de que conoces el modo Autopilot de GKE.

Acerca de la aplicación del tutorial

La aplicación es una pequeña aplicación web de Python creada con el framework Fast Dash. Usa la aplicación para enviar solicitudes de predicción al modelo T5. Esta aplicación registra las entradas de texto y los pares de idiomas de los usuarios y envía la información al modelo. El modelo traduce el texto y devuelve el resultado a la aplicación, que lo muestra al usuario. Para obtener más información sobre Fast Dash, consulta la documentación de Fast Dash.

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

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"

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.

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:

Descarga los artefactos del modelo del repositorio de Hugging Face.
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.
Crea la imagen final con PyTorch Serve.

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.

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.

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

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.

Crea los recursos de Kubernetes:

kubectl create -f kubernetes/serving-gpu.yaml

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

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

Abre un puerto local para el t5-inference servicio:
```
kubectl port-forward svc/t5-inference 8080
```
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:

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

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"
```
Crea los recursos de Kubernetes:
```
kubectl create -f kubernetes/application.yaml
```
El despliegue y el servicio pueden tardar un tiempo en aprovisionarse por completo.

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

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
```
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.
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:

Instalar el adaptador de Stackdriver de métricas personalizadas
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.

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

Crea una cuenta de servicio de IAM para que la use el adaptador:
```
gcloud iam service-accounts create monitoring-viewer
```

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

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

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.

Despliega el recurso PodMonitoring en el mismo espacio de nombres que el Deployment de TorchServe:
```
kubectl apply -f kubernetes/pod-monitoring.yaml
```

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.

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.

Crea el generador de carga:
```
kubectl apply -f kubernetes/loadgenerator.yaml
```
Espera a que los pods del generador de carga estén listos.
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.
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.
Haga clic en la pestaña Gráficos para observar el rendimiento a lo largo del tiempo.
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.

Después, puede ver las métricas mediante el panel de control de TorchServe. Para obtener información sobre cómo usar Google Cloud Managed Service para Prometheus y recoger métricas de tu modelo, consulta la guía de observabilidad de TorchServe en la documentación de Cloud Monitoring.