Configura el ajuste de escala automático para cargas de trabajo de LLM en GPU con Google Kubernetes Engine (GKE)

Autopilot Estándar

En esta página, se muestra cómo configurar tu infraestructura de ajuste de escala automático mediante Horizontal Pod Autoscaler (HPA) de GKE para implementar el modelo de lenguaje grande (LLM) de Gemma con el framework de entrega de la interfaz de generación de texto (TGI) de Hugging Face.

Si deseas obtener más información sobre cómo seleccionar métricas para el ajuste de escala automático, consulta Prácticas recomendadas para el ajuste de escala automático de cargas de trabajo de LLM con GPU en GKE.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la CLI de gcloud como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Familiarízate con el flujo de trabajo en Entrega modelos abiertos de Gemma mediante GPUs en GKE con TGI de Hugging Face.

Ajusta la escala automáticamente con métricas del servidor

Puedes usar las métricas de rendimiento específicas de la carga de trabajo que emite el servidor de inferencia de TGI para dirigir el ajuste de escala automático de los Pods. Para obtener más información sobre estas métricas, consulta Métricas del servidor.

Para configurar el ajuste de escala automático de las métricas personalizadas con las métricas del servidor, sigue estos pasos:

Exporta las métricas del servidor TGI a Cloud Monitoring. Usas Google Cloud Managed Service para Prometheus, que simplifica la implementación y la configuración de tu colector de Prometheus. Google Cloud Managed Service para Prometheus está habilitado de forma predeterminada en tu clúster de GKE. También puedes habilitarlo manualmente.

En el siguiente manifiesto de ejemplo, se muestra cómo configurar tu definición de recursos PodMonitoring a fin de dirigir a Google Cloud Managed Service para Prometheus para que recopile métricas de tus Pods en intervalos recurrentes de 15 segundos:
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: gemma-pod-monitoring
spec:
  selector:
    matchLabels:
      app: gemma-server
  endpoints:
  - port: 8000
    interval: 15s
```
Instala el adaptador de métricas personalizadas de Stackdriver. Este adaptador hace que la métrica personalizada que exportaste a Monitoring sea visible para el controlador de HPA. Si deseas obtener más detalles, consulta Ajuste de escala automático horizontal de Pods en la documentación de Google Cloud Managed Service para Prometheus.

En el siguiente comando de ejemplo, se muestra cómo instalar el adaptador:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```
Configura el recurso de HPA basado en métricas personalizadas. Implementa un recurso de HPA que se base en tu métrica personalizada preferida. Si deseas obtener más detalles, consulta Ajuste de escala automático horizontal de Pods en la documentación de Google Cloud Managed Service para Prometheus.

Selecciona una de estas pestañas para ver ejemplos de cómo configurar el recurso HorizontalPodAutoscaler en el manifiesto:
Tamaño de la cola
En este ejemplo, se usan las métricas del servidor TGI tgi_queue_size, que representan la cantidad de solicitudes en la cola.

A fin de determinar el umbral de tamaño correcto de la cola para HPA, consulta Prácticas recomendadas para el ajuste de escala automático de las cargas de trabajo de inferencia de LLM con GPU.
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-server
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|tgi_queue_size|gauge
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET
```
Tamaño del lote
En este ejemplo, se usa la métrica del servidor TGI tgi_batch_size, que representa la cantidad de solicitudes en el lote actual.

A fin de determinar el umbral de tamaño correcto del lote para HPA, consulta Prácticas recomendadas para el ajuste de escala automático de las cargas de trabajo de inferencia de LLM con GPU.
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-server
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|tgi_batch_current_size|gauge
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET
```

Ajusta automáticamente la escala con métricas de GPU

Puedes usar las métricas de uso y rendimiento que emite la GPU para dirigir el ajuste de escala automático de tus Pods. Para obtener más información sobre estas métricas, consulta Métricas de GPU.

Para configurar el ajuste de escala automático de métricas personalizadas con métricas de GPU, sigue estos pasos:

Exporta las métricas de GPU a Cloud Monitoring. Si tu clúster de GKE tiene habilitadas las métricas del sistema, envía de forma automática la métrica de uso de GPU a Cloud Monitoring a través de la métrica del sistema container/accelerator/duty_cycle, cada 60 segundos.
- Para obtener información sobre cómo habilitar las métricas del sistema de GKE, consulta Configura la recopilación de métricas.
- Para configurar la recopilación administrada, consulta Comienza a usar la recopilación administrada en la documentación de Google Cloud Managed Service para Prometheus.
- Para obtener técnicas adicionales a fin de supervisar el rendimiento de tu carga de trabajo de GPU en GKE, consulta Ejecuta GPU en grupos de nodos de GKE Estándar.
En el siguiente manifiesto de ejemplo, se muestra cómo configurar tu definición de recursos PodMonitoring para transferir métricas desde la carga de trabajo de NVIDIA DCGM:
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: nvidia-dcgm-exporter-for-hpa
  namespace: gmp-public
  labels:
    app.kubernetes.io/name: nvidia-dcgm-exporter
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: nvidia-dcgm-exporter
  endpoints:
    - port: metrics
      interval: 15s
      metricRelabeling:
        - action: keep
          sourceLabels: [__name__]
        - action: replace
          sourceLabels: [__name__]
          targetLabel: __name__
          regex: DCGM_FI_DEV_GPU_UTIL
          replacement: dcgm_fi_dev_gpu_util
```
En el código, asegúrate de cambiar el nombre de la métrica de DCGM para usarlo en HPA a minúsculas. Esto se debe a que hay un problema conocido en el que HPA no funciona con nombres de métricas externas en mayúsculas.
Instala el adaptador de métricas personalizadas de Stackdriver. Este adaptador hace que la métrica personalizada que exportaste a Monitoring sea visible para el controlador de HPA. Si deseas obtener más detalles, consulta Ajuste de escala automático horizontal de Pods en la documentación de Google Cloud Managed Service para Prometheus.

En el siguiente comando de ejemplo, se muestra cómo ejecutar esta instalación:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```

Configura el recurso de HPA basado en métricas personalizadas. Implementa un recurso de HPA en función de tu métrica personalizada preferida. Si deseas obtener más detalles, consulta Ajuste de escala automático horizontal de Pods en la documentación de Google Cloud Managed Service para Prometheus.

Identifica un objetivo de valor promedio para que HPA active el ajuste de escala automático. Puedes hacerlo de forma experimental; Por ejemplo, generar una carga cada vez mayor en tu servidor y observar dónde alcanza su pico de uso de GPU. Ten en cuenta la tolerancia del HPA, que se establece de forma predeterminada en un rango de no acción de 0.1 alrededor del valor objetivo para disminuir la oscilación.
Te recomendamos que uses la herramienta locust-load-inference para realizar pruebas. También puedes crear un panel personalizado de Cloud Monitoring para visualizar el comportamiento de la métrica.

Selecciona una de estas pestañas para ver un ejemplo de cómo configurar el recurso HorizontalPodAutoscaler en el manifiesto:

Ciclo de trabajo (sistema de GKE)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: External
    external:
      metric:
        name: kubernetes.io|container|accelerator|duty_cycle
        selector:
          matchLabels:
            resource.labels.container_name: inference-server
            resource.labels.namespace_name: default
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET

Ciclo de trabajo (DCGM)

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: gemma-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: tgi-gemma-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: External
    external:
      metric:
        name: prometheus.googleapis.com|dcgm_fi_dev_gpu_util|unknown
        selector:
          matchLabels:
            metric.labels.exported_container: inference-server
            metric.labels.exported_namespace: default
      target:
        type: AverageValue
        averageValue:  $HPA_AVERAGEVALUE_TARGET

¿Qué sigue?

Obtén información para optimizar el ajuste de escala automático de Pods según las métricas de Cloud Monitoring.
Obtén más información sobre el ajuste de escala automático horizontal de Pods en la documentación de código abierto de Kubernetes.