Questa pagina è stata tradotta dall'API Cloud Translation.

Alloca dinamicamente i dispositivi ai carichi di lavoro con DRA
Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Standard

Questa pagina spiega come eseguire il deployment dei carichi di lavoro di allocazione dinamica delle risorse (DRA) sui tuoi cluster Google Kubernetes Engine. In questa pagina, creerai un ResourceClaimTemplate per richiedere hardware con DRA e poi eseguirai il deployment di un carico di lavoro di base per dimostrare come Kubernetes alloca in modo flessibile l'hardware nei tuoi pod.

Questa pagina è rivolta a operatori di applicazioni e data engineer che eseguono carichi di lavoro come AI/ML o computing ad alte prestazioni (HPC).

Informazioni sull'allocazione dinamica delle risorse

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

Informazioni sulla richiesta di dispositivi con DRA

Quando configuri l'infrastruttura GKE per la replica dati in tempo reale, i relativi driver sui nodi creano oggetti DeviceClass nel cluster. Un DeviceClass definisce una categoria di dispositivi, ad esempio le GPU, che è possibile richiedere per i carichi di lavoro. Se vuoi, un amministratore della piattaforma può eseguire il deployment di altri DeviceClass che limitano i dispositivi che puoi richiedere in carichi di lavoro specifici.

Per richiedere dispositivi all'interno di un DeviceClass, crea uno dei seguenti oggetti:

ResourceClaim: una richiesta di risorse consente a un pod o a un utente di richiedere risorse hardware filtrando in base a determinati parametri all'interno di una classe di dispositivi.
ResourceClaimTemplate: un ResourceClaimTemplate definisce un modello che i pod possono utilizzare per creare automaticamente nuovi ResourceClaim per ogni pod.

Per ulteriori informazioni sugli oggetti ResourceClaim e ResourceClaimTemplate, consulta Quando utilizzare ResourceClaims e ResourceClaimTemplates.

Gli esempi in questa pagina utilizzano un ResourceClaimTemplate di base per richiedere la configurazione del dispositivo specificata. Per informazioni più dettagliate, consulta la ResourceClaimTemplateSpecdocumentazione di Kubernetes.

Limitazioni

Il provisioning automatico dei nodi non è supportato.
I cluster Autopilot non supportano la replica dinamica.
Non puoi utilizzare le seguenti funzionalità di condivisione della GPU:
- GPU con condivisione del tempo
- GPU a più istanze
- Servizio multiprocesso (MPS)

Requisiti

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

Inoltre, devi conoscere i seguenti requisiti e limitazioni:

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à, installa e poi inizializza gcloud CLI. Se hai già installato l'interfaccia a riga di comando gcloud, ottieni la versione più recente eseguendo gcloud components update.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Assicurati che i cluster GKE siano configurati per i carichi di lavoro DRA.

Utilizzare DRA per eseguire il deployment dei carichi di lavoro

Per richiedere l'allocazione dei dispositivi per pod, devi prima creare un ResourceClaimTemplate che genera un ResourceClaim per descrivere la tua richiesta di GPU o TPU, che Kubernetes utilizza come modello per creare nuovi oggetti ResourceClaim per ogni pod in un carico di lavoro. Quando specifichi ResourceClaimTemplate in un carico di lavoro, Kubernetes alloca le risorse richieste e pianifica i pod sui nodi corrispondenti.

GPU

Salva il seguente manifest come 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

Crea il ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Per creare un carico di lavoro che fa riferimento al file ResourceClaimTemplate, salva il seguente manifest come 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"

Esegui il deployment del carico di lavoro:
```
kubectl create -f dra-gpu-example.yaml
```

TPU

Salva il seguente manifest come 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

Questo ResourceClaimTemplate richiede a GKE di allocare un intero pool di nodi TPU a ogni ResourceClaim.

Crea il ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Per creare un carico di lavoro che fa riferimento al file ResourceClaimTemplate, salva il seguente manifest come 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"

Esegui il deployment del carico di lavoro:
```
kubectl create -f dra-tpu-example.yaml
```

Verifica l'allocazione dell'hardware

Puoi verificare che ai tuoi carichi di lavoro sia stato allocato hardware controllando ResourceClaim o esaminando i log del pod.