Cluster-Operator-Workflow für die Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern

Damit Entwickler KI-/ML-Arbeitslasten auf TKGS-Clustern bereitstellen können, konfigurieren Sie als Cluster-Operator die Kubernetes-Umgebung zur Unterstützung von NVIDIA vGPU-Vorgängen.

Cluster-Operator-Workflow für die Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern

Die allgemeinen Schritte zum Bereitstellen von KI-/ML-Arbeitslasten auf TKGS-Clustern lauten wie folgt:

Schritt	Aktion	Verknüpfen
0	Überprüfen der Systemanforderungen.	Weitere Informationen finden Sie unter Schritt 0 für Operatoren: Überprüfen der Systemanforderungen.
1	Herunterladen von kubectl und des vSphere-Plug-Ins für Kubectl auf die lokale Arbeitsstation.	Weitere Informationen finden Sie unter Schritt 1 für Operatoren: Installieren der Kubernetes-CLI-Tools für vSphere auf Ihrer Arbeitsstation.
2	Verwenden von kubectl zum Anmelden beim Supervisor-Cluster, der .kube/config mit dem Kontext für den neuen Supervisor-Cluster befüllt.	Weitere Informationen finden Sie unter Schritt 2 für Operatoren: Anmelden beim Supervisor-Cluster.
3	Verwenden von kubectl zum Durchführen eines Kontextwechsels zum vSphere-Namespace.	Weitere Informationen finden Sie unter Schritt 3 für Operatoren: Wechseln des Kontexts zum vSphere-Namespace.
4	Verwenden von kubectl zum Auflisten von VM-Klassen und Sicherstellen, dass die NVIDIA vGPU-fähige Klasse vorhanden ist.	Weitere Informationen finden Sie unter Schritt 4 für Operatoren: Abrufen der benutzerdefinierten VM-Klasse für vGPU-Arbeitslasten.
5	Verwenden von kubectl zum Auflisten der verfügbaren Tanzu Kubernetes-Versionen und Sicherstellen, dass das Ubuntu-Image vorhanden ist.	Weitere Informationen finden Sie unter Schritt 5 für Operatoren: Abrufen der Ubuntu Tanzu Kubernetes-Version für GPU-Knoten.
6	Erstellen der YAML-Spezifikation zur Bereitstellung des GPU-fähigen TKGS-Clusters, Angeben der TKR-Version und der VM-Klasse.	Weitere Informationen finden Sie unter Schritt 6 für Operatoren: Erstellen der YAML für die Bereitstellung des vGPU-fähigen TKGS-Clusters.
7	Bereitstellen des TKGS-Clusters.	Weitere Informationen finden Sie unter Schritt 7 für Operatoren: Bereitstellen des TKGS-Clusters.
8	Anmelden beim Cluster und Überprüfen der Bereitstellung.	Weitere Informationen finden Sie unter Schritt 8 für Operatoren: Anmelden beim TKGS-Cluster und Überprüfen der Bereitstellung.
9	Vorbereiten der Installation des NVAIE GPU-Operators durch Erstellung bestimmter vorausgesetzter Objekte im TKGS-Cluster, einschließlich Namespaces, Rollenbindungen, geheimer Image-Schlüssel und Lizenz-Configmaps.	Weitere Informationen finden Sie unter Schritt 9 für Operatoren: Vorbereiten der Installation des NVAIE GPU-Operators.
10	Installieren des NVAIE GPU-Operators im Cluster.	Weitere Informationen finden Sie unter Schritt 10 für Operatoren: Installieren des NVIDIA GPU-Operators im Cluster.
11	Bereitstellen von KI-/ML-Arbeitslasten im vGPU-fähigen TKGS-Cluster.	Weitere Informationen finden Sie unter Schritt 11 für Operatoren: Bereitstellen einer KI-/ML-Arbeitslast.

Schritt 0 für Operatoren: Überprüfen der Systemanforderungen

Informationen zum Einrichten der Umgebung zur Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern finden Sie in den folgenden Systemanforderungen.

Anforderung	Beschreibung
Der vSphere-Administrator hat die Umgebung für NVIDIA vGPU eingerichtet	Siehe vSphere-Administrator-Workflow für die Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern (vGPU).
TKR Ubuntu-OVA	Tanzu Kubernetes-Version Ubuntu ob-18691651-tkgs-ova-ubuntu-2004-v1.20.8---vmware.1-tkg.2
TKG-Clusterbereitsteller	Tanzu Kubernetes Grid-Dienst API-Version: run.tanzu.vmware.com/v1alpha2
NVIDIA GPU-Operator	GPU-Operator v1.8.0
NVIDIA GPU-Treiber-Container	nvcr.io/nvstating/cnt-ea/driver:470.51-ubuntu20.04

Schritt 1 für Operatoren: Installieren der Kubernetes-CLI-Tools für vSphere auf Ihrer Arbeitsstation

Laden Sie die Kubernetes-CLI-Tools für vSphere herunter und installieren Sie sie.

Bei Verwendung von Linux können Sie folgenden Befehl zum Herunterladen der Tools ausführen.

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

Weitere Anleitungen finden Sie unter Herunterladen und Installieren von Kubernetes-CLI-Tools für vSphere.

Schritt 2 für Operatoren: Anmelden beim Supervisor-Cluster

Authentifizieren Sie sich mithilfe des vSphere-Plug-In für kubectl beim Supervisor-Cluster.

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

Schritt 3 für Operatoren: Wechseln des Kontexts zum vSphere-Namespace

Führen Sie mithilfe von kubectl einen Kontextwechsel zum vSphere-Namespace durch, den der vSphere-Administrator für den TKGS GPU-Cluster erstellt hat.

kubectl config get-contexts

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

Schritt 4 für Operatoren: Abrufen der benutzerdefinierten VM-Klasse für vGPU-Arbeitslasten

Stellen Sie sicher, dass die benutzerdefinierte VM-Klasse mit dem vom vSphere-Administrator erstellten vGPU-Profil im Ziel- vSphere-Namespace verfügbar ist.

kubectl get virtualmachineclassbindings

Hinweis: Die VM-Klasse muss an den Ziel- vSphere-Namespace gebunden werden. Wenn die benutzerdefinierte VM-Klasse für vGPU-Arbeitslasten nicht angezeigt wird, wenden Sie sich an den vSphere-Administrator.

Schritt 5 für Operatoren: Abrufen der Ubuntu Tanzu Kubernetes-Version für GPU-Knoten

Stellen Sie sicher, dass die erforderliche Ubuntu Tanzu Kubernetes-Version, die vom vSphere-Administrator über die Inhaltsbibliothek synchronisiert wurde, im vSphere-Namespace verfügbar ist.

kubectl get tanzukubernetesreleases

Oder verwenden Sie die Verknüpfung:

kubectl get tkr

Schritt 6 für Operatoren: Erstellen der YAML für die Bereitstellung des vGPU-fähigen TKGS-Clusters

Erstellen Sie die YAML-Datei für die Bereitstellung eines Tanzu Kubernetes-Clusters.

Beginnen Sie mit einem der folgenden Beispiele. Verwenden Sie die anhand der Ausgabe der vorhergehenden Befehle gesammelten Informationen, um die Clusterspezifikation anzupassen. Ziehen Sie bei Bedarf die vollständige Liste der Konfigurationsparameter hinzu: TKGS-v1alpha2-API für die Bereitstellung von Tanzu Kubernetes-Clustern.

In Beispiel 1 werden zwei Worker-Knotenpools angegeben.

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

In Beispiel 2 wird ein separates Volume auf Worker-Knoten für die Container-Laufzeit mit einer Kapazität von 50 GiB angegeben. Diese Einstellung kann konfiguriert werden. Es wird empfohlen, ein separates Volume mit einer geeigneten Größe für containerbasierte KI-/ML-Arbeitslasten bereitzustellen.

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

Beispiel 3 enthält zusätzliche Clustermetadaten, wie z. B. eine Bezeichnung.

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

Schritt 7 für Operatoren: Bereitstellen des TKGS-Clusters

Stellen Sie den Cluster bereit, indem Sie den folgenden kubectl-Befehl ausführen.

kubectl apply -f CLUSTER-NAME.yaml

Beispiel:

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

Überwachen Sie die Bereitstellung von Clusterknoten mithilfe von kubectl.

kubectl get tanzukubernetesclusters -n NAMESPACE

Schritt 8 für Operatoren: Anmelden beim TKGS-Cluster und Überprüfen der Bereitstellung

Melden Sie sich mit dem vSphere-Plug-In für kubectl beim TKGS-Cluster an.

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

Verwenden Sie die folgenden Befehle zum Überprüfen des Clusters:

kubectl cluster-info

kubectl get nodes

kubectl get namespaces

kubectl api-resources

Schritt 9 für Operatoren: Vorbereiten der Installation des NVAIE GPU-Operators

Führen Sie vor der Installation des GPU-Operators mit NVIDIA AI Enterprise die folgenden Aufgaben für den von Ihnen bereitgestellten TKGS-Cluster aus. Weitere Informationen finden Sie unter Erforderliche Aufgaben in der NVAIE-Dokumentation.

Hinweis: Wenn Sie den NVIDIA-DLS (Delegated Licensing Server) verwenden, finden Sie Anweisungen in folgendem Thema: Nachtrag zum Cluster-Operator für die Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern (DLS)

1. Erstellen Sie den Kubernetes-Namespace gpu-operator-resources. Es empfiehlt sich, immer alles in diesem Namespace bereitzustellen.

   kubectl create ns gpu-operator-resources

2. Erstellen Sie Rollenbindungen.

   Für Tanzu Kubernetes-Cluster ist die Pod-Sicherheitsrichtlinie aktiviert.

   Erstellen Sie die Datei rolebindings.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

   Wenden Sie die Rollenbindung an.

   kubectl apply -f rolebindings.yaml

   Erstellen Sie die Datei 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

   Wenden Sie die Rollenbindung an:

   kubectl apply -f post-rolebindings.yaml

3. Erstellen Sie einen geheimen Image-Schlüssel mit NGC-Anmeldedaten, die von Docker zum Abrufen von Container-Images aus dem NVIDIA GPU-Cloud-Katalog verwendet werden können.

   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. Erstellen Sie eine Configmap für den NVIDIA-Lizenzserver.

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

   Der Befehl gridd.conf verweist auf die Adresse des NVIDIA-Lizenzservers, wie z. B.:

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

Schritt 10 für Operatoren: Installieren des NVIDIA GPU-Operators im Cluster

Installieren Sie den NVAIE GPU-Operator Version 1.8.0 im TKGS-Cluster. Weitere Informationen finden Sie in der Dokumentation zum GPU-Operator.

Hinweis: Wenn Sie den NVIDIA-DLS (Delegated Licensing Server) verwenden, finden Sie Anweisungen in folgendem Thema: Nachtrag zum Cluster-Operator für die Bereitstellung von KI-/ML-Arbeitslasten auf TKGS-Clustern (DLS)

1. Installieren Sie Helm und beachten Sie dabei die Helm-Dokumentation.
2. Fügen Sie das Helm-Repository gpu-operator hinzu.

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

3. Installieren Sie den NVAIE GPU-Operator, indem Sie folgenden Befehl ausführen.

   Ersetzen Sie Umgebungsvariablenwerte gegebenenfalls durch Werte, die Ihrer Umgebung entsprechen.

   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

Schritt 11 für Operatoren: Bereitstellen einer KI-/ML-Arbeitslast

Der NVIDIA GPU-Cloud-Katalog enthält mehrere standardmäßige Container-Images, die Sie zum Ausführen von KI-/ML-Arbeitslasten auf Ihren vGPU-fähigen Tanzu Kubernetes-Clustern verwenden können. Weitere Informationen zu den verfügbaren Images finden Sie in der Dokumentation zu NGC.