Assegnare dispositivi esistenti ai workload con DRA

Standard

Anteprima

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

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

Questa pagina è destinata 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 ulteriori informazioni su ResourceClaim e ResourceClaimTemplate, consulta Quando utilizzare ResourceClaim e ResourceClaimTemplate.

Gli esempi in questo documento utilizzano un ResourceClaimTemplate di base per richiedere la configurazione del dispositivo specificata. Per ulteriori informazioni su tutti i campi che puoi specificare, consulta la documentazione di riferimento dell'API ResourceClaimTemplate.

Limitazioni

Si applicano le seguenti limitazioni:

• Limitazioni di DRA in GKE
• Limitazioni specifiche del dispositivo, che si applicano indipendentemente dal fatto che tu utilizzi DRA: workload GPU sui cluster standard

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita 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 gcloud components update comando. 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 compute/region proprietà. 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.

Richiedi dispositivi ed esegui il deployment dei workload

Per richiedere l'allocazione di dispositivi per pod, crea un ResourceClaimTemplate con la configurazione del dispositivo richiesta, ad esempio GPU di un tipo specifico. Quando esegui il deployment di 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 le GPU in un workload con DRA:

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

2. Crea ResourceClaimTemplate:

   kubectl create -f gpu-claim-template.yaml
   

3. Per creare un workload che faccia 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...); sleep infinity"]
           resources:
             claims:
             - name: single-gpu
         resourceClaims:
         - name: single-gpu
           resourceClaimTemplateName: gpu-claim-template
         tolerations:
         - key: "nvidia.com/gpu"
           operator: "Exists"
           effect: "NoSchedule"
   

4. Esegui il deployment del workload:

   kubectl create -f dra-gpu-example.yaml
   

Verifica l'allocazione dell'hardware

Puoi verificare che ai tuoi workload sia stato allocato hardware controllando ResourceClaim o esaminando i log del pod. Per verificare l'allocazione:

1. Recupera ResourceClaim associato al workload di cui hai eseguito il deployment:

   kubectl get resourceclaims
   

   L'output è simile al seguente:

   NAME                                               STATE                AGE
   dra-gpu-example-64b75dc6b-x8bd6-single-gpu-jwwdh   allocated,reserved   9s
   

2. Ottieni maggiori dettagli sull'hardware assegnato al pod:

   kubectl describe resourceclaims RESOURCECLAIM
   

   Sostituisci RESOURCECLAIM con il nome completo di ResourceClaim che hai ottenuto dall'output del passaggio precedente.

   L'output è simile al seguente:

   Name:         dra-gpu-example-68f595d7dc-prv27-single-gpu-qgjq5
   Namespace:    default
   Labels:       <none>
   Annotations:  resource.kubernetes.io/pod-claim-name: single-gpu
   API Version:  resource.k8s.io/v1
   Kind:         ResourceClaim
   Metadata:
   # Multiple lines are omitted here.
   Spec:
     Devices:
       Requests:
         Exactly:
           Allocation Mode:    ExactCount
           Count:              1
           Device Class Name:  gpu.nvidia.com
         Name:                 single-gpu
   Status:
     Allocation:
       Devices:
         Results:
           Device:   gpu-0
           Driver:   gpu.nvidia.com
           Pool:     gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
           Request:  single-gpu
       Node Selector:
         Node Selector Terms:
           Match Fields:
             Key:       metadata.name
             Operator:  In
             Values:
               gke-cluster-1-dra-gpu-pool-b56c4961-7vnm
     Reserved For:
       Name:      dra-gpu-example-68f595d7dc-prv27
       Resource:  pods
       UID:       e16c2813-08ef-411b-8d92-a72f27ebf5ef
   Events:        <none>
   

3. Recupera i log del workload di cui hai eseguito il deployment:

   kubectl logs deployment/dra-gpu-example --all-pods=true
   

   L'output è simile al seguente:

   [pod/dra-gpu-example-64b75dc6b-x8bd6/ctr] GPU 0: Tesla T4 (UUID: GPU-2087ac7a-f781-8cd7-eb6b-b00943cc13ef)
   

   Questo output indica che GKE ha allocato una GPU al container.

Passaggi successivi

• Esplora altre risorse per l'orchestrazione AI/ML su GKE