Deploy AHPA to resolve service elasticity lag with intelligent prediction and resource warmup - Container Service for Kubernetes

Container Service for Kubernetes prend en charge l'Advanced Horizontal Pod Autoscaler (AHPA). L'AHPA analyse les données historiques pour prédire la demande future en ressources. Il ajuste ensuite dynamiquement le nombre de réplicas de pods pour augmenter la capacité (scale out) et préchauffer les ressources avant les pics de trafic. Cette approche améliore la réactivité et la stabilité du système. L'AHPA réduit également les coûts en diminuant les ressources (scale in) pendant les périodes creuses.

Prérequis

Vous disposez d'un ACK managed cluster ou d'un ACK Serverless cluster. Pour plus d'informations, consultez les rubriques Création d'un ACK managed cluster ou Création d'un cluster.
Managed Service for Prometheus doit être activé et disposer d'au moins sept jours de données historiques sur l'application, telles que l'utilisation du CPU et de la mémoire. Pour savoir comment l'activer, consultez la rubrique Accès et configuration de Managed Service for Prometheus.

Étape 1 : Installation du contrôleur AHPA

Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Components and Add-ons .
Sur la page Add-ons, localisez le composant AHPA Controller. Cliquez sur Install dans la carte du composant et suivez les instructions affichées à l'écran pour terminer l'installation.

Étape 2 : Configuration de la source de données Prometheus

Connectez-vous à la console ARMS.
Dans le volet de navigation de gauche, choisissez Managed Service for Prometheus > Instances.
En haut de la page Instances, sélectionnez la région de votre instance Prometheus, puis cliquez sur le nom de l'instance, qui correspond au nom de votre cluster ACK.
Sur la page Settings, dans la section HTTP API Address (Grafana Read Address), notez les valeurs des champs suivants :
- (Facultatif) Si l'authentification par jeton est activée, notez le jeton d'accès.
- Consultez et notez l'endpoint Internal Network (URL Prometheus).
Définissez l'URL de requête Prometheus dans votre cluster ACK.
1. Créez un fichier nommé application-intelligence.yaml avec le contenu suivant.
  - prometheusUrl : endpoint pour Managed Service for Prometheus.
  - token : jeton d'accès pour Prometheus.
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: application-intelligence
  namespace: kube-system
data:
  prometheusUrl: "http://cn-hangzhou-intranet.arms.aliyuncs.com:9443/api/v1/prometheus/da9d7dece901db4c9fc7f5b9c40****/158120454317****/cc6df477a982145d986e3f79c985a****/cn-hangzhou"
  token: "eyJhxxxxx"
```
  Remarque
  Pour afficher le tableau de bord AHPA dans Managed Service for Prometheus, vous devez également configurer les champs suivants dans ce ConfigMap :
  
  Pour plus d'informations, consultez la rubrique Activation du tableau de bord Prometheus pour AHPA.
2. Exécutez la commande suivante pour déployer application-intelligence.
```
kubectl apply -f application-intelligence.yaml
```

Étape 3 : Déploiement d'un service de test

Le service de test comprend un Deployment nommé fib-deployment, un Service nommé fib-svc et un générateur de charge nommé fib-loader pour simuler les fluctuations du trafic. Vous déploierez également une ressource HorizontalPodAutoscaler (HPA) afin d'établir une base de comparaison avec AHPA.

Créez un fichier nommé demo.yaml avec le contenu suivant.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: fib-deployment
  namespace: default
  annotations:
    k8s.aliyun.com/eci-use-specs: "1-2Gi"
spec:
  replicas: 1
  selector:
    matchLabels:
      app: fib-deployment
  strategy:
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 25%
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: fib-deployment
    spec:
      containers:
      - image: registry.cn-huhehaote.aliyuncs.com/kubeway/knative-sample-fib-server:20200820-171837
        imagePullPolicy: IfNotPresent
        name: user-container
        ports:
        - containerPort: 8080
          name: user-port
          protocol: TCP
        resources:
          limits:
            cpu: "1"
            memory: 2000Mi
          requests:
            cpu: "1"
            memory: 2000Mi
---
apiVersion: v1
kind: Service
metadata:
  name: fib-svc
  namespace: default
spec:
  ports:
  - name: http
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: fib-deployment
  sessionAffinity: None
  type: ClusterIP
---
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://fib-svc.${NAMESPACE}?size=35&interval=0" --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
---
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: fib-hpa
  namespace: default
spec:
  maxReplicas: 50
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: fib-deployment
  targetCPUUtilizationPercentage: 50
---

Étape 4 : Déploiement d'AHPA

Pour configurer une politique de mise à l'échelle, créez une ressource AdvancedHorizontalPodAutoscaler.

Créez un fichier nommé ahpa-demo.yaml avec le contenu suivant.

apiVersion: autoscaling.alibabacloud.com/v1beta1
kind: AdvancedHorizontalPodAutoscaler
metadata:
  name: ahpa-demo
spec:
  scaleStrategy: observer
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 40
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: fib-deployment 
  maxReplicas: 100
  minReplicas: 2
  stabilizationWindowSeconds: 300
  prediction:
    quantile: 95
    scaleUpForward: 180
  instanceBounds:
  - startTime: "2021-12-16 00:00:00"
    endTime: "2031-12-16 00:00:00"
    bounds:
    - cron: "* 0-8 ? * MON-FRI"
      maxReplicas: 15
      minReplicas: 4
    - cron: "* 9-15 ? * MON-FRI"
      maxReplicas: 15
      minReplicas: 10
    - cron: "* 16-23 ? * MON-FRI"
      maxReplicas: 20
      minReplicas: 15

Le tableau suivant décrit certains des paramètres.

Paramètre	Obligatoire	Description
scaleTargetRef	Oui	Spécifie le Deployment cible.
metrics	Oui	Configure les métriques pour la mise à l'échelle. Les métriques prises en charge incluent le CPU, le GPU, la mémoire, les QPS et le RT.
target	Oui	Le seuil cible. Par exemple, `averageUtilization: 40` définit l'utilisation cible du CPU à 40 %.
scaleStrategy	Non	Spécifie le mode de mise à l'échelle. La valeur par défaut est `observer`. `auto` : AHPA effectue les opérations de mise à l'échelle. `observer` : AHPA observe mais n'effectue pas d'opérations de mise à l'échelle. Utilisez ce mode pour vérifier si AHPA fonctionne comme prévu. `proactive` : Seule la prédiction proactive est prise en compte. `reactive` : Seule la mise à l'échelle réactive est prise en compte.
maxReplicas	Oui	Le nombre maximal de réplicas après augmentation (scale out).
minReplicas	Oui	Le nombre minimal de réplicas après réduction (scale in).
stabilizationWindowSeconds	Non	La fenêtre de stabilisation pour les opérations de mise à l'échelle. Cela permet d'éviter les fluctuations rapides du nombre de réplicas. La valeur par défaut est de 300 secondes.
prediction.quantile	Oui	Le quantile de prédiction. Une valeur plus élevée donne lieu à une prédiction plus conservatrice. La valeur doit être comprise entre 0 et 100. La plage recommandée est de 90 à 99, avec une valeur par défaut de 99.
prediction.scaleUpForward	Oui	Le temps nécessaire pour qu'un nouveau pod passe à l'état `Ready`. On parle également de temps de démarrage à froid.
instanceBounds	Non	Les limites du nombre de réplicas pour des plages horaires spécifiques. `startTime` : heure de début. `endTime` : heure de fin.
instanceBounds.bounds.cron	Non	Configure une tâche planifiée. Une expression cron spécifie un planning à l'aide de plusieurs champs séparés par des espaces pour définir un ensemble d'heures. Par exemple, `- cron: " 0-8 ? MON-FRI"` indique que la tâche s'exécute chaque minute de 00 h 00 à 08 h 59 du lundi au vendredi.

Les champs d'une expression cron sont décrits ci-dessous. Pour plus d'informations, consultez la rubrique Tâches planifiées Cron.

|
**Champ**
|
**Obligatoire**
|
**Valeurs autorisées**
|
**Caractères spéciaux**
| | --- | --- | --- | --- | |
Minutes
|
Oui
|
0–59
|
* / , -
| |
Heures
|
Oui
|
0–23
|
* / , -
| |
Jour du mois
|
Oui
|
1–31
|
* / , - ?
| |
Mois
|
Oui
|
1–12 ou JAN–DEC
|
* / , -
| |
Jour de la semaine
|
Oui
|
0–6 ou SUN–SAT
|
* / , - ?
|

Remarque

Les champs Mois et Jour de la semaine ne sont pas sensibles à la casse. Par exemple, SUN, Sun et sun ont le même effet.
Si le champ Jour de la semaine n'est pas configuré, sa valeur par défaut est *.
Caractères spéciaux :
- * : Correspond à toutes les valeurs possibles du champ.
- / : Spécifie un incrément pour une valeur.
- , : Liste des valeurs énumérées.
- - : Spécifie une plage.
- ? : Indique qu'aucune valeur spécifique n'est définie. Utilisez-le dans le champ Jour du mois ou Jour de la semaine lorsque l'autre est spécifié.

Exécutez la commande suivante pour créer la politique de mise à l'échelle AHPA.
```
kubectl apply -f ahpa-demo.yaml
```

Étape 5 : Affichage des résultats de prédiction

Pour afficher les résultats de la mise à l'échelle prédictive d'AHPA, vous pouvez activer le tableau de bord Prometheus pour AHPA.

Remarque

Étant donné que la prédiction nécessite sept jours de données historiques, vous devez exécuter l'application exemple pendant sept jours après le déploiement pour voir les résultats de la prédiction. Si vous disposez déjà d'une application de production, vous pouvez la spécifier directement dans la ressource AHPA.

Cet exemple utilise le mode d'observation observer (observer mode) pour comparer les résultats de prédiction d'AHPA avec ceux d'une politique HPA standard. Les résultats HPA servent de référence pour les besoins réels en ressources de l'application. Cette comparaison vous permet de vérifier si les prédictions d'AHPA répondent à vos attentes.

Utilisation réelle et prédite du CPU : La ligne verte représente l'utilisation réelle du CPU gérée par HPA. La ligne jaune représente l'utilisation du CPU prédite par AHPA.
- Lorsque la courbe jaune se situe au-dessus de la courbe verte, cela indique que la capacité CPU prédite est suffisante.
- Lorsque la courbe jaune augmente avant la courbe verte, cela signifie qu'AHPA prépare les ressources nécessaires à l'avance.

Tendances des pods : La ligne verte représente le nombre réel de pods mis à l'échelle par HPA. La ligne jaune représente le nombre de pods prédit par AHPA.
- Une courbe jaune plus basse peut indiquer qu'AHPA atteint le même objectif avec moins de pods.
- La courbe jaune est plus lisse que la courbe verte, ce qui indique que les événements de mise à l'échelle gérés par AHPA sont moins volatils, améliorant ainsi la stabilité du service.

Les résultats de la prédiction indiquent que la tendance de mise à l'échelle est conforme aux attentes. Si la tendance répond à vos attentes après une période d'observation, vous pouvez définir le mode de mise à l'échelle sur auto et laisser AHPA gérer la mise à l'échelle.

Documentation connexe

Pour utiliser les métriques GPU de Managed Service for Prometheus pour la mise à l'échelle prédictive AHPA, consultez la rubrique Configuration de la mise à l'échelle prédictive AHPA basée sur les métriques GPU.
Pour afficher les tableaux de bord de surveillance fournis par Managed Service for Prometheus, consultez la rubrique Activation du tableau de bord Prometheus pour AHPA.