Flujo de trabajo de operadores de clúster para implementar cargas de trabajo de AI/ML en clústeres TKGS

Para permitir que los desarrolladores implementen cargas de trabajo de AI/ML en clústeres TKGS, como operador de clúster, configure el entorno de Kubernetes para que admita operaciones de NVIDIA vGPU.

Flujo de trabajo de operadores de clúster para implementar cargas de trabajo de AI/ML en clústeres TKGS

Los pasos de alto nivel para implementar cargas de trabajo de AI/ML en clústeres TKGS son los siguientes:

Paso	Acción	Vincular
0	Revise los requisitos del sistema.	Consulte Paso 0 del operador: Revisar los requisitos del sistema.
1	Descargue kubectl y el complemento de vSphere para Kubectl en la estación de trabajo local.	Consulte Paso 1 del operador: Instalar las Herramientas de la CLI de Kubernetes para vSphere en tu estación de trabajo.
2	Utilice kubectl para iniciar sesión en el clúster supervisor, el cual rellena .kube/config con el contexto del nuevo clúster supervisor.	Consulte Paso 2 del operador: Iniciar sesión en el clúster supervisor.
3	Utilice kubectl para cambiar el contexto al espacio de nombres de vSphere.	Consulte Paso 3 del operador: Cambiar el contexto al espacio de nombres de vSphere.
4	Utilice kubectl para enumerar las clases de máquina virtual y comprobar que está incluida la clase habilitada para NVIDIA vGPU.	Consulte Paso 4 del operador: Obtener la clase de máquina virtual personalizada para cargas de trabajo de vGPU.
5	Utilice kubectl para enumerar las versiones de Tanzu Kubernetes disponibles y comprobar que está incluida la imagen de Ubuntu.	Consulte Paso 5 del operador: Obtener la versión de Tanzu Kubernetes de Ubuntu para los nodos de GPU.
6	Diseñe la especificación de YAML para aprovisionar el clúster TKGS habilitado para GPU; especifique la versión de TKR y la clase de máquina virtual.	Consulte Paso 6 del operador: Diseñar el YAML para aprovisionar el clúster TKGS habilitado para vGPU.
7	Aprovisione el clúster TKGS.	Consulte Paso 7 del operador: Aprovisionar el clúster TKGS.
8	Inicie sesión en el clúster y compruebe el aprovisionamiento.	Consulte Paso 8 del operador: Iniciar sesión en el clúster TKGS y comprobar el aprovisionamiento.
9	Prepárese para instalar el operador de GPU NVAIE. Para ello, cree algunos objetos como requisito previo en el clúster TKGS, incluidos un espacio de nombres, enlaces de funciones, el secreto de imagen y el mapa de configuración de licencia.	Consulte Paso 9 del operador: Prepararse para instalar el operador de GPU NVAIE.
10	Instale el operador de GPU NVAIE en el clúster.	Consulte Paso 10 del operador: Instalar el operador de GPU NVIDIA en el clúster.
11	Implemente cargas de trabajo de AI/ML en el clúster TKGS habilitado para vGPU.	Consulte Paso 11 del operador: Implementar una carga de trabajo de AI/ML.

Paso 0 del operador: Revisar los requisitos del sistema

Consulte los siguientes requisitos del sistema para configurar el entorno de implementación de cargas de trabajo de AI/ML en clústeres TKGS.

Requisito	Descripción
El administrador de vSphere ha configurado el entorno para NVIDIA vGPU	Consulte Flujo de trabajo del administrador de vSphere para implementar cargas de trabajo de AI/ML en clústeres TKGS (vGPU).
OVA de TKR Ubuntu	versión de Tanzu Kubernetes Ubuntu ob-18691651-tkgs-ova-ubuntu-2004-v1.20.8---vmware.1-tkg.2
Aprovisionador de clúster TKG	servicio Tanzu Kubernetes Grid Versión de API: run.tanzu.vmware.com/v1alpha2
Operador de GPU NVIDIA	Operador de GPU v1.8.0
Contenedor del controlador de GPU NVIDIA	nvcr.io/nvstating/cnt-ea/driver:470.51-ubuntu20.04

Paso 1 del operador: Instalar las Herramientas de la CLI de Kubernetes para vSphere en tu estación de trabajo

Descargue e instale las Herramientas de la CLI de Kubernetes para vSphere.

Si utiliza Linux, puede ejecutar el siguiente comando para descargar las herramientas.

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

Para obtener más instrucciones, consulte Descargar e instalar Herramientas de la CLI de Kubernetes para vSphere.

Paso 2 del operador: Iniciar sesión en el clúster supervisor

Utilice el complemento de vSphere para kubectl para autenticarse en clúster supervisor.

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

Paso 3 del operador: Cambiar el contexto al espacio de nombres de vSphere

Con kubectl, cambie el contexto al espacio de nombres de vSphere que creó el administrador de vSphere para el clúster de GPU TKGS.

kubectl config get-contexts

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

Paso 4 del operador: Obtener la clase de máquina virtual personalizada para cargas de trabajo de vGPU

Compruebe que la clase de máquina virtual personalizada con el perfil de vGPU que creó el administrador de vSphere esté disponible en el espacio de nombres de vSphere de destino.

kubectl get virtualmachineclassbindings

Nota: La clase de máquina virtual debe estar enlazada al espacio de nombres de vSphere de destino. Si no ve la clase de máquina virtual personalizada para cargas de trabajo de vGPU, consulte con el administrador de vSphere.

Paso 5 del operador: Obtener la versión de Tanzu Kubernetes de Ubuntu para los nodos de GPU

Compruebe que la versión de Tanzu Kubernetes de Ubuntu que se requiere y que sincronizó el administrador de vSphere desde la biblioteca de contenido esté disponible en el espacio de nombres de vSphere.

kubectl get tanzukubernetesreleases

O bien utilice el acceso directo:

kubectl get tkr

Paso 6 del operador: Diseñar el YAML para aprovisionar el clúster TKGS habilitado para vGPU

Cree el archivo YAML para el aprovisionamiento de un clúster de Tanzu Kubernetes.

Comience con uno de los siguientes ejemplos. Utilice la información que recopiló entre los resultados de los comandos anteriores para personalizar la especificación del clúster. Consulte la lista completa de parámetros de configuración: API v1alpha2 de TKGS para aprovisionar clústeres de Tanzu Kubernetes

El ejemplo 1 especifica dos grupos de nodos de trabajo.

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

El ejemplo 2 especifica un volumen independiente en los nodos de trabajo para el tiempo de ejecución en contenedor con una capacidad de 50 GiB. Esta opción se puede configurar. Se recomienda proporcionar un volumen independiente de buen tamaño para las cargas de trabajo de AI/ML basadas en contenedores.

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

El ejemplo 3 incluye metadatos adicionales del clúster, como una etiqueta.

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

Paso 7 del operador: Aprovisionar el clúster TKGS

Ejecute el siguiente comando kubectl para aprovisionar el clúster.

kubectl apply -f CLUSTER-NAME.yaml

Por ejemplo:

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

Supervise la implementación de nodos del clúster mediante kubectl.

kubectl get tanzukubernetesclusters -n NAMESPACE

Paso 8 del operador: Iniciar sesión en el clúster TKGS y comprobar el aprovisionamiento

Con el complemento de vSphere para kubectl, inicie sesión en el clúster TKGS.

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

Con los comandos siguientes, compruebe el clúster:

kubectl cluster-info

kubectl get nodes

kubectl get namespaces

kubectl api-resources

Paso 9 del operador: Prepararse para instalar el operador de GPU NVAIE

Antes de instalar el operador de GPU con NVIDIA AI Enterprise, complete las siguientes tareas para el clúster TKGS que aprovisionó. Para obtener más instrucciones, consulte Tareas obligatorias previas en la documentación de NVAIE.

Nota: Si utiliza el servidor de licencias delegado (DLS) de NVIDIA, consulte el siguiente tema para obtener instrucciones: Anexo de operadores de clúster para implementar cargas de trabajo de AI/ML en clústeres TKGS (DLS)

1. Cree el espacio de nombres de Kubernetes gpu-operator-resources. Como práctica recomendada, implemente siempre todo lo que haya en este espacio de nombres.

   kubectl create ns gpu-operator-resources

2. Cree enlaces de funciones.

   Los clústeres de Tanzu Kubernetes tienen habilitada la directiva de seguridad de pods.

   Cree 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 el enlace de función.

   kubectl apply -f rolebindings.yaml

   Cree 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 el enlace de función:

   kubectl apply -f post-rolebindings.yaml

3. Cree un secreto de imagen con credenciales de NGC que Docker pueda utilizar para extraer imágenes de contenedor del catálogo de NVIDIA GPU Cloud.

   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. Cree un mapa de configuración para el servidor de licencias de NVIDIA.

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

   gridd.conf hace referencia a la dirección del servidor de licencias de NVIDIA; por ejemplo:

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

Paso 10 del operador: Instalar el operador de GPU NVIDIA en el clúster

Instale la versión 1.8.0 del operador de GPU NVAIE en el clúster TKGS. Para ver más instrucciones, consulte la documentación del operador de GPU.

Nota: Si utiliza el servidor de licencias delegado (DLS) de NVIDIA, consulte el siguiente tema para obtener instrucciones: Anexo de operadores de clúster para implementar cargas de trabajo de AI/ML en clústeres TKGS (DLS)

1. Para instalar Helm, consulte la documentación de Helm.
2. Agregue el repositorio de Helm gpu-operator.

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

3. Instale el operador de GPU NVAIE con el siguiente comando.

   Cuando sea necesario, sustituya los valores de variable de entorno por los que coincidan con su entorno.

   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

Paso 11 del operador: Implementar una carga de trabajo de AI/ML

El catálogo de NVIDIA GPU Cloud ofrece varias imágenes de contenedor que se encuentran disponibles para ejecutar cargas de trabajo de AI/ML en los clústeres de Tanzu Kubernetes habilitados para vGPU. Para obtener más información sobre las imágenes disponibles, consulte la documentación de NGC.