Attribuer des appareils existants à des charges de travail avec DRA

Standard

Aperçu

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Vous pouvez demander de manière flexible des appareils pour vos charges de travail Google Kubernetes Engine (GKE) à l'aide de l'allocation dynamique de ressources (DRA). Ce document explique comment créer un ResourceClaimTemplate pour demander des appareils existants dans les pools de nœuds de votre cluster, puis créer une charge de travail pour observer comment Kubernetes alloue de manière flexible les appareils à vos pods.

Ce document est destiné aux opérateurs d'applications et aux ingénieurs de données qui exécutent des charges de travail telles que l'IA/ML ou le calcul hautes performances (HPC).

À propos de la demande d'appareils avec la DRA

Lorsque vous configurez votre infrastructure GKE pour la DRA, les pilotes DRA de vos nœuds créent des objets DeviceClass dans le cluster. Un objet DeviceClass définit une catégorie d'appareils, tels que des GPU, qui peuvent être demandés pour les charges de travail. Un administrateur de plate-forme peut éventuellement déployer des objets DeviceClass supplémentaires qui limitent les appareils que vous pouvez demander dans des charges de travail spécifiques.

Pour demander des appareils dans un objet DeviceClass, créez l'un des objets suivants :

• ResourceClaim : un objet ResourceClaim permet à un pod ou à un utilisateur de demander des ressources matérielles en filtrant certains paramètres dans un objet DeviceClass.
• ResourceClaimTemplate : un objet ResourceClaimTemplate définit un modèle que les pods peuvent utiliser pour créer automatiquement de nouveaux objets ResourceClaim par pod.

Pour en savoir plus sur les objets ResourceClaim et ResourceClaimTemplate, consultez Quand utiliser les objets ResourceClaim et ResourceClaimTemplate.

Les exemples de ce document utilisent un objet ResourceClaimTemplate de base pour demander la configuration d'appareil spécifiée. Pour en savoir plus sur tous les champs que vous pouvez spécifier, consultez la documentation de référence de l'API ResourceClaimTemplate.

Limites

Les limites suivantes s'appliquent :

• Limites de la DRA dans GKE
• Limites spécifiques aux appareils, qui s'appliquent que vous utilisiez ou non la DRA : charges de travail GPU sur les clusters standards

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Pour utiliser Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la gcloud components update commande. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.
  Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

• Assurez-vous que vos clusters GKE sont configurés pour les charges de travail DRA.

Revendiquer des appareils et déployer des charges de travail

Pour demander l'allocation d'appareils par pod, créez un objet ResourceClaimTemplate contenant la configuration d'appareil demandée, par exemple des GPU d'un type spécifique. Lorsque vous déployez une charge de travail qui référence l'objet ResourceClaimTemplate, Kubernetes crée des objets ResourceClaim pour chaque pod de la charge de travail en fonction de l'objet ResourceClaimTemplate. Kubernetes alloue les ressources demandées et planifie les pods sur les nœuds correspondants.

Pour demander des GPU dans une charge de travail avec la DRA, procédez comme suit :

1. Enregistrez le manifeste suivant sous le nom gpu-claim-template.yaml :

   apiVersion: resource.k8s.io/v1
   kind: ResourceClaimTemplate
   metadata:
     name: gpu-claim-template
   spec:
     spec:
       devices:
         requests:
         - name: single-gpu
           exactly:
             deviceClassName: gpu.nvidia.com
             allocationMode: ExactCount
             count: 1
   

2. Créez l'objet ResourceClaimTemplate :

   kubectl create -f gpu-claim-template.yaml
   

3. Pour créer une charge de travail qui référence l'objet ResourceClaimTemplate, enregistrez le manifeste suivant sous le nom dra-gpu-example.yaml :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: dra-gpu-example
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: dra-gpu-example
     template:
       metadata:
         labels:
           app: dra-gpu-example
       spec:
         containers:
         - name: ctr
           image: ubuntu:22.04
           command: ["bash", "-c"]
           args: ["echo $(nvidia-smi -L || echo Waiting...); sleep infinity"]
           resources:
             claims:
             - name: single-gpu
         resourceClaims:
         - name: single-gpu
           resourceClaimTemplateName: gpu-claim-template
         tolerations:
         - key: "nvidia.com/gpu"
           operator: "Exists"
           effect: "NoSchedule"
   

4. Déployez la charge de travail :

   kubectl create -f dra-gpu-example.yaml
   

Vérifier l'allocation matérielle

Vous pouvez vérifier que du matériel a été alloué à vos charges de travail en consultant l'objet ResourceClaim ou les journaux de votre pod. Pour vérifier l'allocation, procédez comme suit :

1. Obtenez l'objet ResourceClaim associé à la charge de travail que vous avez déployée :

   kubectl get resourceclaims
   

   Le résultat ressemble à ce qui suit :

   NAME                                               STATE                AGE
   dra-gpu-example-64b75dc6b-x8bd6-single-gpu-jwwdh   allocated,reserved   9s
   

2. Obtenez plus d'informations sur le matériel attribué au pod :

   kubectl describe resourceclaims RESOURCECLAIM
   

   Remplacez RESOURCECLAIM par le nom complet de l'objet ResourceClaim que vous avez obtenu à partir du résultat de l'étape précédente.

   Le résultat ressemble à ce qui suit :

   Name:         dra-gpu-example-68f595d7dc-prv27-single-gpu-qgjq5
   Namespace:    default
   Labels:       <none>
   Annotations:  resource.kubernetes.io/pod-claim-name: single-gpu
   API Version:  resource.k8s.io/v1
   Kind:         ResourceClaim
   Metadata:
   # Multiple lines are omitted here.
   Spec:
     Devices:
       Requests:
         Exactly:
           Allocation Mode:    ExactCount
           Count:              1
           Device Class Name:  gpu.nvidia.com
         Name:                 single-gpu
   Status:
     Allocation:
       Devices:
         Results:
           Device:   gpu-0
           Driver:   gpu.nvidia.com
           Pool:     gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
           Request:  single-gpu
       Node Selector:
         Node Selector Terms:
           Match Fields:
             Key:       metadata.name
             Operator:  In
             Values:
               gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
     Reserved For:
       Name:      dra-gpu-example-68f595d7dc-prv27
       Resource:  pods
       UID:       e16c2813-08ef-411b-8d92-a72f27ebf5ef
   Events:        <none>
   

3. Obtenez les journaux de la charge de travail que vous avez déployée :

   kubectl logs deployment/dra-gpu-example --all-pods=true
   

   Le résultat ressemble à ce qui suit :

   [pod/dra-gpu-example-64b75dc6b-x8bd6/ctr] GPU 0: Tesla T4 (UUID: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef)
   

   Ce résultat indique que GKE a alloué un GPU au conteneur.

Étape suivante

• Découvrez d'autres ressources pour l'orchestration d'IA/ML sur GKE.