Container Service for Kubernetes:Enable rapid multi-zone auto scaling

Prérequis

Vous avez créé au moins un vSwitch dans chaque zone où vous souhaitez déployer de nouvelles instances. Pour plus d'informations, consultez la rubrique Créer et gérer des vSwitches. Une fois créés, vous pouvez sélectionner le vSwitch approprié lors de la création et gestion des pools de nœuds.

Contexte

L'autoscaler de cluster peut déterminer si un service peut être déployé sur un groupe de mise à l'échelle et envoyer une demande d'extension à un groupe de mise à l'échelle ESS spécifié pour créer de nouvelles instances. Toutefois, un problème survient lorsque vous configurez des vSwitches provenant de plusieurs zones au sein d'un seul groupe de mise à l'échelle ESS. Lorsque les pods de charge de travail ne peuvent pas être planifiés en raison de ressources insuffisantes dans le cluster, ACK déclenche le groupe de mise à l'échelle ESS pour étendre la capacité. Mais sans mécanisme permettant d'associer la demande d'extension à une zone spécifique, le groupe de mise à l'échelle ESS ignore quelle zone nécessite davantage de capacité. Cela peut entraîner une concentration des nouvelles instances dans une seule zone plutôt qu'une répartition sur plusieurs zones, ce qui ne répond pas à l'exigence d'une mise à l'échelle simultanée sur plusieurs zones.

Pour résoudre ce problème, ACK propose le composant ack-autoscaling-placeholder. En utilisant une petite quantité de ressources réservées, ce composant transforme la mise à l'échelle automatique générique sur plusieurs zones en une extension ciblée et simultanée de pools de nœuds spécifiques. Pour plus d'informations, consultez la rubrique Effectuer la mise à l'échelle des conteneurs en quelques secondes avec ack-autoscaling-placeholder. Voici son fonctionnement :

1. Créez un pool de nœuds distinct pour chaque zone et appliquez un libellé de zone unique à chaque pool de nœuds.

2. Utilisez le composant ack-autoscaling-placeholder pour créer des pods de substitution (placeholder) dans chaque zone en utilisant un nodeSelector qui cible les libellés spécifiques à la zone. Par défaut, ces pods de substitution possèdent une PriorityClass de faible priorité, leur conférant une priorité inférieure à celle de vos pods d'application.

3. Lorsqu'un pod de charge de travail à haute priorité passe à l'état Pending, il préempte un pod de substitution dans l'une des zones. Le pod de substitution préempté, doté d'un nodeSelector spécifique à la zone, passe alors à l'état Pending. Cela signale à l'autoscaler de cluster qu'il doit ajouter un nouveau nœud spécifiquement dans cette zone, transformant ainsi un besoin général de mise à l'échelle en une demande ciblée.

L'exemple suivant utilise deux zones pour illustrer comment réaliser une mise à l'échelle simultanée sur plusieurs zones.

1. Le composant ack-autoscaling-placeholder sert d'intermédiaire entre vos applications et l'autoscaler de cluster en créant un pod de substitution dans chaque zone. La priorité d'ordonnancement de ces pods de substitution est inférieure à celle de vos pods d'application.

2. Lorsqu'un pod d'application passe à l'état Pending, il préempte immédiatement un pod de substitution et s'exécute sur un nœud existant dans l'une des zones. Le pod de substitution préempté passe alors à l'état Pending.

3. Étant donné que chaque pod de substitution est configuré avec un nodeSelector spécifique à la zone, l'autoscaler de cluster sait exactement quelle zone mettre à l'échelle, permettant ainsi une extension simultanée dans les zones appropriées.

Étape 1 : Créer des pools de nœuds et ajouter des libellés

1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.

2. Sur la page Clusters, cliquez sur le nom de votre cluster cible. Dans le volet de navigation de gauche, accédez à Nodes > Node Pools.

3. Cliquez sur Create Node Pool et configurez les paramètres comme indiqué.

   Cet exemple crée un pool de nœuds nommé auto-zone-I avec la mise à l'échelle automatique activée dans la zone I. Le tableau suivant décrit les paramètres clés. Pour plus d'informations, consultez la rubrique Créer et gérer des pools de nœuds.

   Parameter	Description
   Node Pool Name	auto-zone-I
   Scaling Mode	Sélectionnez Auto pour activer la mise à l'échelle automatique.
   vSwitch	Sélectionnez le vSwitch pour la zone I.
   Node Labels	Définissez la Key sur available_zone et la Value sur i.

   Dans la liste des pools de nœuds, le pool de nœuds est créé avec succès lorsque son statut passe à Active.

4. Répétez ces étapes pour chaque zone où vous souhaitez activer la mise à l'échelle automatique.

   Après la création, vous pouvez voir les pools de nœuds pour chaque zone (par exemple, auto-zone-I, auto-zone-K et auto-zone-H) dans la liste des pools de nœuds. Vous pouvez sélectionner différents types d'instance selon vos besoins (tels que ecs.hfc7.xlarge, ecs.c7.xlarge ou ecs.s6-c1m2.xlarge). La méthode de facturation est le paiement à l'utilisation et le statut de chaque pool de nœuds est Active avec la mise à l'échelle automatique activée.

Étape 2 : Déployer le composant de substitution et les Deployments

1. Dans le volet de navigation de gauche, accédez à Marketplace > Application market.

2. Recherchez ack-autoscaling-placeholder, cliquez sur la carte du composant, puis cliquez sur Deploy.

3. Sélectionnez un Cluster et un Namespace, cliquez sur Next, sélectionnez une Chart Version, modifiez le Parameter, puis cliquez sur OK.

   Une fois l'application créée, accédez à la page Applications > Helm. Le statut de l'application est Deployed.

4. Dans le volet de navigation de gauche de la page de gestion du cluster, accédez à Application > Helm.

5. Sur la page Helm, recherchez ack-autoscaling-placeholder-default et cliquez sur Update dans la colonne Actions.

6. Dans le panneau Update Release, mettez à jour la configuration YAML comme indiqué dans l'exemple suivant et cliquez sur OK. Vous devez définir un Deployment de substitution pour chaque zone.

   Cet exemple montre comment créer des Deployments de substitution dans les zones I, K et H.

   deployments:
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m     # CPU request for the placeholder pod.
           memory: 6      # Memory request for the placeholder pod.
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-I             # The name of the placeholder Deployment.
     nodeSelector: {"available_zone":"i"}   # The zone label. It must match the label configured for the node pool in Step 1.
     replicaCount: 10                     # The number of pods to create in each scale-out event.
     tolerations: []
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m    # CPU request for the placeholder pod.
           memory: 6     # Memory request for the placeholder pod.
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-K            # The name of the placeholder Deployment.
     nodeSelector: {"available_zone":"k"}  # The zone label. It must match the label configured for the node pool in Step 1.
     replicaCount: 10                    # The number of pods to create in each scale-out event.
     tolerations: []
   - affinity: {}
     annotations: {}
     containers:
     - image: registry-vpc.cn-beijing.aliyuncs.com/acs/pause:3.1
       imagePullPolicy: IfNotPresent
       name: placeholder
       resources:
         requests:
           cpu: 3500m   # CPU request for the placeholder pod.
           memory: 6    # Memory request for the placeholder pod.
     imagePullSecrets: {}
     labels: {}
     name: ack-place-holder-H           # The name of the placeholder Deployment.
     nodeSelector: {"available_zone":"h"} # The zone label. It must match the label configured for the node pool in Step 1.
     replicaCount: 10                   # The number of pods to create in each scale-out event.
     tolerations: []
   fullnameOverride: ""
   nameOverride: ""
   podSecurityContext: {}
   priorityClassDefault:
     enabled: true
     name: default-priority-class
     value: -1

   Une mise à jour réussie crée un Deployment de substitution pour chaque zone.

Étape 3 : Créer une PriorityClass pour la charge de travail

1. Créez un fichier nommé priorityClass.yaml en utilisant le modèle YAML suivant.

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: high-priority
   value: 1000000              # Set a priority value higher than the default priority of the placeholder pods from Step 2.
   globalDefault: false
   description: "This priority class should be used for XYZ service pods only."

   Si vous n'avez pas besoin de configurer une PriorityClass spécifique pour chaque pod, vous pouvez définir une valeur par défaut globale. Une fois configurée, tout pod sans priorityClassName spécifié utilisera automatiquement cette priorité.

   apiVersion: scheduling.k8s.io/v1
   kind: PriorityClass
   metadata:
     name: global-high-priority
   value: 1                              # Set a priority value higher than the default priority of the placeholder pods from Step 2.
   globalDefault: true
   description: "This priority class should be used for XYZ service pods only."

2. Créez la PriorityClass.

   kubectl apply -f priorityClass.yaml

   Résultat attendu :

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

Étape 4 : Créer la charge de travail réelle

L'exemple suivant crée une charge de travail dans la zone I.

1. Créez un fichier nommé workload.yaml en utilisant le modèle YAML 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:                        # Node selector.
           available_zone: "i"
         priorityClassName: high-priority     # The name of the PriorityClass created in Step 3. This field is optional if you have configured a global default.
         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'                        # Resource requests for the actual workload.
               memory: 5Gi

2. Déployez la charge de travail réelle.

   kubectl apply -f workload.yaml

   Résultat attendu :

   deployment.apps/placeholder-test created

   Une fois la charge de travail déployée, accédez à la page Workloads > Pods. Vous constaterez que, grâce à sa PriorityClass plus élevée, la charge de travail préempte un pod de substitution et s'exécute sur son nœud. Le pod de substitution préempté déclenche à son tour l'autoscaler de cluster pour effectuer une mise à l'échelle simultanée, préparant ainsi la capacité pour de futures extensions de charge de travail.

   Sur la page Nodes > Nodes, observez que le pod de charge de travail s'exécute désormais sur le nœud précédemment occupé par un pod de substitution. Vous pouvez également vérifier que le cluster a ajouté de nouveaux nœuds de calcul. Par exemple, vous pourriez voir deux nouveaux nœuds ecs.c6e.xlarge (4 vCPU, 8 GiB) en état running, confirmant que l'autoscaler de cluster a bien effectué la mise à l'échelle simultanée.