Configurar o escalonamento automático para cargas de trabalho LLM em GPUs com o Google Kubernetes Engine (GKE)

Autopilot Standard

Nesta página, mostramos como configurar sua infraestrutura de escalonamento automático usando o Escalonador automático horizontal de pods (HPA) do GKE para implantar o modelo de linguagem grande (LLM) do Gemma com o framework de exibição da Interface de geração de texto (TGI) da Hugging Face.

Para saber mais sobre a seleção de métricas para escalonamento automático, consulte Práticas recomendadas para cargas de trabalho LLM com escalonamento automático com GPUs no GKE.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Ativar a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.
Observação: para instalações atuais da CLI gcloud, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na CLI gcloud, como: One of [--zone, --region] must be supplied: Please specify location.

Conheça o fluxo de trabalho em Exibir modelos abertos do Gemma usando GPUs no GKE com o Hugging Face TGI.

Escalonamento automático usando métricas de servidor

É possível usar as métricas de desempenho específicas da carga de trabalho que são emitidas pelo servidor de inferência TGI para escalonamento automático direto para seus pods. Para saber mais sobre isso, consulte Métricas do servidor.

Para configurar o escalonamento automático de métricas personalizadas com métricas de servidor, siga estas etapas:

Exportar as métricas do servidor TGI para o Cloud Monitoring. Você usa o Google Cloud Managed Service para Prometheus, que simplifica a implantação e a configuração do seu coletor Prometheus. O Google Cloud Managed Service para Prometheus é ativado por padrão nos cluster do GKE. Também é possível ativá-la manualmente.

O manifesto de exemplo a seguir mostra como configurar a definição do recurso PodMonitoring para direcionar o Google Cloud Managed Service para Prometheus para coletar métricas dos pods em intervalos recorrentes 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
```
Instalar o adaptador de métricas personalizadas do Stackdriver. Com esse adaptador, a métrica personalizada que você exportou para o Monitoring fica visível para o controlador HPA. Para mais detalhes, consulte Escalonamento automático horizontal de pods na documentação do Google Cloud Managed Service para Prometheus.

O comando de exemplo abaixo mostra como instalar o adaptador:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```
Configurar o recurso HPA com base em métricas personalizadas. Implante um recurso HPA baseado na métrica personalizada que preferir. Para mais detalhes, consulte Escalonamento automático horizontal de pods na documentação do Google Cloud Managed Service para Prometheus.

Selecione uma dessas guias para ver exemplos de como configurar o recurso HorizontalPodAutoscaler no seu manifesto:
Tamanho da fila
Este exemplo usa as métricas de servidor TGI tgi_queue_size, que representa o número de solicitações na fila.

Para determinar o limite correto de tamanho da fila para o HPA, consulte Práticas recomendadas para escalonamento automático de cargas de trabalho de inferência de LLM com GPUs.
```
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
```
Tamanho do lote
Este exemplo usa a métrica de servidor TGI tgi_batch_size, que representa o número de solicitações do lote atual.

Para determinar o limite correto de tamanho do lote para o HPA, consulte Práticas recomendadas para escalonamento automático de cargas de trabalho de inferência de LLM com GPUs.
```
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
```

Escalonamento automático usando métricas da GPU

É possível usar as métricas de uso e desempenho emitidas pela GPU para direcionar o escalonamento automático para seus pods. Para saber mais sobre essas métricas, consulte Métricas da GPU.

Para configurar o escalonamento automático de métricas personalizadas com métricas da GPU, siga estas etapas:

Exportar as métricas da GPU para o Cloud Monitoring. Se o cluster do GKE tem métricas do sistema ativadas, ele envia automaticamente a métrica de utilização da GPU ao Cloud Monitoring usando a métrica do sistema container/accelerator/duty_cycle a cada 60 segundos.
- Para saber como ativar as métricas do sistema do GKE, consulte Configurar a coleta de métricas.
- Para configurar a coleta gerenciada, consulte Introdução à coleta gerenciada na documentação do Google Cloud Managed Service para Prometheus.
- Para outras técnicas de monitoramento do desempenho da carga de trabalho da GPU no GKE, consulte Executar GPUs em pools de nós do GKE Standard.
O manifesto de exemplo a seguir mostra como configurar a definição do recurso PodMonitoring para ingerir métricas da carga de trabalho 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
```
No código, mude o nome da métrica DCGM para uso no HPA para letras minúsculas. Isso ocorre porque há um problema conhecido em que o HPA não funciona com nomes de métricas externas em maiúsculas.
Instalar o adaptador de métricas personalizadas do Stackdriver. Com esse adaptador, a métrica personalizada que você exportou para o Monitoring fica visível para o controlador HPA. Para mais detalhes, consulte Escalonamento automático horizontal de pods na documentação do Google Cloud Managed Service para Prometheus.

O comando de exemplo a seguir mostra como executar esta instalação:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
```

Configurar o recurso HPA com base em métricas personalizadas. Implante um recurso HPA baseado na métrica personalizada que preferir. Para mais detalhes, consulte Escalonamento automático horizontal de pods na documentação do Google Cloud Managed Service para Prometheus.

Identifique uma meta de valor médio para o HPA acionar o escalonamento automático. Você pode fazer isso de maneira experimental. Por exemplo, gerar carga crescente no servidor e observar o pico de uso da GPU. Esteja atento ao Tolerância de HP: o padrão é um intervalo sem ação de 0,1 ao redor do valor de destino para reduzir a oscilação.
Recomendamos o uso da ferramenta locust-load-inference para testes. Também é possível criar um painel personalizado do Cloud Monitoring para visualizar o comportamento da métrica.

Selecione uma destas guias para ver um exemplo de como configurar o recurso HorizontalPodAutoscaler no seu manifesto:

Ciclo de trabalho (sistema 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 trabalho (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

A seguir

Saiba como otimizar o escalonamento automático de pods com base nas métricas do Cloud Monitoring.
Saiba mais sobre o escalonamento automático horizontal de pods na documentação do Kubernetes de código aberto.