Avvio della dashboard " Kubernetes " dalla console " IBM Cloud "

1. Accedi alla console IBM Cloud.
2. Dalla barra dei menu, seleziona l'account che vuoi utilizzare.
3. Dal menu , fare clic su Contenitori > Cluster.
4. Nella pagina Cluster, fai clic sul cluster a cui vuoi accedere.
5. Dalla pagina dei dettagli del cluster, fai clic sul pulsante Dashboard Kubernetes.

Avvio della dashboard di Kubernetes dalla CLI

Il metodo CLI consente l'automazione e l'integrazione CI/CD. Installare la CLI prima di iniziare.

1. Ottieni le tue credenziali per “ Kubernetes ”.

   kubectl config view -o jsonpath='{.users[0].user.auth-provider.config.id-token}'
   

2. Copiare il valore id-token dall'output.

3. Avviare il proxy.

   kubectl proxy
   

   Output di esempio

   Starting to serve on 127.0.0.1:8001
   

4. Accedi al dashboard.

   1. Accedi al seguente URL URL nel tuo browser:

       http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
       ```
   2. Selezionare il metodo di autenticazione **Token** nella pagina di accesso.
   
   3. Incolla il valore **dell'id-token** nel campo " **Token** " e clicca su " **ACCEDI**".
   
   

Usare CTRL+C per uscire dal comando proxy. Eseguire nuovamente kubectl proxy per riavviare il dashboard.

Prerequisiti

Prima di iniziare

• Crea un cluster o un pool di nodi di lavoro che utilizza un flavor GPU. Tieni presente che l'impostazione di una macchina bare metal può richiedere più di un giorno lavorativo per essere completata. Per un elenco dei flavor disponibili, consultare i seguenti link.

  • Versione classica
  • VPC

• Assicurati di avere assegnato un ruolo di accesso al servizio che ti conceda il ruolo RBAC appropriato " Kubernetes ", in modo da poter utilizzare le risorse " Kubernetes " nel cluster.

Per Kubernetes versione 1.36 e successive: È necessario installare e gestire autonomamente lo stack di driver della GPU NVIDIA. IBM Cloud Kubernetes Service non fornisce più driver GPU preinstallati sui nodi worker. Seguire la guida all'installazione di NVIDIA GPU Operator per installare i componenti necessari:

• NVIDIA driver del kernel
• Componenti runtime del contenitore (ad esempio, nvidia-container-toolkit)
• Kubernetes plugin per dispositivi

Finché il driver non viene installato, i pod che richiedono le GPU rimarranno nello stato Pending. Passeranno automaticamente a Running dopo che un driver compatibile sarà disponibile sul nodo.

Per Kubernetes versione 1.35 e precedenti: IBM- i driver GPU sono installati automaticamente sui nodi worker GPU. Non è richiesta l'installazione di alcun driver aggiuntivo.

Distribuzione di un carico di lavoro

1. Crea un file YAML. In questo esempio, un file YAML di tipo " Job " gestisce carichi di lavoro di tipo batch creando un pod di breve durata che rimane attivo fino al completamento del comando e alla sua corretta chiusura.

   Per i carichi di lavoro su GPU, è necessario specificare il campo “ resources: limits: nvidia.com/gpu ” nel file YAML del job.

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: nvidia-devicequery
     labels:
       name: nvidia-devicequery
   spec:
     template:
       metadata:
         labels:
           name: nvidia-devicequery
       spec:
         containers:
         - name: nvidia-devicequery
           image: nvcr.io/nvidia/k8s/cuda-sample:devicequery-cuda11.7.1-ubuntu20.04
           imagePullPolicy: IfNotPresent
           resources:
             limits:
               nvidia.com/gpu: 2
         restartPolicy: Never
   

   Capire i componenti YAML

   Componente	Descrizione
   Nomi etichetta e metadati	Inserisci un nome e un'etichetta per il lavoro e utilizza lo stesso nome sia nei metadati del file che in quelli di spec template. Ad esempio, nvidia-devicequery.
   containers.image	Fornisci l'immagine di cui il contenitore è un'istanza in esecuzione. In questo esempio, il valore è impostato per utilizzare l'immagine di query del dispositivo CUDA DockerHub:nvcr.io/nvidia/k8s/cuda-sample:devicequery-cuda11.7.1-ubuntu20.04.
   containers.imagePullPolicy	Per scaricare una nuova immagine solo se questa non è attualmente presente sul nodo di lavoro, specificare IfNotPresent``.
   resources.limits	Per le macchine GPU, devi specificare il limite della risorsa. L' Kubernetes Plug-in del dispositivo e imposta la richiesta di risorse predefinita in modo che corrisponda al limite. È necessario specificare la chiave come nvidia.com/gpu. Immettere il numero intero di GPU richieste, ad esempio 2. Nota che i pod del container non condividono GPU e che le GPU non possono essere eccessivamente impegnate. Ad esempio, se hai solo 1 macchina mg1c.16x128, allora hai solo 2 GPU in tale macchina e puoi specificare un massimo di 2.

2. Applica il file YAML. Ad esempio:

   kubectl apply -f nvidia-devicequery.yaml
   

3. Controlla il pod di lavoro filtrando i pod in base all’etichetta “ nvidia-devicequery ”. Verifica che lo STATO sia Completato.

   kubectl get pod -A -l 'name in (nvidia-devicequery)'
   

   Output di esempio

   NAME                  READY     STATUS      RESTARTS   AGE
   nvidia-devicequery-ppkd4      0/1       Completed   0          36s
   

4. Descrivi il pod per visualizzare come il plugin del dispositivo GPU ha pianificato il pod.

   • Nei campi Limits e Requests, controlla che il limite della risorsa che hai specificato corrisponda alla richiesta che imposta automaticamente il plugin del dispositivo.
   • Negli eventi, verifica che il pod sia assegnato al tuo nodo di lavoro GPU.

       kubectl describe pod nvidia-devicequery-ppkd4
       ```
       Output di esempio
       ```sh {: screen}
       NAME:           nvidia-devicequery-ppkd4
       Namespace:      default
       ...
       Limits:
           nvidia.com/gpu:  1
       Requests:
           nvidia.com/gpu:  1
       ...
       Events:
       Type    Reason                 Age   From                     Message
       ----    ------                 ----  ----                     -------
       Normal  Scheduled              1m    default-scheduler        Successfully assigned nvidia-devicequery-ppkd4 to 10.xxx.xx.xxx
       ...
       ```
   

5. Per verificare che il lavoro abbia utilizzato la GPU per calcolare il proprio carico di lavoro, puoi controllare i log.

   kubectl logs nvidia-devicequery-ppkd4
   

   Output di esempio

   /cuda-samples/sample Starting...
   CUDA Device Query (Runtime API) version (CUDART static linking)
   Detected 1 CUDA Capable device(s)
   Device 0: "Tesla P100-PCIE-16GB"
   CUDA Driver Version / Runtime Version          11.4 / 11.7
   CUDA Capability Major/Minor version number:    6.0
   Total amount of global memory:                 16281 MBytes (17071734784 bytes)
   (056) Multiprocessors, (064) CUDA Cores/MP:    3584 CUDA Cores
   GPU Max Clock rate:                            1329 MHz (1.33 GHz)
   Memory Clock rate:                             715 Mhz
   Memory Bus Width:                              4096-bit
   L2 Cache Size:                                 4194304 bytes
   Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
   Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
   Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
   Total amount of constant memory:               65536 bytes
   Total amount of shared memory per block:       49152 bytes
   Total shared memory per multiprocessor:        65536 bytes
   Total number of registers available per block: 65536
   Warp size:                                     32
   Maximum number of threads per multiprocessor:  2048
   Maximum number of threads per block:           1024
   Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
   Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
   Maximum memory pitch:                          2147483647 bytes
   Texture alignment:                             512 bytes
   Concurrent copy and kernel execution:          Yes with 2 copy engine(s)
   Run time limit on kernels:                     No
   Integrated GPU sharing Host Memory:            No
   Support host page-locked memory mapping:       Yes
   Alignment requirement for Surfaces:            Yes
   Device has ECC support:                        Enabled
   Device supports Unified Addressing (UVA):      Yes
   Device supports Managed Memory:                Yes
   Device supports Compute Preemption:            Yes
   Supports Cooperative Kernel Launch:            Yes
   Supports MultiDevice Co-op Kernel Launch:      Yes
   Device PCI Domain ID / Bus ID / location ID:   0 / 175 / 0
   Compute Mode:
   < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >
   deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 11.4, CUDA Runtime Version = 11.7, NumDevs = 1
   Result = PASS
   

   In questo esempio, vedi che una GPU è stata utilizzata per eseguire il lavoro perché la GPU era stata pianificata nel nodo di lavoro. Se il limite è impostato su 2, vengono visualizzate solo 2 GPU.

Ora che hai distribuito un carico di lavoro GPU di test, potresti voler configurare il tuo cluster per eseguire uno strumento che si basa sull'elaborazione GPU, come IBM Maximo Visual Inspection.