Container Service for Kubernetes:Scale containers in seconds with ack-autoscaling-placeholder

Prérequis

• mise à l'échelle automatique des nœuds est activée pour le cluster ACK et un pool de nœuds élastique est configuré.

• Un libellé de nœud est défini sur le pool de nœuds élastique via Node Labels. Ce guide utilise demo=yes.

Fonctionnement

Ces trois étapes fonctionnent conjointement grâce à la préemption par priorité de Kubernetes :

1. Le pod fictif s'exécute avec une PriorityClass de faible valeur (valeur -1), ce qui réserve les ressources du nœud.

2. Lorsqu'une charge de travail réelle est déployée avec une PriorityClass élevée (valeur 1000000), le planificateur expulse le pod fictif et place la charge de travail sur les ressources libérées immédiatement.

3. Le pod fictif, désormais en état Pending, déclenche le CA pour provisionner un nouveau nœud. Une fois le nœud prêt, le pod fictif est replanifié et le tampon est restauré.

Déployer ack-autoscaling-placeholder

1. Connectez-vous à la console Container Service. Dans le volet de navigation de gauche, sélectionnez Marketplace > Marketplace.

2. Dans l'onglet App Catalog , recherchez ack-autoscaling-placeholder et cliquez sur ack-autoscaling-placeholder.

3. Sur la page ack-autoscaling-placeholder , cliquez sur Deploy.

4. Dans le panneau de création, cliquez sur l'onglet Parameter , remplacez les Parameters par le code YAML suivant, puis cliquez sur OK.

   Définissez resources.requests pour correspondre aux ressources allocatables sur le nœud cible, et non à la capacité totale. Les nœuds réservent de la capacité pour kubelet, le système d'exploitation et kube-proxy. Vérifiez cela avec kubectl describe node <node-name> sous Allocatable.

   nameOverride: ""
   fullnameOverride: ""
   
   priorityClassDefault:
     enabled: true
     name: default-priority-class   # Low-priority class for placeholder pods.
     value: -1                      # Must be above the CA expendable-pod cutoff and below real workload priority.
   
   deployments:
      - name: ack-place-holder
        replicaCount: 1
        containers:
          - name: placeholder
            image: registry-vpc.cn-shenzhen.aliyuncs.com/acs/pause:3.1
            pullPolicy: IfNotPresent
            resources:
              requests:
                cpu: 4             # Size these requests to match allocatable node resources,
                memory: 8Gi        # not raw node capacity (deduct kubelet, OS, and kube-proxy overhead).
        imagePullSecrets: {}
        annotations: {}
        nodeSelector:              # Must match the labels on the elastic node pool.
          demo: "yes"
        tolerations: []
        affinity: {}
        labels: {}

5. Sélectionnez Applications > Helm et vérifiez que le statut de l'application est Deployed.

Créer une PriorityClass pour la charge de travail

1. Créez le fichier priorityClass.yaml avec le contenu suivant.

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: high-priority
   value: 1000000       # Must be higher than the placeholder PriorityClass value (-1).
   globalDefault: false
   description: "High-priority class for production workloads."

2. Appliquez la PriorityClass.

   kubectl apply -f priorityClass.yaml

   Résultat attendu :

   priorityclass.scheduling.k8s.io/high-priority created

Déployer la charge de travail

1. Créez le fichier workload.yaml avec le contenu suivant.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: placeholder-test
     labels:
       app: nginx
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         nodeSelector:              # Must match the labels on the elastic node pool.
           demo: "yes"
         priorityClassName: high-priority   # References the PriorityClass created in Step 2.
         containers:
         - name: nginx
           image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
           ports:
           - containerPort: 80
           resources:
             requests:
               cpu: 3             # Must be less than or equal to the placeholder's cpu request (4)
               memory: 5Gi        # so the real workload fits within the reserved space.

2. Appliquez le Deployment.

   kubectl apply -f workload.yaml

   Résultat attendu :

   deployment.apps/placeholder-test created

Vérifier le résultat

1. Après le déploiement, le statut du pod ack-place-holder est Running.

   

2. La charge de travail préempte le pod fictif et démarre sur le même nœud. Le pod fictif passe à l'état Pending.

   • La charge de travail placeholder-test est en état Running sur le nœud précédemment occupé par le pod fictif.

   • Le pod fictif passe à l'état Pending en raison de ressources insuffisantes.

3. Le CA détecte le pod fictif en état Pending et provisionne un nouveau nœud. Une fois prêt, le pod fictif est replanifié et le tampon est restauré.

   

Étapes suivantes

Pour le surapprovisionnement multi-zone, consultez Réaliser une mise à l'échelle élastique rapide dans plusieurs zones simultanément.