Attribuer des appareils existants à des charges de travail avec DRA

Standard

Vous pouvez demander des appareils de manière flexible pour vos charges de travail Google Kubernetes Engine (GKE) à l'aide de l'allocation dynamique des ressources (DRA). Ce document vous 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 s'adresse aux opérateurs d'applications et aux ingénieurs des données qui exécutent des charges de travail telles que l'IA/ML ou le calcul hautes performances (HPC).

Demander des appareils avec DRA

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

Pour demander des appareils dans une DeviceClass, vous devez créer l'un des objets suivants :

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

Pour en savoir plus sur les ResourceClaims et les ResourceClaimTemplates, consultez Quand utiliser les ResourceClaims et les ResourceClaimTemplates.

Les exemples de ce document utilisent un 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 DRA dans GKE
Limites spécifiques aux appareils, qui s'appliquent que vous utilisiez ou non DRA : Charges de travail GPU sur les clusters Standard

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser la Google Cloud CLI pour cette tâche, installez et initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. 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, vous devez créer un ResourceClaimTemplate qui contient la configuration d'appareil souhaitée, comme des GPU d'un type spécifique. Lorsque vous déployez une charge de travail qui fait référence à ResourceClaimTemplate, Kubernetes crée des ResourceClaims pour chaque pod de la charge de travail en fonction de 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 DRA, procédez comme suit :

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

Créez le ResourceClaimTemplate :

kubectl create -f gpu-claim-template.yaml

Pour créer une charge de travail qui fait référence à ResourceClaimTemplate, enregistrez le fichier 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"

Déployer la charge de travail :
```
kubectl create -f dra-gpu-example.yaml
```

Vérifier l'allocation du matériel

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

Obtenez le 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

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

kubectl describe resourceclaims RESOURCECLAIM

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