Ativando o painel do Kubernetes no console do IBM Cloud

1. Efetue login no console da IBM Cloud.
2. Na barra de menus, selecione a conta que você deseja usar.
3. No menu Ícone do menu , clique em Containers > Clusters.
4. Na página Clusters, clique no cluster que você deseja acessar.
5. Na página de detalhes do cluster, clique no botão Painel do Kubernetes.

Ativando o painel do Kubernetes por meio da CLI

O método CLI permite a automação e a integração de CI/CD. Instale a CLI antes de começar.

1. Obtenha suas credenciais do Kubernetes.

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

2. Copie o valor do token de identificação da saída.

3. Inicie o proxy.

   kubectl proxy
   

   Exemplo de saída

   Starting to serve on 127.0.0.1:8001
   

4. Conecte-se ao painel.

   1. Acesse o seguinte endereço URL no seu navegador:

       http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
       ```
   2. Selecione o método de autenticação **Token** na página de logon.
   
   3. Cole o valor **do id-token** no campo “**Token** ” e clique em “**ENTRAR** ”.
   
   

Use CTRL+C para sair do comando proxy. Execute kubectl proxy novamente para reiniciar o painel.

Pré-requisitos

Antes de Iniciar

• Crie um cluster ou um conjunto de trabalhadores que use um tipo de GPU Tenha em mente que a configuração de uma máquina bare metal pode levar mais de um dia útil para ser concluída. Para obter uma lista de tipos disponíveis, consulte os links a seguir:

  • Tipos clássicos
  • Tipos de VPC

• Certifique-se de que esteja designado a uma função de acesso ao serviço que concede a função apropriada de RBAC do Kubernetes para poder trabalhar com recursos do Kubernetes no cluster.

Para a versão Kubernetes 1.36 e posteriores: Você deve instalar e gerenciar a pilha de drivers da GPU NVIDIA por conta própria. IBM Cloud Kubernetes Service não fornece mais drivers de GPU pré-instalados nos nós de trabalho. Siga o guia de instalação do NVIDIA GPU Operator para instalar os componentes necessários:

• NVIDIA driver do kernel
• Componentes de tempo de execução do contêiner (por exemplo, nvidia-container-toolkit)
• Kubernetes plug-in de dispositivo

Até que o driver seja instalado, os pods que solicitam GPUs permanecerão no estado Pending. Eles farão a transição para Running automaticamente depois que um driver compatível estiver disponível no nó.

Para a versão Kubernetes 1.35 e anteriores: IBM- os drivers de GPU fornecidos são instalados automaticamente nos nós de trabalho da GPU. Não é necessário instalar nenhum driver adicional.

Implementando uma carga de trabalho

1. Crie um arquivo YAML. Neste exemplo, um arquivo YAML do tipo “ Job ” gerencia cargas de trabalho semelhantes a processamento em lote, criando um pod de curta duração que é executado até que o comando seja concluído e seja encerrado com sucesso.

   Para cargas de trabalho de GPU, é necessário especificar o campo resources: limits: nvidia.com/gpu no arquivo YAML da tarefa.

   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
   

   Compreensão de seus componentes YAML

   Componente	Descrição
   Metadados e nomes de rótulo	Insira um nome e um rótulo para a tarefa e use o mesmo nome nos metadados do arquivo e nos metadados do spec template. Por exemplo, nvidia-devicequery.
   containers.image	Forneça a imagem da qual o contêiner é uma instância em execução. Neste exemplo, o valor é configurado para usar a imagem de consulta do dispositivo CUDA DockerHub:nvcr.io/nvidia/k8s/cuda-sample:devicequery-cuda11.7.1-ubuntu20.04.
   containers.imagePullPolicy	Para puxar uma nova imagem somente se a imagem não estiver atualmente no nó do trabalhador, especifique IfNotPresent.
   resources.limits	Para máquinas de GPU, deve-se especificar o limite de recurso. O Plug-in do dispositivo do Kubernetes configura a solicitação de recursos padrão para corresponder ao limite. Deve-se especificar a chave como nvidia.com/gpu. Insira o número inteiro de GPUs solicitado, como 2. Observe que os pods de contêiner não compartilham GPUs e as GPUs não podem ser supercomprometidas. Por exemplo, se você tem somente 1 máquina mg1c.16x128, então tem apenas 2 GPUs nessa máquina e pode especificar um máximo de 2.

2. Aplique o arquivo YAML. Por exemplo:

   kubectl apply -f nvidia-devicequery.yaml
   

3. Verifique o pod de tarefa filtrando seus pods pelo rótulo “ nvidia-devicequery ”. Verifique se o STATUS é Concluído.

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

   Exemplo de saída

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

4. Descreva o pod para ver como o plug-in do dispositivo de GPU planejou o pod.

   • Nos campos Limits e Requests, veja se o limite de recurso que você especificou corresponde à solicitação que o plug-in do dispositivo configurou automaticamente.
   • Nos eventos, verifique se o pod está designado ao seu nó do trabalhador da GPU.

       kubectl describe pod nvidia-devicequery-ppkd4
       ```
       Exemplo de saída
       ```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. Para verificar se a tarefa usou a GPU para calcular sua carga de trabalho, é possível verificar os logs.

   kubectl logs nvidia-devicequery-ppkd4
   

   Exemplo de saída

   /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
   

   Neste exemplo, você vê que uma GPU foi usada para executar a tarefa, pois a GPU foi planejada no nó do trabalhador Se o limite for configurado para 2, apenas 2 GPUs serão mostradas.

Agora que você implementou uma carga de trabalho de GPU de teste, talvez deseje configurar o cluster para executar uma ferramenta que conte com processamento de GPU, como IBM Maximo Visual Inspection.