Utiliser le provisionnement automatique des nœuds

Standard

Cette page explique comment utiliser le provisionnement automatique des nœuds dans les clusters Google Kubernetes Engine (GKE) standards. Avant de lire cette page, assurez-vous de bien connaître le provisionnement automatique des nœuds.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Conditions requises

Le provisionnement automatique des nœuds est disponible dans les versions de GKE suivantes :

Versions 1.27.6 et ultérieures, ou 1.28 et ultérieures, pour Cloud TPU v4 et v5e.
Version 1.28.7-gke.1020000 ou ultérieure et 1.29.2-gke.1035000 ou ultérieure pour Cloud TPU v5p.

Activer le provisionnement automatique des nœuds

Vous pouvez activer le provisionnement automatique des nœuds sur un cluster à l'aide de gcloud CLI ou de la console Google Cloud.

Le provisionnement automatique des nœuds présente les limites de ressources suivantes :

Vous devez planifier soigneusement la plage d'adresses IP des nœuds. Vous pouvez étendre la plage d'adresses IP des nœuds après avoir créé un cluster. Toutefois, nous vous recommandons de ne pas étendre la plage d'adresses IP des nœuds après avoir créé le cluster, car vous devez mettre à jour les règles de pare-feu pour inclure la nouvelle plage en tant que source. Vous pouvez étendre la plage d'adresses IP des pods à l'aide d'un CIDR multipods non contigu avec le provisionnement automatique des nœuds.

gcloud

Pour activer le provisionnement automatique des nœuds, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --min-cpu MINIMUM_CPU \
    --min-memory MIMIMUM_MEMORY \
    --max-cpu MAXIMUM_CPU \
    --max-memory MAXIMUM_MEMORY \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster sur lequel activer le provisionnement automatique des nœuds
MINIMUM_CPU : nombre minimal de cœurs dans le cluster
MINIMUM_MEMORY : quantité minimale de mémoire dans le cluster, en gigaoctets
MAXIMUM_CPU : nombre maximal de cœurs dans le cluster
MAXIMUM_MEMORY : quantité maximale de mémoire dans le cluster, en gigaoctets

L'exemple suivant active le provisionnement automatique des nœuds sur le cluster dev-cluster et permet le scaling d'une taille totale de cluster de 1 processeur et 1 gigaoctet de mémoire à une taille maximale de 10 processeurs et 64 gigaoctets de mémoire :

gcloud container clusters update dev-cluster \
    --enable-autoprovisioning \
    --min-cpu 1 \
    --min-memory 1 \
    --max-cpu 10 \
    --max-memory 64

Console

Pour activer le provisionnement automatique des nœuds, procédez comme suit :

Accédez à la page Google Kubernetes Engine dans la console Google Cloud.

Accéder à Google Kubernetes Engine
Cliquez sur le nom du cluster.
Dans la section Automatisation, cliquez sur Modifier pour accéder au Provisionnement automatique des nœuds.
Cochez la case Activer le provisionnement automatique des nœuds.
Définissez l'utilisation minimale et maximale du processeur et de la mémoire pour le cluster.
Cliquez sur Enregistrer les modifications.

Utiliser un fichier de configuration de provisionnement automatique

Le provisionnement automatique des nœuds peut être configuré à l'aide d'un fichier de configuration YAML. Ce fichier peut ne contenir qu'une seule ligne s'il n'y a qu'un seul paramètre à modifier. Plusieurs paramètres peuvent être spécifiés dans un même fichier de configuration. Dans ce cas, tous ces paramètres seront modifiés lors de l'application du fichier de configuration.

Certaines configurations avancées ne peuvent être spécifiées qu'à l'aide d'un fichier de configuration.

Exemple 1 : l'application du fichier de configuration suivant active la réparation et la mise à niveau automatiques des nœuds sur tous les nouveaux pools de nœuds créés par provisionnement automatique :

management:
  autoRepair: true
  autoUpgrade: true

Exemple 2 : l'application du fichier de configuration ci-dessous modifie les paramètres suivants :

resourceLimits : définit les limites de ressources pour le processeur, la mémoire et le GPU. Le provisionnement automatique ne crée pas de nœud si la taille totale du cluster dépasse les limites de ressources spécifiées.
Active la réparation et la mise à niveau automatiques des nœuds sur tous les nouveaux pools de nœuds créés par provisionnement automatique.
Active le démarrage sécurisé et la surveillance de l'intégrité pour tous les nouveaux pools de nœuds créés par provisionnement automatique.
Fixe la taille du disque de démarrage à 100 Go pour tous les nouveaux pools de nœuds créés par provisionnement automatique.

resourceLimits:
  - resourceType: 'cpu'
    minimum: 4
    maximum: 10
  - resourceType: 'memory'
    maximum: 64
  - resourceType: 'nvidia-tesla-t4'
    maximum: 4
management:
  autoRepair: true
  autoUpgrade: true
shieldedInstanceConfig:
  enableSecureBoot: true
  enableIntegrityMonitoring: true
diskSizeGb: 100

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Créez un fichier avec la configuration souhaitée dans un emplacement auquel gcloud CLI peut accéder.
Appliquez la configuration à votre cluster en exécutant la commande suivante :
```
gcloud container clusters update CLUSTER_NAME \
   --enable-autoprovisioning \
   --autoprovisioning-config-file FILE_NAME
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- FILE_NAME : nom du fichier de configuration
Pour en savoir plus, reportez-vous à la documentation gcloud container clusters update.

Paramètres par défaut du provisionnement automatique

Le provisionnement automatique des nœuds examine les exigences de pod dans votre cluster pour déterminer le type de nœud qui conviendrait le mieux à ces pods. Toutefois, certains paramètres de pool de nœuds ne sont pas spécifiés directement par les pods (par exemple, les paramètres liés à la mise à niveau des nœuds). Vous pouvez définir des valeurs par défaut pour ces paramètres. Ces valeurs seront appliquées à tous les pools de nœuds nouvellement créés.

Définir le type d'image de nœud par défaut

Vous pouvez spécifier le type d'image de nœud à utiliser pour tous les nouveaux pools de nœuds provisionnés automatiquement à l'aide de gCloud CLI ou d'un fichier de configuration. Ce paramètre n'est disponible que pour les clusters GKE version 1.20.6-gke.1800 et ultérieures.

gcloud

Pour définir le type d'image de nœud par défaut, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning \
  --autoprovisioning-image-type IMAGE_TYPE

Remplacez l'élément suivant :

CLUSTER_NAME : nom du cluster.
IMAGE_TYPE : le type d'image de nœud, qui peut être l'un des éléments suivants :
- cos_containerd : Container-optimized OS avec containerd
- ubuntu_containerd : Ubuntu avec containerd

Fichier

Pour tous les nouveaux pools de nœuds provisionnés automatiquement, vous pouvez spécifier le type d'image de nœud à utiliser à l'aide d'un fichier de configuration. La configuration YAML suivante indique que pour les nouveaux pools de nœuds provisionnés automatiquement, le type d'image est cos_containerd et est associé à des limites de ressources pour le processeur et la mémoire. Vous devez spécifier des valeurs maximales pour le processeur et la mémoire afin d'activer le provisionnement automatique.

Enregistrez la configuration YAML :

resourceLimits:
  - resourceType: 'cpu'
    minimum: 4
    maximum: 10
  - resourceType: 'memory'
    maximum: 64
imageType: 'cos_containerd'

Appliquez la configuration :

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning \
  --autoprovisioning-config-file FILE_NAME

Remplacez l'élément suivant :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Définir des paramètres d'identité par défaut pour les pools de nœuds provisionnés automatiquement

Les autorisations associées aux ressources Google Cloud sont fournies par les identités.

À l'aide de gCloud CLI ou d'un fichier de configuration, vous pouvez spécifier l'identité par défaut pour les nouveaux pools de nœuds provisionnés automatiquement : soit un compte de service, soit un ou plusieurs champs d'application.

gcloud

Pour spécifier le compte de service IAM par défaut que doit utiliser le provisionnement automatique des nœuds, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning --autoprovisioning-service-account=SERVICE_ACCOUNT

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
SERVICE_ACCOUNT : nom du compte de service par défaut.

L'exemple suivant définit test-service-account@google.com en tant que compte de service par défaut sur le cluster dev-cluster :

gcloud container clusters update dev-cluster \
    --enable-autoprovisioning --autoprovisioning-service-account=test-service-account@google.com

Pour spécifier les champs d'application par défaut qui seront utilisés par le provisionnement automatique des nœuds, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning --autoprovisioning-scopes=SCOPE

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
SCOPE : champs d'application Google Cloud que les pools de nœuds provisionnés automatiquement doivent utiliser. Pour spécifier plusieurs champs d'application, séparez-les par une virgule (par exemple, SCOPE1, SCOPE2,...).

L'exemple suivant définit le champ d'application par défaut du cluster dev-cluster sur devstorage.read_only :

gcloud container clusters update dev-cluster \
    --enable-autoprovisioning \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/pubsub,https://www.googleapis.com/auth/devstorage.read_only

Fichier

Vous pouvez spécifier l'identité par défaut que doit utiliser le provisionnement automatique des nœuds à l'aide d'un fichier de configuration. La configuration YAML suivante définit le compte de service IAM :

  serviceAccount: SERVICE_ACCOUNT

Remplacez SERVICE_ACCOUNT par le nom du compte de service par défaut.

Vous pouvez également utiliser la configuration YAML suivante pour spécifier les champs d'application par défaut que doit utiliser le provisionnement automatique des nœuds :

  scopes: SCOPE

Remplacez SCOPE par le champ d'application Google Cloud que doivent utiliser les pools de nœuds provisionnés automatiquement. Pour spécifier plusieurs champs d'application, séparez-les par une virgule (par exemple, SCOPE1, SCOPE2,...).

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Créez un fichier de configuration spécifiant les paramètres d'identité par défaut dans un emplacement auquel gcloud CLI peut accéder.

Appliquez la configuration à votre cluster en exécutant la commande suivante :

gcloud container clusters update CLUSTER_NAME \
   --enable-autoprovisioning \
   --autoprovisioning-config-file FILE_NAME

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Clés de chiffrement gérées par le client (CMEK)

Vous pouvez spécifier les clés de chiffrement gérées par le client (CMEK) que doivent utiliser les nouveaux pools de nœuds provisionnés automatiquement.

Vous pouvez activer le chiffrement géré par le client sur les disques de démarrage à l'aide d'un fichier de configuration. La configuration YAML suivante définit la clé CMEK :

  bootDiskKmsKey: projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME

Remplacez les éléments suivants :

KEY_PROJECT_ID : identifiant de votre projet de clé
LOCATION : emplacement de votre trousseau de clés
KEY_RING : nom de votre trousseau de clés
KEY_NAME : nom de votre clé

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Créez un fichier de configuration spécifiant une clé CMEK dans un emplacement auquel gcloud CLI peut accéder.
Appliquez la configuration à votre cluster en exécutant la commande suivante :
```
gcloud container clusters update CLUSTER_NAME \
   --enable-autoprovisioning \
   --autoprovisioning-config-file FILE_NAME
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- FILE_NAME : nom du fichier de configuration

Intégrité des nœuds

Le provisionnement automatique des nœuds permet de créer des pools de nœuds avec les fonctionnalités de démarrage sécurisé et de surveillance de l'intégrité activées.

Vous pouvez activer le démarrage sécurisé et la surveillance de l'intégrité à l'aide d'un fichier de configuration. La configuration YAML suivante active le démarrage sécurisé et désactive la surveillance de l'intégrité :

  shieldedInstanceConfig:
    enableSecureBoot: true
    enableIntegrityMonitoring: false

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Copiez la configuration ci-dessus dans un fichier situé dans un emplacement auquel gcloud CLI peut accéder. Modifiez les valeurs définies pour enableSecureBoot et enableIntegrityMonitoring. Enregistrez le fichier.
Appliquez la configuration à votre cluster en exécutant la commande suivante :
```
gcloud container clusters update CLUSTER_NAME \
   --enable-autoprovisioning \
   --autoprovisioning-config-file FILE_NAME
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- FILE_NAME : nom du fichier de configuration

Réparation et mise à niveau automatiques des nœuds

Le provisionnement automatique des nœuds permet de créer des pools de nœuds avec les fonctionnalités de réparation et de mise à niveau automatiques des nœuds activées.

gcloud

Pour activer la réparation et la mise à niveau automatiques sur tous les nouveaux pools de nœuds provisionnés automatiquement, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning --enable-autoprovisioning-autorepair \
    --enable-autoprovisioning-autoupgrade

Remplacez CLUSTER_NAME par le nom du cluster.

Pour désactiver la réparation et la mise à niveau automatiques sur tous les nouveaux pools de nœuds provisionnés automatiquement, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning --no-enable-autoprovisioning-autorepair \
    --no-enable-autoprovisioning-autoupgrade

Remplacez CLUSTER_NAME par le nom du cluster.

Fichier

Vous pouvez activer ou désactiver la réparation et la mise à niveau automatiques des nœuds à l'aide d'un fichier de configuration. La configuration YAML suivante permet d'activer la réparation automatique et de désactiver la mise à niveau automatique :

  management:
    autoRepair: true
    autoUpgrade: false

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Copiez la configuration ci-dessus dans un fichier situé dans un emplacement auquel gcloud CLI peut accéder. Modifiez les valeurs définies pour autoUpgrade et autoRepair. Enregistrez le fichier.
Appliquez la configuration à votre cluster en exécutant la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file FILE_NAME

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Utiliser les mises à niveau de la surutilisation pour les nouveaux pools de nœuds provisionnés automatiquement

Vous pouvez spécifier des paramètres de mise à niveau de la surutilisation sur tous les nouveaux pools de nœuds provisionnés automatiquement à l'aide de gCloud CLI ou d'un fichier de configuration. Par défaut, GKE définit la stratégie de mise à niveau des nœuds sur les mises à niveau de la surutilisation.

gcloud

Pour spécifier les paramètres de mise à niveau de la surutilisation pour tous les nouveaux pools de nœuds provisionnés automatiquement, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-max-surge-upgrade MAX_SURGE \
    --autoprovisioning-max-unavailable-upgrade MAX_UNAVAILABLE

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
MAX_SURGE : nombre maximal de nœuds pouvant être ajoutés au pool de nœuds lors des mises à niveau.
MAX_UNAVAILABLE : nombre maximal de nœuds dans le pool de nœuds pouvant être simultanément indisponibles pendant les mises à niveau.

Fichier

Vous pouvez spécifier les paramètres de mise à niveau de la surutilisation pour tous les nouveaux pools de nœuds provisionnés automatiquement à l'aide d'un fichier de configuration semblable à celui-ci :

  upgradeSettings:
    maxSurgeUpgrade: 1
    maxUnavailableUpgrade: 2

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Copiez la configuration ci-dessus dans un fichier situé dans un emplacement auquel gcloud peut accéder. Modifiez les valeurs définies pour maxSurgeUpgrade et maxUnavailableUpgrade. Enregistrez le fichier.
Appliquez la configuration à votre cluster en exécutant la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file FILE_NAME

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Pour en savoir plus, reportez-vous à la documentation gcloud container clusters update.

Pour revenir à l'utilisation des mises à niveau de la surutilisation pour les nouveaux pools de nœuds provisionnés automatiquement, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning \
  --enable-autoprovisioning-surge-upgrade

Remplacez CLUSTER_NAME par le nom du cluster.

Vous pouvez éventuellement inclure les options de paramètres spécifiques dans les commandes précédentes. GKE réutilise votre configuration précédente pour la stratégie de mise à niveau, si celle-ci a été définie.

Utiliser les mises à niveau bleu-vert pour les nouveaux pools de nœuds provisionnés automatiquement

Vous pouvez utiliser des mises à niveau bleu-vert pour tous les nouveaux pools de nœuds provisionnés automatiquement à l'aide de gcloud CLI. Avec les mises à niveau bleu-vert, vous pouvez utiliser les paramètres par défaut ou les ajuster pour optimiser votre environnement. Pour en savoir plus sur les mises à niveau bleu-vert, consultez la page Mises à niveau bleu-vert.

Pour mettre à jour la stratégie de mise à niveau des nœuds pour tout pool de nœuds existant provisionné automatiquement, consultez la section Activer ou désactiver la mise à niveau de la surutilisation pour un pool de nœuds existant et Mettre à jour une stratégie de mise à niveau bleu-vert d'un pool de nœuds existant.

Les variables suivantes sont utilisées dans les commandes mentionnées ci-dessous :

CLUSTER_NAME : nom du cluster pour le pool de nœuds.
COMPUTE_ZONE : zone du cluster.
NODE_POOL_NAME : nom du pool de nœuds.
NUMBER_NODES : nombre de nœuds du pool de nœuds dans chacune des zones du cluster.
BATCH_NODE_COUNT : nombre de nœuds bleus à drainer dans un lot pendant la phase de drainage du pool bleu. La valeur par défaut est de 1. Si cette valeur est définie sur zéro, la phase de drainage du pool bleu est ignorée.
BATCH_PERCENT : pourcentage de nœuds bleus à drainer dans un lot pendant la phase de drainage du pool bleu. La valeur doit être comprise entre 0,0 et 1,0.
BATCH_SOAK_DURATION : délai d'attente en secondes après chaque drainage par lot. La valeur par défaut est de zéro.
NODE_POOL_SOAK_DURATION : délai d'attente en secondes après le drainage de tous les lots. La valeur par défaut est de 3 600 secondes.

Les paramètres par défaut des mises à niveau bleu-vert sont les suivants :

BATCH_NODE_COUNT = 1
BATCH_SOAK_DURATION = 0 secondes
NODE_POOL_SOAK_DURATION = 3 600 secondes (1 heure)

Mettre à jour un cluster afin d'utiliser des mises à niveau bleu-vert pour les nouveaux pools de nœuds provisionnés automatiquement

Les commandes suivantes utilisent gcloud container clusters update pour mettre à jour la stratégie de mise à niveau des nœuds pour les nouveaux pools de nœuds provisionnés automatiquement.

Vous pouvez également choisir ces options dans les cas suivants :

utiliser la commande gcloud container clusters create pour créer un cluster avec le provisionnement automatique des nœuds activé ;
utiliser la commande gcoud container clusters update pour activer le provisionnement automatique des nœuds.

Pour mettre à jour un cluster de sorte qu'il utilise des mises à niveau bleu-vert avec les paramètres par défaut pour les nouveaux pools de nœuds provisionnés automatiquement, utilisez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning \
  --enable-autoprovisioning-blue-green-upgrade

Vous pouvez mettre à jour un cluster de sorte à utiliser des mises à niveau bleu-vert avec des paramètres spécifiques pour les nouveaux pools de nœuds provisionnés automatiquement. Ces commandes peuvent également être utilisées sans l'option --enable-autoprovisioning-blue-green-upgrade pour mettre à jour les paramètres.

La commande suivante utilise BATCH_NODE_COUNT pour définir la taille absolue du lot de nœuds :

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning \
  --enable-autoprovisioning-blue-green-upgrade \
  --autoprovisioning-node-pool-soak-duration=NODE_POOL_SOAK_DURATION \
  --autoprovisioning-standard-rollout-policy=batch-node-count=BATCH_NODE_COUNT,batch-soak-duration=BATCH_SOAK_DURATION

Vous pouvez également utiliser BATCH_PERCENT pour définir une taille de lot basée sur un pourcentage, en remplaçant batch-node-count dans la dernière commande par batch-percent et en utilisant un nombre décimal compris entre 0 et 1 (par exemple, 25 % équivaut à 0.25). Pour savoir comment les tailles de lot basées sur des pourcentages sont définies, consultez la section Mettre à jour un pool de nœuds avec mise à niveau bleu/vert à l'aide de tailles de lot basées sur des pourcentages.

Disques de démarrage personnalisés

Le provisionnement automatique des nœuds permet de créer des pools de nœuds avec des disques de démarrage personnalisés.

Vous pouvez personnaliser les paramètres du disque de démarrage à l'aide d'un fichier de configuration. GKE réserve une partie du disque de démarrage des nœuds aux fonctions kubelet. Pour plus d'informations, consultez la section Stockage éphémère sauvegardé par le disque de démarrage des nœuds.

La configuration YAML suivante oblige le provisionnement automatique des nœuds à créer des pools de nœuds avec des disques SSD de 100 Go :

  diskSizeGb: 100
  diskType: pd-ssd

Renseignez les champs suivants :

diskSizeGb : taille du disque, spécifiée en Go
diskType : type de disque, qui peut prendre l'une des valeurs suivantes :
- pd-balanced (par défaut)
- pd-standard
- pd-ssd. Dans GKE version 1.22 et versions antérieures, si vous spécifiez pd-ssd, le provisionnement automatique des nœuds ne prend en compte que les types de machines N1 lors de la création de pools de nœuds.

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Créez un fichier avec la configuration de disque de démarrage souhaitée dans un emplacement auquel gcloud CLI peut accéder.
Appliquez la configuration à votre cluster en exécutant la commande suivante :
```
gcloud container clusters update CLUSTER_NAME \
   --enable-autoprovisioning \
   --autoprovisioning-config-file FILE_NAME
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- FILE_NAME : nom du fichier de configuration

Séparer les pods gérés par GKE de vos charges de travail

En tant qu'administrateur de cluster, vous pouvez souhaiter séparer les pods de vos charges de travail gérés par GKE. Cette séparation permet d'éviter les problèmes de scaling à la baisse en cas de nœuds sous-utilisés dans le cluster sur lesquels des pods système sont en cours d'exécution.

L'exemple suivant montre comment séparer les pods gérés de vos charges de travail à l'aide d'une combinaison de provisionnement automatique de nœuds et de tolérances/rejets Kubernetes.

Créez un cluster avec un pool de nœuds par défaut de e2-standard-2 VM et appliquez un rejet de nœud qui ne permet aux charges de travail du système GKE de s'exécuter que sur ces nœuds:
```
gcloud container clusters create test-cluster \
    --machine-type=e2-standard-2 \
    --node-taints=components.gke.io/gke-managed-components=true:NoSchedule
```
Activez le provisionnement automatique des nœuds pour votre cluster :
```
gcloud container clusters update test-cluster \
    --enable-autoprovisioning \
    --min-cpu 1 \
    --min-memory 1 \
    --max-cpu 10 \
    --max-memory 64
```
Votre cluster peut évoluer entre une taille totale de cluster de 1 processeur et 1 gigaoctet de mémoire à une taille maximale de 10 processeurs et 64 gigaoctets de mémoire.
Testez cette configuration en enregistrant l'exemple de fichier manifeste suivant sous le nom nginx.yaml :
```
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    env: test
spec:
  containers:
  - name: nginx
    image: nginx
    imagePullPolicy: IfNotPresent
  tolerations:
  - key: dedicated
    operator: Equal
    value: ui-team
    effect: NoSchedule
  nodeSelector:
    dedicated: ui-team
```
Ce fichier manifeste déploie un pod de charge de travail de test dans le cluster avec le libellé nodeSelector et le rejet de nœud dedicated: ui-team. Sans provisionnement automatique de nœuds, ce pod de charge de travail ne peut pas être planifié, car aucun pool de nœuds ne dispose des libellés et rejets correspondants.
Appliquez le fichier manifeste au cluster :
```
kubectl apply -f nginx.yaml
```
Le résultat ressemble à ce qui suit :
```
pod/nginx created
```

Affichez le nouveau pool de nœuds correspondant au libellé ui-team :

kubectl get node --selector=dedicated=ui-team

Le résultat ressemble à ce qui suit :

NAME                                            STATUS   ROLES    AGE   VERSION
gke-test-nap-e2-medium-14b723z1-19f89fa8-jmhr   Ready    <none>   14s   v1.21.11-gke.900

Votre cluster sépare vos charges de travail des pods GKE gérés.

Limiter la durée d'exécution des nœuds provisionnés automatiquement

Dans GKE version 1.31.1-gke.1146000 et ultérieure, vous pouvez limiter la durée d'exécution des nœuds provisionnés automatiquement à l'aide du sélecteur de nœuds cloud.google.com/gke-max-run-duration-seconds. Ajoutez le champ suivant à votre fichier manifeste:

spec:
  nodeSelector:
    cloud.google.com/gke-max-run-duration-seconds: "MAX_RUN_DURATION"

Remplacez MAX_RUN_DURATION par la durée, en secondes, pendant laquelle vous souhaitez que le nœud autoprovisionné s'exécute avant d'être automatiquement arrêté. Pour en savoir plus sur les restrictions, consultez la section Restrictions MaxRunDuration.

Utiliser des accélérateurs pour les nouveaux pools de nœuds provisionnés automatiquement

Vous pouvez activer le provisionnement automatique des nœuds et configurer GKE pour provisionner automatiquement les accélérateurs GPU ou Cloud TPU afin de garantir la capacité requise pour planifier les charges de travail d'IA/de ML.

Configurer les limites de GPU

Lorsque vous utilisez le provisionnement automatique des nœuds avec des GPU, vous pouvez définir la limite maximale pour chaque type de GPU dans le cluster à l'aide de gCloud CLI ou de Google Cloud Console. La limite de GPU est le nombre maximal de GPU. Par exemple, dans le cadre de cette limite, une VM dotée de 16 GPU compte pour 16 instances au lieu de 1. Pour configurer plusieurs types de GPU, vous devez utiliser un fichier de configuration.

Pour répertorier les types de ressources disponibles, exécutez la commande gcloud compute accelerator-types list.

gcloud

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --max-cpu MAXIMUM_CPU \
    --max-memory MAXIMUM_MEMORY \
    --min-accelerator type=GPU_TYPE,count=MINIMUM_ACCELERATOR \
    --max-accelerator type=GPU_TYPE,count=MAXIMUM_ACCELERATOR

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
MAXIMUM_CPU : nombre maximal de cœurs dans le cluster
MAXIMUM_MEMORY : quantité maximale de mémoire dans le cluster, en gigaoctets
GPU_TYPE : type de GPU.
MINIMUM_ACCELERATOR : nombre minimal d'accélérateurs GPU dans le cluster.
MAXIMUM_ACCELERATOR : nombre maximal d'accélérateurs GPU dans le cluster.

L'exemple suivant définit les limites de GPU pour le type d'accélérateur GPU nvidia-tesla-t4 dans le cluster dev-cluster :

gcloud container clusters update dev-cluster \
    --enable-autoprovisioning \
    --max-cpu 10 \
    --max-memory 64 \
    --min-accelerator type=nvidia-tesla-t4,count=1 \
    --max-accelerator type=nvidia-tesla-t4,count=4

Fichier

Vous pouvez charger des limites pour plusieurs types de GPU à l'aide d'un fichier de configuration. La configuration YAML suivante permet de configurer deux types de GPU différents :

  resourceLimits:
    - resourceType: 'cpu'
      minimum: 4
      maximum: 10
    - resourceType: 'memory'
      maximum: 64
    - resourceType: 'nvidia-tesla-t4'
      maximum: 4
    - resourceType: 'nvidia-tesla-v100'
      maximum: 2

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Copiez la configuration ci-dessus dans un fichier situé dans un emplacement auquel gcloud CLI peut accéder. Modifiez les valeurs définies pour cpu et memory. Ajoutez autant de valeurs que vous le souhaitez pour resourceType. Enregistrez le fichier.
Appliquez la configuration à votre cluster en exécutant la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file FILE_NAME

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Pour en savoir plus, reportez-vous à la documentation gcloud container clusters update.

Console

Pour activer le provisionnement automatique des nœuds à l'aide de ressources GPU, procédez comme suit :

Accédez à la page Google Kubernetes Engine dans la console Google Cloud.

Accéder à Google Kubernetes Engine
Cliquez sur le nom du cluster.
Dans la section Automatisation, cliquez sur Modifier pour accéder au Provisionnement automatique des nœuds.
Cochez la case Activer le provisionnement automatique des nœuds.
Définissez l'utilisation minimale et maximale du processeur et de la mémoire pour le cluster.
Cliquez sur Ajouter une ressource.
Sélectionnez le type de GPU que vous souhaitez ajouter, par exemple NVIDIA T4. Définissez le nombre minimal et maximal de GPU à ajouter au cluster.
Acceptez les limitations des GPU dans GKE.
Cliquez sur Enregistrer les modifications.

Choisir une version du pilote à installer

Dans GKE version 1.29.2-gke.1108000 et ultérieure, vous pouvez sélectionner une version du pilote de GPU que GKE doit installer automatiquement dans les nœuds GPU provisionnés automatiquement. Ajoutez le champ suivant à votre fichier manifeste:

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

Remplacez DRIVER_VERSION par l'une des valeurs suivantes :

default : pilote stable par défaut pour la version de GKE de votre nœud. Si vous omettez le nodeSelector dans votre fichier manifeste, il s'agit de l'option par défaut.
latest : dernière version de pilote disponible pour la version de GKE de votre nœud.

Configurer des Cloud TPU

Pour en savoir plus sur le fonctionnement du provisionnement automatique des nœuds avec les TPU, consultez la page Accélérateurs de machine learning compatibles.

Créez un cluster et configurez vos pods pour qu'ils utilisent des ressources TPU à l'aide de gcloud CLI. Pour configurer plusieurs types de TPU, vous devez utiliser un fichier de configuration.

gcloud

Créez un cluster et définissez les limites de TPU :
```
gcloud container clusters create CLUSTER_NAME \
    --enable-autoprovisioning \
    [--min-cpu  MINIMUM_CPU ] \
    --max-cpu MAXIMUM_CPU \
    [--min-memory MINIMUM_MEMORY ] \
    --max-memory MAXIMUM_MEMORY \
    [--min-accelerator=type=TPU_TYPE,count= MINIMUM_ACCELERATOR ] \
    --max-accelerator=type=TPU_TYPE,count= MAXIMUM_ACCELERATOR
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- MINIMUM_CPU : nombre minimal de processeurs virtuels dans le cluster.
- MAXIMUM_CPU : nombre maximal de processeurs virtuels dans le cluster.
- MINIMUM_MEMORY : quantité minimale de mémoire dans le cluster, en gigaoctets.
- MAXIMUM_MEMORY : quantité maximale de mémoire dans le cluster, en gigaoctets.
- TPU_TYPE : type de TPU que vous choisissez. Utilisez tpu-v4-podslice pour sélectionner un TPU v4. Pour sélectionner un TPU v5e avec un type de machine commençant par ct5lp-, utilisez tpu-v5-lite-podslice. Pour sélectionner un TPU v5e avec un type de machine commençant par ct5l-, utilisez tpu-v5-lite-device.
- MINIMUM_ACCELERATOR : nombre minimal de puces TPU dans le cluster.
  - Notez que l'utilisation de MINIMUM_ACCELERATOR peut bloquer le scaling à la baisse des tranches de TPU multi-hôte, même si count est inférieur au nombre de puces TPU dans la tranche.
- MAXIMUM_ACCELERATOR : nombre maximal de puces TPU dans le cluster.
  - Si la configuration du pod demande une tranche de TPU multi-hôte, GKE crée cette tranche de manière atomique. Définissez une valeur "count" suffisamment élevée pour permettre le provisionnement de tous les puces TPU de la topologie spécifiée. Le nombre de puces dans chaque tranche de TPU est égal au produit de la topologie. Par exemple, si la topologie de la tranche de TPU multi-hôte est 2x2x2, le nombre de puces TPU est égal à 8. La valeur de MAXIMUM_ACCELERATOR doit donc être supérieure à 8.
L'exemple suivant définit les limites de TPU pour les types de machines ct5lp-hightpu-1t, ct5lp-hightpu-4t et ct5lp-hightpu-8t dans le cluster dev-cluster. Par exemple, jusqu'à dix machines ct5lp-hightpu-4t peuvent être provisionnées, chacune avec 4 puces TPU, 112 processeurs virtuels et 192 Gio de mémoire.
```
gcloud container clusters create dev-cluster-inference \
      --enable-autoprovisioning \
      --min-cpu 0 \
      --max-cpu 1120 \
      --min-memory 0 \
      --max-memory 1920 \
      --min-accelerator=type=tpu-v5-lite-podslice,count=0 \
      --max-accelerator=type=tpu-v5-lite-podslice,count=40
```

Créez une spécification de déploiement de sorte qu'un pod demande des ressources TPU. Par exemple, le fichier manifeste suivant amènera GKE à provisionner quatre nœuds ct5lp-hightpu-4t :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 4
  selector:
    matchLabels:
      app: nginx-tpu
  template:
    metadata:
      labels:
        app: nginx-tpu
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        cloud.google.com/gke-tpu-topology:  2x2
        cloud.google.com/reservation-name: my-reservation
      containers:
      - name: nginx
        image: nginx:1.14.2
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4
        ports:
        - containerPort: 80

Dans le champ nodeSelector, vous définissez le type de TPU, la topologie TPU et le nombre d'accélérateurs, où :

cloud.google.com/gke-tpu-accelerator : définit le type de TPU. Exemple : tpu-v4-podslice.
cloud.google.com/gke-tpu-topology : définit la topologie TPU, par exemple 2x2x1 ou 4x4x8.

Pour consommer une réservation existante avec votre charge de travail, spécifiez un libellé supplémentaire dans le champ nodeSelector : * cloud.google.com/reservation-name: définit le nom de la réservation que GKE utilise pour provisionner automatiquement les nœuds.

Sous limits: google.com/tpu, vous définissez le nombre de puces TPU par nœud.

Fichier

Vous pouvez fixer des limites pour plusieurs types de TPU à l'aide d'un fichier de configuration. La configuration YAML suivante permet de configurer deux types de TPU différents :

  resourceLimits:
    - resourceType: 'cpu'
      maximum: 10000
    - resourceType: 'memory'
      maximum: 10000
    - resourceType: 'tpu-v4-podslice'
      maximum: 32
    - resourceType: 'tpu-v5-lite'
      maximum: 64

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Copiez la configuration ci-dessus dans un fichier situé dans un emplacement auquel gcloud CLI peut accéder. Modifiez les valeurs définies pour resourceType et maximum. Ajoutez autant de valeurs que vous le souhaitez pour resourceType. Enregistrez le fichier.
Appliquez la configuration à votre cluster en exécutant la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file FILE_NAME

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
FILE_NAME : nom du fichier de configuration

Pour en savoir plus, reportez-vous à la documentation gcloud container clusters update.

Zones de provisionnement automatique des nœuds

Vous pouvez définir les zones dans lesquelles le provisionnement automatique des nœuds peut créer des pools de nœuds. Les zones régionales ne sont pas acceptées. Les zones doivent appartenir à la même région que le cluster, mais ne sont pas limitées aux emplacements de nœuds définis au niveau du cluster. La modification des zones de provisionnement automatique des nœuds n'a pas d'incidence sur les pools de nœuds existants.

Pour définir des zones dans lesquelles le provisionnement automatique des nœuds peut créer des pools de nœuds, utilisez gcloud CLI ou un fichier de configuration.

gcloud

Exécutez la commande ci-dessous.

gcloud container clusters update CLUSTER_NAME \
  --enable-autoprovisioning --autoprovisioning-locations=ZONE

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
ZONE : zone dans laquelle le provisionnement automatique des nœuds peut créer des pools de nœuds. Pour spécifier plusieurs zones, séparez-les par une virgule (par exemple, ZONE1, ZONE2,...).

Fichier

Pour définir les zones dans lesquelles le provisionnement automatique des nœuds peut créer des pools de nœuds, vous pouvez utiliser un fichier de configuration.

Ajoutez la configuration YAML suivante pour définir l'emplacement des nouveaux pools de nœuds :

    autoprovisioningLocations:
      - ZONE

Remplacez ZONE par la zone dans laquelle le provisionnement automatique des nœuds peut créer des pools de nœuds. Pour spécifier plusieurs zones, ajoutez d'autres zones à la liste. Enregistrez le fichier.

Pour utiliser un fichier de configuration de provisionnement automatique, procédez comme suit :

Créez un fichier de configuration dans un emplacement auquel gcloud CLI peut accéder.
Appliquez la configuration à votre cluster comme suit :
```
gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file FILE_NAME
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- FILE_NAME : chemin d'accès au fichier de configuration.

Nœuds physiquement plus proches avec emplacement compact

À partir de la version 1.25 de GKE, le provisionnement automatique des nœuds est compatible avec la stratégie d'emplacement compact. Avec la stratégie d'emplacement compact, vous pouvez demander à GKE de créer des pools de nœuds plus proches les uns des autres dans une zone.

Pour définir une stratégie d'emplacement compact, ajoutez un nodeSelector à la spécification de pod à l'aide des clés suivantes :

cloud.google.com/gke-placement-group est l'identifiant que vous attribuez au groupe de pods devant s'exécuter ensemble dans le même groupe d'emplacements compacts.
cloud.google.com/machine-family est le nom de la famille de machines. Pour en savoir plus, découvrez les familles de machines compatibles avec l'emplacement compact.

L'exemple suivant définit une stratégie d'emplacement compact avec un identifiant de groupe d'emplacements placement-group-1 et une famille de machines c2 :

apiVersion: v1
kind: Pod
metadata:
  ...
spec:
  ...
  nodeSelector:
    cloud.google.com/gke-placement-group: placement-group-1
    cloud.google.com/machine-family: c2

Pour en savoir plus, découvrez comment définir un emplacement compact pour les nœuds GKE.

Désactivation du provisionnement automatique des nœuds

Lorsque vous désactivez le provisionnement automatique des nœuds pour un cluster, les pools de nœuds ne sont plus provisionnés automatiquement.

gcloud

Pour désactiver le provisionnement automatique des nœuds sur un cluster, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
  --no-enable-autoprovisioning

Remplacez CLUSTER_NAME par le nom de votre cluster.

Fichier

Pour désactiver le provisionnement automatique des nœuds à l'aide de Google Cloud Console, procédez comme suit :

Accédez à la page Google Kubernetes Engine dans la console Google Cloud.

Accéder à Google Kubernetes Engine
Cliquez sur le nom du cluster.
Dans la section Automatisation, cliquez sur Modifier pour accéder au provisionnement automatique des nœuds.
Décochez la case Activer le provisionnement automatique des nœuds.
Cliquez sur Enregistrer les modifications.

Marquage du pool de nœuds comme étant provisionné automatiquement

Après avoir activé le provisionnement automatique des nœuds sur le cluster, vous pouvez spécifier les pools de nœuds qui sont provisionnés automatiquement. Un pool de nœuds provisionné automatiquement est supprimé automatiquement lorsqu'aucune charge de travail ne l'utilise.

Pour marquer un pool de nœuds comme étant provisionné automatiquement, exécutez la commande suivante :

gcloud container node-pools update NODE_POOL_NAME \
  --enable-autoprovisioning

Remplacez NODE_POOL_NAME par le nom du pool de nœuds.

Marquage du pool de nœuds comme n'étant pas provisionné automatiquement

Pour marquer un pool de nœuds comme n'étant pas provisionné automatiquement, exécutez la commande suivante :

gcloud container node-pools update NODE_POOL_NAME \
  --no-enable-autoprovisioning

Remplacez NODE_POOL_NAME par le nom du pool de nœuds.

Utiliser une famille de machines personnalisées

Vous pouvez choisir une série de machines Compute Engine spécifique, telle que n2 ou t2d, pour vos charges de travail en définissant l'un des champs suivants dans votre fichier manifeste:

Définir l'affinité de nœuds avec la clé cloud.google.com/machine-family, l'opérateur In et la valeur correspondant à la famille de machines souhaitée (par exemple, n2).
Ajouter une valeur nodeSelector avec la clé cloud.google.com/machine-family et la valeur correspondant à la famille de machines souhaitée.

Voici un exemple qui définit nodeAffinity sur une famille de machines n2 :

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: cloud.google.com/machine-family
            operator: In
            values:
            - n2

Après avoir appliqué les modifications, le provisionnement automatique des nœuds choisit le meilleur pool de nœuds avec un type de machine dans la série de machines spécifiée. Si vous spécifiez plusieurs entrées pour matchExpressions, GKE choisit arbitrairement une série de machines parmi les entrées spécifiées.

Contrôler les attributs de nœud à l'aide d'une classe de calcul personnalisée

Pour un contrôle plus précis des attributs de vos pools de nœuds provisionnés automatiquement, créez et utilisez des classes de calcul personnalisées. Les classes de calcul personnalisées vous permettent de configurer des comportements de scaling tels que les priorités de remplacement lors du choix des types de machines pour les nœuds ou des seuils d'utilisation de ressources spécifiques qui déclenchent la consolidation des charges de travail sur les nœuds afin de libérer les ressources inutilisées. Les classes de calcul personnalisées sont disponibles dans GKE version 1.30.3-gke.1451000 et ultérieures.

Pour en savoir plus sur les fonctionnalités des classes de calcul personnalisées et sur leur utilisation avec le provisionnement automatique des nœuds, consultez la section À propos des classes de calcul personnalisées.

Configuration minimale de la plate-forme du CPU

Le provisionnement automatique des nœuds permet de créer des pools de nœuds en spécifiant une configuration minimale de la plate-forme du processeur. Vous pouvez spécifier la configuration minimale de la plate-forme du processeur au niveau de la charge de travail (recommandé) ou au niveau du cluster.

Utiliser le provisionnement automatique des nœuds

Avant de commencer

Conditions requises

Activer le provisionnement automatique des nœuds

gcloud

Console

Utiliser un fichier de configuration de provisionnement automatique

Paramètres par défaut du provisionnement automatique

Définir le type d'image de nœud par défaut

gcloud

Fichier

Définir des paramètres d'identité par défaut pour les pools de nœuds provisionnés automatiquement

gcloud

Fichier

Clés de chiffrement gérées par le client (CMEK)

Intégrité des nœuds

Réparation et mise à niveau automatiques des nœuds

gcloud

Fichier

Utiliser les mises à niveau de la surutilisation pour les nouveaux pools de nœuds provisionnés automatiquement

gcloud

Fichier

Utiliser les mises à niveau bleu-vert pour les nouveaux pools de nœuds provisionnés automatiquement

Mettre à jour un cluster afin d'utiliser des mises à niveau bleu-vert pour les nouveaux pools de nœuds provisionnés automatiquement

Disques de démarrage personnalisés

Séparer les pods gérés par GKE de vos charges de travail

Limiter la durée d'exécution des nœuds provisionnés automatiquement

Utiliser des accélérateurs pour les nouveaux pools de nœuds provisionnés automatiquement

Configurer les limites de GPU

gcloud

Fichier

Console

Choisir une version du pilote à installer

Configurer des Cloud TPU

gcloud

Fichier

Zones de provisionnement automatique des nœuds

gcloud

Fichier

Nœuds physiquement plus proches avec emplacement compact

Désactivation du provisionnement automatique des nœuds

gcloud

Fichier

Marquage du pool de nœuds comme étant provisionné automatiquement

Marquage du pool de nœuds comme n'étant pas provisionné automatiquement

Utiliser une famille de machines personnalisées

Contrôler les attributs de nœud à l'aide d'une classe de calcul personnalisée

Configuration minimale de la plate-forme du CPU

Étapes suivantes