Questa pagina è stata tradotta dall'API Cloud Translation.

Allocare dinamicamente i dispositivi ai carichi di lavoro con DRA

Standard

Puoi richiedere in modo flessibile i dispositivi per i tuoi carichi di lavoro Google Kubernetes Engine (GKE) utilizzando l'allocazione dinamica delle risorse (DRA). Questo documento mostra come creare un ResourceClaimTemplate per richiedere dispositivi e poi creare un workload per osservare in che modo Kubernetes alloca in modo flessibile i dispositivi ai tuoi pod.

Questo documento è destinato agli operatori di applicazioni e ai data engineer che eseguono workload come AI/ML o computing ad alte prestazioni (HPC).

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 workload. Un amministratore della piattaforma può, se vuole, eseguire il deployment di DeviceClass aggiuntive che limitano i dispositivi che puoi richiedere in workload specifici.

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

ResourceClaim: un 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ù su ResourceClaim e ResourceClaimTemplate, consulta Quando utilizzare ResourceClaim e ResourceClaimTemplate.

Gli esempi in questa pagina utilizzano un ResourceClaimTemplate di base per richiedere la configurazione del dispositivo specificata. Per saperne di più su tutti i campi che puoi specificare, consulta il riferimento API ResourceClaimTemplate.

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.34 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 il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece 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 workload DRA.

Utilizza DRA per eseguire il deployment dei workload

Per richiedere l'allocazione di dispositivi per pod, crea un ResourceClaimTemplate che contenga la configurazione del dispositivo richiesta, ad esempio GPU di un tipo specifico. Quando deploy un workload che fa riferimento a ResourceClaimTemplate, Kubernetes crea ResourceClaim per ogni pod nel workload in base a ResourceClaimTemplate. Kubernetes alloca le risorse richieste e pianifica i pod sui nodi corrispondenti.

Per richiedere dispositivi in un workload con DRA, seleziona una delle seguenti opzioni:

GPU

Salva il seguente manifest come claim-template.yaml:

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

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

Per creare un workload 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: ["echo $(nvidia-smi -L || echo Waiting...)"]
        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/v1
kind: ResourceClaimTemplate
metadata:
  name: tpu-claim-template
spec:
  spec:
    devices:
      requests:
      - name: all-tpus
        exactly:
          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 workload 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 hardware

Puoi verificare che ai tuoi workload sia stato allocato hardware controllando ResourceClaim o esaminando i log del pod. Per verificare l'allocazione per GPU o TPU, seleziona una delle seguenti opzioni: