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

Préparer l'infrastructure GKE pour les charges de travail DRA

Standard

Cette page explique comment configurer votre infrastructure Google Kubernetes Engine (GKE) pour prendre en charge l'allocation dynamique des ressources (DRA). Sur cette page, vous allez créer des clusters capables de déployer des charges de travail GPU ou TPU, et installer manuellement les pilotes dont vous avez besoin pour activer DRA.

Cette page s'adresse aux administrateurs de plate-forme qui souhaitent réduire la complexité et les frais généraux liés à la configuration de l'infrastructure avec des appareils matériels spécialisés.

À propos de DRA

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.

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, en fonction du type de matériel que vous souhaitez utiliser :

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 les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Si vous n'utilisez pas Cloud Shell, installez la CLI Helm :

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

Créer un cluster GKE standard

Créez un cluster en mode Standard qui active les API bêta Kubernetes pour DRA :

gcloud container clusters create CLUSTER_NAME \
    --quiet \
    --enable-kubernetes-unstable-apis="resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices" \
    --release-channel=rapid \
    --enable-autoupgrade \
    --location CONTROL_PLANE_LOCATION \
    --num-nodes "1" \
    --cluster-version GKE_VERSION \
    --workload-pool="PROJECT_ID.svc.id.goog"

Remplacez les éléments suivants :

CLUSTER_NAME : nom de votre cluster.
CONTROL_PLANE_LOCATION : emplacement Compute Engine du plan de contrôle de votre cluster. Indiquez une région pour les clusters régionaux ou une zone pour les clusters zonaux.
GKE_VERSION : version de GKE à utiliser pour le cluster et les nœuds. Doit être 1.32.1-gke.1489001 ou une version ultérieure.
PROJECT_ID : ID de votre projet.

Préparer votre environnement GKE pour prendre en charge DRA

Sur GKE, vous pouvez utiliser DRA avec des GPU et des TPU. Lorsque vous créez vos pools de nœuds, vous devez utiliser les paramètres suivants qui fonctionnent avec DRA pendant la preview :

Pour les GPU, désactivez l'installation automatique des pilotes de GPU.
Ajoutez les niveaux d'accès requis pour les nœuds.
Ajoutez des libellés de nœud pour n'exécuter que les charges de travail DRA sur les nœuds.
Activez l'autoscaling de cluster.

Tous les autres paramètres de configuration du pool de nœuds, tels que le type de machine, le type et le nombre d'accélérateurs, le système d'exploitation des nœuds et les emplacements des nœuds, dépendent de vos besoins.

Préparer votre environnement pour les GPU

Créez un pool de nœuds avec le matériel requis :

gcloud beta container node-pools create "gpu-pool" \
    --quiet \
    --project PROJECT_ID \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION \
    --node-version KUBERNETES_VERSION \
    --machine-type "n1-standard-8" \
    --accelerator "type=nvidia-tesla-t4,count=2,gpu-driver-version=disabled" \
    --image-type "UBUNTU_CONTAINERD" \
    --disk-type "pd-standard" \
    --disk-size "100" \
    --scopes "https://www.googleapis.com/auth/devstorage.read_only","https://www.googleapis.com/auth/logging.write","https://www.googleapis.com/auth/monitoring","https://www.googleapis.com/auth/servicecontrol","https://www.googleapis.com/auth/service.management.readonly","https://www.googleapis.com/auth/trace.append" \
    --num-nodes "1" \
    --enable-autoscaling \
    --min-nodes "1" \
    --max-nodes "6" \
    --location-policy "ANY" \
    --max-surge-upgrade 1 \
    --max-unavailable-upgrade 0 \
    --node-locations ZONE \
    --node-labels=gke-no-default-nvidia-gpu-device-plugin=true,nvidia.com/gpu.present=true

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster
CONTROL_PLANE_LOCATION : emplacement Compute Engine du plan de contrôle de votre cluster. Indiquez une région pour les clusters régionaux ou une zone pour les clusters zonaux. Assurez-vous que l'emplacement sélectionné appartient à la même région que celle où les GPU que vous spécifiez sont disponibles.
ZONE : zone dans laquelle les GPU que vous spécifiez sont disponibles.

Installez manuellement les pilotes sur vos nœuds Container-Optimized OS ou Ubuntu. Pour obtenir des instructions détaillées, consultez la page Installer manuellement les pilotes de GPU NVIDIA.
- Si vous utilisez COS, exécutez les commandes suivantes pour déployer le DaemonSet d'installation et installer la version par défaut des pilotes de GPU :
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
- Si vous utilisez Ubuntu, le DaemonSet d'installation que vous déployez dépend du type de GPU et de la version de nœud GKE, comme décrit dans la section Ubuntu des instructions.

Extrayez et mettez à jour le chart Helm contenant l'opérateur GPU :

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
    && helm repo update

Créez un espace de noms pour l'opérateur GPU :
```
kubectl create namespace gpu-operator
```

Créez un objet ResourceQuota dans l'espace de noms gpu-operator. ResourceQuota permet à l'opérateur GPU de déployer des pods ayant la même priorité que les pods du système Kubernetes.

kubectl apply -n gpu-operator -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-operator-quota
spec:
  hard:
    pods: 100
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

Installez l'opérateur GPU avec le script Helm :

helm install --wait --generate-name -n gpu-operator nvidia/gpu-operator \
    --set driver.enabled=false \
    --set operator.repository=ghcr.io/nvidia \
    --set operator.version=6171a52d \
    --set validator.repository=ghcr.io/nvidia/gpu-operator \
    --set validator.version=6171a52d \
    --set toolkit.repository=ghcr.io/nvidia \
    --set toolkit.version=5d9b27f1-ubuntu20.04 \
    --set gfd.repository=ghcr.io/nvidia \
    --set gfd.version=f171c926-ubi9 \
    --set cdi.enabled=true \
    --set hostPaths.driverInstallDir=/home/kubernetes/bin/nvidia \
    --set toolkit.installDir=/home/kubernetes/bin/nvidia

Préparer votre environnement pour les TPU

Créez un pool de nœuds qui utilise des TPU. L'exemple suivant crée un pool de nœuds TPU Trillium :

gcloud container node-pools create NODEPOOL_NAME \
    --cluster CLUSTER_NAME --num-nodes 1 \
    --location CONTROL_PLANE_LOCATION \
    --node-labels "gke-no-default-tpu-device-plugin=true,gke-no-default-tpu-dra-plugin=true" \
    --machine-type=ct6e-standard-8t \
    --enable-autoupgrade

Remplacez les éléments suivants : * NODEPOOL_NAME : nom de votre pool de nœuds. * CLUSTER_NAME : nom de votre cluster. * CONTROL_PLANE_LOCATION : emplacement Compute Engine du plan de contrôle de votre cluster. Indiquez une région pour les clusters régionaux ou une zone pour les clusters zonaux.

Accéder aux pilotes DRA et les installer

Les sections suivantes vous expliquent comment installer les pilotes DRA pour les GPU et les TPU. Les pilotes DRA permettent à Kubernetes d'allouer dynamiquement les appareils associés aux charges de travail. Vous pouvez installer des pilotes DRA pour les GPU et les TPU avec le chart Helm fourni. Pour accéder aux charts Helm, procédez comme suit :

Clonez le dépôt ai-on-gke pour accéder aux graphiques Helm contenant les pilotes DRA pour les GPU et les TPU :
```
git clone https://github.com/GoogleCloudPlatform/ai-on-gke/common-infra.git
```
Accédez au répertoire contenant les graphiques :
```
cd common-infra/common/charts
```

Installer des pilotes DRA sur des GPU

Une fois que vous avez accès au graphique Helm contenant les pilotes DRA, installez le pilote DRA pour les GPU en procédant comme suit :

COS

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/home/kubernetes/bin/nvidia/" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

Ubuntu

helm upgrade -i --create-namespace --namespace nvidia nvidia-dra-driver-gpu nvidia-dra-driver-gpu/ \
    --set image.repository=ghcr.io/nvidia/k8s-dra-driver-gpu \
    --set image.tag=d1fad7ed-ubi9 \
    --set image.pullPolicy=Always \
    --set controller.priorityClassName="" \
    --set kubeletPlugin.priorityClassName="" \
    --set nvidiaDriverRoot="/opt/nvidia" \
    --set nvidiaCtkPath=/home/kubernetes/bin/nvidia/toolkit/nvidia-ctk \
    --set deviceClasses="{gpu}" \
    --set gpuResourcesEnabledOverride=true \
    --set resources.computeDomains.enabled=false \
    --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
    --set kubeletPlugin.tolerations[0].operator=Exists \
    --set kubeletPlugin.tolerations[0].effect=NoSchedule \
    --set kubeletPlugin.tolerations[1].key=cloud.google.com/compute-class \
    --set kubeletPlugin.tolerations[1].operator=Exists \
    --set kubeletPlugin.tolerations[1].effect=NoSchedule

Installer des pilotes DRA sur des TPU

Une fois que vous avez accès au graphique Helm contenant les pilotes, installez le pilote TPU en procédant comme suit :

./tpu-dra-driver/install-tpu-dra-driver.sh

Vérifier que votre infrastructure est prête pour DRA

Vérifiez que ResourceSlice liste les appareils que vous avez ajoutés :

kubectl get resourceslices -o yaml

Si vous avez utilisé l'exemple de la section précédente, ResourceSlice ressemble à ce qui suit, selon le type de matériel que vous avez utilisé :

GPU

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          architecture:
            string: Turing
          brand:
            string: Nvidia
          cudaComputeCapability:
            version: 7.5.0
          cudaDriverVersion:
            version: 12.2.0
          driverVersion:
            version: 535.230.2
          index:
            int: 0
          minor:
            int: 0
          productName:
            string: Tesla T4
          type:
            string: gpu
          uuid:
            string: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef
        capacity:
          memory:
            value: 15Gi
      name: gpu-0

TPU

apiVersion: v1
items:
- apiVersion: resource.k8s.io/v1beta1
  kind: ResourceSlice
  metadata:
    # lines omitted for clarity
  spec:
    devices:
    - basic:
        attributes:
          index:
            int: 0
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "0"
    - basic:
        attributes:
          index:
            int: 1
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "1"
    - basic:
        attributes:
          index:
            int: 2
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "2"
    - basic:
        attributes:
          index:
            int: 3
          tpuGen:
            string: v6e
          uuid:
            string: tpu-54de4859-dd8d-f67e-6f91-cf904d965454
      name: "3"
    driver: tpu.google.com
    nodeName: gke-tpu-b4d4b61b-fwbg
    pool:
      generation: 1
      name: gke-tpu-b4d4b61b-fwbg
      resourceSliceCount: 1
kind: List
metadata:
  resourceVersion: ""

Étapes suivantes

Déployer vos charges de travail avec DRA