Vous pouvez utiliser l'allocation dynamique des ressources (DRA) pour allouer des GPU à vos charges de travail Google Kubernetes Engine (GKE). Ce document explique les principes fondamentaux de l'allocation dynamique des ressources, comment l'utiliser dans GKE et ses avantages.
Ce document est destiné aux rôles suivants :
- Les administrateurs de plates-formes qui souhaitent réduire la complexité et les frais généraux liés à la configuration de l'infrastructure avec des périphériques matériels spécialisés.
- Opérateurs d'applications et ingénieurs de données qui exécutent des charges de travail telles que l'IA/le ML ou le calcul hautes performances (HPC).
Vous devez déjà connaître les concepts suivants :
Présentation de DRA
L'allocation dynamique des ressources est une fonctionnalité Kubernetes intégrée qui vous permet de demander, d'allouer et de partager de manière flexible du matériel dans votre cluster entre les pods et les conteneurs. La DRA améliore l'expérience d'allocation du matériel associé, comme les accélérateurs, en permettant aux fournisseurs d'appareils et aux administrateurs de plate-forme de déclarer des classes d'appareils pouvant être demandées et allouées. Les opérateurs d'applications peuvent demander des configurations d'appareils spécifiques dans ces classes, puis demander ces configurations dans leurs charges de travail. Kubernetes et GKE gèrent la planification des pods, les attributions de nœuds et l'allocation des appareils en fonction des requêtes de charge de travail.
Par exemple, un administrateur de plate-forme peut définir une classe d'appareils ne comportant que des GPU NVIDIA A100. Les opérateurs d'application peuvent ensuite filtrer les appareils de cette classe d'appareils en fonction des exigences de la charge de travail, par exemple en filtrant pour un minimum de 80 Go de mémoire GPU. Lorsque l'opérateur d'application déploie une charge de travail qui demande la configuration filtrée, GKE place les pods sur les nœuds qui répondent aux critères sélectionnés. Dans cet exemple, GKE recherche des nœuds disposant de GPU A100 (80 Go) disponibles. L'opérateur de l'application n'a pas besoin de sélectionner des nœuds ou des configurations d'appareil spécifiques dans le fichier manifeste de la charge de travail.
Avantages de l'ARD
Sans DRA, l'allocation d'appareils matériels dans Kubernetes repose sur des plug-ins d'appareils. Pour associer des ressources matérielles à des pods à l'aide de plug-ins d'appareil, vous utilisez des libellés de nœud pour placer les pods sur des nœuds spécifiques. De plus, pour dédier l'intégralité des ressources d'un nœud à un seul pod, vous devez demander le nombre exact d'appareils associés aux nœuds.
Avec DRA, l'allocation d'appareils aux pods est semblable à l'allocation de volumes pour le stockage. Vous définissez des classes d'appareils, demandez des appareils dans ces classes, puis attribuez ces appareils demandés aux charges de travail. DRA fournit une surface beaucoup plus extensible pour filtrer les appareils en fonction de la charge de travail et des besoins de l'entreprise. L'approche DRA consistant à utiliser des expressions et des modèles pour revendiquer du matériel et planifier des pods présente les avantages suivants :
- Allocation déclarative d'appareils : les administrateurs de la plate-forme peuvent définir des configurations d'appareils pour des types spécifiques de charges de travail ou d'équipes.
- Complexité réduite entre les équipes : lorsque les administrateurs de plate-forme provisionnent des nœuds dotés de configurations matérielles spécialisées, les opérateurs d'applications n'ont pas besoin de savoir quels nœuds ont des configurations spécifiques. Les administrateurs de plate-forme n'ont pas besoin d'étiqueter les nœuds ni de communiquer aux opérateurs des informations sur des nœuds et des appareils spécifiques.
- Complexité réduite pour les développeurs : Kubernetes ordonnance les pods en fonction de la configuration de l'appareil de référence. Les opérateurs d'application n'ont pas besoin de sélectionner des nœuds spécifiques dans leurs charges de travail ni de s'assurer que chaque pod demande exactement le nombre d'appareils associés à ces nœuds.
- Gestion centralisée de l'infrastructure : les administrateurs de plate-forme peuvent définir de manière centralisée des configurations matérielles qui répondent à des exigences commerciales spécifiques. Par exemple, un administrateur de plate-forme peut déclarer une configuration hautes performances dotée de GPU H100, ainsi qu'une petite configuration d'inférence dotée de GPU Tesla T4.
- Sélection flexible du matériel : vous pouvez utiliser des expressions CEL pour filtrer les appareils présentant des attributs spécifiques. L'utilisation d'expressions offre la flexibilité nécessaire pour filtrer les appareils optimaux pour des charges de travail spécifiques.
Quand utiliser DRA ?
La principale raison d'utiliser DRA dans GKE est la flexibilité avec laquelle vous pouvez demander des appareils pour les charges de travail. Vous pouvez écrire un fichier manifeste une seule fois et déployer la charge de travail sur différents clusters avec différents types d'appareils sans avoir à modifier le fichier manifeste. Cette flexibilité est idéale pour les cas d'utilisation suivants :
- Améliorez la flexibilité, l'efficacité et la disponibilité de la capacité de calcul des GPU : pour les charges de travail qui ont besoin d'accéder au matériel GPU, vous pouvez utiliser l'ARD pour demander n'importe quel GPU disponible dans le cluster au lieu de devoir spécifier un modèle de GPU. Si ces charges de travail ont des exigences spécifiques en termes de mémoire GPU (VRAM), vous pouvez demander n'importe quel GPU du cluster disposant d'une quantité minimale de mémoire. Ce type de requête flexible élargit l'ensemble des nœuds GPU sur lesquels une charge de travail peut s'exécuter, ce qui réduit le risque que la charge de travail ne soit pas planifiée en raison de ressources indisponibles.
Optimiser la disponibilité des nœuds lors du scaling : la quantité d'appareils requise par une charge de travail peut varier en fonction de facteurs tels que le type d'appareil et ses capacités. Vous pouvez utiliser les ComputeClasses de GKE pour placer des pods accélérés sur des pools de nœuds spécifiques en fonction de la disponibilité des appareils. Vous pouvez ensuite configurer vos pods pour qu'ils revendiquent les appareils de n'importe quel nœud sur lequel GKE place les pods.
L'utilisation de DRA avec des ComputeClasses vous permet de minimiser le risque de charges de travail non planifiées, tout en vous aidant à exécuter des charges de travail sur du matériel optimisé.
Terminologie
Les fournisseurs Kubernetes Open Source et Kubernetes gérés comme GKE utilisent les types d'API DRA principaux suivants :
- ResourceSlice
- Un ResourceSlice liste un ou plusieurs appareils matériels du cluster auxquels les nœuds peuvent accéder. Par exemple, dans un nœud pouvant accéder à un seul GPU, ResourceSlice liste le GPU et le nom du nœud. Les pilotes de périphérique DRA de chaque nœud créent des ResourceSlices. Le programmeur Kubernetes utilise des ResourceSlices pour décider quels appareils allouer pour répondre aux demandes de charge de travail.
- DeviceClass
-
Une DeviceClass définit une catégorie d'appareils, tels que des GPU, qui peuvent être demandés pour des charges de travail.
Certains pilotes d'appareils fournissent des DeviceClasses intégrées, comme la DeviceClass
gpu.nvidia.compour les GPU NVIDIA. Les administrateurs de plate-forme peuvent également créer des DeviceClasses personnalisées qui définissent des configurations d'appareils spécifiques. - ResourceClaim
-
Un ResourceClaim permet à un pod ou à un utilisateur de demander des ressources matérielles en filtrant certains paramètres dans une DeviceClass. Lorsqu'une charge de travail fait référence à une ressource ResourceClaim, Kubernetes attribue les appareils correspondant aux paramètres spécifiés à cette ressource ResourceClaim.
Par exemple, considérons un scénario dans lequel vous créez une ResourceClaim pour un GPU A100 (40 Go), puis déployez une charge de travail qui sélectionne cette ResourceClaim. Kubernetes attribue un GPU A100 (40 Go) disponible à la ResourceClaim et planifie votre pod sur un nœud pouvant accéder à ce GPU.
- ResourceClaimTemplate
-
Un ResourceClaimTemplate définit un modèle que les pods peuvent utiliser pour créer automatiquement des ResourceClaims par pod. Les ResourceClaimTemplates sont utiles lorsque plusieurs charges de travail ont besoin d'accéder à des configurations d'appareils similaires, en particulier lorsque vous utilisez un contrôleur de charge de travail comme Deployments ou StatefulSets.
Les opérateurs d'application déploient des ResourceClaimTemplates, puis les référencent dans les charges de travail. Kubernetes crée des ResourceClaims pour chaque pod en fonction du modèle spécifié, alloue des appareils et planifie les pods. Lorsque les pods s'arrêtent, Kubernetes nettoie les ResourceClaims correspondants.
Pour en savoir plus sur les types d'API DRA, consultez Terminologie DRA.
Fonctionnement de l'ARD
L'utilisation de DRA dans vos clusters et charges de travail est un processus similaire à l'utilisation de StorageClasses, PersistentVolumeClaims et PersistentVolumes pour provisionner dynamiquement des volumes pour les pods.
Le schéma suivant illustre les étapes que les administrateurs de cluster et les opérateurs d'application doivent suivre pour allouer des appareils à l'aide de l'allocation de ressources dynamique :
Dans ce schéma, les administrateurs de cluster et les opérateurs d'application effectuent les opérations suivantes :
- Les administrateurs de cluster installent des pilotes d'appareil compatibles avec la DRA sur les nœuds.
- Les administrateurs de cluster créent des DeviceClasses qui filtrent le matériel répondant à des exigences spécifiques, par exemple tous les GPU disposant de plus de 40 Go de mémoire. Certains appareils peuvent également inclure des DeviceClasses intégrées.
- Les opérateurs d'application créent des ResourceClaimTemplates ou des ResourceClaims qui demandent des configurations d'appareil. Le cas d'utilisation principal de chaque type de revendication est le suivant :
- Une ressource ResourceClaim permet à plusieurs pods de partager l'accès au même appareil.
- Un ResourceClaimTemplate permet à plusieurs pods d'accéder à des appareils distincts et similaires en générant automatiquement des ResourceClaims par pod.
- Les opérateurs d'application ajoutent les ResourceClaimTemplates ou les ResourceClaims à leurs fichiers manifestes de charge de travail.
- Les opérateurs d'application déploient la charge de travail.
Lorsque vous déployez une charge de travail qui fait référence à un ResourceClaimTemplate ou à un ResourceClaim, Kubernetes effectue les étapes de planification suivantes :
- Si la charge de travail fait référence à un ResourceClaimTemplate, Kubernetes crée un objet
ResourceClaimpour chaque instance de la charge de travail (par exemple, chaque instance répliquée dans un déploiement). - Le programmeur Kubernetes utilise les ResourceSlices du cluster pour allouer les appareils disponibles et éligibles au ResourceClaim de chaque pod.
- Le programmeur place chaque pod sur un nœud ayant accès aux appareils qui ont été alloués à la ResourceClaim du pod.
- Le
kubeletsur le nœud de destination appelle le pilote DRA sur le nœud pour associer le matériel alloué au pod afin de répondre à sa requête de ressource.
Quand utiliser ResourceClaims et ResourceClaimTemplates ?
Vous pouvez utiliser ResourceClaims ou ResourceClaimTemplates pour indiquer à Kubernetes que vous souhaitez des appareils répondant à des exigences spécifiques. Lorsqu'un ResourceClaim est référencé dans un pod, Kubernetes alloue des appareils à la ressource d'API ResourceClaim correspondante sur le serveur d'API Kubernetes. Cette allocation se produit, que vous ayez créé la ResourceClaim ou que Kubernetes l'ait créée à partir d'un ResourceClaimTemplate.
Si vous créez un ResourceClaim, puis que vous le référencez dans plusieurs pods, tous ces pods peuvent accéder aux appareils que Kubernetes alloue pour ce ResourceClaim. Par exemple, cet accès partagé peut se produire si vous référencez une ResourceClaim spécifique dans un fichier manifeste de déploiement comportant plusieurs instances répliquées. Toutefois, si les appareils alloués ne sont pas configurés pour être partagés par plusieurs processus, cet accès partagé aux appareils entre les pods peut entraîner un comportement inattendu.
Pour allouer des appareils distincts aux pods, vous pouvez utiliser un ResourceClaimTemplate, qui est un modèle que Kubernetes utilise pour créer automatiquement des ResourceClaims individuels. Par exemple, si vous référencez un ResourceClaimTemplate dans un déploiement comportant plusieurs instances répliquées, Kubernetes crée un ResourceClaim distinct pour chaque pod répliqué. Par conséquent, chaque pod obtient son propre appareil alloué au lieu de partager l'accès à l'appareil avec d'autres pods. Ces ResourceClaims générés automatiquement sont liés à la durée de vie du pod correspondant et sont supprimés lorsque le pod s'arrête. Si vous avez des pods indépendants qui ont besoin d'accéder à des configurations d'appareil similaires, utilisez un ResourceClaimTemplate pour allouer des appareils à chaque pod séparément.
Le tableau suivant décrit certaines différences entre la création manuelle de ResourceClaims et la création de ResourceClaims par Kubernetes à partir d'un ResourceClaimTemplate :
| ResourceClaims créés manuellement | ResourceClaims créés automatiquement |
|---|---|
| Géré par vous | Gérés par Kubernetes |
| Fournit un accès aux mêmes appareils à partir de plusieurs pods | Permet d'accéder aux appareils à partir d'un seul pod |
| Existe dans le cluster indépendamment des pods | Lié au cycle de vie du pod correspondant |
| Idéal pour plusieurs charges de travail qui doivent partager un appareil spécifique | Idéal pour plusieurs charges de travail nécessitant un accès indépendant aux appareils |
Comparaison de l'allocation dynamique des ressources avec l'allocation manuelle des appareils
L'allocation de ressources dynamiques rend l'allocation d'appareils associés semblable au provisionnement dynamique de PersistentVolumes. Kubernetes permet également d'allouer des appareils à l'aide de plug-ins d'appareil. Cette méthode implique les étapes suivantes :
- Un administrateur de cluster crée des nœuds auxquels sont associés des appareils, comme des GPU.
- L'administrateur du cluster communique aux opérateurs de charge de travail des informations sur des nœuds spécifiques et leurs appareils associés.
- Un opérateur de charge de travail demande des appareils dans le fichier manifeste de la charge de travail comme suit :
- Sélectionnez un nœud disposant de la configuration d'appareil requise, comme le modèle de GPU, à l'aide d'un champ
nodeSelector. - Spécifiez le nombre exact d'appareils que les conteneurs doivent utiliser à l'aide du champ
resourcesdans la spécification du pod.
- Sélectionnez un nœud disposant de la configuration d'appareil requise, comme le modèle de GPU, à l'aide d'un champ
Cette méthode d'allocation manuelle nécessite que les opérateurs d'application et les administrateurs de cluster communiquent sur les nœuds ou pools de nœuds spécifiques qui ont certaines configurations d'appareil. Elles doivent coordonner les requêtes de charge de travail pour qu'elles correspondent aux appareils sur les nœuds, sinon le déploiement échoue. En comparaison, l'allocation dynamique des ressources vous permet d'utiliser des expressions pour filtrer de manière flexible les appareils en fonction d'attributs, et n'exige pas que les opérateurs de charge de travail connaissent la configuration exacte des nœuds du cluster.
Le tableau suivant compare l'ARD aux plug-ins d'appareil :
| DRA | Attribution manuelle |
|---|---|
| Sélection flexible d'appareils à l'aide d'expressions CEL | Sélection de nœuds spécifiques à l'aide de sélecteurs et de requêtes de ressources |
| Décisions de planification prises par Kubernetes | Décisions de planification prises par l'opérateur à l'aide de sélecteurs de nœuds |
| Le filtrage des appareils est distinct de la création de charges de travail | Le filtrage des appareils doit être effectué dans le fichier manifeste de la charge de travail |
| Filtrage centralisé des appareils et classes basées sur les besoins, gérés par les administrateurs de la plate-forme | Filtrage des appareils isolés par les opérateurs d'application |
| Les opérateurs d'applications n'ont pas besoin de connaître la capacité des nœuds, les informations sur les libellés des nœuds ni les modèles d'appareils associés à chaque nœud. | Les opérateurs d'applications doivent savoir quels nœuds disposent de modèles et de quantités spécifiques de certains appareils associés. |
DRA et autoscaling de l'infrastructure
Pour ajuster automatiquement le nombre de nœuds dans un pool de nœuds en mode Standard, vous utilisez l'autoscaler de cluster. Vous pouvez activer l'autoscaler de cluster dans n'importe quel pool de nœuds créé manuellement, y compris les pools de nœuds dotés de pilotes DRA.
Pour les pools de nœuds qui utilisent la DRA, l'utilisation des appareils affecte la façon dont l'autoscaler de cluster ajoute et supprime des nœuds dans un pool de nœuds. Pour calculer l'utilisation des appareils dans un pool de nœuds, l'autoscaler de cluster prend en compte les facteurs suivants :
- Tous les appareils d'un pool de ressources doivent être locaux à un nœud spécifique. Si un ResourceSlice dispose d'un pool d'appareils associés à plusieurs nœuds, l'autoscaler de cluster ignore ces appareils.
- Tous les appareils du pool de nœuds sont identiques et ont la même importance.
- Les appareils DRA sont prioritaires par rapport au processeur ou à la mémoire. Dans les pools de nœuds DRA, l'autoscaler de cluster ignore l'utilisation du processeur et de la mémoire.
Ces facteurs peuvent entraîner un comportement de scaling à la baisse différent dans les pools de nœuds DRA par rapport aux autres pools de nœuds.
Appareils GKE compatibles avec l'ARD
Le tableau suivant décrit les appareils que vous pouvez allouer aux charges de travail avec DRA dans GKE :
| Type d'appareil | Description |
|---|---|
| GPU | Tout type de GPU disponible dans votre emplacement. Pour en savoir plus, consultez Emplacements des GPU. |
| Interfaces réseau | Plusieurs types d'interfaces réseau, telles que les interfaces compatibles RDMA, en installant le pilote DRANET géré. Pour en savoir plus, consultez Allouer des ressources réseau à l'aide de DRANET géré par GKE. |
Limites
Les limites suivantes s'appliquent lorsque vous utilisez DRA :
Mode de fonctionnement : DRA n'est disponible que dans les clusters en mode Standard.
Type d'accélérateur : l'allocation dynamique des ressources dans GKE n'est compatible qu'avec les GPU.
GPU :
- Vous ne pouvez pas utiliser de GPU à temps partagé, de GPU multi-instances ni de service multiprocessus (MPS).
- Pour les nœuds qui utilisent les pilotes GPU DRA, vous ne pouvez pas utiliser le package de métriques géré du gestionnaire GPU de centre de données (DCGM) NVIDIA pour envoyer des métriques DCGM à Cloud Monitoring.
- Le pilote GPU pour DRA appartient à NVIDIA, et non à GKE. Pour en savoir plus, consultez la documentation NVIDIA.
Interfaces réseau : consultez la section Limites de la page "Allouer des ressources réseau à l'aide de DRANET géré par GKE".
Autoscaling :
- Pour les pilotes DRA tiers que vous installez, l'autoscaler de cluster nécessite que vos pools de nœuds comportent au moins un nœud. Pour empêcher les pools de nœuds qui utilisent des pilotes tiers de passer à zéro nœud, définissez le nombre minimal de nœuds sur au moins
1. - Il est possible que l'autoscaler de cluster ne fonctionne pas correctement avec les pilotes DRA tiers. Si vous utilisez des pilotes tiers, vérifiez qu'ils ne publient des informations que pour les appareils locaux de nœuds spécifiques.
- Pour les DaemonSets dans des pools de nœuds avec autoscaling qui utilisent un ResourceClaim statique pour partager l'accès aux appareils entre les pods, l'autoscaling accepte jusqu'à 128 pods DaemonSet. Pour contourner cette limitation, effectuez l'une des opérations suivantes :
- Empêchez le pool de nœuds d'effectuer un scaling au-delà de 128 nœuds en définissant le nombre maximal de nœuds.
- Utilisez le champ
adminAccess(bêta) dans ResourceClaim, qui permet au DaemonSet d'accéder aux appareils en cours d'utilisation.
- Si vos pods font référence à des ResourceClaims et ont une PriorityClass qui définit la règle de préemption sur
PreemptLowerPriority, la latence de l'autoscaling peut augmenter.PreemptLowerPriorityest la règle de préemption par défaut pour PriorityClass. Assurez-vous donc que vos PriorityClasses définissent explicitement le champpreemptionPolicysurNever. Pour en savoir plus, consultez PriorityClass sans préemption.
- Pour les pilotes DRA tiers que vous installez, l'autoscaler de cluster nécessite que vos pools de nœuds comportent au moins un nœud. Pour empêcher les pools de nœuds qui utilisent des pilotes tiers de passer à zéro nœud, définissez le nombre minimal de nœuds sur au moins
Compétences recommandées pour comprendre et utiliser l'ARD
Cette section fournit des recommandations aux administrateurs de plate-forme ou aux opérateurs d'applications qui souhaitent utiliser l'ARD pour allouer des appareils aux charges de travail. L'allocation dynamique des ressources modifie considérablement la méthode de demande d'appareils associés, à la fois dans GKE et dans Kubernetes. Pour bénéficier de cas d'utilisation plus avancés, tels que le remplacement multi-appareil ou le filtrage et la sélection d'appareils précis, tenez compte des conseils suivants :
Apprendre le CEL : avec DRA, vous pouvez utiliser des expressions CEL pour effectuer un filtrage précis des appareils dans vos requêtes d'allocation de ressources et vos DeviceClasses. Les ressources suivantes peuvent vous aider à apprendre le langage CEL :
En savoir plus sur les ComputeClasses dans GKE : vous pouvez utiliser des ComputeClasses avec DRA pour répondre à des besoins métier, comme le provisionnement de VM Spot pour exécuter des charges de travail d'inférence qui demandent des GPU économiques. Les ressources suivantes vous aident à en savoir plus sur les ComputeClasses :
Étapes suivantes
- Préparer votre infrastructure GKE pour les charges de travail DRA
- Allouer dynamiquement des appareils aux charges de travail avec DRA