Container Service for Kubernetes:Schedule applications to specific node pools

Choisir une méthode de planification

Fonctionnement

ACK utilise le mécanisme natif de planification Kubernetes pour associer les pods aux nœuds en fonction des étiquettes. Le processus se déroule comme suit :

1. Définissez les étiquettes du pool de nœuds. Un pool de nœuds gère un groupe de nœuds partageant la même configuration. Lorsque vous configurez Node Labels pour un pool de nœuds, ACK synchronise ces étiquettes sur tous les nœuds du pool, y compris les nouveaux nœuds ajoutés lors du scale-out.

   Une fois que vous avez ouvert Configuration du pool de nœuds et sélectionné Update Labels and Taints of Existing Nodes , ACK synchronise également les étiquettes sur les nœuds existants.

2. Définissez une règle de planification. Dans la spécification du pod, utilisez nodeSelector ou nodeAffinity pour spécifier les étiquettes que les nœuds cibles doivent posséder.

3. (Facultatif) Configurez un accès exclusif. Ajoutez une taint au pool de nœuds afin que seuls les pods dotés d'une toleration correspondante y soient planifiés.

4. Planification automatique. Le planificateur Kubernetes place les pods sur les nœuds qui satisfont aux règles ci-dessus.

ACK crée automatiquement une étiquette globalement unique alibabacloud.com/nodepool-id pour chaque pool de nœuds. Utilisez cette étiquette pour cibler un pool de nœuds spécifique par correspondance exacte.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Un cluster ACK avec au moins un pool de nœuds

• kubectl configuré pour se connecter à votre cluster

Étape 1 : Définir des étiquettes sur un pool de nœuds

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

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

3. Dans la colonne Actions du pool de nœuds cible, cliquez sur Edit. Développez la section des options avancées et configurez Node Labels :

   Champ	Exigence	Détails
   Key (partie nom)	Obligatoire	1 à 63 caractères ; commence et se termine par [a-z0-9A-Z] ; autorise les lettres, chiffres, traits d'union (-), underscores (_) et points (.)
   Key (partie préfixe)	Facultatif	Un sous-domaine DNS pouvant comporter jusqu'à 253 caractères et se terminant par /. Le préfixe kubernetes.io/ est réservé — utilisez plutôt kubelet.kubernetes.io/ ou node.kubernetes.io/.
   Value	Facultatif	Jusqu'à 63 caractères ; commence et se termine par [a-z0-9A-Z] ; autorise les lettres, chiffres, traits d'union, underscores et points

4. Si nécessaire, sélectionnez Update Labels and Taints of Existing Nodes pour synchroniser les étiquettes sur les nœuds déjà présents dans le pool.

5. Dans le volet de navigation de gauche, choisissez Nodes > Nodes. Cliquez sur Manage Labels and Taints et vérifiez les étiquettes dans l'onglet Labels.

Étape 2 : Configurer une règle de planification

Une fois les étiquettes du pool de nœuds définies, configurez nodeSelector ou nodeAffinity dans la spécification du pod de votre déploiement.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment-basic
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        pod: nginx      # The node must have this label for the pod to be scheduled there.
      containers:
      - name: nginx
        image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        ports:
        - containerPort: 80
        # Declare resource requests and limits in production to guarantee Quality of Service (QoS).
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "200m"
            memory: "256Mi"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-with-affinity
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      affinity:
        nodeAffinity:
          # Hard affinity: the pod is not scheduled if no node matches.
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: pod         # The node label key
                operator: In
                values:
                - nginx          # The node label value
      containers:
      - name: nginx-with-affinity
        image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        ports:
        - containerPort: 80
        # Declare resource requests and limits in production to guarantee Quality of Service (QoS).
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "200m"
            memory: "256Mi"

Étape 3 : Déployer et vérifier

1. Appliquez le déploiement :

   kubectl apply -f deployment.yaml

2. Vérifiez l'état des pods et le résultat de la planification. L'indicateur -o wide affiche le nœud sur lequel chaque pod a été planifié :

   kubectl get pods -l app=nginx -o wide

   Vous pouvez vérifier dans la sortie si le pod est planifié sur le nœud de destination.

Étapes suivantes

• Pour définir des étiquettes sur des nœuds individuels afin d'affiner la planification, consultez Gérer les étiquettes de nœud.

• Si un pod reste en état Pending après avoir appliqué la règle de planification, consultez Résoudre les anomalies de pod.

• Pour les options de planification avancées, notamment le scale-out séquentiel et la planification consciente de la charge, consultez Politiques de planification fournies par ACK.

• Si l'affinité stricte ne trouve aucun nœud correspondant, ACK peut effectuer automatiquement un scale-out des nœuds à partir d'un pool de nœuds disposant des étiquettes correspondantes et ayant l'auto scaling activé.

• Pour les clusters créés avant l'introduction des pools de nœuds, consultez Migrer des nœuds non gérés vers un pool de nœuds.