À 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, et fournit des recommandations pour vous aider à améliorer l'évolutivité. Ce document est destiné aux administrateurs de cluster 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 ou 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 possède 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'intégralité 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 effectue un scaling automatique des 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 automatiquement la capacité de votre cluster et d'en supprimer les pools de nœuds vides. Vous ne pouvez pas définir un nombre minimal de nœuds pour chaque pool de nœuds créé automatiquement, 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 requêtes de ressources des pods en attente. Vous pouvez définir vos exigences matérielles de différentes manières :

  • Utilisez des 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 vous pouvez 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 étiquettes de nœuds GKE spécifiques dans les spécifications de pod.

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 ont 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 vos requêtes de pod 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 une étiquette de nœud avec la clé cloud.google.com/compute-class définie sur le nom de cette ComputeClass.

  • Si votre pod dispose à la fois d'une tolérance et d'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 de 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 entrants en attente. Si le nombre de pods d'un pool de nœuds créé automatiquement diminue, l'autoscaler de cluster réduit progressivement le pool de nœuds. Dans la mesure du 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 égal à zéro, 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, tels que les pools de nœuds créés manuellement. Pour en savoir plus sur la façon dont l'autoscaler de cluster effectue un scaling à la baisse 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 effectue un autoscaling de votre infrastructure :

  • Réduire le gaspillage des ressources de calcul : GKE utilise la capacité des 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 grands pour les nouveaux pools de nœuds, afin qu'un plus grand nombre de vos pods puissent s'exécuter sur chaque nœud du pool de nœuds.
  • Optimiser l'évolutivité et la latence : GKE donne toujours la priorité au scaling à la hausse des pools de nœuds compatibles existants plutôt qu'à la création de pools de nœuds. L'importance 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 des limites acceptées pour une latence et une évolutivité optimales, GKE donne moins de 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 ont un petit nombre de pools de nœuds et une utilisation des ressources plus faible, GKE crée de nouveaux pools de nœuds plus fréquemment 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 fréquemment et utilise des types de machines plus grands pour ces pools de nœuds, de sorte que la planification des pods puisse se poursuivre tout en ralentissant la progression vers les limites d'évolutivité 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 le champ 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, en fonction de la façon dont vous configurez votre cluster.

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

Dans GKE 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 de manière flexible le scaling dans votre cluster. 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 dans 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 à la version 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 des 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. Spécification ComputeClass ou 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 spécification ComputeClass ou 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 les ComputeClasses, les spécifications de pod ou comme valeur par défaut pour le provisionnement automatique des nœuds au niveau du cluster, GKE utilise la valeur par défaut que Google Cloud définit pour le cluster.

Par exemple, imaginez 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 du pod ou la ComputeClass du pod spécifie 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 détails 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 si nécessaire. 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 diverses contraintes et paramètres 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 utilisent GKE version 1.33.3-gke.1136000 et ultérieure, vous pouvez utiliser ces champs dans une ComputeClass sans activer le provisionnement automatique des nœuds au niveau du cluster.

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 des 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 active la création automatique de pools de nœuds pour tout pod qui utilise 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 le 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é de provisionnement automatique des nœuds pour le cluster à l'aide de l'API Kubernetes Engine. Le provisionnement automatique des nœuds permet à GKE de créer des pools de nœuds selon les 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 pas les pools de nœuds existants 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 qui exécute une version de GKE antérieure à la version 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 à la version 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 ComputeClasses.

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

Après avoir activé le provisionnement automatique des nœuds, vous pouvez configurer des valeurs par défaut pour différents paramètres de nœud à l'aide de la 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 le processeur, la mémoire, les GPU et les TPU dans le cluster. Ces limites s'appliquent à la somme de toutes les capacités de 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 utilisent GKE version 1.33.3-gke.1136000 et ultérieure, vous pouvez utiliser la création automatique de pools de nœuds dans ComputeClasses sans activer le provisionnement automatique des nœuds.

Si votre cluster répond à ces exigences, nous vous recommandons d'utiliser uniquement des 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 utilisez 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 ComputeClass 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 sur 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 que vous avez appliqué le fichier de configuration au cluster, GKE n'utilise les paramètres du fichier que 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 créés par GKE dans le cluster. Si vous mettez à jour 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 remplacez cette valeur par 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 les 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 avec la création automatique de pools de nœuds. Pour en savoir plus sur les autres cas d'utilisation 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 de pod : pour une série de machines, utilisez un sélecteur de nœuds pour l'étiquette de nœud cloud.google.com/machine-family. Pour un type de machine, utilisez les étiquettes de nœud cloud.google.com/machine-family et node.kubernetes.io/instance-type. Pour en savoir plus, consultez Sélectionner une série de machines 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 de machines ou un type de machine, assurez-vous que les autres sélecteurs de nœuds et vos requêtes de ressources de 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éries de machines compatibles

Vous pouvez demander explicitement n'importe quelle série de machines ou type de machine Compute Engine compatible dans une ComputeClass ou une charge de travail. Vos requêtes peuvent inclure des configurations matérielles spécifiques, telles que l'architecture Arm.

La création automatique de pools de nœuds n'est compatible avec les séries de machines suivantes que dans certaines versions de GKE :

Série de machines Versions de GKE compatibles
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 (VM)
  • 1.30.7-gke.1136000 et versions ultérieures
  • 1.31.3-gke.1056000 et versions ultérieures
Instances Bare Metal C4A
  • c4a-highmem-96-metal : 1.35.3-gke.1389000 et versions ultérieures
  • c4a-standard-96-metal : non compatible
Série de machines C4D (VM) 1.32.3-gke.1717000 et versions ultérieures
Instances Bare Metal C4D 1.37.0-gke.4713000 et versions ultérieures
Série de machines C4N 1.36.0-gke.3009002 et versions ultérieures
Série de machines N4 1.29.3 et versions ultérieures
Série de machines N4A 1.34.1-gke.3403001 et versions ultérieures
Série de machines N4D
  • 1.33.12-gke.1208000 et versions ultérieures
  • 1.34.1-gke.2037000 et versions ultérieures
Série de machines Z3 1.29 et versions ultérieures
Série de machines Z4D 1.36.3-gke.1244000 et versions ultérieures
Série de machines Z4M 1.37.0-gke.4713000 et versions ultérieures

Les autres séries 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 GPU dans les pods.
  • Spécifications des pods :
    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 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é du processeur et de la mémoire des nœuds.

Exigences de version de GKE pour les GPU

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 avec les Cloud TPU suivants que dans certaines versions de GKE :

  • TPU v3 : 1.31.0 et versions ultérieures.
  • TPU v5 et TPU v4 : 1.29.0 et versions ultérieures.
  • TPU Trillium : 1.32.0 et versions ultérieures.
  • Ironwood (TPU7x) : 1.34.1-gke.2541000 ou version ultérieure.

Les autres types de Cloud TPU sont compatibles avec toutes les versions de GKE. Pour en savoir plus sur les versions de GKE disponibles pour les TPU, consultez Valider la disponibilité des TPU dans GKE.

Autoscaling du pool de nœuds Cloud TPU

GKE effectue le scaling des 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 options 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 de tranche TPU à hôte unique.
  • 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 un type de machine ct5lp-hightpu-4t et une topologie 16x16, le pool de nœuds contient toujours 64 nœuds ou zéro nœud. GKE réduit le pool de nœuds s'il ne contient aucune charge de travail TPU. Pour effectuer un scaling à la baisse du pool de nœuds, GKE supprime tous les pods planifiés et tous les nœuds du pool de nœuds. Pour en savoir plus sur la création d'un pool de nœuds de tranche TPU multi-hôte, consultez Créer un pool de nœuds de tranche TPU multi-hôte.

Configuration du pool de nœuds Cloud TPU

GKE utilise la configuration de votre pod ou de votre ComputeClass pour déterminer la configuration de vos nœuds TPU. Le fichier manifeste suivant est un exemple de spécification du déploiement qui demande des TPU dans la spécification du 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
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        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 des TPU :

  • cloud.google.com/gke-tpu-accelerator : version et type de TPU. Par exemple, utilisez tpu7x-standard-4t pour Ironwood (TPU7x).
  • cloud.google.com/gke-tpu-topology : topologie avec le nombre et la disposition physique des puces TPU au sein d'une tranche de TPU. Par exemple, utilisez 2x2x2.
  • limits.google.com/tpu : nombre de puces TPU par VM. Par exemple, si vous utilisez tpu7x-standard-4t, le nombre de puces TPU par VM est de 4.

Sélection de VM Spot

Vous pouvez sélectionner des VM Spot 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 l'étiquette de nœud cloud.google.com/gke-spot="true" avec l'effet NoSchedule. Ajoutez un sélecteur de nœuds pour les étiquettes de nœud cloud.google.com/gke-spot=true ou cloud.google.com/gke-provisioning=spot. Vous pouvez également sélectionner des VM préemptives en utilisant l'étiquette 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 VM Spot à la place.

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 utilisé par GKE 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 des 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 pouvant être alloué 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 des demandes de stockage éphémère de vos 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 l'une des manières suivantes :

  • ComputeClasses : les nœuds créés par GKE 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 en utilisant l'affinité et 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 de 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 remplies :
    • Le pod utilise un sélecteur de nœud pour demander une clé et une valeur de libellé de nœud personnalisées. Vous ne pouvez pas utiliser d'étiquettes de nœud système pour la séparation des charges de travail.
    • Le pod dispose d'une tolérance pour la même clé d'étiquette 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 de GKE antérieures à la version 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 procéder au scaling des nœuds des pools de nœuds existants qui utilisent ces configurations.

Étapes suivantes