Allouer dynamiquement des appareils aux 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, puis comment 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 sur 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 cette page 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

Le provisionnement automatique des nœuds n'est pas compatible.
Les clusters Autopilot ne sont pas compatibles avec DRA.
Vous ne pouvez pas utiliser les fonctionnalités de partage de GPU suivantes :
- GPU de partage de temps
- GPU multi-instances
- Multi-process Service (MPS)

Conditions requises

Pour utiliser DRA, votre version de GKE doit être la version 1.34 ou ultérieure.

Vous devez également connaître les exigences et les limites suivantes :

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

Utiliser DRA pour 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 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 appareils dans une charge de travail avec DRA, sélectionnez l'une des options suivantes :

GPU

Enregistrez le manifeste suivant sous le nom 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 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...)"]
        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
```

TPU

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

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        exactly:
          deviceClassName: tpu.google.com
          allocationMode: All

Ce ResourceClaimTemplate demande à GKE d'allouer un pool de nœuds TPU entier à chaque ResourceClaim.

Créez le ResourceClaimTemplate :
```
kubectl create -f 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-tpu-example.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dra-tpu-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dra-tpu-example
  template:
    metadata:
      labels:
        app: dra-tpu-example
    spec:
      containers:
      - name: ctr
        image: ubuntu:22.04
        command:
          - /bin/sh
          - -c
          - |
            echo "Environment Variables:"
            env
            echo "Sleeping indefinitely..."
            sleep infinity
        resources:
          claims:
          - name: all-tpus
      resourceClaims:
      - name: all-tpus
        resourceClaimTemplateName: tpu-claim-template
      tolerations:
      - key: "google.com/tpu"
        operator: "Exists"
        effect: "NoSchedule"

Déployer la charge de travail :
```
kubectl create -f dra-tpu-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'allocation des GPU ou des TPU, sélectionnez l'une des options suivantes :