Esta página foi traduzida pela API Cloud Translation.

Configure a escala automática para cargas de trabalho de MDIs em GPUs com o Google Kubernetes Engine (GKE)

Autopilot Padrão

Esta página mostra como configurar a sua infraestrutura de dimensionamento automático através do GKE Horizontal Pod Autoscaler (HPA) para implementar o modelo de linguagem de grande dimensão (LLM) Gemma com a estrutura de serviço Text Generation Interface (TGI) da Hugging Face.

Para saber como selecionar métricas para a escala automática, consulte o artigo Práticas recomendadas para a escala automática de cargas de trabalho de MDIs com GPUs no GKE.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ative a API Google Kubernetes Engine

Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Familiarize-se com o fluxo de trabalho em Implemente modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face.

Use a escala automática com métricas do servidor

Pode usar as métricas de desempenho específicas da carga de trabalho emitidas pelo servidor de inferência do TGI para direcionar o dimensionamento automático dos seus pods. Para saber mais acerca destas métricas, consulte o artigo Métricas do servidor.

Para configurar o ajuste de escala automático de métricas personalizadas com métricas do servidor, siga estes passos:

Exporte as métricas do servidor TGI para o Cloud Monitoring. Usa o Managed Service for Prometheus do Google Cloud, que simplifica a implementação e a configuração do seu coletor do Prometheus. O Google Cloud Managed Service for Prometheus está ativado por predefinição no seu cluster do GKE. Também pode ativá-lo manualmente.

O exemplo de manifesto seguinte mostra como configurar a definição de recursos PodMonitoring para direcionar o serviço gerido do Google Cloud para o Prometheus de modo a extrair métricas dos seus pods a 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
```
Instale o adaptador do Stackdriver de métricas personalizadas. Este adaptador torna a métrica personalizada que exportou para o Monitoring visível para o controlador HPA. Para mais detalhes, consulte o artigo Ajuste de escala automático de pods horizontal na documentação do serviço gerido do Google Cloud para o Prometheus.

O comando de exemplo seguinte 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
```

Configure o recurso HPA baseado em métricas personalizadas. Implemente um recurso HPA baseado na sua métrica personalizada preferida. Para mais detalhes, consulte o artigo Ajuste de escala automático de pods horizontal na documentação do serviço gerido do Google Cloud para o Prometheus.

Selecione um destes separadores para ver exemplos de como configurar o recurso HorizontalPodAutoscaler no seu manifesto:

Tamanho da fila

Este exemplo usa as métricas do servidor TGI, que representam o número de pedidos na fila.tgi_queue_size

Para determinar o limite de tamanho da fila adequado para o HPA, consulte as práticas recomendadas para o ajuste de escala automático de cargas de trabalho de inferência de MDIs 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 do servidor tgi_batch_size TGI, que representa o número de pedidos no lote atual.

Para determinar o limite de tamanho do lote adequado para o HPA, consulte as práticas recomendadas para o ajuste de escala automático de cargas de trabalho de inferência de MDIs 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

Crie uma escala automática com métricas de GPU

Pode usar as métricas de utilização e desempenho emitidas pela GPU para direcionar o ajuste automático dos seus pods. Para saber mais acerca destas métricas, consulte Métricas da GPU.

Para configurar o ajuste de escala automático de métricas personalizadas com métricas de GPU, siga estes passos:

Exporte as métricas de GPU para o Cloud Monitoring. Se o cluster do GKE tiver as métricas do sistema ativadas, envia automaticamente a métrica de utilização da GPU para o Cloud Monitoring através da métrica do sistema container/accelerator/duty_cycle a cada 60 segundos.
- Para saber como ativar as métricas do sistema do GKE, consulte o artigo Configure a recolha de métricas.
- Para configurar a recolha gerida, consulte o artigo Comece a usar a recolha gerida na documentação do Google Cloud Managed Service for Prometheus.
- Para técnicas adicionais de monitorização do desempenho da carga de trabalho da GPU no GKE, consulte o artigo Execute GPUs em pools de nós padrão do GKE.
O manifesto de exemplo seguinte mostra como configurar a definição do recurso PodMonitoring para carregar métricas da carga de trabalho do NVIDIA DCGM:
```
apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: nvidia-dcgm-exporter-for-hpa
  namespace: gke-managed-system
  labels:
    app.kubernetes.io/name: nvidia-dcgm-exporter
    app.kubernetes.io/part-of: google-cloud-managed-prometheus
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: gke-managed-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, certifique-se de que altera o nome da métrica DCGM a usar no HPA para letras minúsculas. Isto deve-se a um problema conhecido em que o HPA não funciona com nomes de métricas externas em maiúsculas. Para clusters que não usam um exportador DCGM gerido, certifique-se de que os campos metadata.namespace e spec.selector.matchLabels do HPA correspondem exatamente à configuração do exportador DCGM.Este alinhamento preciso é fundamental para a descoberta e a consulta bem-sucedidas de métricas personalizadas pelo HPA.
Instale o adaptador do Stackdriver de métricas personalizadas. Este adaptador torna a métrica personalizada que exportou para o Monitoring visível para o controlador HPA. Para mais detalhes, consulte o artigo Ajuste de escala automático de pods horizontal na documentação do serviço gerido do Google Cloud para o Prometheus.

O comando de exemplo seguinte 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
```

Configure o recurso HPA baseado em métricas personalizadas. Implemente um recurso HPA com base na sua métrica personalizada preferida. Para mais detalhes, consulte o artigo Ajuste de escala automático de pods horizontal na documentação do serviço gerido do Google Cloud para o Prometheus.

Identificar um alvo de valor médio para o HPA acionar o dimensionamento automático. Pode fazê-lo experimentalmente. Por exemplo, gere uma carga crescente no seu servidor e observe onde a utilização da GPU atinge o pico. Tenha em atenção a tolerância de HPA, que tem por predefinição um intervalo de não ação de 0,1 em torno do valor alvo para reduzir a oscilação.
Recomendamos que use a ferramenta locust-load-inference para testes. Também pode criar um painel de controlo personalizado do Cloud Monitoring para visualizar o comportamento das métricas.

Selecione um destes separadores para ver um exemplo de como configurar o recurso HorizontalPodAutoscaler no seu manifesto:

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

O que se segue?

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