Windows-VM aus ISO-Image in Anthos-Clustern auf Bare Metal erstellen

In diesem Dokument erfahren Sie, wie Sie eine virtuelle Windows-Maschine (VM) erstellen, die über die Anthos-VM-Laufzeit über eine ISO gestartet wird. Wenn die VM gestartet wird, schließen Sie die Windows-Einrichtungsroutine manuell ab.

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

Hinweis

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

Zugriff auf Anthos-Cluster 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. Bei Bedarf können Sie Anthos-Cluster auf Bare Metal in Compute Engine ausprobieren oder die Übersicht über die Clustererstellung aufrufen.
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 die Schritte und Abschnitte in diesem Dokument der Reihe nach aus, um eine Windows-VM zu erstellen.

Erstellen Sie zum Booten von einem Windows-ISO-Image zuerst ein VirtualMachineDisk mit diskType von cdrom. Verwenden Sie Ihre 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 zum Windows-ISO. Sie können auch Anmeldedaten erstellen und verwenden, um eine ISO-Datei 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 unter Windows erfolgreich zu starten und den Installationsvorgang abzuschließen. Führen Sie die folgenden Schritte aus, um die virtio-Treiber für die VM 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 vom Windows-ISO VirtualMachineDisk aus startet und das Treiberlaufwerk virtio anhängt:

Erstellen Sie im Editor Ihrer Wahl ein Manifest, das eine VirtualMachineDisk für das Boot-Volume und eine 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
interfaces:
  - name: eth0
    networkName: pod-network

Ersetzen Sie VM_NAME durch den Namen Ihrer VM.

Dieses Manifest erstellt ein Boot-Volume von 100 Gibibyte (GiB). Da dieses Boot-Volume beim ersten Start der VM leer ist, startet die VM von ISO als CD-ROM-Gerät, um die Einrichtungsroutine zu starten. Außerdem sind die virtio-Treiber 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 von der Windows-ISO im vorherigen Abschnitt gestartet und gestartet. Stellen Sie eine Verbindung zur 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.
Wählen Sie bei der Windows-Einrichtung eine benutzerdefinierte Installation aus.
Wählen Sie Load-Treiber aus, wechseln Sie zum Verzeichnis viostor auf dem Laufwerk virtio und wählen Sie dann das Verzeichnis aus, das der Windows-Version entspricht, die Sie installieren möchten.

Weitere Informationen finden Sie unter KubeVirt-Windows-virtio-Treiber.
Schließen Sie den Rest des Windows-Installationsprozesses ab, wenn die Speicher- und Netzwerktreiber von virtio verfügbar sind.

Wir empfehlen, 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 ISO-Image von Windows von der VM:

Beenden Sie Ihre 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 im Editor den Abschnitt spec.disks, um die Windows-ISO- und virtio-Laufwerke zu entfernen, wie im folgenden Beispiel gezeigt. Das einzige Laufwerk, das 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 Ihre 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, prüfen Sie das Ressourcenmanifest VirtualMachine, um sicherzustellen, dass nur das Windows-ISO- und das virtio-Laufwerk entfernt wurden. Prüfen Sie, ob der Host genügend Rechenressourcen hat, um Ihre VM zu starten.