À propos de la création automatique de pools de nœuds

Google Kubernetes Engine (GKE) peut créer et gérer automatiquement des pools de nœuds dans vos clusters en fonction de la configuration de vos charges de travail. Ce document décrit le fonctionnement de la création automatique de pools de nœuds, les paramètres de scaling et le comportement par défaut. Il fournit également des recommandations qui peuvent vous aider à améliorer la scalabilité. Ce document s'adresse aux administrateurs de clusters qui souhaitent réduire les coûts associés à la gestion manuelle de l'infrastructure dans leurs clusters en mode Standard.

Vous devez déjà connaître les concepts suivants :

En mode Autopilot, GKE crée et gère toujours les nœuds et les pools de nœuds pour vous en fonction de vos charges de travail. Vous n'avez pas besoin de configurer manuellement la création automatique de pools de nœuds pour les clusters Autopilot ni pour les charges de travail Autopilot dans les clusters standards. Pour en savoir plus, consultez la présentation de GKE Autopilot.

Qu'est-ce que la création automatique de pools de nœuds ?

Dans GKE, les pools de nœuds sont des groupes logiques de nœuds. Chaque nœud d'un pool de nœuds a la même configuration que tous les autres nœuds de ce pool. La création automatique de pools de nœuds est un mécanisme d'autoscaling de l'infrastructure qui permet à GKE de créer des pools de nœuds dans votre cluster qui répondent aux exigences de vos charges de travail. GKE gère ces pools de nœuds créés automatiquement, en effectuant des tâches telles que la mise à jour des métadonnées des nœuds, la création et la suppression de nœuds dans le pool de nœuds, et la suppression de l'ensemble du pool de nœuds lorsqu'il n'est plus nécessaire. La création automatique de pools de nœuds est une extension de l'autoscaler de cluster GKE, qui met automatiquement à l'échelle les nœuds dans des pools de nœuds individuels.

La création automatique de pools de nœuds est conçue pour permettre à GKE de réduire et de supprimer automatiquement les pools de nœuds vides de votre cluster. Vous ne pouvez pas définir un nombre minimal de nœuds que chaque pool de nœuds créé automatiquement doit comporter, car un nombre minimal supérieur à zéro empêcherait la suppression des pools de nœuds vides. Si votre cas d'utilisation nécessite qu'un nombre minimal de nœuds s'exécute toujours dans votre cluster, créez manuellement un pool de nœuds avec l'autoscaling activé.

Fonctionnement

La création automatique de pools de nœuds étend l'autoscaler de cluster GKE pour permettre à GKE de provisionner de nouveaux pools de nœuds qui répondent aux exigences matérielles et aux demandes de ressources des pods en attente. Vous pouvez définir vos exigences matérielles de différentes manières :

  • Utilisez ComputeClasses, que vous sélectionnez ensuite dans différents pods à l'aide d'un sélecteur de nœud. Nous vous recommandons cette méthode, car elle vous permet de définir de manière centralisée des configurations de nœuds communes que plusieurs charges de travail peuvent utiliser.
  • Utilisez des sélecteurs de nœuds ou l'affinité de nœuds pour demander des libellés de nœuds GKE spécifiques dans les spécifications de pods.

GKE configure les nouveaux pools de nœuds en fonction de paramètres tels que les suivants :

  • Demandes de ressources de processeur, de mémoire et de stockage éphémère dans vos pods et conteneurs, y compris les pods gérés par des DaemonSets.
  • Requêtes GPU et TPU dans les spécifications de pod ou dans les ComputeClasses.
  • Exigences matérielles, telles que les types de machines ou de disque de démarrage, dans les spécifications des pods en attente ou dans les ComputeClasses.
  • Tolérances dans les spécifications des pods en attente qui comportent des sélecteurs de nœuds correspondants.

GKE configure la capacité de ressources de chaque nœud d'un pool de nœuds créé automatiquement pour qu'elle soit supérieure ou égale aux demandes de ressources de vos pods en attente. Vous devez vous assurer que vos demandes de ressources sont suffisamment volumineuses pour que le pod fonctionne comme prévu. Si les demandes de vos pods sont trop faibles, les pods ne s'exécuteront pas comme prévu une fois que GKE les aura planifiés sur des nœuds créés automatiquement.

Configuration des métadonnées de nœud

GKE configure également les métadonnées des nœuds (comme les libellés, les annotations et les rejets de nœuds) en fonction des exigences de votre charge de travail, comme dans les exemples suivants :

  • Si vous demandez la série de machines N2, GKE ajoute l'étiquette de nœud cloud.google.com/machine-family: n2 à chacun des nœuds.
  • Si vous sélectionnez une ComputeClass dans votre pod, GKE ajoute un libellé de nœud avec la clé cloud.google.com/compute-class définie sur le nom de cette ComputeClass.
  • Si votre pod comporte à la fois une tolérance et un sélecteur de nœuds pour le même libellé de nœud, GKE ajoute des rejets de nœuds pour ces tolérances aux nœuds créés automatiquement.

Suppression des pools de nœuds créés automatiquement

La création automatique de pools de nœuds permet à l'autoscaler de cluster de créer des pools de nœuds et des nœuds pour exécuter les pods en attente entrants. Si le nombre de pods dans un pool de nœuds créé automatiquement diminue, l'autoscaler de cluster réduit progressivement la taille du pool de nœuds. Lorsque cela est possible, GKE draine les nœuds sous-utilisés du pool de nœuds, consolide les pods sur d'autres nœuds et supprime les nœuds vides.

Si le nombre de nœuds dans un pool de nœuds créé automatiquement est nul, GKE supprime ce pool de nœuds. GKE ne supprime pas les pools de nœuds que vous excluez de la création automatique de pools de nœuds, comme les pools de nœuds créés manuellement. Pour en savoir plus sur la façon dont l'autoscaler de cluster réduit la taille des pools de nœuds, consultez Fonctionnement de l'autoscaler de cluster.

Préférences de scaling GKE

Les préférences suivantes s'appliquent lorsque GKE autoscale votre infrastructure :

  • Réduisez le gaspillage de ressources de calcul : GKE utilise la capacité de ressources des pools de nœuds existants créés automatiquement dans votre cluster pour déterminer le type de machine à utiliser pour les nouveaux pools de nœuds. À mesure que la taille de votre cluster augmente, GKE préfère utiliser des types de machines plus volumineux pour les nouveaux pools de nœuds, afin que davantage de vos pods puissent s'exécuter sur chaque nœud du pool de nœuds.
  • Optimiser la scalabilité et la latence : GKE donne toujours la priorité à l'augmentation de la taille des pools de nœuds compatibles existants plutôt qu'à la création de nouveaux pools de nœuds. La force de cette préférence augmente à mesure que le nombre de pools de nœuds distincts dans votre cluster augmente. Lorsque le nombre de pools de nœuds distincts approche les limites acceptées pour une latence et une évolutivité optimales, GKE donne la priorité à la création de pools de nœuds.

Ces priorités permettent de s'assurer que vos clusters utilisent efficacement les ressources de calcul à grande échelle, comme dans les exemples de scénarios suivants :

  • Dans les clusters qui comportent un petit nombre de pools de nœuds et qui utilisent moins de ressources, GKE crée plus souvent des pools de nœuds et utilise des types de machines plus petits pour ces pools de nœuds.
  • Dans les clusters comportant un grand nombre de pools de nœuds, l'utilisation des ressources est élevée. GKE crée des pools de nœuds moins souvent et utilise des types de machines plus volumineux pour ces pools de nœuds. Cela permet de continuer à planifier les pods, tout en ralentissant la progression vers les limites de scalabilité et de latence du cluster.

Vous pouvez contrôler manuellement la taille minimale des instances que GKE utilise pour vos pools de nœuds créés automatiquement à l'aide d'une ComputeClass comportant le champ priorities.machineFamily et le champ priorities.minCores ou priorities.minMemoryGb.

Méthodes d'activation de la création automatique de pools de nœuds

GKE peut créer automatiquement des pools de nœuds pour des ComputeClasses spécifiques ou pour toute charge de travail utilisant une configuration compatible, selon la façon dont vous configurez votre cluster.

Méthodes d'activation
Au niveau de la charge de travail (recommandé)

Dans GKE version 1.33.3-gke.1136000 et versions ultérieures, utilisez ComputeClasses pour activer la création automatique de pools de nœuds sans utiliser le provisionnement automatique des nœuds au niveau du cluster. GKE ne crée des pools de nœuds que pour les charges de travail qui sélectionnent des ComputeClasses spécifiques pour lesquelles la création automatique est activée. Les charges de travail existantes dans le cluster ne sont pas affectées.

Même dans les versions de GKE antérieures à la version 1.33.3-gke.1136000, les ComputeClasses sont la méthode recommandée pour demander et configurer l'infrastructure de vos charges de travail. Les ComputeClasses offrent des fonctionnalités uniques et vous permettent d'optimiser l'évolutivité de votre cluster de manière flexible. Pour en savoir plus, consultez À propos des ComputeClasses personnalisées.
Au niveau du cluster

Activez le provisionnement automatique des nœuds pour l'ensemble du cluster. Vous devez définir des limites pour les ressources telles que le processeur et la mémoire de votre cluster. Ces limites s'appliquent à l'ensemble du cluster. La configuration au niveau du cluster est requise pour activer la création automatique de pools de nœuds dans les versions de GKE antérieures à 1.33.3-gke.1136000.

GKE peut créer des pools de nœuds pour toute charge de travail en attente dans le cluster à l'aide de ComputeClasses ou de sélecteurs dans les spécifications de pod.

Ces méthodes de configuration ne s'excluent pas mutuellement. Vous pouvez utiliser ComputeClasses pour créer automatiquement des pools de nœuds dans les clusters qui utilisent le provisionnement automatique des nœuds. Si vous utilisez ces deux méthodes pour activer la création automatique de pools de nœuds dans un cluster, GKE utilise l'ordre de préférence suivant pour trouver la valeur d'un paramètre de configuration à utiliser pour un pool de nœuds :

  1. ComputeClass ou spécification de pod : si vous spécifiez un paramètre (tel qu'un type de machine) dans une ComputeClass ou dans une spécification de pod, GKE utilise ce paramètre.
  2. Valeur par défaut du provisionnement automatique des nœuds au niveau du cluster : si un paramètre n'est pas spécifié dans une ComputeClass ou une spécification de pod, GKE vérifie si vous avez défini une valeur par défaut pour le provisionnement automatique des nœuds dans le cluster. Si une valeur par défaut au niveau du cluster existe, GKE l'utilise.
  3. Valeur par défaut au niveau du cluster : si un paramètre n'est pas spécifié dans ComputeClasses, dans les spécifications de pod ou en tant que valeur par défaut pour le provisionnement automatique des nœuds au niveau du cluster, GKE utilise la valeur par défaut définie par Google Cloud pour le cluster.

Prenons l'exemple d'un scénario dans lequel GKE tente de trouver un type de machine à utiliser pour un pool de nœuds créé automatiquement. L'ordre de préférence précédent s'applique comme suit :

  1. GKE vérifie si la spécification de pod ou la ComputeClass du pod spécifient un type de machine.
  2. Si la spécification de pod ou la ComputeClass ne spécifient pas de type de machine, GKE vérifie si vous avez défini un type de machine par défaut pour le provisionnement automatique des nœuds dans le cluster.
  3. Si vous n'avez pas défini de type de machine par défaut pour le provisionnement automatique des nœuds, GKE utilise le type de machine par défaut du cluster.

Dans la plupart des cas, nous vous recommandons d'utiliser uniquement la méthode d'activation ComputeClass. Les sections suivantes fournissent des informations sur chacune de ces méthodes de configuration, y compris les limites et les points à prendre en compte.

Activation au niveau de la charge de travail avec ComputeClasses

Vous pouvez activer la création automatique de pools de nœuds pour n'importe quelle ComputeClass de votre cluster en utilisant l'un des champs suivants dans la spécification ComputeClass :

  • nodePoolAutoCreation : permet à GKE de créer automatiquement des pools de nœuds selon les besoins. Vous pouvez toujours interagir avec les pools de nœuds. GKE n'implémente que les paramètres ou les contraintes que vous configurez.
  • autopilot : exécutez les charges de travail qui sélectionnent cette ComputeClass en mode Autopilot. Comme pour un cluster Autopilot, GKE gère entièrement les nœuds pour vous et implémente divers paramètres et contraintes Autopilot. Si vous utilisez le champ autopilot, vous pouvez ignorer ce document. Pour en savoir plus, consultez À propos des charges de travail en mode Autopilot dans les clusters Standard.

Dans les clusters qui répondent aux exigences suivantes, vous pouvez utiliser ces champs dans une ComputeClass sans activer le provisionnement automatique des nœuds au niveau du cluster :

  • Utilisez GKE version 1.33.3-gke.1136000 ou ultérieure.
  • être enregistré dans le version disponible "Version précoce".

Si vous configurez la création automatique de pools de nœuds dans une ComputeClass sans activer le provisionnement automatique des nœuds pour le cluster, GKE ne crée de nouveaux pools de nœuds que pour les charges de travail qui utilisent la ComputeClass. Les autres charges de travail ne sont pas affectées.

L'exemple de fichier manifeste ComputeClass suivant permet la création automatique de pools de nœuds pour tout pod utilisant la ComputeClass :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: example-computeclass
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: c4
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Activation au niveau du cluster avec provisionnement automatique des nœuds

Pour activer la création automatique de pools de nœuds pour l'ensemble du cluster, vous devez activer la fonctionnalité Provisionnement automatique de nœuds pour le cluster à l'aide de l'API Google Kubernetes Engine. Le provisionnement automatique des nœuds permet à GKE de créer des pools de nœuds en fonction des besoins de n'importe quelle charge de travail du cluster, en fonction des spécifications des pods ou des configurations ComputeClass. GKE ne gère aucun pool de nœuds existant dans le cluster, mais vous pouvez marquer des pools de nœuds individuels comme étant provisionnés automatiquement après avoir activé le provisionnement automatique des nœuds pour le cluster.

Activez le provisionnement automatique des nœuds dans les situations suivantes :

  • Vous souhaitez que GKE crée automatiquement des pools de nœuds dans un cluster exécutant une version de GKE antérieure à 1.33.3-gke.1136000.

  • Vous souhaitez définir manuellement des limites de ressources à l'échelle du cluster. Dans les versions de GKE antérieures à 1.33.3-gke.1136000, vous devez définir des limites de ressources à l'échelle du cluster, même si vous utilisez des ComputeClasses.

  • Vous souhaitez utiliser des fonctionnalités ou des configurations spécifiques qui ne sont pas compatibles avec les classes de calcul.

  • Vous souhaitez définir des valeurs de configuration de nœud par défaut pour l'ensemble du cluster.

Une fois le provisionnement automatique des nœuds activé, vous pouvez configurer des valeurs par défaut pour différents paramètres de nœud à l'aide de Google Cloud CLI ou d'un fichier de configuration YAML.

Limites de ressources au niveau du cluster avec le provisionnement automatique des nœuds

Lorsque vous activez le provisionnement automatique des nœuds pour un cluster entier, vous devez également configurer des limites pour les ressources telles que les processeurs, la mémoire, les GPU et les TPU dans le cluster. Ces limites s'appliquent à la somme de la capacité de toutes les ressources du cluster, y compris les pools de nœuds et les ComputeClasses créés manuellement. GKE ne crée pas de nœuds ni de pools de nœuds si l'opération dépasse l'une de ces limites de ressources.

Ces limites de ressources au niveau du cluster ne sont requises que si vous activez le provisionnement automatique des nœuds dans le cluster. Dans les clusters qui répondent aux exigences suivantes, vous pouvez utiliser la création automatique de pools de nœuds dans ComputeClasses sans activer le provisionnement automatique des nœuds :

  • Utilisez GKE version 1.33.3-gke.1136000 ou ultérieure.
  • être enregistré dans le version disponible "Version précoce".

Si votre cluster répond à ces exigences, nous vous recommandons d'utiliser uniquement ComputeClasses pour configurer les pools de nœuds créés automatiquement.

Paramètres par défaut pour les pools de nœuds créés automatiquement

Vous pouvez spécifier des valeurs par défaut que GKE applique aux pools de nœuds créés automatiquement au niveau de la charge de travail ou du cluster.

  • Paramètres par défaut au niveau de la charge de travail : vous pouvez utiliser les champs spec.nodePoolConfig et spec.priorityDefaults dans la spécification ComputeClass pour définir des valeurs par défaut pour des paramètres de nœud spécifiques. Ces valeurs par défaut ne s'appliquent qu'aux pools de nœuds créés par GKE pour cette ComputeClass.
  • Paramètres par défaut au niveau du cluster : vous pouvez définir des valeurs par défaut pour les pools de nœuds créés automatiquement lorsque vous configurez le provisionnement automatique des nœuds. Pour spécifier des valeurs par défaut, vous devez utiliser la gcloud CLI ou un fichier de configuration YAML.

Ces méthodes de définition des valeurs par défaut ne s'excluent pas mutuellement. Si vous configurez des valeurs par défaut pour un paramètre spécifique dans une ComputeClass et pour l'ensemble du cluster, GKE utilise la valeur de la ComputeClass. Si la classe de calcul ne spécifie pas de valeur pour ce paramètre, GKE utilise la valeur par défaut au niveau du cluster.

Paramètres par défaut au niveau du cluster avec un fichier de configuration

Lorsque vous activez le provisionnement automatique des nœuds, vous pouvez utiliser un fichier de configuration YAML pour spécifier les paramètres par défaut à l'échelle du cluster pour les pools de nœuds créés automatiquement. Vous pouvez spécifier plusieurs paramètres dans un même fichier de configuration. Certaines configurations avancées (comme les paramètres de réparation automatique) ne peuvent être spécifiées qu'à l'aide d'un fichier de configuration.

  • L'exemple de fichier de configuration suivant active la réparation et la mise à niveau automatiques des nœuds pour tous les nouveaux pools de nœuds créés automatiquement :

    management:
  autoRepair: true
  autoUpgrade: true

  • L'exemple de fichier de configuration suivant définit les limites de ressources à l'échelle du cluster pour le provisionnement automatique des nœuds et configure plusieurs paramètres par défaut :

    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

    Ce fichier de configuration définit les valeurs par défaut suivantes :

Une fois le fichier de configuration appliqué au cluster, GKE utilise les paramètres du fichier uniquement pour les nouveaux pools de nœuds créés automatiquement dans le cluster. Les paramètres nouveaux ou modifiés que vous spécifiez dans le fichier ne s'appliquent pas aux pools de nœuds existants que GKE a créés dans le cluster. Si vous modifiez une valeur précédemment définie pour le cluster, GKE utilise la nouvelle valeur pour tous les nouveaux pools de nœuds. Par exemple, si vous avez précédemment défini la série de machines par défaut sur N2 et que vous mettez à jour la valeur sur N4 dans votre fichier de configuration, tous les nouveaux pools de nœuds utiliseront des types de machines N4.

Pour en savoir plus sur l'utilisation du fichier de configuration au niveau du cluster, consultez Configurer des paramètres avec un fichier de configuration de provisionnement automatique des nœuds.

Cas d'utilisation de la création automatique de pools de nœuds

Les sections suivantes décrivent certains cas d'utilisation courants et le matériel compatible pour la création automatique de pools de nœuds. 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élection de la série ou du type de machine

Vous pouvez sélectionner une série ou un type de machine Compute Engine que GKE utilisera pour les pools de nœuds créés automatiquement de l'une des manières suivantes :

  • ComputeClasses : utilisez les règles de priorité machineFamily ou machineType.
  • Spécifications du pod : pour une série de machines, utilisez un sélecteur de nœuds pour le libellé de nœud cloud.google.com/machine-family. Pour un type de machine, utilisez les libellés de nœud cloud.google.com/machine-family et node.kubernetes.io/instance-type. Pour en savoir plus, consultez Sélectionner une série ou un type de machine.

Si vous ne sélectionnez pas explicitement de machine, GKE utilise la série de machines E2 ou un type de machine compatible avec le matériel demandé par votre charge de travail. Par exemple, GKE utilise des types de machines GPU pour les GPU et des machines spécialisées pour les ressources TPU.

Lorsque vous demandez une série ou un type de machine, assurez-vous que les autres sélecteurs de nœuds et les demandes de ressources de votre pod sont compatibles avec la machine spécifiée. Par exemple, vous ne pouvez pas demander un GPU et la série de machines N2 en même temps.

Série de machines compatible

Vous pouvez demander explicitement n'importe quelle série ou n'importe quel type de machine Compute Engine compatible dans une ComputeClass ou une charge de travail. La création automatique de pools de nœuds n'est compatible qu'avec les séries de machines suivantes dans des versions spécifiques de GKE :

  • Série de machines Z3 : 1.29 et versions ultérieures.
  • Série de machines C4 :
    • 1.28.15-gke.1159000 et versions ultérieures.
    • 1.29.10-gke.1227000 et versions ultérieures.
    • 1.30.3-gke.1225000 et versions ultérieures.
  • Série de machines C4A :
    • 1.28.15-gke.1344000 et versions ultérieures.
    • 1.29.11-gke.1012000 et versions ultérieures
    • 1.30.7-gke.1136000 et versions ultérieures
    • 1.31.3-gke.1056000 et versions ultérieures.
  • Série de machines C4D : 1.32.3-gke.1717000 et versions ultérieures.
  • Série de machines N4 : version 1.29.3 et ultérieure.

Les autres familles de machines sont compatibles avec toutes les versions de GKE.

Sélection du GPU

Vous pouvez demander des GPU pour les pools de nœuds créés automatiquement de l'une des manières suivantes :

  • ComputeClasses :
    1. Utilisez la règle de priorité gpu pour configurer les GPU.
    2. Demandez des ressources de GPU dans les pods.
  • Spécifications du pod :
    1. Configurez des limites de GPU à l'échelle du cluster pour le provisionnement automatique des nœuds.
    2. Utilisez des sélecteurs de nœuds pour configurer les GPU.
    3. Demandez des ressources de GPU dans les pods.

GKE sélectionne un type de machine GPU suffisamment grand pour prendre en charge le nombre de GPU. Le nombre de GPU que vous sélectionnez affecte la capacité de processeur et de mémoire des nœuds.

Sélection de Cloud TPU

Vous pouvez demander des ressources Cloud TPU pour les pools de nœuds créés automatiquement de l'une des manières suivantes :

Les pools de nœuds de tranche TPU à hôte unique et les pools de nœuds de tranche TPU multi-hôtes sont tous deux compatibles avec l'autoscaling et la création automatique de pools de nœuds. Pour la création automatique de pools de nœuds, GKE crée des pools de nœuds de tranche TPU à hôte unique ou multi-hôte avec une version et une topologie de TPU qui répondent aux exigences des charges de travail en attente.

Exigences de version GKE pour Cloud TPU

La création automatique de pools de nœuds n'est compatible qu'avec les Cloud TPU suivants dans des versions spécifiques de GKE :

  • Cloud TPU v5p :
    • 1.28.7-gke.1020000 et versions ultérieures.
    • 1.29.2-gke.1035000 et versions ultérieures.
  • TPU Trillium : 1.31.1-gke.1146000 et versions ultérieures.

Les autres types de Cloud TPU sont compatibles avec toutes les versions de GKE.

Autoscaling des pools de nœuds Cloud TPU

GKE met à l'échelle les pools de nœuds Cloud TPU créés automatiquement ou manuellement qui utilisent l'autoscaler de cluster de l'une des manières suivantes :

  • Pool de nœuds de tranche TPU à hôte unique : GKE ajoute ou supprime des nœuds TPU dans le pool de nœuds existant. Le pool de nœuds peut contenir un nombre de nœuds TPU compris entre zéro et la taille maximale du pool de nœuds, tel que déterminé par les indicateurs d'autoscaling --max-nodes et --total-max-nodes. Tous les nœuds TPU du pool de nœuds ont le même type de machine et la même topologie. Pour en savoir plus sur la création d'un pool de nœuds de tranche TPU à hôte unique, consultez Créer un pool de nœuds.
  • Pool de nœuds de tranche TPU multi-hôte : GKE effectue un scaling du pool de nœuds de façon atomique, de zéro jusqu'au nombre de nœuds requis pour satisfaire la topologie TPU. Par exemple, pour un pool de nœuds TPU avec le type de machine ct5lp-hightpu-4t et une topologie 16x16, le pool de nœuds comporte toujours 64 nœuds ou aucun nœud. GKE réduit la capacité du pool de nœuds s'il ne contient aucune charge de travail TPU. Pour réduire la taille du pool de nœuds, GKE évince tous les pods planifiés et supprime tous les nœuds du pool de nœuds. Pour savoir comment créer un pool de nœuds de tranche TPU multi-hôte, consultez Créer un pool de nœuds.

Configuration du pool de nœuds Cloud TPU

GKE utilise la configuration de votre Pod ou ComputeClass pour déterminer la configuration de vos nœuds TPU. Le fichier manifeste suivant est un exemple de spécification de déploiement qui demande des TPU dans la spécification de pod. Si le paramètre de provisionnement automatique des nœuds au niveau du cluster est activé, ce déploiement déclenche la création automatique du pool de nœuds. Lorsque vous créez cet exemple de déploiement, GKE crée un pool de nœuds contenant une tranche de TPU v4 avec une topologie 2x2x2 et deux machines ct4p-hightpu-4t.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-tpu
  template:
    metadata:
      labels:
        app: nginx-tpu
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
        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 ce fichier manifeste, les champs suivants définissent la configuration du TPU :

  • cloud.google.com/gke-tpu-accelerator : version et type de TPU. Par exemple, vous pouvez utiliser l'une des options suivantes :
    • TPU v4 avec tpu-v4-podslice
    • TPU v5e avec tpu-v5-lite-podslice.
    • TPU v5p avec tpu-v5p-slice.
    • TPU Trillium (v6e) avec tpu-v6e-slice.
  • cloud.google.com/gke-tpu-topology : nombre et disposition physique des puces TPU au sein d'une tranche de TPU. Pour en savoir plus, consultez Choisir une topologie.
  • limits.google.com/tpu : nombre de puces TPU sur la VM TPU. La plupart des configurations n'ont qu'une seule valeur correcte. Pour en savoir plus, consultez Fonctionnement des TPU dans GKE.
  • cloud.google.com/reservation-name : nom de la réservation de capacité à utiliser pour obtenir des ressources TPU. Si cette option est omise, la charge de travail n'utilise aucune réservation.

La configuration du pool de nœuds créé automatiquement dépend du type et de la topologie de TPU, ainsi que du nombre de puces TPU que vous sélectionnez. Pour prédire le type, la taille et la configuration de votre pool de nœuds, procédez comme suit :

  1. Dans Choisir une topologie, filtrez le tableau sur Standard pour le type de TPU que vous avez spécifié, tel que TPU Trillium ou TPU v5e.
  2. Utilisez les valeurs que vous avez spécifiées pour identifier la configuration du pool de nœuds, comme suit :
    1. gke-tpu-topology : recherchez la ligne du tableau qui a la même valeur pour Topology.
    2. limits : dans le tableau, divisez la valeur de Nombre de puces TPU par la valeur de Nombre de VM. Recherchez dans le tableau la ligne dont la valeur résultante est identique à celle que vous avez spécifiée.

Par exemple, imaginons que vous ayez demandé tpu-v6e-slice (TPU Trillium) avec une topologie 2x4. Dans ce scénario, vous filtrez le tableau de la section Choisir une topologie pour TPU Trillium. Ensuite, identifiez la ligne qui correspond à la configuration que vous avez spécifiée, comme suit :

  • gke-tpu-topology : le TPU Trillium présente les configurations suivantes pour une topologie 2x4 :
    • Pool de nœuds de tranche de TPU à hôte unique comportant huit puces TPU dans une instance ct6e-standard-8t.
    • Pool de nœuds de tranche de TPU multi-hôte comportant huit puces TPU réparties sur deux instances ct6e-standard-4t.
  • limits : comme TPU Trillium propose plusieurs options pour la topologie 2x4, la valeur que vous spécifiez dans le champ limits dépend du type de pool de nœuds que vous souhaitez, comme suit :
    • Pool de nœuds de tranche TPU à hôte unique : spécifiez limits.google.com/tpu: 8 pour obtenir un pool de nœuds comportant huit puces TPU et une VM. Les huit puces sont associées à cette VM.
    • Pool de nœuds de tranche TPU multi-hôte : spécifiez limits.google.com/tpu: 4 pour obtenir un pool de nœuds comportant huit puces TPU et deux VM. Chaque VM possède quatre puces.

Sélection de VM Spot

Vous pouvez sélectionner Spot VM pour les pools de nœuds créés automatiquement de l'une des manières suivantes :

  • ComputeClasses : utilisez le champ spot dans une règle de priorité.
  • Spécifications du pod : utilisez une tolérance pour le libellé de nœud cloud.google.com/gke-spot="true" avec l'effet NoSchedule. Ajoutez un sélecteur de nœuds pour les libellés de nœuds cloud.google.com/gke-spot=true ou cloud.google.com/gke-provisioning=spot. Vous pouvez également sélectionner des VM préemptives à l'aide du libellé de nœud cloud.google.com/gke-preemptible dans votre tolérance et votre sélecteur de nœuds. Toutefois, nous vous recommandons vivement d'utiliser des Spot VM.

Configuration du stockage éphémère

GKE utilise une partie du disque de démarrage des nœuds pour le stockage éphémère des pods. Vous pouvez personnaliser la taille du disque de démarrage que GKE utilise pour les nœuds créés automatiquement de l'une des manières suivantes :

  • ComputeClasses : utilisez les champs storage.bootDiskSize et storage.bootDiskType dans une règle de priorité. Vous pouvez configurer différents paramètres de disque de démarrage pour différentes ComputeClasses.
  • Spécifications des pods : utilisez les champs diskSizeGb et diskType dans le fichier de configuration au niveau du cluster. Cette méthode ne vous permet pas de contrôler la taille et le type du disque de démarrage pour les pods individuels.

Pour en savoir plus, consultez Disques de démarrage personnalisés. Si vous ne modifiez pas explicitement les paramètres du disque de démarrage, la valeur par défaut est un volume pd-balanced d'une capacité de 100 Gio.

GKE ne crée un pool de nœuds que si le stockage éphémère pouvant être alloué d'un nœud avec un disque de démarrage spécifié est supérieur ou égal à la demande de stockage éphémère d'un pod en attente. Si la demande de stockage éphémère est supérieure au stockage éphémère allouable d'un nœud, GKE ne crée pas de pool de nœuds et le pod reste à l'état "En attente". GKE n'ajuste pas de manière dynamique la taille des disque de démarrage en fonction de vos demandes de stockage éphémère de pods.

Séparation de la charge de travail

Vous pouvez demander que des pods spécifiques s'exécutent toujours sur des nœuds distincts des autres pods du cluster. GKE utilise des rejets de nœuds pour empêcher d'autres charges de travail de s'exécuter sur ces nœuds. Vous pouvez configurer la séparation des charges de travail dans les pools de nœuds créés automatiquement de plusieurs manières :

  • ComputeClasses : les nœuds que GKE crée pour une ComputeClass spécifique ne peuvent exécuter que les pods qui sélectionnent cette ComputeClass. Vous n'avez pas besoin de modifier les spécifications de vos pods. Vous pouvez séparer les pods d'une ComputeClass à l'aide de l'affinité et de l'anti-affinité inter-pods.
  • Spécifications de pod : si vous activez le provisionnement automatique des nœuds pour le cluster, vous pouvez configurer la séparation des charges de travail à l'aide des champs de la spécification de pod. Lors de la création automatique de pools de nœuds, GKE peut créer des pools de nœuds avec des libellés et des rejets si toutes les conditions suivantes sont réunies :
    • Le pod utilise un sélecteur de nœuds pour demander une clé et une valeur de libellé de nœud personnalisées. Vous ne pouvez pas utiliser les libellés de nœud système pour la séparation des charges de travail.
    • Le pod a une tolérance pour la même clé de libellé de nœud.
    • L'effet de tolérance est NoSchedule, NoExecute ou n'est pas spécifié.

Pour en savoir plus sur la configuration de ces champs et sur les limites, consultez Configurer la séparation des charges de travail dans GKE.

Limites

  • 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.

Configurations non compatibles

GKE ne crée pas de pools de nœuds utilisant les configurations suivantes :

L'autoscaler de cluster peut mettre à l'échelle les nœuds des pools de nœuds existants qui utilisent ces configurations.

Étapes suivantes