Anthos Clusters on Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

Diese Seite wurde von der Cloud Translation API übersetzt.

Windows-VM aus ISO-Image in Google Distributed Cloud erstellen

In diesem Dokument erfahren Sie, wie Sie mit VM-Laufzeit auf GDC eine virtuelle Windows-Maschine (VM) erstellen, die von einem ISO startet. Wenn die VM gestartet wird, führen Sie die Windows-Einrichtungsroutine manuell aus.

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 Google Distributed Cloud-Cluster Version 1.12.0 (anthosBareMetalVersion: 1.12.0) oder höher. Sie können einen beliebigen Clustertyp verwenden, der Arbeitslasten ausführen kann. Probieren Sie bei Bedarf Google Distributed Cloud in Compute Engine aus oder lesen Sie die Übersicht zum Erstellen von Clustern.
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 erfolgreich zu erstellen.

Wenn Sie von einem Windows-ISO-Image starten möchten, erstellen Sie zuerst ein VirtualMachineDisk mit diskType von cdrom. Verwenden Sie Ihre Windows-ISO-Datei 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-Wert. 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

Damit die VM erfolgreich aus einem Windows-ISO starten und den Installationsvorgang abschließen kann, benötigt die VM Zugriff auf die virtio-Treiber. 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
```
Mit diesem Manifest werden die neuesten virtio-Treiber aus einem öffentlichen Docker-Repository abgerufen und diskType als cdrom festgelegt. Ihre VM verwendet dieses Laufwerk während des Installationsvorgangs.
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-Standard VirtualMachineDisk gestartet und das Treiberlaufwerk virtio angehängt wird:

Erstellen Sie im Editor Ihrer Wahl ein Manifest, das ein VirtualMachineDisk für das Boot-Volume und ein 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 von 100 Gibibyte (GiB). Da dieses Boot-Volume beim ersten Start der VM leer ist, startet sie von ISO als CD-ROM-Gerät, um die Einrichtungsroutine zu starten. Die virtio-Treiber sind ebenfalls angehängt, um den Installationsvorgang 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.

Geben Sie bei Aufforderung die Nutzeranmeldedaten für Windows-Gastbetriebssystem für Ihre VM ein.

Weitere Informationen zur Verwendung von kubectl virt vnc zum Herstellen einer Verbindung zu Ihrer VM finden Sie unter Direkte Verbindung über VNC.
Wählen Sie beim Einrichten von Windows eine benutzerdefinierte Installation aus.
Wählen Sie Treiber laden aus, wechseln Sie zum Verzeichnis viostor auf dem Laufwerk virtio und wählen Sie dann 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, schließen Sie den Rest der Windows-Installation ab.

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 virtio-Treiberlaufwerk 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 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 bleiben soll, 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 und achten Sie darauf, dass Sie nur das Windows-ISO-Laufwerk und das Windows-Laufwerk virtio entfernt haben. Prüfen Sie, ob der Host genügend Rechenressourcen zum Starten der VM hat.