Configurer l'autoscaling pour les charges de travail LLM sur les GPU avec Google Kubernetes Engine (GKE)

Autopilot Standard

Cette page explique comment configurer votre infrastructure d'autoscaling à l'aide de l'autoscaler horizontal des pods (HPA) de GKE pour déployer le grand modèle de langage (LLM) Gemma avec le framework de diffusion d'interface de génération de texte (TGI) de Hugging Face.

Pour en savoir plus sur la sélection de métriques pour l'autoscaling, consultez la page Bonnes pratiques pour l'autoscaling des charges de travail LLM à l'aide de GPU sur GKE.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Familiarisez-vous avec le workflow décrit dans la section Diffuser des modèles ouverts Gemma à l'aide de GPU sur GKE avec Hugging Face TGI.

Autoscaling à l'aide de métriques de serveur

Vous pouvez utiliser les métriques de performances spécifiques à la charge de travail émises par le serveur d'inférence TGI pour diriger l'autoscaling pour vos pods. Pour en savoir plus sur ces métriques, consultez la page Métriques de serveur.

Pour configurer l'autoscaling de métriques personnalisées avec des métriques de serveur, procédez comme suit :

Exportez les métriques du serveur TGI vers Cloud Monitoring. Vous utilisez Google Cloud Managed Service pour Prometheus, ce qui simplifie le déploiement et la configuration de votre collecteur Prometheus. Google Cloud Managed Service pour Prometheus est activé par défaut dans votre cluster GKE. Vous pouvez aussi l'activer manuellement.

L'exemple de fichier manifeste suivant montre comment configurer la définition de votre ressource PodMonitoring pour demander à Google Cloud Managed Service pour Prometheus de scraper les métriques de vos pods à des intervalles récurrents de 15 secondes :
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: gemma-pod-monitoring
spec:
  selector:
    matchLabels:
      app: gemma-server
  endpoints:
  - port: 8000
    interval: 15s
```
Installez l'adaptateur de métriques personnalisées Stackdriver. Cet adaptateur rend la métrique personnalisée que vous avez exportée vers Monitoring visible par le contrôleur HPA. Pour en savoir plus, consultez la page Autoscaling horizontal des pods dans la documentation de Google Cloud Managed Service pour Prometheus.

L'exemple de commande suivant montre comment installer l'adaptateur :
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```
Configurez la ressource HPA basée sur des métriques personnalisées. Déployez une ressource HPA basée sur la métrique personnalisée de votre choix. Pour en savoir plus, consultez la page Autoscaling horizontal des pods dans la documentation de Google Cloud Managed Service pour Prometheus.

Sélectionnez l'un de ces onglets pour voir des exemples de configuration de la ressource HorizontalPodAutoscaler dans votre fichier manifeste :
Taille de la file d'attente
Cet exemple utilise les métriques du serveur TGI tgi_queue_size, qui représentent le nombre de requêtes dans la file d'attente.

Pour déterminer le seuil de taille de file d'attente approprié pour l'HPA, consultez la page Bonnes pratiques pour l'autoscaling des charges de travail d'inférence LLM à l'aide de 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
```
Taille de lot
Cet exemple utilise la métrique de serveur TGI tgi_batch_size, qui représente le nombre de requêtes dans le lot actuel.

Pour déterminer le seuil de taille de lot approprié pour l'HPA, consultez la page Bonnes pratiques pour l'autoscaling des charges de travail d'inférence LLM à l'aide de 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
```

Autoscaling à l'aide de métriques GPU

Vous pouvez utiliser les métriques d'utilisation et de performances émises par le GPU pour diriger l'autoscaling de vos pods. Pour en savoir plus sur ces métriques, consultez la page Métriques de GPU.

Pour configurer l'autoscaling de métriques personnalisées à l'aide de métriques GPU, procédez comme suit :

Exportez les métriques GPU vers Cloud Monitoring. Si les métriques système sont activées sur votre cluster GKE, la métrique d'utilisation du GPU est automatiquement envoyée à Cloud Monitoring via la métrique système container/accelerator/duty_cycle, toutes les 60 secondes.
- Pour savoir comment activer les métriques système GKE, consultez la page Configurer la collecte de métriques.
- Pour configurer la collecte gérée, consultez la section Premiers pas avec la collecte gérée dans la documentation de Google Cloud Managed Service pour Prometheus.
- Pour découvrir d'autres techniques permettant de surveiller les performances des charges de travail des GPU dans GKE, consultez la page Exécuter des GPU dans des pools de nœuds GKE Standard.
L'exemple de fichier manifeste suivant montre comment configurer la définition de votre ressource PodMonitoring pour ingérer des métriques de la charge de travail DCGM NVIDIA :
```
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
```
Dans le code, veillez à passer en minuscules le nom de la métrique DCGM à utiliser dans l'HPA. En effet, il existe un problème connu où l'HPA ne fonctionne pas avec des noms de métriques externes en majuscules.
Installez l'adaptateur de métriques personnalisées Stackdriver. Cet adaptateur rend la métrique personnalisée exportée vers Monitoring visible par le contrôleur HPA. Pour en savoir plus, consultez la page Autoscaling horizontal des pods dans la documentation de Google Cloud Managed Service pour Prometheus.

L'exemple de commande suivant montre comment exécuter cette installation :
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```

Configurez la ressource HPA basée sur des métriques personnalisées. Déployez une ressource HPA en fonction de la métrique personnalisée de votre choix. Pour en savoir plus, consultez la page Autoscaling horizontal des pods dans la documentation de Google Cloud Managed Service pour Prometheus.

Identifiez une valeur moyenne cible pour que l'autoscaler horizontal des pods déclenche l'autoscaling. Vous pouvez le faire de manière expérimentale. Par exemple, générez une charge croissante sur votre serveur et observez les pics d'utilisation des GPU. Tenez compte de la tolérance HPA, qui est définie par défaut sur une plage d'absence d'action de 0,1 autour de la valeur cible afin d'atténuer l'oscillation.
Nous vous recommandons d'utiliser l'outil d'inférence locust-load-inference pour les tests. Vous pouvez également créer un tableau de bord personnalisé Cloud Monitoring pour visualiser le comportement de la métrique.

Sélectionnez l'un de ces onglets pour voir un exemple de configuration de la ressource HorizontalPodAutoscaler dans votre fichier manifeste :

Cycle d'utilisation (système 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

Cycle d'utilisation (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

Étape suivante

Découvrez comment optimiser l'autoscaling des pods en fonction des métriques de Cloud Monitoring.
En savoir plus sur l'autoscaling horizontal des pods dans la documentation Open Source de Kubernetes.