Bereitstellen einer eigenständigen VM in vSphere with Tanzu

Als DevOps-Ingenieur können Sie verfügbare VM-Ressourcen überprüfen und eine eigenständige VM in einem Namespace auf einem Supervisor bereitstellen. Verwenden Sie den kubectl-Befehl, um die folgenden Aufgaben auszuführen.

Voraussetzungen

Um eine eigenständige VM in vSphere with Tanzu bereitstellen zu können, muss ein DevOps-Ingenieur Zugriff auf bestimmte VM-Ressourcen haben. Stellen Sie sicher, dass ein vSphere-Administrator diese Schritte durchgeführt hat, um VM-Ressourcen verfügbar zu machen:

Erstellen Sie einen Namespace und weisen Sie ihm Speicherrichtlinien zu. Informationen hierzu finden Sie in Installieren und Konfigurieren von vSphere with Tanzu unter Erstellen und Konfigurieren eines vSphere-Namespace.
Erstellen Sie eine Inhaltsbibliothek und ordnen Sie sie dem Namespace zu. Weitere Informationen finden Sie unter Erstellen und Verwalten von Inhaltsbibliotheken für eigenständige VMs in vSphere with Tanzu.
- Wenn eine Inhaltsbibliothek durch eine Sicherheitsrichtlinie geschützt ist, müssen alle Bibliothekselemente konform sein. Wenn die geschützte Bibliothek eine Kombination aus konformen und nicht konformen Elementen enthält, werden den DevOps-Ingenieuren über den Befehl kubectl get virtualmachineimages keine VM-Images angezeigt.
- Wenn Sie VMs mit vGPU-Geräten bereitstellen möchten, müssen Sie Zugriff auf Images haben, wobei der Startmodus auf EFI festgelegt ist, z. B. CentOS.
Ordnen Sie Standard- oder benutzerdefinierte VM-Klassen einem Namespace zu. Weitere Informationen finden Sie unter Arbeiten mit VM-Klassen in vSphere with Tanzu.
Wenn Sie NVIDIA vGPU oder andere PCI-Geräte für Ihre VMs verwenden möchten, muss die VM-Klasse die PCI-Konfiguration enthalten. Weitere Informationen finden Sie unter Hinzufügen von PCI-Geräten zu einer VM-Klasse in vSphere with Tanzu.

Anzeigen der in einem Namespace verfügbaren VM-Ressourcen in vSphere with Tanzu

Stellen Sie als DevOps-Ingenieur sicher, dass Sie auf VM-Ressourcen in Ihrem Namespace zugreifen können, und zeigen Sie vm-Klassen und VM-Vorlagen an, die in Ihrer Umgebung verfügbar sind. Sie können auch Speicherklassen und andere Elemente auflisten, die Sie möglicherweise für den Self-Service einer VM benötigen.

Diese Aufgabe umfasst Befehle, mit denen Sie auf Ressourcen zugreifen können, die für eine Bereitstellung einer eigenständigen VM verfügbar sind. Informationen zu den Ressourcen, die für die Bereitstellung von Tanzu Kubernetes Grid-Clustern und VMs erforderlich sind, die die Cluster bilden, finden Sie unter VM-Klassen für Tanzu Kubernetes-Cluster in der Dokumentation zu Verwenden von Tanzu Kubernetes Grid 2 mit vSphere with Tanzu.

Prozedur

Greifen Sie in der Kubernetes-Umgebung auf Ihren Namespace zu.
Weitere Informationen finden Sie unter Abrufen und Verwenden des Supervisor-Kontexts.
Um die in Ihrem Namespace verfügbaren VM-Klassen anzeigen zu können, führen Sie den folgenden Befehl aus.
kubectl get virtualmachineclassbindings
Sie sehen die folgende Ausgabe.

Hinweis: Da der bestmögliche VM-Klassentyp eine Überbelegung von Ressourcen zulässt, ist es möglich, dass keine Ressourcen mehr verfügbar sind, wenn Sie Grenzwerte für den Namespace festgelegt haben, in dem Sie die VMs bereitstellen. Verwenden Sie aus diesem Grund den garantierten VM-Klassentyp in der Produktionsumgebung.
```
NAME                       VIRTUALMACHINECLASS        AGE

best-effort-large          best-effort-large          44m
best-effort-medium         best-effort-medium         44m
best-effort-small          best-effort-small          44m
best-effort-xsmall         best-effort-xsmall         44m
custom                     custom                     44m
```
Zum Anzeigen von Details zu einer bestimmten VM-Klasse führen Sie die folgenden Befehle aus:
- kubectl describe virtualmachineclasses name_vm_class
  Wenn eine VM-Klasse ein vGPU-Gerät enthält, können Sie sein Profil unter spec: hardware: devices: vgpuDevices anzeigen.
```
......
spec:
  hardware:
    cpus: 4
    devices:
      vgpuDevices:
      - profileName: grid_v100-q4
......
```
- kubectl get virtualmachineclasses -o wide
  Wenn die VM-Klasse ein vGPU- oder Passthrough-Gerät enthält, wird es in der Spalte VGPUDevicesProfileNames oder PassthroughDeviceIDs ausgegeben.

Zeigen Sie die VM-Images an.

kubectl get virtualmachineimages

Die angezeigte Ausgabe lautet in etwa wie folgt:

NAME                                              VERSION  OSTYPE                FORMAT  IMAGESUPPORTED  AGE
centos-stream-8-vmservice-v1alpha1-xxxxxxxxxxxxx           centos8_64Guest       ovf     true            4d3h

Verwenden Sie den folgenden Befehl, um ein bestimmtes Image zu beschreiben.
kubectl describe virtualmachineimage/centos-stream-8-vmservice-v1alpha1-xxxxxxxxxxxxx
VMs mit vGPU-Geräten erfordern Images, für die als Startmodus EFI festgelegt ist, z. B. CentOS. Sie müssen Zugriff auf diese Images haben.

Überprüfen Sie, ob Sie auf Speicherklassen zugreifen können.

kubectl get resourcequotas

Weitere Informationen finden Sie unter Anzeigen von Speicherklassen in einem vSphere-Namespace.

NAME                        AGE   REQUEST                                                                                         LIMIT
my-ns-ubuntu-storagequota   24h   wcpglobal-storage-profile.storageclass.storage.k8s.io/requests.storage: 0/9223372036854775807

Wenn Sie vSphere Distributed Switch für Ihr Arbeitslastnetzwerk verwenden, erhalten Sie den Namen des Netzwerks.

Hinweis: Sie verwenden diese Informationen, um den networkName-Parameter in der VM-YAML-Datei anzugeben, wenn networkType den Wert vsphere-distributed aufweist. Sie müssen den Netzwerknamen nicht abrufen und angeben, wenn Sie VMware NSX verwenden.

kubectl get network
```
NAME      AGE
primary   7d2h
```

Bereitstellen einer virtuellen Maschine in vSphere with Tanzu

Stellen Sie als DevOps-Ingenieur eine VM und ihr Gastbetriebssystem deklarativ bereit, indem Sie VM-Bereitstellungsspezifikationen in eine Kubernetes-YAML-Datei schreiben.

Voraussetzungen

Wenn Sie NVIDIA vGPU oder andere PCI-Geräte für Ihre VMs verwenden, beachten Sie Folgendes:

Stellen Sie sicher, dass Sie eine geeignete VM-Klasse mit PCI-Konfiguration verwenden. Weitere Informationen finden Sie unter Hinzufügen von PCI-Geräten zu einer VM-Klasse in vSphere with Tanzu.
VMs mit vGPU-Geräten erfordern Images, für die als Startmodus EFI festgelegt ist, z. B. CentOS.
VMs mit vGPU-Geräten, die vom VM-Dienst verwaltet werden, werden automatisch ausgeschaltet, wenn ein ESXi-Host in den Wartungsmodus wechselt. Dies kann sich vorübergehend auf Arbeitslasten auswirken, die in den VMs ausgeführt werden. Die VMs werden automatisch eingeschaltet, nachdem der Host im Wartungsmodus ausgeführt wurde.

Prozedur

Bereiten Sie die VM-YAML-Datei vor.

Geben Sie in der Datei die folgenden Parameter an:

Option	Bezeichnung
apiVersion	Gibt die Version der VM-Dienst-API an. Beispiel: `vmoperator.vmware.com/v1alpha1`.
kind	Gibt den Typ der zu erstellenden Kubernetes-Ressource an. Der einzige verfügbare Wert ist `VirtualMachine`.
spec.imageName	Gibt das Image der Inhaltsbibliothek an, das die VM verwenden soll.
spec.storageClass	Identifiziert die Speicherklasse, die für die Speicherung der persistenten Volumes verwendet werden soll.
spec.className	Gibt den Namen der VM-Klasse an, in der die zu verwendenden Einstellungen für die virtuelle Hardware beschrieben werden.
spec.networkInterfaces	Gibt netzwerkbezogene Einstellungen für die VM an. networkType. Die Werte für diesen Schlüssel können `nsx-t` oder `vsphere-distributed` lauten. networkName. Geben Sie den Namen nur an, wenn networkType den Wert `vsphere-distributed` aufweist. Sie können diese Informationen mithilfe des Befehls kubectl get network abrufen. Wenn es sich bei networkType um `nsx-t` handelt, müssen Sie networkName nicht angeben.
spec.vmMetadata	Enthält zusätzliche Metadaten, die an die VM übergeben werden sollen. Sie können diesen Schlüssel verwenden, um das Gastbetriebssystem-Image anzupassen und Elemente wie den hostname der VM und user-data festzulegen, einschließlich Kennwörter, SSH-Schlüssel usw. In der folgenden Beispiel-YAML wird zum Speichern der Metadaten ConfigMap verwendet.
topology.kubernetes.io/zone	Steuert die Platzierung der VM auf einem Supervisor mit drei Zonen. Beispiel: topology.kubernetes.io/zone: zone-a02.

Verwenden Sie das Folgende als Beispiel für eine YAML-Datei ubuntu-impish-vm.yaml.

apiVersion: vmoperator.vmware.com/v1alpha1
kind: VirtualMachine
metadata:
  name: ubuntu-impish-vm
  namespace: sr-1
  annotations:
    vmoperator.vmware.com/image-supported-check: disable
spec:
  networkInterfaces:
  - networkName: ""
    networkType: nsx-t
  className: best-effort-medium
  imageName: ubuntu-impish-21.10-cloudimg 
  powerState: poweredOn
  storageClass: vsan-default-storage-policy
  vmMetadata:
    configMapName: user-data-2
    transport: CloudInit
---
apiVersion: v1
kind: ConfigMap
metadata:
    name: user-data-2
    namespace: sr-1
data:
  user-data: |
    #cloud-config
    ssh_pwauth: true
    users:
      - name: vmware
        sudo: ALL=(ALL) NOPASSWD:ALL
        lock_passwd: false
        passwd: '$1$salt$SOC33fVbA/ZxeIwD5yw1u1'
        shell: /bin/bash
    write_files:
      - content: |
          VMSVC Says Hello World
        path: /helloworld

ConfigMap enthält das cloud-config-Blob, das den Benutzernamen und das Kennwort für das Gastbetriebssystem angibt.

Weitere Informationen zu cloud-config-Spezifikationen finden Sie unter https://cloudinit.readthedocs.io/en/latest/topics/examples.html.

Stellen Sie die VM bereit.
```
kubectl apply -f ubuntu-impish-vm.yaml
```

Stellen Sie sicher, dass die VM erstellt wurde.

kubectl get vm -n ubuntu-impish-vm
NAME              AGE
ubuntu-impish-vm  28s

Überprüfen Sie den Status der VM und die zugehörigen Ereignisse.

kubectl describe virtualmachine ubuntu-impish-vm

Die Ausgabe lautet in etwa wie folgt: Über die Ausgabe können Sie auch die IP-Adresse der VM abrufen, die in der Vm Ip angezeigt wird.

Name:         ubuntu-impish-vm
Namespace:    sr-1
Annotations:  vmoperator.vmware.com/image-supported-check: disabled
API Version:  vmoperator.vmware.com/v1alpha1
Kind:         VirtualMachine
Metadata:
  Creation Timestamp:  2021-03-23T19:07:36Z
  Finalizers:
    virtualmachine.vmoperator.vmware.com
  Generation:  1
  Managed Fields:
 ...  
 ... 
Spec:
  Class Name:  best-effort-medium
  Image Name:  ubuntu-impish-21.10-cloudimg
  Network Interfaces:
    Network Name:  ""
    Network Type:  nsx-t
  Power State:     poweredOn
  Storage Class:   vsan-default-storage-policy
  Vm Metadata:
    Config Map Name:  user-data-2
    Transport:        CloudInit
Status:
  Bios UUID:              4218ec42-aeb3-9491-fe22-19b6f954ce38
  Change Block Tracking:  false
  Conditions:
    Last Transition Time:  2021-03-23T19:08:59Z
    Status:                True
    Type:                  VirtualMachinePrereqReady
  Host:                    10.185.240.10
  Instance UUID:           50180b3a-86ee-870a-c3da-90ddbaffc950
  Phase:                   Created
  Power State:             poweredOn
  Unique ID:               vm-73
  Vm Ip:                   10.161.75.162
Events:                    <none>
...

Stellen Sie sicher, dass die VM-IP-Adresse erreichbar ist.

ping 10.161.75.162
PING 10.161.75.162 (10.161.75.162): 56 data bytes
64 bytes from 10.161.75.162: icmp_seq=0 ttl=59 time=43.528 ms
64 bytes from 10.161.75.162: icmp_seq=1 ttl=59 time=53.885 ms
64 bytes from 10.161.75.162: icmp_seq=2 ttl=59 time=31.581 ms

Ergebnisse

Eine über den VM-Dienst erstellte VM kann nur von DevOps aus dem Kubernetes-Namespace verwaltet werden. Der Lebenszyklus kann nicht über den vSphere Client verwaltet werden. vSphere-Administratoren können jedoch die VM und ihre Ressourcen überwachen. Weitere Informationen finden Sie unter Überwachen der in vSphere with Tanzu verfügbaren virtuellen Maschinen.

Nächste Maßnahme

Weitere Informationen finden Sie im Blog Introducing Virtual Machine Provisioning.

Installieren des NVIDIA-Gasttreibers in einer VM in vSphere with Tanzu

Wenn die VM ein für vGPU konfiguriertes PCI-Gerät enthält, installieren Sie nach dem Erstellen und Starten der VM in Ihrer vSphere with Tanzu-Umgebung den NVIDIA vGPU-Grafiktreiber, um GPU-Vorgänge vollständig zu aktivieren.

Voraussetzungen

Achten Sie darauf, dass die erstellte VM auf die VM-Klasse mit der vGPU-Definition verweist. Weitere Informationen finden Sie unter Hinzufügen von PCI-Geräten zu einer VM-Klasse in vSphere with Tanzu.
Vergewissern Sie sich, dass Sie das vGPU-Softwarepaket von der NVIDIA-Downloadseite heruntergeladen und das Paket dekomprimiert haben und dass die Gastlaufwerkkomponente bereit ist. Informationen finden Sie in der entsprechenden Dokumentation zur NVIDIA Virtual GPU-Software.
Hinweis: Die Version der Treiberkomponente muss der Version des vGPU-Managers entsprechen, die ein vSphere-Administrator auf dem ESXi-Host installiert hat.

Prozedur

Kopieren Sie das Linux-Treiberpaket für die NVIDIA vGPU-Software, z. B. NVIDIA-Linux-x86_64-version-grid.run, auf die Gast-VM.
Beenden Sie alle Anwendungen, bevor Sie versuchen, das Treiberinstallationsprogramm auszuführen.
Starten Sie das Installationsprogramm für den NVIDIA vGPU-Treiber.
```
sudo ./NVIDIA-Linux-x86_64-version-grid.run
```
Akzeptieren Sie die NVIDIA Software-Lizenzvereinbarung und klicken Sie auf Ja, um die X-Konfigurationseinstellungen automatisch zu aktualisieren.

Stellen Sie sicher, dass der Treiber installiert wurde.

Beispiel:

~$ nvidia-smi
Wed May 19 22:15:04 2021
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 460.63       Driver Version: 460.63       CUDA Version: 11.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  GRID V100-4Q        On   | 00000000:02:00.0 Off |                  N/A|
| N/AN/AP0    N/A/  N/A|    304MiB /  4096MiB |      0%      Default |
|                               |                      |                  N/A|
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+