Implementar previsão elástica do AHPA com base em métricas de GPU - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O AHPA utiliza dados de utilização de GPU do Prometheus Adapter, combinados com tendências históricas de carga e algoritmos de previsão, para estimar as necessidades futuras de recursos de GPU. Ele ajusta automaticamente o número de réplicas de pods ou aloca recursos de GPU para escalar horizontalmente antes que os recursos fiquem limitados e reduzir a escala quando estiverem ociosos. Essa abordagem reduz custos e melhora a eficiência do cluster.

Pré-requisitos

Crie um cluster de GPU gerenciado. Para mais informações, consulte Adicionar nós de GPU a um cluster.
Instale o componente AHPA e configure a source das métricas. Para mais informações, consulte Previsão de dimensionamento elástico (AHPA).
Ative o monitoramento do Prometheus e garanta a coleta de pelo menos sete dias de dados históricos da aplicação (GPU) no Prometheus. Para mais informações, consulte Conectar e configurar o monitoramento Alibaba Cloud Prometheus.

Como funciona

Na computação de alto desempenho (HPC), especialmente no treinamento e na inferência de modelos de deep learning, o gerenciamento granular e o ajuste dinâmico de recursos de GPU melhoram a utilização e reduzem custos. O Container Service for Kubernetes oferece suporte ao dimensionamento elástico com base em métricas de GPU. Use o Prometheus para coletar métricas essenciais de GPU, como utilização em tempo real e uso de memória da GPU. Em seguida, utilize o Prometheus Adapter para transformar essas métricas em um formato compatível com Kubernetes e integrá-las ao AHPA. O AHPA usa esses dados, juntamente com tendências históricas de carga e algoritmos de previsão, para estimar as necessidades futuras de recursos de GPU e ajustar automaticamente o número de réplicas de pods ou a alocação de recursos de GPU. Isso garante que o scale-out ocorra antes que os recursos fiquem limitados e que o scale-in aconteça prontamente quando os recursos estiverem ociosos, reduzindo custos e aumentando a eficiência do cluster.

Etapa 1: Implantar o Metrics Adapter

Obtenha o endpoint interno da API HTTP.
1. Faça login no console ARMS.
2. No painel de navegação à esquerda, escolha Managed Service for Prometheus > Instances.
3. Na página Instances, selecione a região onde seu cluster Container Service for Kubernetes está localizado.
4. Clique no nome da sua instância do Prometheus de destino. No painel de navegação à esquerda, clique em Settings para obter o endpoint interno em HTTP API address.
Implante o ack-alibaba-cloud-metrics-adapter.
1. Faça login no console ACK. No painel de navegação à esquerda, clique em Marketplace > Marketplace.
2. Na página Marketplace, clique na aba App Catalog, pesquise por ack-alibaba-cloud-metrics-adapter e clique nele.
3. Na página ack-alibaba-cloud-metrics-adapter, clique em Quick Deployment no canto superior direito.
4. No assistente de Basic Information, selecione seu Cluster e Namespace, depois clique em Next.
5. No assistente de Parameters, selecione uma Chart Version. Na seção Parameter, defina o endpoint interno da API HTTP obtido na Etapa 1 como o valor para prometheus.url e clique em OK.
```
prometheus:
  enabled: true
  url: http://
```

Etapa 2: Implementar a previsão elástica do AHPA com base em métricas de GPU

Este tópico implanta um serviço de inferência de modelo em uma GPU e envia solicitações continuamente para ele. O AHPA realiza a previsão elástica com base na utilização da GPU.

Implante o serviço de inferência.

Execute o comando a seguir para implantar o serviço de inferência.

Expandir para ver detalhes

cat <<EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bert-intent-detection
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bert-intent-detection
  template:
    metadata:
      labels:
        app: bert-intent-detection
    spec:
      containers:
      - name: bert-container
        image: registry.cn-hangzhou.aliyuncs.com/ai-samples/bert-intent-detection:1.0.1
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: "1"
            memory: 2G
            nvidia.com/gpu: "1"
          requests:
            cpu: 200m
            memory: 500M
            nvidia.com/gpu: "1"
---
apiVersion: v1
kind: Service
metadata:
  name: bert-intent-detection-svc
  labels:
    app: bert-intent-detection
spec:
  selector:
    app: bert-intent-detection
  ports:
  - protocol: TCP
    name: http
    port: 80
    targetPort: 80
  type: LoadBalancer
EOF

Execute o comando a seguir para verificar o status do pod.

kubectl get pods -o wide

Saída esperada:

NAME                                    READY   STATUS    RESTARTS   AGE     IP           NODE                        NOMINATED NODE   READINESS GATES
bert-intent-detection-7b486f6bf-f****   1/1     Running   0          3m24s   10.15.1.17   cn-beijing.192.168.94.107   <none>           <none>

Execute o comando a seguir para chamar o serviço de inferência e verificar a implantação.

Use o comando kubectl get svc bert-intent-detection-svc para obter o endereço IP do nó de GPU e substitua 47.95.XX.XX no comando a seguir.

curl -v  "http://47.95.XX.XX/predict?query=Music"

Saída esperada:

*   Trying 47.95.XX.XX...
* TCP_NODELAY set
* Connected to 47.95.XX.XX (47.95.XX.XX) port 80 (#0)
> GET /predict?query=Music HTTP/1.1
> Host: 47.95.XX.XX
> User-Agent: curl/7.64.1
> Accept: */*
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Content-Type: text/html; charset=utf-8
< Content-Length: 9
< Server: Werkzeug/1.0.1 Python/3.6.9
< Date: Wed, 16 Feb 2022 03:52:11 GMT
<
* Closing connection 0
PlayMusic #Intent recognition result.

Se a solicitação HTTP retornar o código de status 200 e um resultado de reconhecimento de intenção, o serviço de inferência foi implantado com sucesso.

Configure o AHPA.

Este exemplo utiliza a utilização de GPU. O scale-out é acionado quando a utilização de GPU de um pod excede 20%.

Configure a source de métricas do AHPA.

Crie um arquivo chamado application-intelligence.yaml com o seguinte conteúdo.

prometheusUrl define o endpoint para o Alibaba Cloud Prometheus. Utilize o endpoint interno obtido na Etapa 1.

apiVersion: v1
kind: ConfigMap
metadata:
  name: application-intelligence
  namespace: kube-system
data:
  prometheusUrl: "http://cn-shanghai-intranet.arms.aliyuncs.com:9090/api/v1/prometheus/da9d7dece901db4c9fc7f5b*******/1581204543170*****/c54417d182c6d430fb062ec364e****/cn-shanghai"

Execute o comando a seguir para implantar o application-intelligence.
```
kubectl apply -f application-intelligence.yaml
```

Implante o AHPA.

Crie um arquivo chamado fib-gpu.yaml com o seguinte conteúdo.

O modo está definido como observer. Para mais informações sobre parâmetros, consulte descrição de métricas.

Expandir para ver detalhes

apiVersion: autoscaling.alibabacloud.com/v1beta1
kind: AdvancedHorizontalPodAutoscaler
metadata:
  name: fib-gpu
  namespace: default
spec:
  metrics:
  - resource:
      name: gpu
      target:
        averageUtilization: 20
        type: Utilization
    type: Resource
  minReplicas: 0
  maxReplicas: 100
  prediction:
    quantile: 95
    scaleUpForward: 180
  scaleStrategy: observer
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: bert-intent-detection
  instanceBounds:
  - startTime: "2021-12-16 00:00:00"
    endTime: "2022-12-16 00:00:00"
    bounds:
    - cron: "* 0-8 ? * MON-FRI"
      maxReplicas: 50
      minReplicas: 4
    - cron: "* 9-15 ? * MON-FRI"
      maxReplicas: 50
      minReplicas: 10
    - cron: "* 16-23 ? * MON-FRI"
      maxReplicas: 50
      minReplicas: 12

Execute o comando a seguir para implantar o AHPA.
```
kubectl apply -f fib-gpu.yaml
```

Execute o comando a seguir para verificar o status do AHPA.

kubectl get ahpa

Saída esperada:

NAME             STRATEGY   REFERENCE               METRIC   TARGET(%)   CURRENT(%)   DESIREDPODS   REPLICAS   MINPODS   MAXPODS   AGE
fib-gpu          observer   bert-intent-detection   gpu      20          0          0            1          10        50        6d19h

A saída esperada mostra que CURRENT(%) é 0 e TARGET(%) é 20. Isso significa que a utilização atual de GPU é de 0%. O scale-out elástico é acionado quando a utilização de GPU excede 20%.

Teste o dimensionamento elástico para o serviço de inferência.

Execute o comando a seguir para acessar o serviço de inferência.

Expandir para ver detalhes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: fib-loader
  namespace: default
spec:
  progressDeadlineSeconds: 600
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: fib-loader
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: fib-loader
    spec:
      containers:
      - args:
        - -c
        - |
          /ko-app/fib-loader --service-url="http://bert-intent-detection-svc.${NAMESPACE}/predict?query=Music" --save-path=/tmp/fib-loader-chart.html
        command:
        - sh
        env:
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.namespace
        image: registry.cn-huhehaote.aliyuncs.com/kubeway/knative-sample-fib-loader:20201126-110434
        imagePullPolicy: IfNotPresent
        name: loader
        ports:
        - containerPort: 8090
          name: chart
          protocol: TCP
        resources:
          limits:
            cpu: "8"
            memory: 16000Mi
          requests:
            cpu: "2"
            memory: 4000Mi

Enquanto acessa o serviço, execute o comando a seguir para verificar o status do AHPA.

kubectl get ahpa

Saída esperada:

NAME             STRATEGY   REFERENCE               METRIC   TARGET(%)   CURRENT(%)   DESIREDPODS   REPLICAS   MINPODS   MAXPODS   AGE
fib-gpu          observer   bert-intent-detection   gpu      20          189          10            4          10        50        6d19h

A saída esperada mostra que a utilização atual de GPU CURRENT(%) excede o valor de TARGET(%). O dimensionamento elástico é acionado e o número desejado de pods DESIREDPODS é 10.

Execute o comando a seguir para visualizar a tendência de previsão.
```
kubectl get --raw '/apis/metrics.alibabacloud.com/v1beta1/namespaces/default/predictionsobserver/fib-gpu'|jq -r '.content' |base64 -d > observer.html
```
A figura a seguir mostra um exemplo de tendência de previsão com base em sete dias de métricas históricas de GPU:
- Predict GPU Resource Observer: A linha azul mostra o uso real de GPU. A linha verde mostra o uso de GPU previsto pelo AHPA. A curva verde está majoritariamente acima da curva azul, indicando que a capacidade de GPU prevista é suficiente.
- Predict POD Observer: A linha azul mostra o número real de pods escalados. A linha verde mostra o número de pods previstos pelo AHPA. A curva verde está majoritariamente abaixo da curva azul, indicando que o AHPA prevê menos pods. Defina o modo de dimensionamento elástico como auto para usar a contagem de pods prevista, o que economiza recursos de pods e evita desperdício.
Os resultados da previsão atendem às expectativas. Após a observação, se os resultados permanecerem satisfatórios, defina o modo de dimensionamento elástico como auto para que o AHPA gerencie o dimensionamento.

Referências

O Knative Serverless oferece suporte aos recursos elásticos do AHPA (Advanced Horizontal Pod Autoscaler). Quando os requisitos de recursos da aplicação são periódicos, a previsão elástica pré-aquece os recursos e resolve problemas de cold start no Knative. Para mais informações, consulte Usar previsão elástica do AHPA no Knative.
Em muitos cenários, as aplicações precisam dimensionar com base em métricas personalizadas, como QPS de solicitações HTTP ou tamanho da fila de mensagens. O AHPA fornece um mecanismo de External Metrics. Combinado com o componente alibaba-cloud-metrics-adapter, ele oferece opções de dimensionamento mais ricas. Para mais informações, consulte Configurar métricas personalizadas com AHPA para dimensionar aplicações.