Windows-VM aus ISO-Image in GDCV für Bare Metal erstellen

In diesem Dokument erfahren Sie, wie Sie mithilfe der VM-Laufzeit auf GDC eine virtuelle Windows-Maschine (VM) erstellen, die von einem ISO startet. Wenn die VM gestartet wird, schließen Sie die Windows-Einrichtungsroutine manuell ab.

Sie können eine Windows-VM auch aus einem vorbereiteten Laufwerk-Image mithilfe einer HTTP-Quelle oder aus Cloud Storage erstellen.

Hinweise

Um dieses Dokument abzuschließen, benötigen Sie Zugriff auf die folgenden Ressourcen:

Zugriff auf den Cluster GKE on Bare Metal Version 1.12.0 (anthosBareMetalVersion: 1.12.0) oder höher. Sie können einen beliebigen Clustertyp verwenden, der Arbeitslasten ausführen kann. Versuchen Sie es bei Bedarf mit GDCV für Bare Metal in Compute Engine oder sehen Sie sich die Übersicht über die Clustererstellung an.
Das virtctl-Clienttool, das als Plug-in für kubectl installiert wurde. Installieren Sie bei Bedarf das virtctl-Clienttool.

Virtuelles Laufwerk für das ISO-Image erstellen

Führen Sie zum Erstellen einer Windows-VM der Reihe nach die Schritte und Abschnitte in diesem Dokument aus.

Zum Starten von einem Windows-ISO-Image erstellen Sie zuerst ein VirtualMachineDisk mit diskType von cdrom. Verwenden Sie Ihr Windows-ISO als Quelle für dieses Laufwerk.

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachineDisk-Manifest wie windows-iso.yaml.
```
nano windows-iso.yaml
```
Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  source:
    http:
      url: IMG_URL
  size: 10Gi
  diskType: cdrom
```
Ersetzen Sie IMG_URL durch den HTTP-Pfad zu Ihrem Windows-ISO. Sie können auch Anmeldedaten erstellen und verwenden, um ein ISO aus Cloud Storage zu importieren.
Speichern und schließen Sie das Manifest in Ihrem Editor.
Erstellen Sie VirtualMachineDisk mit kubectl:
```
kubectl apply -f windows-iso.yaml
```

VM-Treiberlaufwerk erstellen

Die VM benötigt Zugriff auf die virtio-Treiber, um erfolgreich von einem Windows-ISO zu starten und die Installation abzuschließen. Führen Sie die folgenden Schritte aus, um der VM die virtio-Treiber bereitzustellen:

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachineDisk-Manifest wie virtio-driver.yaml.
```
nano virtio-driver.yaml
```
Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: virtio-driver
spec:
  size: 1Gi
  source:
    registry:
      url: docker://quay.io/kubevirt/virtio-container-disk:latest
  diskType: cdrom
```
Dieses Manifest ruft die neuesten virtio-Treiber aus einem öffentlichen Docker-Repository ab und legt diskType als cdrom fest. Ihre VM verwendet dieses Laufwerk während der Installation.
Speichern und schließen Sie das Manifest in Ihrem Editor.
Erstellen Sie VirtualMachineDisk mit kubectl:
```
kubectl apply -f virtio-driver.yaml
```

Windows-VM erstellen

Erstellen Sie eine VM, die von der Windows-ISO-VirtualMachineDisk-Instanz startet und das Treiberlaufwerk virtio anhängt:

Erstellen Sie im Editor Ihrer Wahl ein Manifest, das eine VirtualMachineDisk für das Boot-Volume und einen VirtualMachine wie windows-vm.yaml definiert:
```
nano windows-vm.yaml
```

Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: VM_NAME-boot-dv
spec:
  size: 100Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: VM_NAME-boot-dv
      boot: true
    - virtualMachineDiskName: windows-iso
    - virtualMachineDiskName: virtio-driver
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: pod-network

Ersetzen Sie VM_NAME durch den gewünschten Namen für die VM.

Dieses Manifest erstellt ein Boot-Volume 100 Gibibyte (GiB). Da dieses Boot-Volume beim ersten Start der VM leer ist, startet die VM aus ISO als CD-ROM-Gerät, um die Einrichtungsroutine zu starten. Die virtio-Treiber sind ebenfalls angehängt, um die Installation abzuschließen.

Speichern und schließen Sie das Manifest in Ihrem Editor.
Erstellen Sie VirtualMachineDisk und VirtualMachine mit kubectl:
```
kubectl apply -f windows-vm.yaml
```

Mit Windows-VM verbinden und Betriebssysteminstallation abschließen

Die VM wird über das im vorherigen Abschnitt genannte Windows-ISO gestartet und gestartet. Stellen Sie eine Verbindung zu Ihrer VM her, schließen Sie die Windows-Installation ab und konfigurieren Sie die VM:

Stellen Sie eine Verbindung zur Windows-VM her:
```
kubectl virt vnc VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen Ihrer Windows-VM.

Wenn Sie dazu aufgefordert werden, geben Sie die Nutzeranmeldedaten für Windows-Gastbetriebssysteme für die VM ein.

Weitere Informationen zum Herstellen einer Verbindung zu Ihrer VM mithilfe von kubectl virt vnc finden Sie unter Direkte Verbindung über VNC herstellen.
Wählen Sie beim Windows-Setup eine benutzerdefinierte Installation aus.
Wählen Sie Treiber laden aus, gehen Sie zum Verzeichnis viostor auf dem Laufwerk virtio und wählen Sie das Verzeichnis aus, das der zu installierenden Windows-Version entspricht.

Weitere Informationen finden Sie unter virtio-Treiber für KubeVirt.
Sobald die Speicher- und Netzwerktreiber von virtio verfügbar sind, können Sie die restlichen Windows-Installationsschritte abschließen.

Wir empfehlen, das Remote Desktop Protocol zu aktivieren, damit Sie nach der Installation eine direkte Verbindung zur VM herstellen können.

ISO-Image und Treiberlaufwerk trennen

Entfernen Sie nach Abschluss der Windows-Installation das Treiberlaufwerk virtio und das Windows-ISO-Image von der VM:

Beenden Sie die Windows-VM:
```
kubectl virt stop VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen Ihrer Windows-VM.
Verwenden Sie kubectl zum Bearbeiten der VM:
```
kubectl edit gvm VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen Ihrer Windows-VM.
Aktualisieren Sie in Ihrem Editor den Abschnitt spec.disks, um die Windows-ISO- und virtio-Laufwerke zu entfernen, wie im folgenden Beispiel gezeigt. Das einzige Laufwerk, das noch an die VM angehängt ist, sollte VM_NAME-boot-dv sein:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
  interfaces:
...
```
Speichern und schließen Sie das VM-Manifest.
Starten Sie die Windows-VM:
```
kubectl virt start VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen Ihrer Windows-VM.
Prüfen Sie den STATUS Ihrer VM:
```
kubectl get gvm VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen Ihrer Windows-VM.

Achten Sie darauf, dass die VM den Status Running hat. Wenn die VM nicht den Status Running hat, sehen Sie in Ihrem VirtualMachine-Ressourcenmanifest nach, ob Sie nur das Windows-ISO-Laufwerk und das virtio-Laufwerk entfernt haben. Prüfen Sie, ob der Host genügend Rechenressourcen zum Starten der VM hat.