Implement AHPA elastic prediction based on GPU metrics - Container Service for Kubernetes

AHPA utilise les données d'utilisation du GPU provenant de l'adaptateur Prometheus, combinées aux tendances historiques de charge et à des algorithmes de prédiction, pour anticiper les besoins futurs en ressources GPU. Il ajuste automatiquement le nombre de réplicas de pods ou alloue des ressources GPU pour effectuer un scale-out avant que les ressources ne soient saturées, et un scale-in lorsque les ressources sont inactives. Cette approche réduit les coûts et améliore l'efficacité du cluster.

Prérequis

Vous avez créé un cluster GPU managé. Pour plus d'informations, consultez la rubrique Ajouter des nœuds GPU à un cluster.
Installez le composant AHPA et configurez la source de métriques. Pour plus d'informations, consultez la rubrique Prédiction de mise à l'échelle élastique (AHPA).
Activez la surveillance Prometheus et assurez-vous qu'au moins sept jours de données historiques d'application (GPU) ont été collectées dans Prometheus. Pour plus d'informations, consultez la rubrique Se connecter et configurer la surveillance Alibaba Cloud Prometheus.

Fonctionnement

Dans le domaine du calcul haute performance (HPC), en particulier pour l'entraînement et l'inférence de modèles d'apprentissage profond, une gestion fine et un ajustement dynamique des ressources GPU permettent d'améliorer l'utilisation et de réduire les coûts. Container Service for Kubernetes prend en charge la mise à l'échelle élastique basée sur les métriques GPU. Vous pouvez utiliser Prometheus pour collecter des métriques GPU clés, telles que l'utilisation en temps réel et l'utilisation de la mémoire GPU. Ensuite, utilisez l'adaptateur Prometheus pour transformer ces métriques dans un format compatible avec Kubernetes et les intégrer à AHPA. AHPA exploite ces données, ainsi que les tendances historiques de charge et des algorithmes de prédiction, pour anticiper les besoins futurs en ressources GPU et ajuste automatiquement le nombre de réplicas de pods ou l'allocation des ressources GPU. Cela garantit que le scale-out se produit avant la saturation des ressources et que le scale-in s'effectue rapidement lorsque les ressources sont inactives, réduisant ainsi les coûts et améliorant l'efficacité du cluster.

Étape 1 : Déployer l'adaptateur de métriques

Obtenez le point de terminaison HTTP API interne.
1. Connectez-vous à la console ARMS.
2. Dans le volet de navigation de gauche, choisissez Managed Service for Prometheus > Instances.
3. Sur la page Instances, sélectionnez la région où se trouve votre cluster Container Service for Kubernetes.
4. Cliquez sur le nom de votre instance Prometheus cible. Dans le volet de navigation de gauche, cliquez sur Settings pour obtenir le point de terminaison interne sous l'adresse HTTP API.
Déployez ack-alibaba-cloud-metrics-adapter.
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Marketplace > Marketplace.
2. Sur la page Marketplace, cliquez sur l'onglet App Catalog, recherchez ack-alibaba-cloud-metrics-adapter, puis cliquez dessus.
3. Sur la page ack-alibaba-cloud-metrics-adapter, cliquez sur Quick Deployment dans le coin supérieur droit.
4. Dans l'assistant Basic Information, sélectionnez votre Cluster et votre Namespace, puis cliquez sur Next.
5. Dans l'assistant Parameters, sélectionnez une Chart Version. Dans la section Parameter, définissez le point de terminaison HTTP API interne obtenu à l'étape Étape 1 comme valeur pour prometheus.url, puis cliquez sur OK.
```
prometheus:
  enabled: true
  url: http://
```

Étape 2 : Mettre en œuvre la prédiction élastique AHPA basée sur les métriques GPU

Cette rubrique décrit le déploiement d'un service d'inférence de modèle sur un GPU et l'envoi continu de requêtes vers celui-ci. AHPA effectue une prédiction élastique basée sur l'utilisation du GPU.

Déployez le service d'inférence.

Exécutez la commande suivante pour déployer le service d'inférence.

Expand to view details

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

Exécutez la commande suivante pour vérifier l'état des pods.

kubectl get pods -o wide

Résultat attendu :

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>

Exécutez la commande suivante pour appeler le service d'inférence et vérifier le déploiement.

Utilisez la commande kubectl get svc bert-intent-detection-svc pour obtenir l'adresse IP du nœud GPU et remplacez 47.95.XX.XX dans la commande suivante.

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

Résultat attendu :

*   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.

Si la requête HTTP renvoie le code d'état 200 et un résultat de reconnaissance d'intention, le service d'inférence est déployé avec succès.

Configurez AHPA.

Cet exemple utilise l'utilisation du GPU. Le scale-out est déclenché lorsque l'utilisation du GPU d'un pod dépasse 20 %.

Configurez la source de métriques AHPA.

Créez un fichier nommé application-intelligence.yaml avec le contenu suivant.

prometheusUrl définit le point de terminaison pour Alibaba Cloud Prometheus. Utilisez le point de terminaison interne obtenu à l'étape Étape 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"

Exécutez la commande suivante pour déployer application-intelligence.
```
kubectl apply -f application-intelligence.yaml
```

Déployez AHPA.

Créez un fichier nommé fib-gpu.yaml avec le contenu suivant.

Le mode est défini sur observer. Pour plus d'informations sur les paramètres, consultez la rubrique description des métriques.

Expand to view details

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

Exécutez la commande suivante pour déployer AHPA.
```
kubectl apply -f fib-gpu.yaml
```
Exécutez la commande suivante pour vérifier l'état d'AHPA.
```
kubectl get ahpa
```
Résultat attendu :
```
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
```
Le résultat attendu indique que CURRENT(%) est égal à 0 et que TARGET(%) est égal à 20. Cela signifie que l'utilisation actuelle du GPU est de 0 %. Le scale-out élastique est déclenché lorsque l'utilisation du GPU dépasse 20 %.

Testez la mise à l'échelle élastique pour le service d'inférence.

Exécutez la commande suivante pour accéder au service d'inférence.

Expand to view details

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

Pendant l'accès au service, exécutez la commande suivante pour vérifier l'état d'AHPA.
```
kubectl get ahpa
```
Résultat attendu :
```
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
```
Le résultat attendu montre que l'utilisation actuelle du GPU CURRENT(%) dépasse la valeur TARGET(%). La mise à l'échelle élastique est déclenchée et le nombre souhaité de pods DESIREDPODS est de 10.
Exécutez la commande suivante pour afficher la tendance de prédiction.
```
kubectl get --raw '/apis/metrics.alibabacloud.com/v1beta1/namespaces/default/predictionsobserver/fib-gpu'|jq -r '.content' |base64 -d > observer.html
```
La figure suivante illustre un exemple de tendance de prédiction basé sur sept jours de métriques GPU historiques :
- Predict GPU Resource Observer : la ligne bleue représente l'utilisation réelle du GPU. La ligne verte représente l'utilisation du GPU prédite par AHPA. La courbe verte se situe principalement au-dessus de la courbe bleue, ce qui indique que la capacité GPU prédite est suffisante.
- Predict POD Observer : la ligne bleue représente le nombre réel de pods mis à l'échelle. La ligne verte représente le nombre de pods prédit par AHPA. La courbe verte se situe principalement en dessous de la courbe bleue, ce qui indique qu'AHPA prédit un nombre de pods inférieur. Vous pouvez définir le mode de mise à l'échelle élastique sur auto pour utiliser le nombre de pods prédit, ce qui permet d'économiser des ressources de pods et d'éviter le gaspillage.
Les résultats de prédiction sont conformes aux attentes. Après observation, si les résultats restent satisfaisants, définissez le mode de mise à l'échelle élastique sur auto afin qu'AHPA gère la mise à l'échelle.

Références

Knative Serverless prend en charge les capacités élastiques d'AHPA (Advanced Horizontal Pod Autoscaler). Lorsque les besoins en ressources des applications sont périodiques, la prédiction élastique prépare les ressources et résout les problèmes de démarrage à froid dans Knative. Pour plus d'informations, consultez la rubrique Utiliser la prédiction élastique AHPA dans Knative.
Dans de nombreux scénarios, les applications doivent être mises à l'échelle en fonction de métriques personnalisées, telles que le QPS des requêtes HTTP ou la longueur de la file d'attente des messages. AHPA fournit un mécanisme de métriques externes. Combiné au composant alibaba-cloud-metrics-adapter, il offre des options de mise à l'échelle plus riches. Pour plus d'informations, consultez la rubrique Configurer des métriques personnalisées avec AHPA pour mettre à l'échelle les applications.