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

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 n'avez besoin de 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 maintenance, 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, si vous le souhaitez, lancent des mises à niveau de cluster GKE.

Utilisez la stratégie parallèle pour les nœuds des charges de travail où 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 d'indisponibilité 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 où la méthode la moins perturbatrice pour effectuer des modifications consiste à avoir 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 eux.

La stratégie suit ces grandes étapes :

  1. Arrêter les charges de travail : sélectionnez les pools de nœuds, puis arrêtez les charges de travail qui s'y exécutent ou déplacez-les vers d'autres nœuds qui restent disponibles.
  2. Déclencher la maintenance de l'hôte : appliquez le libellé 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.
  3. Mettre à niveau la version de GKE : modifiez la version de GKE des nœuds.
  4. Redémarrer les charges de travail : une fois que toutes les opérations de maintenance de l'hôte et les mises à niveau sont terminées, redémarrez vos charges de travail.

Les instructions fournies effectuent des modifications pour un seul pool de nœuds. Toutefois, vous pouvez adapter les étapes pour effectuer des modifications pour plusieurs pools de nœuds en même temps. Avant de commencer ces étapes, 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 interruptions lors de la réception de modifications critiques pour les instances Compute Engine sous-jacentes et les nœuds GKE, utilisez cette période de temps d'arrêt 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, tenez compte des points suivants :

  • Éviter de redéployer des 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 perturbations : assurez-vous que vos charges de travail peuvent être interrompues pendant un certain temps. Ces étapes prennent plusieurs heures, principalement en raison du temps nécessaire à 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, si vous le souhaitez, mettre à niveau la version de GKE, procédez comme suit :

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

  2. Démarrer la maintenance de l'hôte : appliquez le libellé de maintenance à tous les nœuds de le pool de nœuds sélectionné :

    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.

  3. Surveiller l'état de la maintenance de l'hôte : GKE supprime le libellé de maintenance une fois la maintenance terminée. Une fois la maintenance terminée, vous pouvez trouver 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.

  4. Facultatif : Mettre à niveau la version des nœuds GKE : suivez les instructions pour mettre à niveau la version de 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 sur les 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 dupliquées soient temporairement hors connexion.

La stratégie suit ces grandes étapes :

  1. 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.
  2. Parcourir les lots : pour chaque lot, appliquez le libellé de maintenance et surveillez le lot de nœuds jusqu'à ce que le libellé soit supprimé.
  3. 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, tenez compte des points suivants :

  • Comprendre votre déploiement : le succès nécessite une connaissance détaillée de la distribution de votre charge de travail, du placement des instances dupliquées et des domaines de défaillance. Assurez-vous de maintenir une capacité de diffusion suffisante tout au long du processus.
  • Planifier les tailles de lot : 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 dupliquées par modèle de diffusion.
    • Distribution des instances dupliquées sur les nœuds et les domaines de défaillance.
    • PodDisruptionBudgets peuvent vous aider à appliquer le nombre maximal de pods simultanément en panne.
    • Recommandation : pour simplifier la gestion, envisagez de dédier différents pools de nœuds à différents ensembles d'instances dupliqué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 timing suivants :
    • Chaque lot peut prendre plusieurs heures pour terminer l'étape de maintenance de l'hôte.
    • Calculez la taille minimale du lot pour vous assurer que toutes les opérations de maintenance sont terminées 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 avez choisie doit être égale ou supérieure à MIN_PER_BATCH.
  • Examiner des types de charges de travail spécifiques : tenez compte des points suivants pour les types de configuration respectifs :
    • Mixture of Experts (MOE) : assurez-vous que votre stratégie de traitement par lots maintient le nombre minimal requis d'instances répliquées pour chaque modèle.
    • Diffusion désagrégée : assurez-vous de suivre toutes les instances dupliqué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 devrez probablement désactiver 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 progressives, procédez comme suit :

  1. Identifier les nœuds pour la maintenance : identifiez tous les nœuds sur lesquels vous souhaitez effectuer la maintenance et enregistrez cette liste. Pour identifier les nœuds, utilisez l'une des méthodes suivantes ou sélectionnez-les manuellement :

    • Obtenez 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 avec un libellé spécifique :

      kubectl get nodes -l LABEL -o jsonpath='{.items[*].metadata.name}'

      Remplacez LABEL par le libellé du nœud.

  2. Diviser les nœuds en lots : divisez les nœuds identifiés en lots égaux. Déterminez la taille du lot à l'aide de la formule décrite dans l'élément de liste Calculer les contraintes de temps de la section À savoir avant de commencer.

  3. Effectuer la maintenance de l'hôte : pour chaque lot, procédez comme suit :

    1. Sélectionnez un lot de nœuds et appliquez le libellé de maintenance :

      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. Par exemple, node-1 node-2 node-3.

    2. Surveillez l'état de la maintenance de l'hôte. GKE supprime le libellé de maintenance une fois la maintenance terminée. Une fois la maintenance terminée, vous pouvez trouver 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 deux étapes précédentes pour chaque lot restant jusqu'à ce que vous ayez terminé la maintenance de l'hôte pour tous les lots.

  4. 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 nœuds, afin d'éviter les scénarios dans lesquels les nœuds GKE sont déployés sur des hôtes dont la maintenance n'est pas encore terminée. Consultez les instructions de la section suivante.

Mettre à niveau la version de 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 de l'hôte 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 des 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 des mises à niveau de surutilisation. Si vos lots comportent plus de 100 nœuds par zone et par pool de nœuds, supprimez-les et recréez-les.

Utiliser des mises à niveau de surutilisation

  1. Configurez les mises à niveau de surutilisation à l'aide du maxUnavailable paramètre pour déterminer le nombre de nœuds pouvant être indisponibles en même temps, 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 où vous n'avez pas de capacité excédentaire. Pour en savoir plus sur l'intérêt de ce paramètre, consultez Effectuer une mise à niveau dans un environnement à ressources limitées.

  2. 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 :

Supprimer et recréer les nœuds

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

  1. Supprimez le pool de nœuds :

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

  2. 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 pour les pools de nœuds de cluster Standard. Si votre cluster ne dispose pas de cible de mise à niveau automatique recommandée, consultez les dernières entrées Mises à jour de version dans les notes de version de GKE.