Cette page a été traduite par l'API Cloud Translation.

Allouer dynamiquement des appareils à des charges de travail avec DRA

Standard

Cette page explique comment déployer des charges de travail d'allocation dynamique des ressources (DRA, Dynamic Resource Allocation) sur vos clusters Google Kubernetes Engine. Sur cette page, vous allez créer un ResourceClaimTemplate pour demander du matériel avec DRA, puis déployer une charge de travail de base pour montrer comment Kubernetes alloue de manière flexible du matériel à vos pods.

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

À propos de l'allocation dynamique des ressources

DRA est une fonctionnalité Kubernetes intégrée qui vous permet de demander, d'allouer et de partager du matériel de manière flexible dans votre cluster entre les pods et les conteneurs. Pour en savoir plus, consultez À propos de l'allocation dynamique des ressources.

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 un DeviceClass, vous devez créer l'un des objets suivants :

ResourceClaim : Une 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 objets ResourceClaim et ResourceClaimTemplate, consultez Quand utiliser ResourceClaims et ResourceClaimTemplates.

Les exemples de cette page utilisent un ResourceClaimTemplate de base pour demander la configuration d'appareil spécifiée. Pour en savoir plus, consultez la documentation Kubernetes ResourceClaimTemplateSpec.

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
- Service multiprocessus (MPS)

Conditions requises

Pour utiliser DRA, votre version de GKE doit être la version 1.32.1-gke.1489001 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 gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de 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 telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si l'emplacement de votre cluster diffère de celui 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 d'abord créer un ResourceClaimTemplate qui produit un ResourceClaim pour décrire votre demande de GPU ou de TPU. Kubernetes utilise ce ResourceClaim comme modèle pour créer des objets ResourceClaim pour chaque pod d'une charge de travail. Lorsque vous spécifiez ResourceClaimTemplate dans une charge de travail, Kubernetes alloue les ressources demandées et planifie les pods sur les nœuds correspondants.

GPU

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

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

Créez le sous-réseau ResourceClaimTemplate :
```
kubectl create -f claim-template.yaml
```

Pour créer une charge de travail qui référence le 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: ["while [ 1 ]; do date; echo $(nvidia-smi -L || echo Waiting...); sleep 60; done"]
        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/v1beta1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        deviceClassName: tpu.google.com
        allocationMode: All

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

Créez le sous-réseau ResourceClaimTemplate :
```
kubectl create -f claim-template.yaml
```

Pour créer une charge de travail qui référence le 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

Pour vérifier que du matériel a été alloué à vos charges de travail, consultez ResourceClaim ou les journaux de votre pod.