Prepara l'infrastruttura GKE per i carichi di lavoro DRA

Questa pagina spiega come configurare l'infrastruttura Google Kubernetes Engine (GKE) per supportare l'allocazione dinamica delle risorse (DRA). In questa pagina creerai cluster in grado di eseguire il deployment di carichi di lavoro GPU o TPU e installerai manualmente i driver necessari per abilitare DRA.

Questa pagina è destinata agli amministratori della piattaforma che vogliono ridurre la complessità e l'overhead della configurazione dell'infrastruttura con dispositivi hardware specializzati.

Informazioni su DRA

DRA è una funzionalità integrata di Kubernetes che ti consente di richiedere, allocare e condividere in modo flessibile l'hardware nel tuo cluster tra pod e container. Per saperne di più, consulta Informazioni sull'allocazione dinamica delle risorse.

Limitazioni

  • Il provisioning automatico dei nodi non è supportato.
  • I cluster Autopilot non supportano DRA.
  • Non puoi utilizzare le seguenti funzionalità di condivisione della GPU:
    • GPU in time-sharing
    • GPU multi-istanza
    • Servizio multi-processo (MPS)

Requisiti

Per utilizzare DRA, la versione di GKE deve essere la 1.32.1-gke.1489001 o versioni successive.

Devi inoltre conoscere i seguenti requisiti e limitazioni, a seconda del tipo di hardware che vuoi utilizzare:

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

  • Se non utilizzi Cloud Shell, installa l'interfaccia a riga di comando di 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

Crea un cluster GKE Standard

Crea un cluster in modalità Standard che abiliti le API beta di Kubernetes per 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"

Sostituisci quanto segue:

  • CLUSTER_NAME: un nome per il cluster.
  • CONTROL_PLANE_LOCATION: la posizione di Compute Engine del control plane del tuo cluster. Fornisci una regione per i cluster regionali o una zona per i cluster zonali.
  • GKE_VERSION: la versione di GKE da utilizzare per il cluster e i nodi. Deve essere 1.32.1-gke.1489001 o versioni successive.
  • PROJECT_ID: il tuo ID progetto.

Preparare l'ambiente GKE per supportare DRA

Su GKE, puoi utilizzare DRA sia con le GPU che con le TPU. Quando crei i tuoi node pool, devi utilizzare le seguenti impostazioni che funzionano con DRA durante l'anteprima:

  • Per le GPU, disattiva l'installazione automatica dei driver GPU.
  • Aggiungi gli ambiti di accesso richiesti per i nodi.
  • Aggiungi etichette ai nodi per eseguire solo i carichi di lavoro DRA sui nodi.
  • Abilita la scalabilità automatica del cluster.

Tutte le altre impostazioni di configurazione del pool di nodi, come tipo di macchina, tipo di acceleratore, conteggio, sistema operativo del nodo e località dei nodi, dipendono dai tuoi requisiti.

Preparare l'ambiente per le GPU

  1. Crea un pool di nodi con l'hardware richiesto:

    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

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del tuo cluster.
    • CONTROL_PLANE_LOCATION: la posizione di Compute Engine del control plane del tuo cluster. Fornisci una regione per i cluster regionali o una zona per i cluster zonali. Assicurati che la località selezionata appartenga alla stessa regione in cui sono disponibili le GPU che specifichi.
    • ZONE: una zona in cui sono disponibili le GPU che specifichi.

  2. Installa manualmente i driver sui nodi Container-Optimized OS o Ubuntu. Per istruzioni dettagliate, consulta Installare manualmente i driver GPU NVIDIA.

    • Se utilizzi COS, esegui i seguenti comandi per eseguire il deployment di DaemonSet di installazione e installare la versione predefinita del driver GPU:

      kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

    • Se utilizzi Ubuntu, il DaemonSet di installazione che implementi dipende dal tipo di GPU e dalla versione del nodo GKE, come descritto nella sezione Ubuntu delle istruzioni.

  3. Estrai e aggiorna il grafico Helm che contiene l'operatore GPU:

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

  4. Crea uno spazio dei nomi per l'operatore GPU:

    kubectl create namespace gpu-operator

  5. Crea un oggetto ResourceQuota nello spazio dei nomi gpu-operator. ResourceQuota consente all'operatore GPU di eseguire il deployment di pod con la stessa priorità dei pod di sistema 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

  6. Installa l'operatore GPU con lo 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

Prepara l'ambiente per le TPU

Crea un pool di nodi che utilizza le TPU. L'esempio seguente crea un pool di nodi 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

Sostituisci quanto segue: * NODEPOOL_NAME: il nome del tuo pool di nodi. * CLUSTER_NAME: il nome del cluster. * CONTROL_PLANE_LOCATION: la posizione di Compute Engine del control plane del cluster. Fornisci una regione per i cluster regionali o una zona per i cluster zonali.

Accedere e installare i driver DRA

Le sezioni seguenti mostrano come installare i driver DRA per GPU e TPU. I driver DRA consentono a Kubernetes di allocare dinamicamente i dispositivi collegati ai carichi di lavoro. Puoi installare i driver DRA per GPU e TPU con il grafico Helm fornito. Per accedere ai grafici Helm, completa i seguenti passaggi:

  1. Clona il repository ai-on-gke per accedere ai grafici Helm che contengono i driver DRA per GPU e TPU:

    git clone https://github.com/GoogleCloudPlatform/ai-on-gke/common-infra.git

  2. Vai alla directory che contiene i grafici:

    cd common-infra/common/charts

Installare i driver DRA sulle GPU

Dopo aver avuto accesso al grafico Helm che contiene i driver DRA, installa il driver DRA per le GPU completando il seguente passaggio:

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

Installare i driver DRA sulle TPU

Dopo aver ottenuto l'accesso al grafico Helm che contiene i driver, installa il driver TPU completando il seguente passaggio:

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

Verifica che la tua infrastruttura sia pronta per DRA

Verifica che ResourceSlice elenchi i dispositivi hardware che hai aggiunto:

kubectl get resourceslices -o yaml

Se hai utilizzato l'esempio nella sezione precedente, ResourceSlice assomiglia a quanto segue, a seconda del tipo di hardware utilizzato:

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: ""

Passaggi successivi