Fluxo de trabalho do operador de cluster para a implantação de cargas de trabalho de AI / ML em clusters TKGS

Para permitir que os desenvolvedores implantem cargas de trabalho de AI / ML em clusters TKGS, como operador de cluster, você configura o ambiente do Kubernetes para oferecer suporte a operações NVIDIA vGPU.

Fluxo de trabalho do operador de cluster para a implantação de cargas de trabalho de AI / ML em clusters TKGS

As etapas de alto nível para implantar cargas de trabalho de AI / ML em clusters TKGS são as seguintes:

Etapa	Ação	Link
0	Revise os requisitos do sistema.	Consulte o Etapa 0 do operador: revisão dos requisitos do sistema.
1	Baixe kubectl e vSphere Plugin for Kubectl para a estação de trabalho local.	Consulte o Etapa 1 do operador: instalar o Kubernetes CLI Tools for vSphere na sua estação de trabalho.
2	Use kubectl para fazer login no Cluster de Supervisor, que preenche .kube / config com o contexto para o novo Cluster de Supervisor.	Consulte o Etapa 2 do operador: fazer login no cluster de supervisor.
3	Use kubectl para alternar o contexto para o Namespace do vSphere.	Consulte o Etapa 3 do operador: alternar o contexto para o namespace do vSphere.
4	Use kubectl para listar classes de VM e verificar se a classe habilitada para NVIDIA vGPU está presente.	Consulte o Etapa 4 do operador: obter a classe de VM personalizada para cargas de trabalho vGPU.
5	Use kubectl para listar as versões disponíveis do Tanzu Kubernetes e verifique se a imagem do Ubuntu está presente.	Consulte o Etapa 5 do operador: obter a versão do Ubuntu Tanzu Kubernetes para nós de GPU.
6	Elabore a especificação YAML para provisionar o cluster TKGS habilitado para GPU; especifique a versão do TKR e a classe da VM.	Consulte o Etapa 6 do operador: criar o YAML para provisionar o cluster TKGS habilitado para vGPU.
7	Provisione o cluster TKGS.	Consulte o Etapa 7 do operador: provisionar o cluster TKGS.
8	Faça login no cluster e verifique o provisionamento.	Consulte o Etapa 8 do operador: fazer login no cluster TKGS e verificar o provisionamento.
9	Prepare-se para instalar o NVAIE GPU Operator criando alguns objetos de pré-requisito no cluster TKGS, incluindo um namespace, associações de função, segredo de imagem e configmap de licença.	Consulte o Etapa 9 do operador: preparar para instalar o operador NVAIE GPU.
10	Instale o NVAIE GPU Operator no cluster.	Consulte o Etapa 10 do operador: instalar o operador de GPU NVIDIA no cluster.
11	Implante cargas de trabalho de AI / ML no cluster TKGS habilitado para vGPU.	Consulte o Etapa 11 do operador: implantar uma carga de trabalho de IA / ML.

Etapa 0 do operador: revisão dos requisitos do sistema

Consulte os seguintes requisitos do sistema para configurar o ambiente para implantar cargas de trabalho de AI / ML em clusters TKGS.

Requisito	Descrição
O vSphere Administrator configurou o ambiente para NVIDIA vGPU	Consulte Fluxo de trabalho do administrador do vSphere para a implantação de cargas de trabalho de AI / ML em clusters TKGS (vGPU)
TKR Ubuntu OVA	Tanzu Kubernetes release Ubuntu ob-18691651-tkgs-ova-ubuntu-2004-v1.20.8---vmware.1-tkg.2
Provisionador de Cluster TKG	Tanzu Kubernetes Grid Service Versão da API: run.tanzu.vmware.com/v1alpha2
NVIDIA GPU Operator	GPU Operator v1.8.0
Contêiner de driver de GPU NVIDIA	nvcr.io/nvstating/cnt-ea/driver:470.51-ubuntu20.04

Etapa 1 do operador: instalar o Kubernetes CLI Tools for vSphere na sua estação de trabalho

Baixe e instale o Kubernetes CLI Tools for vSphere.

Se você estiver usando o Linux, poderá executar o seguinte comando para baixar as ferramentas.

curl -LOk https://${SC_IP}/wcp/plugin/linux-amd64/vsphere-plugin.zip
unzip vsphere-plugin.zip
mv -v bin/* /usr/local/bin/

Para obter orientação adicional, consulte Baixe e instale o Kubernetes CLI Tools for vSphere.

Etapa 2 do operador: fazer login no cluster de supervisor

Usando o vSphere Plugin for kubectl, autentique-se com o Supervisor Cluster.

kubectl vsphere login --server=IP-ADDRESS --vsphere-username USERNAME

Etapa 3 do operador: alternar o contexto para o namespace do vSphere

Usando kubectl, alterne o contexto para o vSphere Namespace que o administrador do vSphere criou para o cluster de GPU TKGS.

kubectl config get-contexts

kubectl config use-context TKGS-GPU-CLUSTER-NAMESPACE

Etapa 4 do operador: obter a classe de VM personalizada para cargas de trabalho vGPU

Verifique se a classe de VM personalizada com o perfil vGPU que o administrador do vSphere criou está disponível no vSphere Namespace de destino.

kubectl get virtualmachineclassbindings

Observação: A classe de VM deve ser vinculada ao vSphere Namespace de destino. Se você não vir a classe de VM personalizada para cargas de trabalho do vGPU, verifique com o Administrador do vSphere.

Etapa 5 do operador: obter a versão do Ubuntu Tanzu Kubernetes para nós de GPU

Verifique se o Ubuntu necessário Tanzu Kubernetes release que o Administrador do vSphere sincronizou da Biblioteca de conteúdo está disponível no vSphere Namespace.

kubectl get tanzukubernetesreleases

Ou, usando o atalho:

kubectl get tkr

Etapa 6 do operador: criar o YAML para provisionar o cluster TKGS habilitado para vGPU

Construa o arquivo YAML para provisionar um cluster do Tanzu Kubernetes.

Comece com um dos exemplos abaixo. Use as informações coletadas da saída dos comandos anteriores para personalizar a especificação do cluster. Consulte a lista completa de parâmetros de configuração: Parâmetros de configuração para o provisionamento de clusters Tanzu Kubernetes usando a API do Tanzu Kubernetes Grid Service v1alpha2.

O exemplo 1 especifica dois pools de nós de trabalhador.

apiVersion: run.tanzu.vmware.com/v1alpha2
kind: TanzuKubernetesCluster
metadata:
   #cluster name
   name: tkgs-cluster-gpu-a100
   #target vsphere namespace
   namespace: tkgs-gpu-operator
spec:
   topology:
     controlPlane:
       replicas: 3
       #storage class for control plane nodes
       #use `kubectl describe storageclasses`
       #to get available pvcs
       storageClass: vwt-storage-policy
       vmClass: guaranteed-medium
       #TKR NAME for Ubuntu ova supporting GPU
       tkr:
         reference:
           name: 1.20.8---vmware.1-tkg.1
     nodePools:
     - name: nodepool-a100-primary
       replicas: 3
       storageClass: vwt-storage-policy
       #custom VM class for vGPU
       vmClass: class-vgpu-a100
       #TKR NAME for Ubuntu ova supporting GPU 
       tkr:
         reference:
           name: 1.20.8---vmware.1-tkg.1
     - name: nodepool-a100-secondary
       replicas: 3
       vmClass: class-vgpu-a100
       storageClass: vwt-storage-policy
       #TKR NAME for Ubuntu ova supporting GPU
       tkr:
         reference:
           name: 1.20.8---vmware.1-tkg.1
   settings:
     storage:
       defaultClass: vwt-storage-policy
     network:
       cni:
        name: antrea
       services:
        cidrBlocks: ["198.51.100.0/12"]
       pods:
        cidrBlocks: ["192.0.2.0/16"]
       serviceDomain: managedcluster.local

O exemplo 2 especifica um volume separado em nós de trabalho para o tempo de execução de contenção com uma capacidade de 50 GiB. É possível configurar esta definição. O fornecimento de um volume separado de bom tamanho é recomendado para cargas de trabalho de AI / ML baseadas em contêiner.

apiVersion: run.tanzu.vmware.com/v1alpha2
kind: TanzuKubernetesCluster
metadata:
  name: tkc
  namespace: tkg-ns-auto
spec:
  distribution:
    fullVersion: v1.20.8+vmware.1-tkg.1
  topology:
    controlPlane:
      replicas: 3
      storageClass: vwt-storage-policy
      tkr:
        reference:
          name: v1.20.8---vmware.1-tkg.1
      vmClass: best-effort-medium
    nodePools:
    - name: workers
      replicas: 3
      storageClass: k8s-storage-policy
      tkr:
        reference:
          name: v1.20.8---vmware.1-tkg.1
      vmClass: vmclass-vgpu
      volumes:
      - capacity:
          storage: 50Gi
        mountPath: /var/lib/containerd
        name: containerd
      - capacity:
          storage: 50Gi
        mountPath: /var/lib/kubelet
        name: kubelet
    - name: nodepool-1
      replicas: 1
      storageClass: vwt-storage-policy
      vmClass: best-effort-medium

O exemplo 3 inclui metadados adicionais do cluster, como um rótulo.

apiVersion: run.tanzu.vmware.com/v1alpha2
kind: TanzuKubernetesCluster
metadata:
  annotations:
  labels:
    run.tanzu.vmware.com/tkr: v1.20.8---vmware.1-tkg.1
  name: tkgs-gpu-direct-rdma
  namespace: tkgs-ns
spec:
  settings:
    network:
      cni:
        name: antrea
      pods:
        cidrBlocks:
        - 192.168.0.0/16
      serviceDomain: cluster.local
      services:
        cidrBlocks:
        - 10.96.0.0/12
  topology:
    controlPlane:
      replicas: 3
      storageClass: tkgs-storage-policy
      vmClass: guaranteed-medium
      tkr:
        reference:
          name: v1.20.8---vmware.1-tkg.1
    nodePools:
    - name: workers
      replicas: 5
      storageClass: tkgs-storage-policy
      vmClass: claire-gpu-direct-rdma
      volumes:
      - capacity:
          storage: 50Gi
        mountPath: /var/lib/containerd
        name: containerd
      - capacity:
          storage: 50Gi
        mountPath: /var/lib/kubelet
        name: kubelet
      tkr:
        reference:
          name: v1.20.8---vmware.1-tkg.1

Etapa 7 do operador: provisionar o cluster TKGS

Provisione o cluster executando o seguinte comando kubectl.

kubectl apply -f CLUSTER-NAME.yaml

Por exemplo:

kubectl apply -f tkgs-gpu-cluster-1.yaml

Monitore a implantação de nós do cluster usando kubectl.

kubectl get tanzukubernetesclusters -n NAMESPACE

Etapa 8 do operador: fazer login no cluster TKGS e verificar o provisionamento

Usando o vSphere Plugin for kubectl, faça login no cluster TKGS.

kubectl vsphere login --server=IP-ADDRESS --vsphere-username USERNAME \
--tanzu-kubernetes-cluster-name CLUSTER-NAME --tanzu-kubernetes-cluster-namespace NAMESPACE-NAME

Use os seguintes comandos para verificar o cluster:

kubectl cluster-info

kubectl get nodes

kubectl get namespaces

kubectl api-resources

Etapa 9 do operador: preparar para instalar o operador NVAIE GPU

Antes de instalar o GPU Operator com NVIDIA AI Enterprise, conclua as seguintes tarefas para o cluster TKGS que você provisionou. Para obter orientação adicional, consulte Tarefas de pré-requisitos na documentação do NVAIE.

Observação: Se você estiver usando o NVIDIA Delegated Licensing Server (DLS), consulte o seguinte tópico para obter instruções: Cluster Operator Addendum for Deploying AI / ML Workloads on TKGS Clusters (DLS)

1. Crie o namespace Kubernetes gpu-operator-resources. Como prática recomendada, sempre implante tudo nesse namespace.

   kubectl create ns gpu-operator-resources

2. Crie associações de função.

   Os clusters Tanzu Kubernetes têm a política de segurança de pod ativada.

   Crie rolebidings.yaml .

   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: psp:vmware-system-privileged:default
     namespace: default
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: psp:vmware-system-privileged
   subjects:
   - apiGroup: rbac.authorization.k8s.io
     kind: Group
     name: system:nodes
   - apiGroup: rbac.authorization.k8s.io
     kind: Group
     name: system:serviceaccounts

   Aplique a associação de função.

   kubectl apply -f rolebindings.yaml

   Crie post-rolebindings.yaml .

   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: psp:vmware-system-privileged:gpu-operator-resources
     namespace: gpu-operator-resources
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: psp:vmware-system-privileged
   subjects:
   - kind: Group
     apiGroup: rbac.authorization.k8s.io
     name: system:serviceaccounts

   Aplique a associação de função:

   kubectl apply -f post-rolebindings.yaml

3. Crie um segredo de imagem com credenciais NGC que possa ser usado pelo Docker para extrair imagens de contêiner do Catálogo de Nuvem de GPU NVIDIA .

   kubectl create secret docker-registry registry-secret \
        --docker-server=server-name --docker-username='$oauthtoken' \
        --docker-password=<place_holder> \
        --docker-email=email-name -n gpu-operator-resources

4. Crie um mapa de configuração para o servidor de licença NVIDIA.

   kubectl create configmap licensing-config -n gpu-operator-resources --from-file=gridd.conf

   A referência de gridd.conf ao endereço do servidor de licença NVIDIA, por exemplo:

   # Description: Set License Server Address
   # Data type: string
   # Format:  "<address>"
   ServerAddress=<place_holder>
   

Etapa 10 do operador: instalar o operador de GPU NVIDIA no cluster

Instale o NVAIE GPU Operator versão 1.8.0 no cluster TKGS. Para obter orientação adicional, consulte a documentação do operador de GPU https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/platform-support.html.

Observação: Se você estiver usando o NVIDIA Delegated Licensing Server (DLS), consulte o seguinte tópico para obter instruções: Cluster Operator Addendum for Deploying AI / ML Workloads on TKGS Clusters (DLS)

1. Instale o Helm consultando a documentação do Helm .
2. Adicione o repositório do gpu-operator Helm.

   helm repo add nvidia https://nvidia.github.io/gpu-operator

3. Instale o NVAIE GPU Operator executando o seguinte comando.

   Quando necessário, substitua os valores das variáveis de ambiente por aqueles que correspondem ao seu ambiente.

   export PRIVATE_REGISTRY="private/registry/path"
   export OS_TAG=ubuntu20.04
   export VERSION=460.73.01
   export VGPU_DRIVER_VERSION=460.73.01-grid
   export NGC_API_KEY=ZmJjMHZya...LWExNTRi
   export REGISTRY_SECRET_NAME=registry-secret
   
   helm install nvidia/gpu-operator \
      --set driver.repository=$PRIVATE_REGISTRY \
      --set driver.version=$VERSION \
      --set driver.imagePullSecrets={$REGISTRY_SECRET_NAME} \
      --set operator.defaultRuntime=containerd \
      --set driver.licensingConfig.configMapName=licensing-config

Etapa 11 do operador: implantar uma carga de trabalho de IA / ML

O NVIDIA GPU Cloud Catalog oferece várias imagens de contêiner prontas para uso que você pode usar para executar cargas de trabalho de IA / ML em seus clusters do Tanzu Kubernetes habilitados para vGPU. Para obter mais informações sobre as imagens disponíveis, consulte a documentação do NGC .