Container Service for Kubernetes:Implement rapid elastic scaling across multiple zones

To resolve this issue, ACK introduces the ack-autoscaling-placeholder component. The component fixes this issue by using resource redundancy. The component transforms multi-zone elastic scaling into directed scaling of concurrent node pools. For more information, see Use ack-autoscaling-placeholder to scale pods within seconds. The principle is as follows.

1. Create a node pool in each zone and add a label to the node pool. The label specifies the zone in which the node pool is deployed.

2. Configure the nodeSelector to schedule pods based on zone labels. This way, ack-autoscaling-placehodler can schedule a placeholder pod to each zone. The default placeholder pods have a PriorityClass with a lower weight, which is lower than that of application pods.

3. This allows pending application pods to replace placeholder pods. After the pending application pods replace the placeholder pods that are scheduled by using the nodeSelector, the placeholder pods become pending. The node scheduling policy that is used by the node auto scaling component is changed from antiAffinity to nodeSelector. In this way, the node requests from the scaling out section can be processed.

The following figure shows how to achieve simultaneous scaling in two zones based on the existing architecture.

1. ack-autoscaling-placeholder is the bridge between the application pods and the node auto scaling component and can be used to create a placeholder pod in each zone. The scheduling priority of placeholder pods is lower than the priority of actual business applications.

2. When application pods are in the Pending state, they quickly preempt placeholder pods and are deployed on existing nodes in each zone. Meanwhile, the preempted placeholder pods enter the Pending state.

3. The placeholder pods are scheduled by using the nodeSelector. The node auto scaling component can be concurrently scaled out to the corresponding zones.

Step 1: Create a node pool for each zone and configure a custom node label

1. Log on to the ACK console. In the left-side navigation pane, click Clusters.

2. On the Clusters page, find the cluster to manage and click its name. In the left-side navigation pane, choose Nodes > Node Pools.

3. Click Create Node Pool and complete the node pool configuration as prompted.

   This example describes how to create a node pool named auto-zone-I with auto scaling enabled in Zone I. The following section describes only the key parameters. For more information, see Create and manage a node pool.

   Parameter	Description
   Node Pool Name	auto-zone-I
   Scaling Mode	Select Auto to enable auto scaling.
   vSwitch	Select a vSwitch in Zone I.
   Node Labels	Set the Key of the node label to available_zone and the Value to i.

   In the node pool list, when the status of the auto-zone-I node pool is Active, the node pool is created successfully.

4. Repeat the preceding steps to create a node pool with auto scaling enabled for each zone that requires auto scaling.

   

Step 2: Deploy placeholder and placeholder Deployments

1. In the left-side navigation pane of the ACK console, choose Marketplace > Marketplace.

2. Find and click ack-autoscaling-placeholder. On the ack-autoscaling-placeholder page, click Deploy.

3. Select a cluster from the Cluster drop-down list and a namespace from the Namespace drop-down list, and then click Next. Select a chart version from the Chart Version drop-down list, configure the parameters, and then click OK.

   After the creation is successful, choose Applications > Helm in the left-side navigation pane, and you can find that the application is in the Deployed state.

4. In the left-side navigation pane of the details page, choose Applications > Helm.

5. On the Helm page, click Update in the Actions column of ack-autoscaling-placeholder-default.

6. In the Update Release panel, update the YAML file based on the following example, and then click OK. Deploy a placeholder for each zone and define a placeholder Deployment for each zone.

   This example shows how to create placeholder Deployments in Zones I, K, and H.

   deployments:
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m     # The CPU request of the placeholder Deployment. 
           memory: 6      # The memory request of the placeholder Deployment. 
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-I             # The name of the placeholder Deployment. 
     nodeSelector: {"avaliable_zone":i}   # The zone label. The label must be the same as the label that you specified in Step 1 when you created the node pool. 
     replicaCount: 10                     # The number of pods that are created in each scale-out activity. 
     tolerations: []
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m    # The CPU request of the placeholder Deployment. 
           memory: 6     # The memory request of the placeholder Deployment. 
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-K            # The name of the placeholder Deployment. 
     nodeSelector: {"avaliable_zone":k}  # The zone label. The label must be the same as the label that you specified in Step 1 when you created the node pool. 
     replicaCount: 10                    # The number of pods that are created in each scale-out activity. 
     tolerations: []
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m   # The CPU request of the placeholder Deployment. 
           memory: 6    # The memory request of the placeholder Deployment. 
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-H           # The name of the placeholder Deployment. 
     nodeSelector: {"avaliable_zone":h} # The zone label. The label must be the same as the label that you specified in Step 1 when you created the node pool. 
     replicaCount: 10                   # The number of pods that are created in each scale-out activity. 
     tolerations: []
   fullnameOverride: ""
   nameOverride: ""
   podSecurityContext: {}
   priorityClassDefault:
     enabled: true
     name: default-priority-class
     value: -1

   After the update is successful, placeholder Deployments are created for each zone.

Step 3: Create a PriorityClass for a workload

1. Create a file named priorityClass.yaml and copy the following content to the file:

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: high-priority
   value: 1000000              # Specify the priority value. The value must be higher than the default priority value of the workload that you create in Step 2.
   globalDefault: false
   description: "This priority class should be used for XYZ service pods only."

   If you do not need to configure a separate PriorityClass for a pod, you can configure a global PriorityClass as the default configuration. After the configuration takes effect, pods without a specified PriorityClass will automatically adopt this priority value, and the preemption capability will automatically take effect.

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: global-high-priority
   value: 1                              # Specify the priority value. The value must be higher than the default priority value of the workload that you create in Step 2.
   globalDefault: true
   description: "This priority class should be used for XYZ service pods only."

2. Create a PriorityClass for a workload.

   kubectl apply -f priorityClass.yaml

   Expected output:

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

Step 4: Create a workload

In this example, Zone I is used.

1. Create a file named workload.yaml and copy the following content to the file:

   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:                        # Specify rules that are used to select nodes.
           avaliable_zone: "i"
         priorityClassName: high-priority     # The name of the PriorityClass configured in Step 3. This is optional if global configuration is enabled.
         containers:
         - name: nginx
           image: nginx:1.7.9
           ports:
           - containerPort: 80
           resources:
             requests:
               cpu: 3                         # Specify the resource request of the workload.
               memory: 5

2. Deploy a workload.

   kubectl apply -f workload.yaml

   Expected output:

   deployment.apps/placeholder-test created

   After the deployment, on the Workloads > Pods page, you can see that the PriorityClass of the workload is higher than the PriorityClass of the placeholder pod, the placeholder pod runs on the scaled-out node. The placeholder pod triggers concurrent scaling of the node auto scaling component to prepare for the next workload scaling.

   Choose Nodes > Nodes. On the Nodes page, you can find that the workload pod runs on the node that hosts the placeholder pod.