Pour permettre aux développeurs de déployer des charges de travail AI/ML sur des clusters TKGS, en tant qu'opérateur de cluster, vous configurez l'environnement Kubernetes pour prendre en charge les opérations NVIDIA vGPU.

Workflow de l'opérateur de cluster pour le déploiement de charges de travail AI/ML sur des clusters TKGS

Les étapes de haut niveau du déploiement des charges de travail AI/ML sur des clusters TKGS sont les suivantes :
Étape Action Lier
0

Vérifiez la configuration système requise.

 Reportez-vous à la section Étape 0 pour l'opérateur : Vérification de la configuration système requise.
1 Téléchargez kubectl et le plug-in vSphere pour Kubectl sur le poste de travail local. Reportez-vous à la section Étape 1 pour l'opérateur : Installation de Outils de l'interface de ligne de commande Kubernetes pour vSphere sur votre Workstation.
2 Utilisez kubectl pour vous connecter au cluster superviseur, qui remplit .kube/config avec le contexte du nouveau cluster superviseur. Reportez-vous à la section Étape 2 pour l'opérateur : Connexion au cluster superviseur.
3 Utilisez kubectl pour faire basculer le contexte vers l'espace de noms vSphere. Reportez-vous à la section Étape 3 pour l'opérateur : Basculement du contexte vers l'espace de noms vSphere.
4 Utilisez kubectl pour répertorier les classes de machine virtuelle et assurez-vous que la classe compatible avec NVIDIA vGPU est présente. Reportez-vous à la section Étape 4 pour l'opérateur : Obtention de la classe de machine virtuelle personnalisée pour les charges de travail vGPU.
5 Utilisez kubectl pour répertorier les versions de Tanzu Kubernetes disponibles et assurez-vous que l'image Ubuntu est présente. Reportez-vous à la section Étape 5 pour l'opérateur : Obtention de la version Tanzu Kubernetes d'Ubuntu pour les nœuds GPU.
6 Créez la spécification YAML pour le provisionnement du cluster TKGS compatible avec GPU ; spécifiez la version de TKR et la classe de machine virtuelle. Reportez-vous à la section Étape 6 pour l'opérateur : Création du YAML pour le provisionnement du cluster TKGS compatible avec vGPU.
7 Provisionnez le cluster TKGS. Reportez-vous à la section Étape 7 pour l'opérateur : Provisionnement du cluster TKGS.
8 Connectez-vous au cluster et vérifiez le provisionnement. Reportez-vous à la section Étape 8 pour l'opérateur : Connexion au cluster TKGS et vérification du provisionnement.
9 Préparez-vous à installer l'opérateur GPU NVAIE en créant certains objets prérequis dans le cluster TKGS, notamment un espace de noms, des liaisons de rôle, un secret d'image et un configmap de licence. Reportez-vous à la section Étape 9 pour l'opérateur : Préparation de l'installation de l'opérateur NVAIE GPU.
10 Installez l'opérateur NVAIE GPU dans le cluster. Reportez-vous à la section Étape 10 pour l'opérateur : Installation de l'opérateur NVIDIA GPU dans le cluster.
11 Déployez des charges de travail AI/ML sur le cluster TKGS compatible avec vGPU. Reportez-vous à la section Étape 11 pour l'opérateur : Déploiement d'une charge de travail AI/ML.

Étape 0 pour l'opérateur : Vérification de la configuration système requise

Reportez-vous à la configuration système requise suivante pour configurer l'environnement de déploiement de charges de travail AI/ML sur des clusters TKGS.
Serveur Description

vSphere Administrator a configuré l'environnement pour NVIDIA vGPU

Reportez-vous à la section Workflow de l'administrateur vSphere pour le déploiement de charges de travail AI/ML sur des clusters TKGS (vGPU).
Fichier OVA TKR Ubuntu

Version de Tanzu Kubernetes Ubuntu

ob-18691651-tkgs-ova-ubuntu-2004-v1.20.8---vmware.1-tkg.2
Provisionneur de cluster TKG

Service Tanzu Kubernetes Grid

Version de l'API : run.tanzu.vmware.com/v1alpha2

Opérateur NVIDIA GPU

Opérateur GPU v1.8.0

Conteneur de pilote NVIDIA GPU

nvcr.io/nvstating/cnt-ea/driver:470.51-ubuntu20.04

Étape 1 pour l'opérateur : Installation de Outils de l'interface de ligne de commande Kubernetes pour vSphere sur votre Workstation

Téléchargez et installez les Outils de l'interface de ligne de commande Kubernetes pour vSphere .

Si vous utilisez Linux, vous pouvez exécuter la commande suivante pour télécharger les outils.

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

Pour des commandes supplémentaires, consultez Télécharger et installer les Outils de l'interface de ligne de commande Kubernetes pour vSphere.

Étape 2 pour l'opérateur : Connexion au cluster superviseur

À l'aide du Plug-in vSphere pour kubectl, authentifiez-vous dans le Cluster superviseur. 
kubectl vsphere login --server=IP-ADDRESS --vsphere-username USERNAME

Étape 3 pour l'opérateur : Basculement du contexte vers l'espace de noms vSphere

À l'aide de kubectl, faites basculer le contexte sur le Espace de noms vSphere que l'administrateur vSphere a créé pour le cluster TKGS GPU. 
kubectl config get-contexts
kubectl config use-context TKGS-GPU-CLUSTER-NAMESPACE

Étape 4 pour l'opérateur : Obtention de la classe de machine virtuelle personnalisée pour les charges de travail vGPU

Assurez-vous que la classe de machine virtuelle personnalisée avec le profil vGPU que l'administrateur vSphere a créé est disponible dans le Espace de noms vSphere cible. 
kubectl get virtualmachineclassbindings
Note : La classe de machine virtuelle doit être liée au Espace de noms vSphere cible. Si vous ne voyez pas la classe de machine virtuelle personnalisée pour les charges de travail vGPU, vérifiez auprès de l'administrateur vSphere.

Étape 5 pour l'opérateur : Obtention de la version Tanzu Kubernetes d'Ubuntu pour les nœuds GPU

Assurez-vous que la Version de Tanzu Kubernetes d'Ubuntu requise que l'administrateur vSphere a synchronisée à partir de la bibliothèque de contenu est disponible dans le Espace de noms vSphere. 
kubectl get tanzukubernetesreleases
Ou, en utilisant le raccourci : 
kubectl get tkr

Étape 6 pour l'opérateur : Création du YAML pour le provisionnement du cluster TKGS compatible avec vGPU

Créez le fichier YAML pour le provisionnement d'un cluster Tanzu Kubernetes.

Commencez par l'un des exemples ci-dessous. Utilisez les informations que vous avez collectées à partir de la sortie des commandes précédentes pour personnaliser la spécification de cluster. Reportez-vous à la liste complète des paramètres de configuration : API TKGS v1alpha2 pour le provisionnement des clusters Tanzu Kubernetes.

L'exemple 1 comporte deux pools de nœuds worker. 
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
L'exemple 2 comporte un volume distinct sur les nœuds worker pour l'exécution en conteneur avec une capacité de 50 Gio. Ce paramètre peut être configuré. Il est recommandé de fournir un volume distinct de bonne taille pour les charges de travail AI/ML basées sur un conteneur. 
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
L'exemple 3 comporte des métadonnées supplémentaires de cluster, telles qu'une étiquette. 
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

Étape 7 pour l'opérateur : Provisionnement du cluster TKGS

Provisionnez le cluster en exécutant la commande kubectl suivante. 
kubectl apply -f CLUSTER-NAME.yaml
Par exemple : 
kubectl apply -f tkgs-gpu-cluster-1.yaml
Surveillez le déploiement des nœuds de cluster à l'aide de kubectl. 
kubectl get tanzukubernetesclusters -n NAMESPACE

Étape 8 pour l'opérateur : Connexion au cluster TKGS et vérification du provisionnement

À l'aide du Plug-in vSphere pour kubectl, connectez-vous au cluster TKGS. 
kubectl vsphere login --server=IP-ADDRESS --vsphere-username USERNAME \
--tanzu-kubernetes-cluster-name CLUSTER-NAME --tanzu-kubernetes-cluster-namespace NAMESPACE-NAME
Utilisez la commande suivante pour vérifier le cluster : 
kubectl cluster-info
kubectl get nodes
kubectl get namespaces
kubectl api-resources

Étape 9 pour l'opérateur : Préparation de l'installation de l'opérateur NVAIE GPU

Avant d'installer l'opérateur GPU avec NVIDIA AI Enterprise, effectuez les tâches suivantes pour le cluster TKGS que vous avez provisionné. Pour obtenir des instructions supplémentaires, reportez-vous à la section Conditions préalables de la documentation sur NVAIE.
Note : Si vous utilisez le serveur DLS (Delegated Licensing Server) NVIDIA, reportez-vous à la rubrique suivante pour obtenir des instructions : Addendum à l'intention des opérateurs de cluster pour le déploiement de charges de travail AI/ML sur des clusters TKGS (DLS)
  1. Créez l'espace de noms Kubernetes gpu-operator-resources. Il est recommandé de toujours déployer tout ce qui se trouve dans cet espace de noms.
    kubectl create ns gpu-operator-resources
  2. Créez des liaisons de rôles.

    La stratégie de sécurité de l'espace est activée sur les clusters Tanzu Kubernetes.

    Créez 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
    Appliquez la liaison de rôle. 
    kubectl apply -f rolebindings.yaml
    Créez 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
    Appliquez la liaison de rôle : 
    kubectl apply -f post-rolebindings.yaml
  3. Créez un secret d'image avec des informations d'identification NGC qui peuvent être utilisées par Docker pour extraire des images de conteneur du catalogue 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. Créez un fichier configmap pour le License Server NVIDIA.
    kubectl create configmap licensing-config -n gpu-operator-resources --from-file=gridd.conf

    Le gridd.conf fait référence à l'adresse du License Server NVIDIA, par exemple :

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

Étape 10 pour l'opérateur : Installation de l'opérateur NVIDIA GPU dans le cluster

Installez l' opérateur NVIDIA GPU version 1.8.0 dans le cluster TKGS. Pour obtenir des instructions supplémentaires, reportez-vous à la documentation de l'opérateur GPU.
Note : Si vous utilisez le serveur DLS (Delegated Licensing Server) NVIDIA, reportez-vous à la rubrique suivante pour obtenir des instructions : Addendum à l'intention des opérateurs de cluster pour le déploiement de charges de travail AI/ML sur des clusters TKGS (DLS)
  1. Installez Helm en vous référant à la documentation Helm.
  2. Ajoutez le référentiel Helm d'gpu-operator suivant :
    helm repo add nvidia https://nvidia.github.io/gpu-operator
  3. Obtenez l'opérateur NVAIE GPU en exécutant la commande suivante :

    Si nécessaire, remplacez les valeurs des variables d'environnement par celles qui correspondent à votre environnement.

    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

Étape 11 pour l'opérateur : Déploiement d'une charge de travail AI/ML

Le catalogue NVIDIA GPU Cloud propose plusieurs images de conteneur prêtes à l'emploi que vous pouvez utiliser pour exécuter des charges de travail AI/ML sur vos clusters Tanzu Kubernetes compatibles avec vGPU. Pour plus d'informations sur les images disponibles, reportez-vous à la documentation NGC.