Il est possible qu'une partie ou l'ensemble des informations de cette page ne s'appliquent pas au Cloud de confiance S3NS. Pour en savoir plus, consultez Différences par rapport à Google Cloud.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Effectuer la maintenance de l'hôte pour les nœuds exécutant des charges de travail d'entraînement et d'inférence

Autopilot Standard

Ce document explique comment effectuer la maintenance de l'hôte des instances Compute Engine sous-jacentes pour les nœuds des clusters Google Kubernetes Engine (GKE). Vous ne devez gérer activement cette maintenance que pour certains types d'instances Compute Engine qui ne migrent pas à chaud, y compris les instances avec des GPU et des TPU. Les stratégies décrites dans ce document fonctionnent bien pour les charges de travail d'entraînement et d'inférence. Si vous n'avez besoin d'effectuer manuellement la maintenance de l'hôte que pour un nœud individuel, ou si vos charges de travail peuvent tolérer la maintenance automatique de l'hôte, consultez Comprendre comment effectuer la maintenance de l'hôte sur GKE.

Ces stratégies effectuent la maintenance de l'hôte pour des groupes de nœuds et, éventuellement, lancent des mises à niveau de clusters GKE.

Utilisez la stratégie parallèle pour les nœuds des charges de travail pour lesquelles vous pouvez avoir une seule période d'indisponibilité, par exemple pour les nœuds des charges de travail d'entraînement. Utilisez la stratégie progressive pour les nœuds des charges de travail où vous pouvez avoir des lots de temps d'arrêt tout en maintenant la disponibilité de la majorité des ressources, par exemple pour les nœuds des charges de travail d'inférence.

Utiliser une stratégie parallèle pour mettre à jour les nœuds des charges de travail d'entraînement

Cette stratégie effectue des modifications simultanément pour un groupe de nœuds qui utilisent des accélérateurs. Vous pouvez utiliser cette stratégie pour les charges de travail d'entraînement. Vous pouvez également l'utiliser pour d'autres types de charges de travail pour lesquelles la méthode la moins perturbatrice pour effectuer des modifications consiste à disposer d'une seule fenêtre d'indisponibilité complète pour tous les nœuds du groupe et les charges de travail qui s'exécutent sur ceux-ci.

La stratégie suit les étapes générales suivantes :

Arrêter les charges de travail : sélectionnez les pools de nœuds, puis arrêtez les charges de travail qui s'exécutent sur ces pools ou déplacez-les vers d'autres nœuds qui restent disponibles.
Déclencher la maintenance de l'hôte : appliquez l'étiquette de maintenance à tous les nœuds sélectionnés en même temps et attendez que le processus se termine sur tous les nœuds.
Mettre à niveau la version de GKE : modifiez la version de GKE des nœuds.
Redémarrer les charges de travail : une fois la maintenance et les mises à niveau de l'hôte terminées, redémarrez vos charges de travail.

Les instructions fournies permettent d'apporter des modifications à un seul pool de nœuds. Toutefois, vous pouvez adapter les étapes pour effectuer des modifications sur plusieurs pools de nœuds en même temps. Avant de commencer, assurez-vous de disposer d'au moins quelques heures pendant lesquelles cette charge de travail n'a pas besoin de s'exécuter sur ces nœuds.

Pour minimiser les perturbations tout en recevant les modifications critiques pour les instances Compute Engine sous-jacentes et les nœuds GKE, utilisez cette période d'indisponibilité pour effectuer à la fois la maintenance de l'hôte et les mises à niveau de la version de GKE. Toutefois, vous ne pouvez effectuer que la maintenance de l'hôte si vous ne souhaitez pas mettre à niveau la version de vos nœuds GKE.

À savoir avant de commencer

Avant de commencer, prenez connaissance des points suivants :

Évitez de redéployer les charges de travail : pour éviter les retards inutiles dus aux PodDisruptionBudgets, ne redéployez aucune charge de travail tant que vous n'avez pas terminé toutes les étapes.
Planifier les interruptions : assurez-vous que vos charges de travail peuvent être interrompues pendant un certain temps. Ces étapes prennent plusieurs heures, principalement en raison du temps requis pour la maintenance de l'hôte.

Effectuer des mises à jour pour tous les nœuds simultanément

Pour effectuer la maintenance de l'hôte et, éventuellement, mettre à niveau la version de GKE, procédez comme suit :

Préparer vos charges de travail : arrêtez vos charges de travail ou assurez-vous qu'elles ont pris un instantané ou un point de contrôle récent.
Démarrer et surveiller la maintenance de l'hôte :
- Sous-blocs de réservations qui utilisent la planification de maintenance groupée : déclenchez la maintenance sur les réservations, les blocs de réservation ou les sous-blocs de réservation à l'aide de la sous-commande gcloud compute reservations correspondante. Par exemple, la commande suivante démarre la maintenance d'un sous-bloc :
```
gcloud compute reservations sub-blocks perform-maintenance RESERVATION_NAME \
    --block-name=BLOCK_NAME \
    --sub-block-name=SUB_BLOCK_NAME \
    --zone=ZONE
```
  Remplacez les éléments suivants :
  - RESERVATION_NAME : nom de la réservation.
  - BLOCK_NAME : nom du bloc de réservation.
  - SUB_BLOCK_NAME : nom du sous-bloc de réservation.
  - ZONE : zone où se trouve la réservation.
  Compute Engine commence à drainer et à mettre à jour simultanément toutes les instances du sous-bloc. Ce processus peut prendre quelques heures.
  
  Pour surveiller, affichez l'état de la maintenance en vérifiant le champ de métadonnées upcomingGroupMaintenance dans les ressources de réservation. Pour en savoir plus, consultez Afficher l'état de maintenance.
- Instances qui utilisent la planification de maintenance indépendante : déclenchez la maintenance pour les instances à la demande ou pour les réservations qui n'utilisent pas de sous-blocs en appliquant l'étiquette cloud.google.com/perform-maintenance=true aux nœuds de votre pool de nœuds :
  
  Avertissement : Les instances configurées pour utiliser la planification de maintenance groupée (comme A4X, A4X Max, TPU v6e et TPU7x) sont étroitement couplées et doivent être gérées ensemble comme une seule unité. Vous devez utiliser la maintenance au niveau du sous-bloc.
```
kubectl label nodes -l cloud.google.com/gke-nodepool=NODE_POOL_NAME cloud.google.com/perform-maintenance=true --overwrite
```
  Compute Engine commence à drainer et à mettre à jour les instances sous-jacentes simultanément. Ce processus peut prendre quelques heures. Pour en savoir plus, consultez Processus d'arrêt progressif.
  
  Pour surveiller l'état de la maintenance, vérifiez les nœuds. GKE supprime l'étiquette de maintenance une fois la maintenance terminée, si elle a été appliquée. Une fois la maintenance terminée, vous trouverez un journal contenant le message suivant dans Cloud Logging :
```
Maintenance window has completed for this instance. All maintenance
notifications on the instance have been removed.
```
Facultatif : Mettez à niveau la version des nœuds GKE : suivez les instructions pour mettre à niveau la version GKE des nœuds.

Utiliser une stratégie progressive pour mettre à jour les nœuds des charges de travail d'inférence

Cette stratégie décrit une approche manuelle pour effectuer la maintenance des nœuds GKE exécutant des charges de travail d'inférence. Elle implique la mise à jour des nœuds par lots pour maintenir la disponibilité du service. Cette méthode est particulièrement adaptée aux charges de travail qui peuvent tolérer qu'un certain pourcentage d'instances répliquées soit temporairement hors connexion.

La stratégie suit les étapes générales suivantes :

Identifier et regrouper les nœuds : choisissez les pools de nœuds à mettre à jour. Regroupez les nœuds en lots dimensionnés en fonction de la tolérance aux pannes de votre charge de travail.
Parcourir les lots : pour chaque lot, appliquez l'étiquette de maintenance et surveillez le lot de nœuds jusqu'à ce que l'étiquette soit supprimée.
Mettre à niveau la version de GKE : une fois que tous les lots ont terminé la maintenance de l'hôte, modifiez la version des nœuds GKE.

À savoir avant de commencer

Avant de commencer, prenez connaissance des points suivants :

Comprendre votre déploiement : pour réussir, vous devez connaître en détail la répartition de votre charge de travail, l'emplacement des instances répliquées et les domaines de défaillance. Assurez-vous de maintenir une capacité de diffusion suffisante tout au long du processus.
Planifier la taille des lots : mettez à jour les nœuds par lots. La taille de chaque lot est déterminée par la tolérance aux pannes de votre charge de travail. Voici quelques facteurs à prendre en compte :
- Nombre d'instances répliquées par modèle de diffusion.
- La distribution des instances répliquées entre les nœuds et les domaines de défaillance.
- PodDisruptionBudgets peut vous aider à appliquer le nombre maximal de pods indisponibles simultanément.
- Recommandation : pour simplifier la gestion, envisagez de dédier différents pools de nœuds à différents ensembles d'instances répliquées, ce qui vous permet d'isoler les domaines de défaillance au niveau du pool de nœuds.
Calculer les contraintes de temps : tenez compte des facteurs de temps suivants :
- Chaque lot peut prendre plusieurs heures pour terminer l'étape de maintenance de l'hôte.
- Calculez la taille de lot minimale pour vous assurer que toutes les opérations de maintenance se terminent dans les délais requis :
  1. MAINTENANCE_BLOCKS = floor(HOURS_TO_MAINTENANCE / 4) (où HOURS_TO_MAINTENANCE correspond au temps total disponible).
  2. MIN_PER_BATCH = TOTAL_NODE_COUNT / MAINTENANCE_BLOCKS
- La taille de lot que vous choisissez doit être supérieure ou égale à MIN_PER_BATCH.
Examinez les types de charges de travail spécifiques : tenez compte des éléments suivants pour les types de configuration respectifs :
- Mixture of Experts (MOE) : assurez-vous que votre stratégie de traitement par lot conserve le nombre minimal d'instances répliquées requis pour chaque modèle.
- Diffusion désagrégée : assurez-vous de suivre toutes les instances répliquées impliquées dans la configuration désagrégée lors de la planification des lots.
- Pools de nœuds multi-hôtes (TPU, MNNVL) : pour ces configurations, vous allez probablement arrêter un pool de nœuds entier à la fois. Planifiez vos domaines de défaillance sur plusieurs pools de nœuds en conséquence.

Effectuer des mises à jour progressives par lots

Pour effectuer des mises à jour de maintenance d'hôte progressives, vous pouvez mettre à jour votre capacité à partir de réservations qui utilisent la planification de maintenance groupée par lots d'un ou de plusieurs sous-blocs, ou vous pouvez mettre à jour des ensembles spécifiques de nœuds dans le cluster par nom avec une planification de maintenance indépendante.

Choisissez la stratégie appropriée pour vos ressources :

Mettre à jour les réservations par lots de sous-blocs

Pour effectuer une maintenance d'hôte progressive pour les réservations de capacité par lots de sous-blocs, procédez comme suit :

Identifier les réservations pour la maintenance : identifiez le nom de la réservation de capacité, ainsi que les blocs ou sous-blocs de réservation utilisés par le cluster GKE. Pour ce faire, effectuez une recherche à l'aide des libellés de nœud GKE et de la commande gcloud compute reservations :
1. Répertoriez le nom de la réservation, ainsi que les ID de topologie de bloc physique et de sous-bloc des nœuds de votre pool de nœuds :
```
kubectl get nodes -l cloud.google.com/gke-nodepool=NODE_POOL_NAME \
    -o custom-columns='NAME:.metadata.name,RESERVATION:.metadata.labels.cloud\.google\.com/reservation-name,BLOCK_ID:.metadata.labels.cloud\.google\.com/gce-topology-block,SUBBLOCK_ID:.metadata.labels.cloud\.google\.com/gce-topology-subblock'
```
  Remplacez NODE_POOL_NAME par le nom du pool de nœuds.
  
  Notez les valeurs de sortie : le nom de la réservation (par exemple, nvidia-gb300-m7kp2xq9vd4j1), l'ID du bloc (par exemple, 3f2a8c9b1d4e0756f8a2b3c1d9e4f0a5) et l'ID du sous-bloc (par exemple, e7b91f4a3c2d58069e1a4b7f3d2c8056).
2. Pour identifier le nom de ressource du bloc de réservation, interrogez la liste des blocs de réservation Compute Engine à l'aide du nom de la réservation et filtrez par ID de bloc :
```
gcloud compute reservations blocks list RESERVATION_NAME \
    --zone=ZONE \
    --project=PROJECT_ID \
    --filter="physicalTopology.block=BLOCK_ID"
```
  Remplacez les éléments suivants :
  - RESERVATION_NAME : nom de la réservation.
  - ZONE : zone où se trouve la réservation.
  - PROJECT_ID : ID du projet dans lequel se trouve la réservation.
  - BLOCK_ID : ID de bloc récupéré à partir des libellés de nœud.
  Notez le nom du bloc à partir de la sortie.
3. Pour identifier le nom de la ressource du sous-bloc de réservation, interrogez la liste des sous-blocs de réservation à l'aide du nom de la réservation et du nom du bloc, puis filtrez par ID de sous-bloc :
```
gcloud compute reservations sub-blocks list RESERVATION_NAME \
    --block-name=BLOCK_NAME \
    --zone=ZONE \
    --project=PROJECT_ID \
    --filter="physicalTopology.subBlock=SUBBLOCK_ID"
```
  Remplacez les éléments suivants :
  - RESERVATION_NAME : nom de la réservation.
  - BLOCK_NAME : nom de la ressource du bloc de réservation.
  - ZONE : zone où se trouve la réservation.
  - PROJECT_ID : ID du projet dans lequel se trouve la réservation.
  - SUBBLOCK_ID : ID du sous-bloc récupéré à partir des étiquettes de nœud.
  Le résultat affiche des détails sur le sous-bloc de réservation correspondant, y compris son nom de ressource.
Diviser les réservations en lots : divisez les sous-blocs de réservation de capacité identifiés en lots égaux. Déterminez la taille de lot à l'aide de la formule décrite dans l'élément de liste Calculer les contraintes de temps de la section Éléments à prendre en compte avant de commencer ci-dessus. Chaque lot correspond à un ou plusieurs sous-blocs de réservation, et chaque lot doit être au moins de la taille d'un sous-bloc.
Effectuer la maintenance de l'hôte : pour chaque lot, procédez comme suit :
1. Sélectionnez un lot de sous-blocs de réservation et déclenchez la maintenance de l'hôte. Vous pouvez déclencher la maintenance sur vos réservations, blocs de réservation ou sous-blocs de réservation. Pour les types de machines tels que A4X, A4X Max, TPU v6e et TPU7x, vous devez déclencher la maintenance de cette manière. La maintenance est effectuée sur des groupes de sous-blocs. Exécutez la commande gcloud compute reservations sub-blocks perform-maintenance :
```
gcloud compute reservations sub-blocks perform-maintenance RESERVATION_NAME \
    --block-name=BLOCK_NAME \
    --sub-block-name=SUB_BLOCK_NAME \
    --zone=ZONE
```
  Remplacez les éléments suivants :
  - RESERVATION_NAME : nom de la réservation.
  - BLOCK_NAME : nom du bloc de réservation.
  - SUB_BLOCK_NAME : nom du sous-bloc de réservation.
  - ZONE : zone où se trouve la réservation.
  Compute Engine commence à drainer et à mettre à jour simultanément toutes les instances du sous-bloc. Ce processus peut prendre quelques heures.
2. Surveillez l'état de la maintenance en consultant le champ de métadonnées upcomingGroupMaintenance dans les ressources de réservation. Pour en savoir plus, consultez Afficher l'état de maintenance d'une réservation.
3. Répétez les étapes précédentes pour chaque lot restant jusqu'à ce que vous ayez terminé la maintenance de l'hôte pour tous les lots.
Facultatif : Mettre à niveau la version des nœuds GKE : n'effectuez cette étape qu'une fois la maintenance de l'hôte terminée pour tous les sous-blocs de réservation, afin d'éviter que les nœuds GKE ne soient déployés sur des hôtes dont la maintenance n'est pas encore terminée. Suivez les instructions pour mettre à niveau la version GKE des nœuds.

Mettre à jour les nœuds par lots

Pour effectuer une maintenance d'hôte progressive pour les instances à la demande ou les réservations qui ne sont pas compatibles avec les sous-blocs par lots, procédez comme suit :

Identifier les nœuds pour la maintenance : identifiez tous les nœuds sur lesquels vous souhaitez effectuer la maintenance, puis enregistrez cette liste. Pour identifier les nœuds, utilisez l'une des méthodes suivantes ou sélectionnez-les manuellement :
- Récupérez tous les nœuds du cluster qui utilisent des accélérateurs (TPU ou GPU) :
```
kubectl get nodes -o json | jq -r '.items[] | select(.spec.taints[]? | select(.key=="nvidia.com/gpu" or .key=="google.com/tpu")) | .metadata.name'
```
- Obtenez tous les nœuds d'un pool de nœuds spécifique :
```
kubectl get nodes -l cloud.google.com/gke-nodepool=NODE_POOL_NAME --no-headers -o custom-columns=":metadata.name"
```
  Remplacez NODE_POOL_NAME par le nom du pool de nœuds.
- Obtenez tous les nœuds associés à un libellé spécifique :
```
kubectl get nodes -l LABEL -o jsonpath='{.items[*].metadata.name}'
```
  Remplacez LABEL par l'étiquette du nœud.
Diviser les nœuds en lots : divisez les nœuds identifiés en lots égaux. Déterminez la taille de lot à l'aide de la formule décrite dans l'élément de liste Calculer les contraintes de temps de la section Éléments à prendre en compte avant de commencer ci-dessus.
Effectuer la maintenance de l'hôte : pour chaque lot, procédez comme suit :
1. Sélectionnez un lot de nœuds et déclenchez la maintenance au niveau de l'instance à l'aide de l'API instances en appliquant l'étiquette de maintenance :
  
  Avertissement : Les instances configurées pour utiliser la planification de maintenance groupée (comme A4X, A4X Max, TPU v6e et TPU7x) sont étroitement couplées et doivent être gérées ensemble comme une seule unité. Vous devez utiliser la maintenance au niveau du sous-bloc.
```
kubectl label nodes LIST_OF_NODES_IN_BATCH cloud.google.com/perform-maintenance=true --overwrite
```
  Remplacez LIST_OF_NODES_IN_BATCH par une liste de nœuds du lot, séparés par des espaces. Exemple : node-1 node-2 node-3.
  
  Compute Engine commence à drainer et à mettre à jour les instances sous-jacentes simultanément. Ce processus peut prendre quelques heures. Pour en savoir plus, consultez Processus d'arrêt progressif.
2. Surveillez l'état de la maintenance de l'hôte. GKE supprime l'étiquette de maintenance une fois la maintenance terminée, si elle a été appliquée. Une fois la maintenance terminée, vous trouverez un journal contenant le message suivant dans Logging :
```
Maintenance window has completed for this instance. All maintenance
notifications on the instance have been removed.
```
3. Répétez les étapes précédentes pour chaque lot restant jusqu'à ce que vous ayez terminé la maintenance de l'hôte pour tous les lots.
Facultatif : Mettez à niveau la version des nœuds GKE : n'effectuez cette étape qu'une fois la maintenance de l'hôte terminée pour tous les nœuds, afin d'éviter que les nœuds GKE ne soient déployés sur des hôtes dont la maintenance n'est pas encore terminée. Suivez les instructions pour mettre à niveau la version GKE des nœuds.

Mettre à niveau la version GKE des nœuds

Tenez compte du nombre de nœuds que vous souhaitez mettre à niveau en même temps. Avec la stratégie parallèle, vous avez effectué la maintenance de l'hôte pour l'ensemble de votre pool de nœuds ou pour plusieurs pools de nœuds en même temps. Avec la stratégie progressive, vous avez effectué la maintenance des hôtes par lots. Déterminez la méthode de mise à niveau que vous utiliserez en fonction de la taille des groupes de nœuds :

Stratégie parallèle : si vos pools de nœuds comportent chacun 100 nœuds ou moins par zone, utilisez les mises à niveau de surutilisation. Si vos pools de nœuds comportent chacun plus de 100 nœuds par zone, supprimez-les et recréez-les.
Stratégie progressive : si vos lots comportent 100 nœuds ou moins par zone et par pool de nœuds, utilisez les mises à niveau de la surutilisation. Si vos lots comportent plus de 100 nœuds, par zone et par pool de nœuds, supprimez et recréez les nœuds.

Utiliser les mises à niveau de surutilisation

Configurez les mises à niveau de surutilisation à l'aide du paramètre maxUnavailable pour déterminer le nombre de nœuds pouvant être indisponibles simultanément, par zone, dans un pool de nœuds. Par exemple, si vous avez 18 nœuds dans une zone d'un pool de nœuds, définissez la valeur du champ maxUnavailable sur 18.

Ce paramètre fonctionne mieux lorsque vous utilisez la capacité d'une réservation pour laquelle vous n'avez pas de capacité excédentaire. Pour en savoir plus sur l'utilisation de ce paramètre, consultez Effectuer une mise à niveau dans un environnement à ressources limitées.
Mettez à niveau le pool de nœuds en exécutant la commande suivante. Si vous souhaitez mettre à niveau plusieurs pools de nœuds, exécutez cette commande pour chaque pool de nœuds :
```
gcloud container clusters upgrade CLUSTER_NAME \
    --node-pool NODE_POOL_NAME \
    --cluster-version VERSION \
    --location CONTROL_PLANE_LOCATION \
    --quiet
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- NODE_POOL_NAME : nom du pool de nœuds.
- VERSION : cible de mise à niveau automatique recommandée pour le pool de nœuds. Pour en savoir plus, consultez Obtenir des informations sur les mises à niveau des pools de nœuds de cluster Standard. Si votre cluster ne dispose pas d'une cible de mise à niveau automatique recommandée, consultez les dernières entrées Mises à jour de version dans les notes de version de GKE.
- CONTROL_PLANE_LOCATION : emplacement du plan de contrôle de votre cluster.

Supprimer et recréer les nœuds

Supprimez le pool de nœuds et recréez-le à l'aide de la version ultérieure :

Supprimez le pool de nœuds :

gcloud container node-pools delete NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION

Recréez le pool de nœuds en transmettant la nouvelle version à l'aide de l'option --cluster-version. Transmettez la cible de mise à niveau automatique recommandée pour le pool de nœuds. Pour en savoir plus, consultez Obtenir des informations sur les mises à niveau des pools de nœuds de cluster Standard. Si votre cluster ne dispose pas d'une cible de mise à niveau automatique recommandée, consultez les dernières entrées Mises à jour de version dans les notes de version de GKE.