Cette page a été traduite par l'API Cloud Translation.

Configurer la création automatique de pools de nœuds

Standard

Vous pouvez réduire la quantité de gestion manuelle de l'infrastructure dans les clusters Google Kubernetes Engine (GKE) Standard en laissant GKE créer automatiquement des pools de nœuds pour les pods en attente. Ce document explique comment activer la création automatique de pools de nœuds pour les clusters et les charges de travail, définir des valeurs par défaut pour les nœuds créés automatiquement et déclencher la création automatique pour certains cas d'utilisation courants.

Ce document s'adresse aux administrateurs, opérateurs et développeurs de clusters qui gèrent l'infrastructure et déploient des charges de travail dans des clusters Standard. Pour en savoir plus sur le fonctionnement de la création automatique de pools de nœuds et sur les différentes méthodes d'activation (telles que les ComputeClasses et le provisionnement automatique de nœuds au niveau du cluster), consultez À propos de la création automatique de pools de nœuds.

Limites

La création automatique de pools de nœuds présente les limites suivantes :

Toutes les limites de l'autoscaler de cluster s'appliquent également à la création automatique de pools de nœuds.
Les clusters qui comportent plus de 200 pools de nœuds au total peuvent présenter une latence accrue lors de l'autoscaling. Toute configuration qui déclenche la création d'un pool de nœuds, comme la séparation des charges de travail ou l'utilisation de plusieurs ComputeClasses, augmente ce nombre. Pour en savoir plus sur les limites des clusters, consultez Limites et bonnes pratiques dans "Planifier des clusters de grande taille".
Toutes les limites de ressources que vous définissez pour le cluster lorsque vous activez le provisionnement automatique des nœuds s'appliquent également aux pools de nœuds que GKE crée pour les ComputeClasses.
Les paramètres suivants ne sont pas compatibles avec ComputeClasses :
- Mises à niveau de la surutilisation ou mises à niveau bleu-vert.
- Intégrité des nœuds et démarrage sécurisé.
Pour activer la création automatique de pools de nœuds pour une ComputeClass dans les versions GKE antérieures à 1.33.3-gke.1136000, vous devez également activer le provisionnement automatique des nœuds au niveau du cluster. Cette limite ne s'applique pas aux versions 1.33.3-gke.1136000 et ultérieures de GKE.

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é la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de gcloud CLI ne permettent pas d'exécuter les commandes de ce document.
Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

Conditions requises

Vous pouvez activer la création automatique de pools de nœuds pour l'ensemble de votre cluster dans n'importe quelle version de GKE à l'aide de la fonctionnalité de provisionnement automatique des nœuds. Si vous souhaitez utiliser une ComputeClass pour activer la création automatique de pools de nœuds au niveau de la charge de travail, et que vous ne souhaitez pas activer le provisionnement automatique des nœuds, votre cluster doit répondre aux exigences suivantes :

Utilisez GKE version 1.33.3-gke.1136000 ou ultérieure.
Utilisez la version disponible précoce.

Pour déclencher la création automatique de pools de nœuds pour des configurations de nœuds spécifiques, vous devez respecter les exigences de version correspondantes. Pour en savoir plus sur la compatibilité des versions avec différentes configurations, consultez les notes de version de GKE (nouvelles fonctionnalités) ou la documentation correspondant à votre cas d'utilisation.

Activer la création automatique au niveau de la charge de travail

Vous pouvez activer la création automatique de pools de nœuds pour des charges de travail spécifiques dans le cluster à l'aide d'une ComputeClass. Le champ nodePoolAutoCreation d'une spécification ComputeClass indique si GKE peut créer des pools de nœuds pour les pods qui sélectionnent cette ComputeClass. Dans GKE 1.33.3-gke.1136000 et versions ultérieures, vous pouvez activer la création automatique de pools de nœuds pour une ComputeClass, même si le provisionnement automatique des nœuds n'est pas activé pour le cluster. Dans les versions antérieures à 1.33.3-gke.1136000, vous devez également activer le provisionnement automatique des nœuds au niveau du cluster.

Pour activer la création automatique de pools de nœuds pour une ComputeClass, procédez comme suit :

Utilisez un cluster standard nouveau ou existant qui répond aux exigences suivantes :
- Utilise GKE version 1.33.3-gke.1136000 ou ultérieure.
- Utilise la version disponible précoce.
Vous pouvez également créer un cluster standard.
Si votre cluster ne répond pas aux exigences de l'étape précédente, activez le provisionnement automatique des nœuds au niveau du cluster.
Enregistrez l'exemple ComputeClass suivant en tant que fichier YAML :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  -  machineFamily: n4
  -  machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Remplacez COMPUTE_CLASS par le nom de la nouvelle ComputeClass. Pour en savoir plus sur les champs disponibles dans ComputeClasses, consultez la définition de ressource personnalisée ComputeClass.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

Enregistrez l'exemple de déploiement suivant, qui sélectionne une ComputeClass, sous le nom helloweb-deploy.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      nodeSelector:
        # Replace with the name of a compute class
        cloud.google.com/compute-class: COMPUTE_CLASS 
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "1Gi"

Créez le déploiement dans le cluster :
```
kubectl apply -f helloweb-deploy.yaml
```
Pour vérifier que GKE a créé un pool de nœuds pour votre pod, obtenez la liste des pools de nœuds de votre cluster :
```
gcloud container node-pools list \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- CONTROL_PLANE_LOCATION : région ou zone du plan de contrôle du cluster, par exemple us-central1 ou us-central1-a.

Activer le provisionnement automatique des nœuds au niveau du cluster

Pour activer la création automatique de pools de nœuds pour l'ensemble de votre cluster GKE, utilisez le paramètre Provisionnement automatique des nœuds. Le provisionnement automatique des nœuds permet à GKE de créer des pools de nœuds pour les charges de travail en attente dans le cluster, en fonction de la configuration dans la spécification du pod ou dans une ComputeClass. Vous pouvez activer le provisionnement automatique des nœuds pour les clusters nouveaux ou existants.

Avant d'activer le provisionnement automatique des nœuds, planifiez la taille de la plage d'adresses IPv4 principale de votre sous-réseau VPC. GKE utilise cette plage d'adresses IP comme plage d'adresses IP principale des nœuds. En fonction de la taille et de l'échelle de votre cluster, la plage d'adresses IP de nœuds par défaut peut ne pas comporter suffisamment d'adresses IP à attribuer aux nouveaux nœuds. Si vous modifiez la taille de la plage d'adresses IP des nœuds après avoir créé votre cluster, vous devez mettre à jour les règles de pare-feu du cluster GKE pour autoriser le trafic provenant des nouvelles adresses IP.

Pour obtenir des pools de nœuds créés automatiquement dans les versions de GKE antérieures à la version 1.33.3-gke.1136000, vous devez suivre les étapes de cette section. Vous pouvez également activer le provisionnement automatique des nœuds pour un cluster existant en modifiant la configuration du cluster dans la console Google Cloud .

Pour activer le provisionnement automatique des nœuds lorsque vous créez un cluster, sélectionnez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Créer un cluster Kubernetes.
Accéder à la page "Créer un cluster Kubernetes"
Sur la page Paramètres de base du cluster, spécifiez un nom et un emplacement pour votre nouveau cluster.
Dans le menu de navigation, cliquez sur Automatisation.
Cochez la case Activer le provisionnement automatique des nœuds. Une section Limites s'affiche.
Spécifiez des limites pour le processeur et la mémoire.
Cliquez sur Enregistrer les modifications.

gcloud

gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_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
CONTROL_PLANE_LOCATION : région ou zone du plan de contrôle du cluster, par exemple us-central1 ou us-central1-a.
MINIMUM_CPU : nombre minimal de cœurs dans le cluster
MINIMUM_MEMORY : capacité de mémoire minimale du cluster, en Gio.
MAXIMUM_CPU : nombre maximal de cœurs dans le cluster Cette limite s'applique à la somme des cœurs de processeur de tous les nœuds nouveaux et existants du cluster, y compris les pools de nœuds créés manuellement.
MAXIMUM_MEMORY : capacité de mémoire maximale du cluster, en Gio. Cette limite s'applique à la somme de la capacité de mémoire de tous les pools de nœuds nouveaux et existants du cluster, y compris ceux créés manuellement.

Configurer les paramètres avec un fichier de configuration de provisionnement automatique des nœuds

Vous pouvez configurer les limites de ressources et les paramètres de configuration des nœuds pour le provisionnement automatique des nœuds à l'aide d'un fichier de configuration YAML. Le fichier de configuration vous permet de spécifier de manière déclarative les valeurs par défaut des pools de nœuds créés automatiquement et d'effectuer une configuration avancée, comme l'activation de la réparation automatique des nœuds. Ce fichier n'est pas lié aux ComputeClasses, qui sont des ressources personnalisées Kubernetes. Le fichier de configuration est plutôt une alternative plus extensible à l'utilisation d'indicateurs de ligne de commande pour spécifier les paramètres du provisionnement automatique des nœuds. Pour en savoir plus, consultez Paramètres par défaut au niveau du cluster avec un fichier de configuration.

Pour créer et utiliser un fichier de configuration, procédez comme suit :

Dans un éditeur de texte, créez un fichier YAML dans un chemin d'accès auquel la Google Cloud CLI peut accéder.
Ajoutez les configurations que vous souhaitez définir ou modifier, comme dans l'exemple suivant :
```
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
```
Cet exemple présente les paramètres suivants pour le provisionnement automatique des nœuds :
- resourceLimits : définit les limites de ressources pour le processeur, la capacité de mémoire et les GPU NVIDIA T4 dans le cluster. Ces limites s'appliquent à la somme de la capacité de ressources du cluster, y compris dans les pools de nœuds créés manuellement.
- management : active la réparation et la mise à niveau automatiques des nœuds pour tous les nouveaux pools de nœuds créés automatiquement dans le cluster.
- shieldedInstanceConfig : active le démarrage sécurisé et la surveillance de l'intégrité des nœuds pour tous les nouveaux pools de nœuds créés automatiquement dans le cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Une fois le fichier de configuration appliqué au cluster, GKE utilise les paramètres du fichier pour les nouveaux pools de nœuds créés automatiquement dans le cluster. Ces paramètres ne s'appliquent pas aux pools de nœuds existants que GKE a créés dans le cluster.

Configurer les limites de ressources pour le provisionnement automatique des nœuds

Lorsque vous utilisez le provisionnement automatique des nœuds au niveau du cluster, vous devez configurer des limites pour la quantité totale de ressources que votre cluster peut avoir dans tous ses pools de nœuds. Pour activer le provisionnement automatique des nœuds pour un cluster, vous devez spécifier des limites de capacité de processeur et de mémoire dans le cluster. De plus, pour utiliser d'autres types de ressources associées, comme les GPU et les TPU, vous devez spécifier des limites pour ces ressources. Ces limites ne sont requises que si vous activez le paramètre de provisionnement automatique des nœuds pour votre cluster. Si vous n'utilisez que des ComputeClasses pour obtenir des pools de nœuds créés automatiquement, vous n'avez pas besoin de configurer de limites de ressources.

Vous pouvez ajouter ou modifier les limites de ressources pour la création automatique de pools de nœuds à l'aide de l'une des méthodes suivantes :

La console Google Cloud
Indicateurs de gcloud CLI
Fichier de configuration au niveau du cluster

Pour configurer les limites de ressources d'un cluster existant, sélectionnez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Clusters Kubernetes.

Accéder à la page "Clusters Kubernetes"
Cliquez sur le nom du cluster. La page Détails du cluster s'ouvre.
Cliquez sur l'onglet Détails.
Dans la section Automatisation, sur la ligne Provisionnement automatique des nœuds, cliquez sur Modifier. Le volet Modifier le provisionnement automatique des nœuds s'ouvre.
Cochez la case Activer le provisionnement automatique des nœuds.
Dans la section Limites, spécifiez les valeurs minimales et maximales pour la capacité de processeur et de mémoire du cluster.
Pour configurer des limites pour une autre ressource, comme les GPU ou les TPU, procédez comme suit :
1. Cliquez sur Ajouter une ressource.
2. Dans la liste déroulante Type de ressource, sélectionnez le modèle de GPU ou le type de machine TPU, comme NVIDIA A100 80 Go ou ct5p.
3. Spécifiez les valeurs minimale et maximale de la ressource.
Facultatif : Dans la section Emplacements des pools de nœuds, sélectionnez des zones spécifiques dans lesquelles GKE créera des nœuds. Par exemple, si vous prévoyez d'exécuter des charges de travail de GPU, sélectionnez les zones qui offrent une haute disponibilité pour le type de GPU sélectionné.
Cliquez sur Enregistrer les modifications.

gcloud

Exécutez l'une des commandes suivantes :

Spécifiez les limites de ressources de processeur et de mémoire :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY
```
Remplacez les éléments suivants :
- MINIMUM_CPU : nombre minimal de cœurs dans le cluster
- MINIMUM_MEMORY : capacité de mémoire minimale du cluster, en Gio.
- MAXIMUM_CPU : nombre maximal de cœurs dans le cluster Cette limite s'applique à la somme des cœurs de processeur de tous les pools de nœuds du cluster, y compris ceux créés manuellement.
- MAXIMUM_MEMORY : capacité de mémoire maximale du cluster, en Gio. Cette limite s'applique à la somme de la capacité de mémoire de tous les pools de nœuds du cluster, y compris ceux créés manuellement.

Spécifiez les limites de ressources GPU :

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --min-accelerator=type=GPU_TYPE,count=MINIMUM_GPU_COUNT \
    --max-accelerator=type=GPU_TYPE,count=MAXIMUM_GPU_COUNT

Remplacez les éléments suivants :

GPU_TYPE : type de GPU pour lequel définir une limite, tel que nvidia-l4.
MINIMUM_GPU_COUNT : nombre minimal de GPU du type spécifié que le cluster peut comporter.
MAXIMUM_GPU_COUNT : nombre maximal de GPU du type spécifié que le cluster peut comporter.

Spécifiez les limites de ressources TPU :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
    --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
```
Remplacez les éléments suivants :
- TPU_TYPE : type de TPU pour lequel définir une limite. Les valeurs suivantes sont acceptées :
  - tpu-v4-podslice : TPU v4.
  - tpu-v5-lite-podslice : TPU v5e avec des types de machines commençant par ct5lp-.
  - tpu-v5p-slice : TPU v5e avec des types de machines commençant par ct5p-.
  - tpu-v6e-slice : TPU Trillium.
- MINIMUM_TPU_COUNT : nombre minimal de puces TPU du type spécifié que le cluster peut contenir. Si la valeur que vous spécifiez est supérieure au nombre de puces TPU dans une tranche de TPU multi-hôte, il est possible que votre tranche de TPU ne soit pas réduite.
- MAXIMUM_TPU_COUNT : nombre maximal de puces TPU du type spécifié que le cluster peut contenir. Pour les tranches TPU multi-hôtes, spécifiez une valeur supérieure au nombre de puces dans chaque tranche afin que GKE puisse mettre à l'échelle la tranche de manière atomique. Le nombre de puces dans une tranche correspond au produit de la topologie TPU. Par exemple, si la topologie est 2x2x2, le nombre de puces dans la tranche est 8, ce qui signifie que la valeur de MAXIMUM_TPU_COUNT doit être supérieure à 8.

Fichier de configuration

Dans votre fichier de configuration, spécifiez l'un des ensembles de champs suivants dans le champ resourceLimits :
- Spécifiez les limites de ressources de processeur et de mémoire :
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
```
  Remplacez les éléments suivants :
  - MINIMUM_CPU : nombre minimal de cœurs dans le cluster
  - MINIMUM_MEMORY : capacité de mémoire minimale du cluster, en Gio.
  - MAXIMUM_CPU : nombre maximal de cœurs dans le cluster Cette limite s'applique à la somme des cœurs de processeur de tous les pools de nœuds du cluster, y compris ceux créés manuellement.
  - MAXIMUM_MEMORY : capacité de mémoire maximale du cluster, en Gio. Cette limite s'applique à la somme de la capacité de mémoire de tous les pools de nœuds du cluster, y compris ceux créés manuellement.
- Spécifiez les limites de ressources GPU :
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
  - resourceType: 'GPU1_TYPE'
    minimum: MINIMUM_GPU1_COUNT
    maximum: MAXIMUM_GPU1_COUNT
  - resourceType: 'GPU2_TYPE'
    minimum: MINIMUM_GPU2_COUNT
    maximum: MAXIMUM_GPU2_COUNT
```
  Remplacez les éléments suivants :
  - GPU1_TYPE,GPU2_TYPE : types de GPU pour lesquels définir des limites, par exemple nvidia-l4.
  - MINIMUM_GPU1_COUNT,MINIMUM_GPU2_COUNT : nombre minimal de GPU des types spécifiés que le cluster peut contenir.
  - MAXIMUM_GPU1_COUNT,MAXIMUM_GPU2_COUNT : nombre maximal de GPU des types spécifiés que le cluster peut contenir.
- Spécifiez les limites de ressources TPU :
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
  - resourceType: 'TPU1_TYPE'
    minimum: MINIMUM_TPU1_COUNT
    maximum: MAXIMUM_TPU1_COUNT
  - resourceType: 'TPU2_TYPE'
    minimum: MINIMUM_TPU2_COUNT
    maximum: MAXIMUM_TPU2_COUNT
```
  Remplacez les éléments suivants :
  - TPU1_TYPE,TPU2_TYPE : types de TPU pour lesquels définir des limites. Les valeurs suivantes sont acceptées :
    - tpu-v4-podslice : TPU v4.
    - tpu-v5-lite-podslice : TPU v5e avec des types de machines commençant par ct5lp-.
    - tpu-v5p-slice : TPU v5e avec des types de machines commençant par ct5p-.
    - tpu-v6e-slice : TPU Trillium.
  - MINIMUM_TPU1_COUNT,MINIMUM_TPU2_COUNT : nombre minimal de puces TPU du type spécifié que le cluster peut comporter. Si la valeur que vous spécifiez est supérieure au nombre de puces TPU dans une tranche de TPU multi-hôte, il est possible que votre tranche de TPU ne soit pas réduite.
  - MAXIMUM_TPU1_COUNT,MAXIMUM_TPU2_COUNT : nombre maximal de puces TPU du type spécifié que le cluster peut contenir. Pour les tranches TPU multi-hôtes, spécifiez une valeur supérieure au nombre de puces dans chaque tranche afin que GKE puisse effectuer le scaling de la tranche de manière atomique. Le nombre de puces dans une tranche correspond au produit de la topologie TPU. Par exemple, si la topologie de TPU1_TYPE est 2x2x2, le nombre de puces dans la tranche est 8, ce qui signifie que la valeur de MAXIMUM_TPU1_COUNT doit être supérieure à 8.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Marquer les pools de nœuds existants comme créés automatiquement

Après avoir activé le provisionnement automatique des nœuds au niveau du cluster, vous pouvez marquer les pools de nœuds existants dans le cluster comme créés automatiquement. GKE gère le scaling dans ces pools de nœuds, y compris la suppression des pools de nœuds lorsqu'ils sont vides. Vous pouvez marquer les pools de nœuds créés manuellement comme étant créés automatiquement pour permettre à GKE de les gérer pour vous.

Si vous désactivez le provisionnement automatique pour votre cluster, GKE cesse de gérer tous les pools de nœuds créés automatiquement dans le cluster. Si vous réactivez le provisionnement automatique pour le cluster ultérieurement, GKE ne reprend pas automatiquement la gestion de ces pools de nœuds existants. Vous devez marquer ces pools de nœuds existants comme créés automatiquement.

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

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning

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

Configurer les paramètres par défaut des pools de nœuds créés automatiquement

GKE utilise vos ComputeClasses et les spécifications de vos pods pour déterminer les types de nœuds qui peuvent exécuter de manière optimale vos pods en attente. Vous pouvez éventuellement configurer des paramètres par défaut que GKE applique aux pools de nœuds créés automatiquement, tels qu'un compte de service Identity and Access Management (IAM) personnalisé pour les nœuds ou des configurations de disque de démarrage personnalisées. Ces paramètres par défaut remplacent toutes les valeurs par défaut correspondantes que Google définit pour vos clusters. Par exemple, vous pouvez définir une image de nœud Ubuntu comme image par défaut pour les pools de nœuds créés automatiquement, ce qui remplace l'image de nœud Container-Optimized OS par défaut de GKE.

Vous pouvez configurer les paramètres par défaut au niveau du cluster à l'aide du provisionnement automatique de nœuds ou au niveau de la charge de travail dans ComputeClasses. Avant de configurer un paramètre à l'un de ces niveaux, tenez compte des points suivants :

Les paramètres au niveau du cluster s'appliquent à tous les pools de nœuds créés automatiquement dans le cluster, et les paramètres ComputeClass ne s'appliquent qu'aux charges de travail qui utilisent cette ComputeClass.
Si vous spécifiez le même paramètre par défaut dans une ComputeClass et au niveau du cluster, GKE utilise le paramètre ComputeClass pour les charges de travail qui utilisent la ComputeClass.
Toutes les valeurs par défaut que vous configurez ne s'appliquent qu'aux pools de nœuds créés automatiquement nouvellement. Les pools de nœuds existants ne sont pas affectés.

Les sections suivantes vous expliquent comment configurer des paramètres par défaut spécifiques.

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

Sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, utilisez le champ nodePoolConfig.imageType. Ce champ est disponible dans GKE version 1.32.4-gke.1198000 et ultérieure.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  nodePoolConfig:
    imageType: IMAGE_TYPE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Remplacez IMAGE_TYPE par une valeur pour l'image de nœud, qui peut être l'une des suivantes :
- cos_containerd : Container-optimized OS avec containerd
- ubuntu_containerd : Ubuntu avec containerd
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Pour définir l'image de nœud par défaut sur la ligne de commande, utilisez l'option --autoprovisioning-image-type :

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

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster.
IMAGE_TYPE : l'image de nœud, qui peut être l'une des suivantes :
- cos_containerd : Container-optimized OS avec containerd
- ubuntu_containerd : Ubuntu avec containerd

Pour définir l'image de nœud par défaut dans un fichier de configuration, procédez comme suit :

Dans votre fichier de configuration, spécifiez le champ imageType :
```
  imageType: 'IMAGE_TYPE'
```
Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Définir le compte de service IAM par défaut pour les nœuds

Les nœuds GKE utilisent un compte de service IAM pour les tâches système telles que la journalisation et la surveillance. Pour modifier le compte de service IAM des pools de nœuds créés automatiquement, sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste Computeclass, utilisez le champ nodePoolConfig.serviceAccount. Ce champ est disponible dans GKE version 1.31.4-gke.1072000 et ultérieure.

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  nodePoolConfig:
    serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Remplacez les éléments suivants :

SERVICE_ACCOUNT_NAME : nom du compte de service IAM, tel que my-node-account.
PROJECT_ID : ID de projet du projet de compte de service.

Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Lorsque vous utilisez gcloud CLI pour configurer un compte de service par défaut pour les pools de nœuds créés automatiquement, vous devez également spécifier les scopes d'accès dont les pools de nœuds ont besoin pour fonctionner correctement.

Pour définir le compte de service et les niveaux d'accès par défaut sur la ligne de commande, utilisez les indicateurs --autoprovisioning-service-account et --autoprovisioning-scopes :

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append

Remplacez les éléments suivants :

SERVICE_ACCOUNT_NAME : nom du compte de service IAM, tel que my-node-account.
PROJECT_ID : ID du projet du compte de service.

Pour définir le compte de service et les niveaux d'accès par défaut dans un fichier de configuration, procédez comme suit :

Dans votre fichier de configuration, spécifiez les champs serviceAccount et scopes :
```
serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
scopes: https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append
```
Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Définir les zones par défaut pour les nœuds créés automatiquement

Par défaut, GKE crée automatiquement des nœuds dans les zones suivantes, en fonction du type de cluster :

Clusters régionaux : GKE crée des nœuds dans trois zones aléatoires de la région du cluster.
Clusters zonaux : GKE crée des nœuds dans la même zone que le plan de contrôle du cluster.

Vous pouvez spécifier manuellement une liste de zones dans lesquelles GKE crée automatiquement des nœuds. Ces zones doivent se trouver dans la même région que le plan de contrôle du cluster. Par exemple, si vous disposez d'un cluster zonal avec le plan de contrôle dans us-central1-a, vous pouvez spécifier n'importe quelle zone de la région us-central1 pour que GKE crée automatiquement des nœuds. Si vous modifiez les zones par défaut pour les nœuds créés automatiquement dans un cluster existant, les modifications ne s'appliquent qu'aux nouveaux pools de nœuds créés par GKE.

Pour spécifier les zones par défaut des nœuds créés automatiquement, sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, utilisez le champ spec.priorityDefaults.location.zones. Ce champ est disponible dans GKE version 1.33.1-gke.1545000 et ultérieure.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorityDefaults:
    location:
      zones: ['ZONE1','ZONE2','...']
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Remplacez ZONE1,ZONE2,... par une liste de zones par défaut pour les nœuds créés automatiquement, séparées par une virgule, par exemple us-central1-a','us-central1-b', 'us-central1-f'. GKE utilise ces zones si des règles spécifiques dans le champ spec.priorities n'incluent pas de liste explicite de zones.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Pour définir les zones par défaut pour la création automatique de pools de nœuds sur la ligne de commande, utilisez l'indicateur --autoprovisioning-locations :

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-locations=ZONE1,ZONE2,...

Remplacez ZONE1,ZONE2,... par une liste, séparée par une virgule, des zones par défaut pour les nœuds créés automatiquement, par exemple us-central1-a','us-central1-b', 'us-central1-f'.

Pour définir les zones par défaut pour la création automatique de pools de nœuds à l'aide d'un fichier de configuration, procédez comme suit :

Spécifiez le champ autoprovisioningLocations dans le fichier de configuration :
```
autoprovisioningLocations:
- ZONE1
- ZONE2
```
Remplacez ZONE1,ZONE2 par les zones par défaut pour les nœuds créés automatiquement, par exemple "us-central1-a" et "us-central1-b".

Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Définir des clés de chiffrement gérées par le client pour le chiffrement du disque de démarrage

Vous pouvez spécifier une clé de chiffrement gérée par le client (CMEK) dans Cloud Key Management Service que GKE utilise pour chiffrer les disques de démarrage des nœuds dans les pools de nœuds créés automatiquement. Vous devez créer la clé avant de l'utiliser avec la création automatique de pools de nœuds. Pour définir une clé CMEK pour les disques de démarrage de vos nœuds, sélectionnez l'une des options suivantes :

ComputeClass

Dans ComputeClasses, vous devez spécifier la clé dans chaque règle de priorité dans le champ spec.priorities de ComputeClass.

Dans un fichier manifeste ComputeClass, utilisez le champ priorities.storage.bootDiskKMSKey :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
    storage:
      bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
  - machineFamily: n4d
    storage:
      bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Remplacez les éléments suivants :

KEY_PROJECT_ID : ID du projet contenant la clé.
KEY_LOCATION : emplacement du trousseau de clés.
KEY_RING : nom du trousseau de clés qui inclut la clé
KEY_NAME : nom de la clé.

Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Spécifiez le champ bootDiskKmsKey dans le fichier de configuration :
```
bootDiskKmsKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
```
Remplacez les éléments suivants :
- KEY_PROJECT_ID : ID du projet contenant la clé.
- KEY_LOCATION : emplacement du trousseau de clés.
- KEY_RING : nom du trousseau de clés qui inclut la clé
- KEY_NAME : nom de la clé.
Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Configurer l'intégrité des nœuds et le démarrage sécurisé

Vous pouvez activer le démarrage sécurisé et la surveillance de l'intégrité pour les pools de nœuds créés automatiquement uniquement à l'aide du fichier de configuration du provisionnement automatique des nœuds.

Spécifiez le champ shieldedInstanceConfig dans le fichier de configuration :
```
shieldedInstanceConfig:
  enableSecureBoot: true
  enableIntegrityMonitoring: true
```
Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Configurer la réparation et la mise à niveau automatiques des nœuds

Vous pouvez modifier les paramètres de réparation automatique des nœuds et de mise à niveau automatique des nœuds dans les pools de nœuds créés automatiquement. Ces fonctionnalités sont activées par défaut dans tous les clusters et pools de nœuds GKE. Nous vous recommandons de laisser ces fonctionnalités activées pour améliorer la fiabilité et la stabilité de vos clusters.

Pour modifier les paramètres de réparation et de mise à niveau automatiques des nœuds, sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, utilisez les champs autoRepair et autoUpgrade dans le champ spec.nodePoolConfig. Ces champs sont disponibles dans GKE 1.34.0-gke.2201000 et versions ultérieures.

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  nodePoolConfig:
    autoRepair: true
    autoUpgrade: true
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Pour activer les paramètres de réparation et de mise à niveau automatiques sur la ligne de commande, utilisez les options --enable-autoprovisioning-autorepair et --enable-autoprovisioning-autoupgrade :

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-autorepair \
    --enable-autoprovisioning-autoupgrade

Pour désactiver les paramètres de réparation et de mise à niveau automatiques sur la ligne de commande, utilisez les options --no-enable-autoprovisioning-autorepair et --no-enable-autoprovisioning-autoupgrade :

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

Pour modifier les paramètres de réparation et de mise à niveau automatiques des nœuds à l'aide d'un fichier de configuration, procédez comme suit :
1. Spécifiez les champs management.autoRepair et management.autoUpgrade dans le fichier de configuration :
```
management:
  autoRepair: true
  autoUpgrade: true
```
  Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
2. Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
  Remplacez les éléments suivants :
  - CLUSTER_NAME : nom du cluster.
  - PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Configurer les paramètres de mise à niveau de la surutilisation

Vous pouvez spécifier des paramètres de mise à niveau de la surutilisation dans les pools de nœuds créés automatiquement. Les mises à niveau de la surutilisation sont la stratégie de mise à niveau des nœuds GKE par défaut. Pour modifier les paramètres de mise à niveau de la surutilisation, vous devez configurer le provisionnement automatique des nœuds au niveau du cluster.

Pour spécifier les paramètres de mise à niveau de la surutilisation sur la ligne de commande, utilisez les indicateurs --autoprovisioning-max-surge-upgrade et --autoprovisioning-max-unavailable-upgrade :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-max-surge-upgrade=MAX_SURGE \
    --autoprovisioning-max-unavailable-upgrade=MAX_UNAVAILABLE
```
Remplacez les éléments suivants :
- 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.
Pour spécifier les paramètres de mise à niveau de la surutilisation à l'aide d'un fichier de configuration, procédez comme suit :
1. Spécifiez les champs upgradeSettings.maxSurgeUpgrade et upgradeSettings.maxUnavailableUpgrade dans le fichier de configuration :
```
upgradeSettings:
  maxSurgeUpgrade: MAX_SURGE
  maxUnavailableUpgrade: MAX_UNAVAILABLE
```
  Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
2. Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
  Remplacez les éléments suivants :
  - CLUSTER_NAME : nom du cluster.
  - PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

Les paramètres de mise à niveau de la surutilisation que vous spécifiez ne s'appliquent que si votre cluster utilise des mises à niveau de la surutilisation pour mettre à niveau les pools de nœuds créés automatiquement. Pour passer à la stratégie de mise à niveau des nœuds par surutilisation pour les nouveaux pools de nœuds créés automatiquement, exécutez la commande suivante :

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-surge-upgrade

Lorsque vous changez de stratégie de mise à niveau, GKE utilise tous les paramètres que vous avez configurés précédemment pour cette stratégie.

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

Vous pouvez remplacer votre stratégie de mise à niveau des nœuds par des mises à niveau bleu-vert pour tous les nouveaux pools de nœuds créés automatiquement et ajuster les paramètres par défaut des mises à niveau bleu-vert. Pour modifier votre stratégie de mise à niveau, vous devez configurer le provisionnement automatique des nœuds au niveau du cluster. Toutes les modifications que vous apportez ne s'appliquent qu'aux nouveaux pools de nœuds créés automatiquement. Vous pouvez également mettre à jour les pools de nœuds créés automatiquement existants pour utiliser les mises à niveau bleu-vert.

Pour utiliser les mises à niveau bleu-vert et les paramètres GKE par défaut pour les nouveaux pools de nœuds créés automatiquement, exécutez la commande suivante :

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

Pour utiliser les mises à niveau bleu-vert et configurer vos propres paramètres par défaut pour les nouveaux pools de nœuds créés automatiquement, exécutez la commande suivante :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --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
```
Remplacez les éléments suivants :
- NODE_POOL_SOAK_DURATION : durée, en secondes, pendant laquelle GKE attend après avoir drainé tous les lots de nœuds du pool bleu avant de supprimer ce pool. La valeur par défaut est 3600.
- BATCH_NODE_COUNT : nombre de nœuds à drainer dans un lot pendant la phase de drainage du pool bleu. La valeur par défaut est 1. Si vous spécifiez une valeur de 0, GKE ignore la phase de drainage du pool bleu.
- BATCH_SOAK_DURATION : durée, en secondes, pendant laquelle GKE attend avant de démarrer une opération de drainage par lot après la fin de l'opération de drainage précédente. La valeur par défaut est 0.

Configurer des disques de démarrage de nœud personnalisés

Pour spécifier le type et la taille des disques de démarrage que GKE associe à chaque VM de nœud dans un pool de nœuds créé automatiquement, sélectionnez l'une des options suivantes :

ComputeClass

Utilisez les champs bootDiskType et bootDiskSize dans le champ spec.priorities.storage d'une ComputeClass :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
    storage:
      bootDiskType: BOOT_DISK_TYPE
      bootDiskSize: BOOT_DISK_SIZE
  - machineFamily: n4d
    storage:
      bootDiskType: BOOT_DISK_TYPE
      bootDiskSize: BOOT_DISK_SIZE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Remplacez les éléments suivants :
- BOOT_DISK_TYPE : type de disque à utiliser comme disque de démarrage du nœud. La valeur que vous spécifiez doit être compatible avec le type de machine Compute Engine que GKE utilise pour cette règle de priorité. La valeur doit être l'une des suivantes :
  - pd-balanced : disque persistant avec équilibrage.
  - pd-standard : disque persistant standard.
  - pd-ssd : Persistent Disk SSD (performances).
  - hyperdisk-balanced : Google Cloud Hyperdisk Balanced.
- BOOT_DISK_SIZE : taille du disque de démarrage du nœud, en Gio. La valeur minimale est 10.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

gcloud

Dans votre fichier de configuration, spécifiez les champs diskSizeGb et diskType :
```
diskSizeGb: BOOT_DISK_SIZE
diskType: BOOT_DISK_TYPE
```
Remplacez les éléments suivants :
- BOOT_DISK_TYPE : type de disque à utiliser comme disque de démarrage du nœud. La valeur que vous spécifiez doit être compatible avec le type de machine Compute Engine que GKE utilise pour cette règle de priorité. La valeur doit être l'une des suivantes :
  - pd-balanced : disque persistant avec équilibrage.
  - pd-standard : disque persistant standard.
  - pd-ssd : Persistent Disk SSD (performances).
  - hyperdisk-balanced : Google Cloud Hyperdisk Balanced.
- BOOT_DISK_SIZE : taille du disque de démarrage du nœud, en Gio. La valeur minimale est 10.
Si votre fichier de configuration comporte d'autres paramètres, ne les modifiez pas. Toute modification ou suppression dans le fichier de configuration modifie également les paramètres correspondants au niveau du cluster.
Fournissez le fichier de configuration à GKE en spécifiant l'option --autoprovisioning-config-file et l'option --enable-autoprovisioning pour un cluster nouveau ou existant :
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster.
- PATH_TO_CONFIGURATION_FILE : chemin d'accès au fichier de configuration.

GKE réserve une partie du disque de démarrage des nœuds pour les fonctionnalités système et le stockage éphémère. Pour en savoir plus, consultez Stockage éphémère sauvegardé par le disque de démarrage des nœuds.

Configurer des pools de nœuds créés automatiquement pour des scénarios courants

Les sections suivantes vous expliquent comment demander des pools de nœuds créés automatiquement pour certains cas d'utilisation courants de GKE. Pour en savoir plus sur les cas d'utilisation supplémentaires et les configurations compatibles, consultez la documentation correspondant à votre cas d'utilisation spécifique.

Sélectionner une série ou un type de machine

Pour sélectionner une série ou un type de machine Compute Engine compatibles, sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, spécifiez l'un des champs suivants dans le champ spec.priorities. Vous pouvez spécifier ces deux champs dans le même fichier manifeste ComputeClass, mais pas dans la même règle de priorité.
- Pour sélectionner une série de machines, spécifiez le champ machineFamily dans une règle de priorité :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: MACHINE_SERIES
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
  Remplacez MACHINE_SERIES par une série de machines Compute Engine, par exemple n4.
- Pour sélectionner un type de machine, spécifiez le champ machineType dans une règle de priorité :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineType: MACHINE_TYPE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
  Remplacez MACHINE_TYPE par un type de machine Compute Engine, tel que c4-standard-96. Dans les versions 1.33.2-gke.1111000 et ultérieures de GKE, vous pouvez également spécifier des types de machines personnalisés dans ce champ.
Vous ne pouvez pas spécifier les champs machineFamily et machineType dans la même règle de priorité.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.
Sélectionnez la classe de calcul dans une charge de travail.

Pod specification

Dans un fichier manifeste de pod, sélectionnez l'un des libellés de nœud suivants :
- Pour sélectionner une série de machines, utilisez le libellé de nœud cloud.google.com/machine-family :
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
  Remplacez MACHINE_SERIES par une série de machines Compute Engine, par exemple n4.
- Pour sélectionner un type de machine prédéfini, utilisez les libellés de nœud cloud.google.com/machine-family et node.kubernetes.io/instance-type :
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
    node.kubernetes.io/instance-type: MACHINE_TYPE
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
  Remplacez MACHINE_TYPE par un type de machine Compute Engine dans la série de machines spécifiée. Par exemple, si vous spécifiez n4 pour MACHINE_SERIES, vous pouvez spécifier n4-standard-80 pour MACHINE_TYPE.
  
  Dans la version 1.33.2-gke.1111000 de GKE, vous pouvez également spécifier des types de machines personnalisés dans ce champ.
Créez le pod :
```
kubectl apply -f PATH_TO_POD_MANIFEST
```
Remplacez PATH_TO_POD_MANIFEST par le chemin d'accès au fichier manifeste du pod.

Sélectionner les GPU

Pour demander des GPU pour les pools de nœuds créés automatiquement, sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, spécifiez le champ spec.priorities.gpu :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - gpu:
      type: GPU_TYPE
      count: GPU_COUNT
      driverVersion: DRIVER_VERSION
  whenUnsatisfiable: DoNotScaleUp
  nodePoolAutoCreation:
    enabled: true
```
Remplacez les éléments suivants :
- GPU_TYPE : type de GPU à associer, tel que nvidia-l4.
- GPU_COUNT : nombre de GPU à associer à chaque nœud. Cette valeur doit être au moins égale à 1.
- DRIVER_VERSION : version du pilote de GPU à installer. Cette valeur doit être default ou latest : Ce champ nécessite GKE version 1.31.1-gke.1858000 ou ultérieure.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.

Sélectionnez la classe de calcul dans une charge de travail GPU, comme dans l'exemple suivant :

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: nvidia-l4-class
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
      nvidia.com/gpu: 1

Pod specification

Pour sélectionner des GPU dans vos spécifications de pod, vous devez configurer le provisionnement automatique des nœuds au niveau du cluster et définir des limites de ressources pour ce type de GPU. Pour configurer les limites de ressources GPU et sélectionner des GPU dans vos pods, procédez comme suit :

Configurez des limites de ressources au niveau du cluster pour les GPU que vous souhaitez utiliser, comme décrit dans la section Configurer des limites de ressources pour la création automatique de pools de nœuds.
Sélectionnez des GPU à l'aide d'étiquettes de nœud dans la spécification de pod :
```
apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
    cloud.google.com/gke-gpu-driver-version: DRIVER_VERSION
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
      nvidia.com/gpu: GPU_QUANTITY
```
Remplacez les éléments suivants :
- GPU_TYPE : type de GPU à associer, tel que nvidia-l4.
- GPU_COUNT : nombre de GPU à associer à chaque nœud. Cette valeur doit être au moins égale à 1.
- DRIVER_VERSION : version du pilote de GPU à installer. Cette valeur doit être default ou latest : Dans GKE version 1.32.2-gke.1297000 et ultérieure, GKE installe automatiquement la version du pilote default. Ce libellé de nœud nécessite GKE version 1.29.2-gke.1108000 ou ultérieure. Pour en savoir plus, consultez Installer des pilotes à l'aide du provisionnement automatique des nœuds avec des GPU.
- GPU_QUANTITY : nombre de GPU à associer au pod. Cette valeur doit être inférieure ou égale à celle de GPU_COUNT.

Sélectionner des TPU

Vous pouvez demander des TPU dans les spécifications ComputeClasses ou Pod. Cette section suppose que vous êtes familiarisé avec la sélection de Cloud TPU et que vous connaissez le type, la topologie et le nombre de TPU que vous souhaitez utiliser. Les étapes à suivre dépendent de la façon dont vous sélectionnez les TPU :

ComputeClasses : consultez Provisionner des TPU à l'aide de classes de calcul personnalisées.
Spécification du pod :
1. Configurez les limites de ressources au niveau du cluster pour les TPU que vous souhaitez utiliser, comme décrit dans la section Configurer les limites de ressources pour la création automatique de pools de nœuds.
2. Configurez les sélecteurs et les requêtes de ressources dans les spécifications de vos pods, comme décrit dans Exécuter votre charge de travail sur des nœuds de tranche TPU.

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

Vous pouvez spécifier une durée maximale au-delà de laquelle GKE met fin aux nœuds créés automatiquement. Les restrictions Compute Engine s'appliquent à cette limite de temps.

Sélectionnez l'une des options suivantes :

ComputeClass

Dans un fichier manifeste ComputeClass, utilisez le champ spec.priorities.maxRunDurationSeconds. Ce champ est disponible dans GKE version 1.32.1-gke.1159000 et ultérieure.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machine-family: n4
    maxRunDurationSeconds: MAX_RUN_DURATION
  whenUnsatisfiable: DoNotScaleUp
  nodePoolAutoCreation:
    enabled: true
```
Remplacez MAX_RUN_DURATION par la durée, en secondes, pendant laquelle les nœuds créés automatiquement peuvent s'exécuter avant que GKE ne les arrête.
Appliquez le fichier manifeste ComputeClass au cluster :
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Remplacez PATH_TO_COMPUTECLASS_MANIFEST par le chemin d'accès au fichier manifeste ComputeClass.
Sélectionnez la classe de calcul dans une charge de travail.

Pod specification

Dans le fichier manifeste de votre pod, utilisez un sélecteur de nœuds pour le libellé de nœud cloud.google.com/gke-max-run-duration-seconds. Ce libellé de nœud est disponible dans GKE version 1.31.2-gke.1518000 et versions ultérieures.
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: n4
    cloud.google.com/gke-max-run-duration-seconds: MAX_RUN_DURATION
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
Remplacez MAX_RUN_DURATION par la durée, en secondes, pendant laquelle les nœuds créés automatiquement peuvent s'exécuter avant que GKE ne les arrête.
Créez le pod :
```
kubectl apply -f PATH_TO_POD_MANIFEST
```
Remplacez PATH_TO_POD_MANIFEST par le chemin d'accès au fichier manifeste du pod.

Spécifier une configuration minimum de plate-forme de processeur

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.

Désactiver la création automatique de pools de nœuds

Les sections suivantes vous expliquent comment désactiver la création automatique de pools de nœuds pour des pools de nœuds spécifiques ou pour l'ensemble du cluster. Vous pouvez également désactiver la création automatique de pools de nœuds dans une ComputeClass en spécifiant la valeur false dans le champ nodePoolAutoCreation.enabled de la ComputeClass. Toutefois, nous vous déconseillons de désactiver la création automatique pour les ComputeClasses, car il s'agit d'un avantage majeur qui vous permet d'utiliser des fonctionnalités telles que la migration active et les priorités de secours.

Désactiver la création automatique pour des pools de nœuds spécifiques

Vous pouvez empêcher GKE de gérer les nœuds dans les pools de nœuds existants créés automatiquement. Cette action a les effets suivants :

L'autoscaler de cluster cesse de créer ou de supprimer des nœuds dans ce pool de nœuds. Si vous souhaitez que GKE autoscale les nœuds, vous pouvez activer l'autoscaler de cluster pour ce pool de nœuds séparément.
GKE ne supprime pas le pool de nœuds lorsque le nombre de nœuds est nul.
GKE continue de placer les pods en attente sur les nœuds existants de ce pool de nœuds qui sont disponibles. Si le provisionnement automatique des nœuds est toujours activé pour le cluster, GKE peut également créer des pools de nœuds pour les pods en attente, si nécessaire.

Pour désactiver la création automatique pour un pool de nœuds spécifique, exécutez la commande suivante :

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Désactiver le provisionnement automatique des nœuds pour le cluster

Vous pouvez désactiver la création automatique de pools de nœuds pour l'ensemble de votre cluster en désactivant le paramètre de cluster de provisionnement automatique des nœuds. Cette action a les effets suivants :

L'autoscaler de cluster cesse de créer et de supprimer des nœuds dans les pools de nœuds existants créés automatiquement. Les pools de nœuds créés manuellement qui utilisent l'autoscaler de cluster ne sont pas concernés.
GKE ne crée pas automatiquement de pools de nœuds pour les charges de travail en attente. Surveillez votre cluster pour éviter que les pods ne restent bloqués.
Si le cluster répond aux exigences suivantes, GKE continue de créer des pools de nœuds pour les ComputeClasses qui permettent la création automatique :
- Utilise GKE version 1.33.3-gke.1136000 ou ultérieure.
- être enregistré dans le version disponible "Version précoce".
Si le cluster ne répond pas à ces exigences, GKE ne crée pas de pools de nœuds pour les ComputeClasses qui permettent la création automatique.

Si vous réactivez ultérieurement le paramètre de provisionnement automatique des nœuds au niveau du cluster, GKE ne réactive pas la création automatique de pools de nœuds sur les pools de nœuds existants. Vous devez marquer chaque pool de nœuds comme étant créé automatiquement.

Pour désactiver le paramètre de provisionnement automatique des nœuds au niveau du cluster, sélectionnez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Clusters Kubernetes :

Accéder à la page "Clusters Kubernetes"
Cliquez sur le nom du cluster à modifier. La page Détails du cluster s'ouvre.
Cliquez sur l'onglet Détails.
Dans la section Automatisation, sur la ligne Provisionnement automatique des nœuds, cliquez sur Modifier. Le volet Modifier le provisionnement automatique des nœuds s'affiche.
Décochez la case Activer le provisionnement automatique des nœuds.
Cliquez sur Enregistrer les modifications.

gcloud

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Configurer la création automatique de pools de nœuds Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Limites

Avant de commencer

Conditions requises

Activer la création automatique au niveau de la charge de travail

Activer le provisionnement automatique des nœuds au niveau du cluster

Console

gcloud

Configurer les paramètres avec un fichier de configuration de provisionnement automatique des nœuds

Configurer les limites de ressources pour le provisionnement automatique des nœuds

Console

gcloud

Fichier de configuration

Marquer les pools de nœuds existants comme créés automatiquement

Configurer les paramètres par défaut des pools de nœuds créés automatiquement

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

ComputeClass

gcloud

Définir le compte de service IAM par défaut pour les nœuds

ComputeClass

gcloud

Définir les zones par défaut pour les nœuds créés automatiquement

ComputeClass

gcloud

Définir des clés de chiffrement gérées par le client pour le chiffrement du disque de démarrage

ComputeClass

gcloud

Configurer l'intégrité des nœuds et le démarrage sécurisé

Configurer la réparation et la mise à niveau automatiques des nœuds

ComputeClass

gcloud

Configurer les paramètres de mise à niveau de la surutilisation

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

Configurer des disques de démarrage de nœud personnalisés

ComputeClass

gcloud

Configurer des pools de nœuds créés automatiquement pour des scénarios courants

Sélectionner une série ou un type de machine

ComputeClass

Pod specification

Sélectionner les GPU

ComputeClass

Pod specification

Sélectionner des TPU

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

ComputeClass

Pod specification

Spécifier une configuration minimum de plate-forme de processeur

Désactiver la création automatique de pools de nœuds

Désactiver la création automatique pour des pools de nœuds spécifiques

Désactiver le provisionnement automatique des nœuds pour le cluster

Console

gcloud

Étapes suivantes

Configurer la création automatique de pools de nœuds