Implement elastic scaling for applications with HPA based on QPS data - Container Service for Kubernetes

Si votre application doit ajuster dynamiquement les ressources de calcul totales en fonction du volume de requêtes, utilisez les métriques QPS d'ALB Ingress issues de Log Service pour mettre à l'échelle automatiquement les pods d'application avec HPA.

Prérequis

Assurez-vous d'avoir :

Installé la version 2.3.0 ou ultérieure de alibaba-cloud-metrics-adapter.
Installé le contrôleur ALB Ingress.
Installé Apache Benchmark.
Créé un projet Log Service.
Déployé deux vSwitches dans différentes zones du Virtual Private Cloud (VPC) où réside votre cluster.

Fonctionnement

Créez un déploiement et un service pour votre application.
Créez un ALB Ingress pour acheminer le trafic externe vers le service.
Créez un Horizontal Pod Autoscaler (HPA) qui surveille la métrique sls_alb_ingress_qps depuis Log Service.
Lorsque le nombre de QPS dépasse le seuil par pod, le HPA augmente le nombre de réplicas du déploiement. Lorsque le nombre de QPS diminue, le HPA le réduit.

Étape 1 : Créer une application et un service

Créez un fichier nommé tea.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment-basic
  labels:
    app: tea
spec:
  replicas: 2
  selector:
    matchLabels:
      app: tea
  template:
    metadata:
      labels:
        app: tea
    spec:
      containers:
      - name: tea
        image: nginx:1.7.9
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: tea-svc
  namespace: default
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 80
  selector:
    app: tea
  type: NodePort

Appliquez le manifeste :
```
kubectl apply -f tea.yaml
```

Étape 2 : Créer un ALB Ingress

Créer un objet AlbConfig

Identifiez le projet Log Service associé à votre cluster. Dans la console ACK, ouvrez la page des détails du cluster, sélectionnez l'onglet Cluster Information, repérez Log Service Project et notez le nom du projet. Créez un fichier nommé alb-test.yaml :alb-test.yaml :

Champ	Description
`zoneMappings`	Au moins deux ID de vSwitch provenant de zones différentes au sein du même VPC.
`logProject`	Le nom du projet Log Service.
`logStore`	Le nom du Logstore. Doit commencer par `alb_`. Créé automatiquement s'il n'existe pas.

apiVersion: alibabacloud.com/v1
kind: AlbConfig
metadata:
  name: alb-demo
spec:
  config:
    name: alb-test
    addressType: Internet        # Internet-facing ALB
    zoneMappings:
    - vSwitchId: vsw-uf6ccg2a9g71hx8go****   # Replace with your first vSwitch ID
    - vSwitchId: vsw-uf6nun9tql5t8nh15****   # Replace with your second vSwitch ID (different zone)
    accessLogConfig:
      logProject: "****"         # Replace with your Log Service project name
      logStore: "alb_****"       # Replace with your Logstore name; must start with alb_

Appliquez le manifeste :
```
kubectl apply -f alb-test.yaml
```

Créer une IngressClass

Créez un fichier nommé alb.yaml :

apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb
spec:
  controller: ingress.k8s.alibabacloud/alb
  parameters:
    apiGroup: alibabacloud.com
    kind: AlbConfig
    name: alb-demo              # Must match the AlbConfig metadata.name above

Appliquez le manifeste :
```
kubectl apply -f alb.yaml
```

Créer l'Ingress

Créez un fichier nommé tea-ingress.yaml :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tea-ingress
spec:
  ingressClassName: alb
  rules:
   - host: demo.ingress.top
     http:
      paths:
      - path: /tea
        pathType: Prefix
        backend:
          service:
            name: tea-svc
            port:
              number: 80

Appliquez le manifeste :
```
kubectl apply -f tea-ingress.yaml
```

Récupérez l'adresse ALB attribuée à l'Ingress :

kubectl get ingress

Sortie attendue :

NAME          CLASS   HOSTS              ADDRESS                                            PORTS   AGE
tea-ingress   alb     demo.ingress.top   alb-110zvs5nhsvfv*****.cn-chengdu.alb.aliyuncs.com   80      7m5s

Notez la valeur ADDRESS pour le test de charge à l'étape 4.

Étape 3 : Créer un HPA

Créez un fichier nommé hpa.yaml :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: ingress-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx-deployment-basic   # The Deployment to scale
  minReplicas: 2                   # Minimum number of pods
  maxReplicas: 10                  # Maximum number of pods
  metrics:
    - type: External
      external:
        metric:
          name: sls_alb_ingress_qps   # ALB QPS metric from Log Service
          selector:
            matchLabels:
              sls.project: "****"              # Replace with your Log Service project name
              sls.logstore: "alb_****"         # Replace with your Logstore name
              sls.ingress.route: "default-tea-svc-80"
              # Format: <namespace>-<service-name>-<port>
              # Example: default-nginx-80
        target:
          type: AverageValue        # Scale based on average QPS per pod
          averageValue: 2           # Scale out when average QPS per pod exceeds 2

Ce HPA ajuste le nombre de pods de nginx-deployment-basic entre 2 et 10. Il augmente le nombre de pods lorsque la QPS moyenne par pod dépasse 2, et le réduit lorsque la QPS diminue.

Appliquez le manifeste :
```
kubectl apply -f hpa.yaml
```

Vérifiez la création du HPA :

kubectl get hpa

Sortie attendue :

NAME          REFERENCE                           TARGETS     MINPODS   MAXPODS   REPLICAS   AGE
ingress-hpa   Deployment/nginx-deployment-basic   0/2 (avg)   2         10        2          4h34m

La QPS est 0 car aucun trafic n'atteint encore l'application. Le nombre de pods est à son minimum (2).

(Facultatif) Inspectez les détails du HPA :

kubectl describe hpa ingress-hpa

Sortie attendue :

Name:                                            ingress-hpa
Namespace:                                       default
Labels:                                          <none>
Annotations:                                     <none>
CreationTimestamp:                               Tue, 31 Jan 2023 11:35:01 +0800
Reference:                                       Deployment/nginx-deployment-basic
Metrics:                                         ( current / target )
"sls_alb_ingress_qps" (target average value):    0 / 2
Min replicas:                                    2
Max replicas:                                    10
Deployment pods:                                 2 current / 2 desired

Étape 4 : Vérifier la mise à l'échelle automatique

Vérifier l'augmentation du nombre de pods (scale-out)

Exécutez un test de charge sur l'adresse ALB obtenue à l'étape 2. Remplacez l'espace réservé par votre adresse réelle.
```
ab -c 5 -n 5000 -H Host:demo.ingress.top http://alb-110zvs5nhsvfv*****.cn-chengdu.alb.aliyuncs.com/tea
```
Pendant l'exécution du test, observez l'état du HPA en temps réel :
```
kubectl get hpa ingress-hpa --watch
```
Lorsque la QPS dépasse le seuil, le nombre de réplicas augmente. Appuyez sur Ctrl+C pour arrêter.

Après le test de charge, confirmez l'augmentation du nombre de pods :

kubectl get hpa

Sortie attendue :

NAME          REFERENCE                           TARGETS          MINPODS   MAXPODS   REPLICAS   AGE
ingress-hpa   Deployment/nginx-deployment-basic   12500m/2 (avg)   2         10        10         15m

La valeur REPLICAS est 10, ce qui confirme que le déploiement a atteint le nombre maximal de pods.

Vérifier la réduction du nombre de pods (scale-in)

Une fois le test de charge terminé, la QPS retombe à 0 et le HPA réduit le nombre de pods du déploiement. La réduction du nombre de pods implique une fenêtre de stabilisation d'environ 5 minutes ; attendez donc avant de vérifier.

kubectl get hpa

Sortie attendue :

NAME          REFERENCE                           TARGETS      MINPODS   MAXPODS   REPLICAS   AGE
ingress-hpa   Deployment/nginx-deployment-basic   0/2 (avg)    2         10        2          60m

La valeur REPLICAS est revenue à 2, ce qui confirme que le déploiement a réduit son nombre de pods.

Étapes suivantes

Ajustez l'augmentation et la réduction du nombre de pods en configurant le champ behavior dans la spécification HPA.
Mettez à l'échelle sur la base de métriques Alibaba Cloud supplémentaires.