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 .