Crea una VM Windows da un'immagine ISO in GKE su Bare Metal

Questo documento mostra come creare una macchina virtuale (VM) Windows che si avvia da un file ISO utilizzando VM Runtime su Google Distributed Cloud. All'avvio della VM, completi manualmente la routine di configurazione di Windows.

Puoi anche creare una VM Windows da un'immagine disco preparata utilizzando un'origine HTTP o da Cloud Storage.

Prima di iniziare

Per completare questo documento, devi avere accesso alle seguenti risorse:

Accesso al cluster GKE su Bare Metal versione 1.12.0 (anthosBareMetalVersion: 1.12.0) o successiva. Puoi utilizzare qualsiasi tipo di cluster in grado di eseguire carichi di lavoro. Se necessario, prova GKE su Bare Metal su Compute Engine o consulta la panoramica sulla creazione dei cluster.
Lo strumento client virtctl installato come plug-in per kubectl. Se necessario, installa lo strumento client virtctl.

Crea un disco virtuale per l'immagine ISO

Per creare correttamente una VM Windows, segui i passaggi e le sezioni di questo documento in ordine.

Per l'avvio da un'immagine ISO di Windows, crea prima un VirtualMachineDisk con diskType di cdrom. Utilizza il tuo ISO di Windows come origine per questo disco.

Crea un manifest VirtualMachineDisk, ad esempio windows-iso.yaml, nell'editor che preferisci:
```
nano windows-iso.yaml
```
Copia e incolla il seguente manifest YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  source:
    http:
      url: IMG_URL
  size: 10Gi
  diskType: cdrom
```
Sostituisci IMG_URL con il percorso HTTP della tua immagine ISO di Windows. Puoi anche creare e utilizzare le credenziali per importare un file ISO da Cloud Storage.
Salva e chiudi il manifest nell'editor.
Crea VirtualMachineDisk utilizzando kubectl:
```
kubectl apply -f windows-iso.yaml
```

Crea un disco dei driver VM

Per eseguire correttamente l'avvio da un file ISO di Windows e completare il processo di installazione, la VM deve avere accesso ai driver virtio. Per fornire i driver virtio alla VM, completa i seguenti passaggi:

Crea un manifest VirtualMachineDisk, ad esempio virtio-driver.yaml, nell'editor che preferisci:
```
nano virtio-driver.yaml
```
Copia e incolla il seguente manifest YAML:
```
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
```
Questo manifest estrae i driver virtio più recenti da un repository Docker pubblico e imposta diskType come cdrom. La VM utilizza questo disco durante il processo di installazione.
Salva e chiudi il manifest nell'editor.
Crea VirtualMachineDisk utilizzando kubectl:
```
kubectl apply -f virtio-driver.yaml
```

Crea una VM Windows

Crea una VM che si avvia dal file VirtualMachineDisk ISO di Windows e collega il disco dei driver virtio:

Crea un manifest che definisce un VirtualMachineDisk per il volume di avvio e un VirtualMachine, come windows-vm.yaml, nell'editor di tua scelta:
```
nano windows-vm.yaml
```

Copia e incolla il seguente manifest YAML:

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

Sostituisci VM_NAME con il nome che vuoi assegnare alla VM.

Questo manifest crea un volume di avvio di 100 gibibyte (GiB). Poiché questo volume di avvio è vuoto al primo avvio della VM, quest'ultima viene avviata da ISO come dispositivo CD-ROM per avviare la routine di configurazione. Sono collegati anche i driver virtio per completare il processo di installazione.

Salva e chiudi il manifest nell'editor.
Crea VirtualMachineDisk e VirtualMachine utilizzando kubectl:
```
kubectl apply -f windows-vm.yaml
```

Connettiti alla VM Windows e completa l'installazione del sistema operativo

La VM viene avviata e avviata dall'ISO di Windows nella sezione precedente. Connettiti alla VM, completa il processo di installazione di Windows e configura la VM:

Connettiti alla tua VM Windows:
```
kubectl virt vnc VM_NAME
```
Sostituisci VM_NAME con il nome della tua VM Windows.

Quando richiesto, inserisci le credenziali utente del sistema operativo guest di Windows per la VM.

Per ulteriori informazioni sull'utilizzo di kubectl virt vnc per la connessione alla VM, consulta Connessione diretta tramite VNC.
Nella configurazione di Windows, scegli di eseguire un'installazione personalizzata.
Seleziona Carica driver, passa alla directory viostor sul disco virtio, quindi seleziona la directory corrispondente alla versione di Windows che vuoi installare.

Per ulteriori informazioni, consulta la pagina relativa ai driver per Windows virtio KubeVirt.
Con i driver di archiviazione e di rete di virtio ora disponibili, completa il resto del processo di installazione di Windows.

Ti consigliamo di abilitare Remote Desktop Protocol in modo da poterti connettere direttamente alla VM dopo l'installazione.

Scollega l'immagine ISO e il disco dei driver

Una volta completata l'installazione di Windows, rimuovi il disco dei driver virtio e l'immagine ISO di Windows dalla VM:

Arresta la VM Windows:
```
kubectl virt stop VM_NAME
```
Sostituisci VM_NAME con il nome della tua VM Windows.
Utilizza kubectl per modificare la VM:
```
kubectl edit gvm VM_NAME
```
Sostituisci VM_NAME con il nome della tua VM Windows.

Nell'editor, aggiorna la sezione spec.disks per rimuovere i dischi ISO e virtio di Windows, come mostrato nell'esempio seguente. L'unico disco rimasto collegato alla VM dovrebbe essere VM_NAME-boot-dv:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
  interfaces:
...

Salva e chiudi il manifest della VM.
Avvia la VM Windows:
```
kubectl virt start VM_NAME
```
Sostituisci VM_NAME con il nome della tua VM Windows.
Controlla STATUS della VM:
```
kubectl get gvm VM_NAME
```
Sostituisci VM_NAME con il nome della tua VM Windows.

Assicurati che la VM sia in stato Running. Se la VM non è in stato Running, controlla il manifest della risorsa VirtualMachine per assicurarti di aver rimosso solo il disco ISO e virtio di Windows. Verifica che l'host disponga di un numero sufficiente di risorse di calcolo per avviare la VM.