Alcune o tutte le informazioni in questa pagina potrebbero non essere applicabili a Trusted Cloud by S3NS.

Questa pagina è stata tradotta dall'API Cloud Translation.

Alloca dinamicamente i dispositivi ai carichi di lavoro con DRA

Standard

Questa pagina spiega come eseguire il deployment dei carichi di lavoro di allocazione dinamica delle risorse (DRA) sui 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 in che modo Kubernetes alloca in modo flessibile l'hardware sui tuoi pod.

Questa pagina è destinata agli operatori di applicazioni e agli ingegneri dei dati che eseguono workload come AI/ML o computing ad alte prestazioni (HPC).

Informazioni sull'allocazione dinamica delle risorse

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.

Informazioni sulla richiesta di dispositivi con DRA

Quando configuri l'infrastruttura GKE per DRA, i driver DRA sui nodi creano oggetti DeviceClass nel cluster. Una DeviceClass definisce una categoria di dispositivi, ad esempio le GPU, disponibili per le richieste per i carichi di lavoro. Un amministratore della piattaforma può, se vuole, eseguire il deployment di DeviceClass aggiuntive 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 ResourceClaim consente a un pod o a un utente di richiedere risorse hardware filtrando determinati parametri all'interno di una DeviceClass.
ResourceClaimTemplate: un ResourceClaimTemplate definisce un modello che i pod possono utilizzare per creare automaticamente nuovi ResourceClaim per pod.

Per saperne di più sugli oggetti ResourceClaim e ResourceClaimTemplate, vedi 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 ResourceClaimTemplateSpec documentazione di Kubernetes.

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

Devi inoltre 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à, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.
Nota:per le installazioni esistenti di gcloud CLI, assicurati di impostare la compute/region proprietà. Se utilizzi principalmente cluster zonali, imposta compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

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

Utilizzare DRA per eseguire il deployment dei carichi di lavoro

Per richiedere l'allocazione di dispositivi per pod, devi prima creare un ResourceClaimTemplate che produce 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 ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Per creare un carico di lavoro che fa riferimento a 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 ResourceClaimTemplate:
```
kubectl create -f claim-template.yaml
```

Per creare un carico di lavoro che fa riferimento a 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.