Le produit décrit dans cette documentation, Anthos Clusters on AWS (génération précédente), est désormais en mode de maintenance. Toutes les nouvelles installations doivent utiliser le produit de génération actuelle, Anthos Clusters on AWS.

Procéder au scaling des clusters d'utilisateur

Pour procéder au scaling de vos charges de travail sur les clusters Anthos sur AWS, vous pouvez configurer vos pools AWSNodePool afin qu'ils procèdent au scaling automatique, ou créer et supprimer manuellement ces derniers pour effectuer un scaling à la hausse ou à la baisse.

Autoscaler de cluster

Clusters Anthos sur AWS met en œuvre l'autoscaler de cluster Kubernetes. Lorsque la demande sur vos nœuds est élevée, l'autoscaler de cluster ajoute des nœuds au pool de nœuds. Lorsque la demande est faible, l'autoscaler de cluster redimensionne les pools à la taille minimale que vous avez définie. Cela permet d'augmenter la disponibilité de vos charges de travail lorsque vous en avez besoin, tout en contrôlant les coûts.

Présentation

L'autoscaler de cluster redimensionne automatiquement le nombre de nœuds dans un pool de nœuds donné, en fonction des demandes des charges de travail. Vous n'avez pas besoin d'ajouter ou de supprimer manuellement des nœuds, ni de surprovisionner vos pools de nœuds. À la place, il suffit de spécifier une taille minimale et maximale pour le pool de nœuds, et le cluster évolue automatiquement.

Si des ressources sont supprimées ou déplacées lors de l'autoscaling de votre cluster, vos charges de travail peuvent être temporairement interrompues. Par exemple, si votre charge de travail comprend une seule instance dupliquée, le pod de cette instance dupliquée peut être reprogrammé sur un nœud différent si son nœud actuel est supprimé. Avant d'activer l'autoscaler de cluster dans la ressource AWSNodePool, concevez vos charges de travail de manière à tolérer des perturbations potentielles ou à garantir que les pods critiques ne sont pas interrompus.

Fonctionnement de l'autoscaler de cluster

L'autoscaler de cluster fonctionne par pool de nœuds. Lorsque vous créez un pool de nœuds, vous spécifiez une taille minimale et maximale pour le pool de nœuds dans la ressource Kubernetes AWSNodePool.

Vous pouvez désactiver l'autoscaler de cluster en définissant spec.minNodeCount pour qu'il soit égal à spec.maxNodeCount sur votre ressource AWSNodePools.

Cette fonctionnalité augmente ou diminue automatiquement la taille d'un pool de nœuds en fonction des demandes en ressources (plutôt que de l'utilisation réelle) des pods exécutés sur les nœuds de ce pool. Elle vérifie régulièrement l'état des pods et des nœuds, et prend les mesures suivantes :

Si les pods ne peuvent pas être programmés, car il n'y a pas assez de nœuds dans le pool de nœuds, l'autoscaler de cluster en ajoute jusqu'à atteindre la taille maximale du pool de nœuds. Si les nœuds sont sous-utilisés et que tous les pods peuvent être programmés, même avec moins de nœuds dans le pool, l'autoscaler de cluster supprime des nœuds jusqu'à atteindre la taille minimale du pool de nœuds. Si le nœud ne peut pas être drainé correctement après un délai d'inactivité (10 minutes), le nœud est arrêté de force. Le délai de grâce n'est pas configurable.

Si vos pods n'ont pas demandé suffisamment de ressources (par exemple, si les valeurs par défaut sont insuffisantes), l'autoscaler de cluster ne corrige pas la situation. Vous pouvez vous assurer que l'autoscaler de cluster fonctionne aussi précisément que possible en effectuant des demandes de ressources adéquates pour toutes vos charges de travail.

Critères d'exploitation

L'autoscaler de cluster repose sur les hypothèses suivantes lors du redimensionnement d'un pool de nœuds :

Tous les pods répliqués peuvent être démarrés sur un autre nœud, provoquant éventuellement une brève interruption. Si vos services ne tolèrent pas les perturbations, nous vous déconseillons d'utiliser l'autoscaler de cluster.
Tous les nœuds d'un pool de nœuds unique ont le même ensemble de libellés.
Si vous disposez d'une ressource AWSNodePools avec différents types d'instances, l'autoscaler de cluster prend en compte le coût relatif du lancement de nouveaux nœuds et tente d'étendre le pool de nœuds le moins coûteux.
Les libellés ajoutés manuellement après la création initiale du cluster ou du pool de nœuds ne font l'objet d'aucun suivi. Les nœuds créés par l'autoscaler de cluster se voient attribuer des libellés spécifiés avec --node-labels au moment de la création du pool de nœuds.

Redimensionner un pool de nœuds

Une ressource AWSNodePool inclut des champs minNodeCount et maxNodeCount. Ces champs déclarent un nombre minimal et maximal de nœuds de calcul dans le pool. Vous pouvez modifier ces valeurs avant ou après la création de la ressource AWSNodePool.

Avant de commencer

Provisionnez un cluster à l'aide des instructions de la section Créer un cluster d'utilisateur. Gardez à disposition le fichier YAML (par exemple, cluster-0.yaml) qui permet de créer le cluster.

Activer le scaling automatique du pool de nœuds

À partir de votre répertoire anthos-aws, utilisez anthos-gke pour basculer vers le contexte de votre service de gestion.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Remarque : anthos-gke utilise les identifiants que vous avez spécifiés lors de l'exécution de aws configure.
Pour activer l'autoscaler de cluster, vous devez modifier le fichier manifeste de votre ressource AWSNodePool. Modifiez le fichier cluster-0.yaml et recherchez la section AWSNodePool. Modifiez les valeurs définies pour spec.minNodeCount et spec.maxNodeCount.

L'exemple ci-dessous conserve une taille minimale de 3 nœuds pour ce pool de nœuds, mais permet à l'autoscaler de cluster d'augmenter sa taille à 10 nœuds.
```
apiVersion: multicloud.cluster.gke.io/v1
kind: AWSNodePool
metadata:
  name: cluster-0-pool-0
spec:
  clusterName: cluster-0
  version: 1.25.5-gke.2100
  minNodeCount: 3
  maxNodeCount: 10
  ...
```

Appliquez ensuite le fichier YAML pour redimensionner le pool de nœuds.

env HTTPS_PROXY=http://localhost:8118 \
    kubectl apply -f cluster-0.yaml

La ressource AWSNodePool passe à l'état Resizing. Lorsque la ressource AWSNodePool termine le scaling, elle passe à l'état Provisioned.
```
env HTTPS_PROXY=http://localhost:8118 \
    kubectl get AWSNodePools
```
La sortie indique que la ressource AWSNodePool est en cours de redimensionnement (Resizing). Les opérations de redimensionnement prennent plusieurs minutes.
```
NAME               CLUSTER     STATE     AGE   VERSION
cluster-0-pool-0   cluster-0   Resizing  3h    1.25.5-gke.2100
```

Créer manuellement une nouvelle ressource AWSNodePool

Vous pouvez également effectuer le scaling de votre cluster en créant de nouvelles ressources AWSNodePools. Lorsque vous créez une ressource AWSNodePool, vous pouvez également augmenter ou diminuer les tailles des instances.

Vous pouvez récupérer le fichier manifeste de configuration d'une ressource AWSNodePool existante avec kubectl get.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl get awsnodepool cluster-0-pool-0 -o yaml > new_nodepool.yaml
```

Modifiez new_nodepool.yaml et supprimez les sections qui ne sont pas présentes dans l'exemple suivant. Enregistrez le fichier.

apiVersion: multicloud.cluster.gke.io/v1
kind: AWSNodePool
metadata:
  name: NODE_POOL_NAME
spec:
  clusterName: AWSCLUSTER_NAME
  version:  CLUSTER_VERSION # latest version is 1.25.5-gke.2100
  region: AWS_REGION
  subnetID: AWS_SUBNET_ID
  minNodeCount: MINIMUM_NODE_COUNT
  maxNodeCount: MAXIMUM_NODE_COUNT
  maxPodsPerNode: MAXIMUM_PODS_PER_NODE_COUNT
  instanceType: AWS_NODE_TYPE
  keyName: KMS_KEY_PAIR_NAME
  iamInstanceProfile: NODE_IAM_PROFILE
  proxySecretName: PROXY_SECRET_NAME
  rootVolume:
    sizeGiB: ROOT_VOLUME_SIZE
    volumeType: VOLUME_TYPE # Optional
    iops: IOPS # Optional
    kmsKeyARN: NODE_VOLUME_KEY # Optional

Pour créer une nouvelle ressource AWSNodePool, appliquez le fichier manifeste à votre cluster de gestion.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f new_nodepool.yaml
```

Étapes suivantes

Déployez un service sauvegardé par Ingress.

Pour découvrir d'autres options, consultez la documentation de référence sur AWSNodePool.