Crea e gestisci dischi virtuali nei cluster Anthos su Bare Metal

Questo documento è destinato ai proprietari di applicazioni che eseguono cluster Anthos su Bare Metal. Questo documento mostra come creare e gestire risorse del disco per macchine virtuali (VM) che utilizzano il runtime VM Anthos.

Prima di iniziare

Per completare il documento, devi accedere alle seguenti risorse:

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

Crea una VM con un disco collegato

Quando crei una VM, puoi collegare un disco di avvio o di dati esistente, creare un disco da un'immagine (anche per il disco di avvio) o creare un disco vuoto.

Disco vuoto

In questo scenario, crei un disco vuoto e lo colleghi alla VM. Questo scenografico ti consente di creare un disco dati per archiviare i dati dell'applicazione.

Crea un manifest che definisca VirtualMachineDisk e VirtualMachine, ad esempio my-vm.yaml, nell'editor che preferisci:
```
nano my-vm.yaml
```

Copia e incolla la seguente definizione YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

Questo esempio crea un disco 10Gi vuoto (10 gibibyte) denominato DISK_NAME. Nella sezione spec.disks della VM, devi anche collegare un disco di avvio, ad esempio da un'immagine, come mostrato nella sezione successiva.

Salva e chiudi il file manifest nell'editor.
Crea la VM e il disco utilizzando kubectl:
```
kubectl apply -f my-vm.yaml
```

Dall'immagine

In questo scenario, crei un disco da un'immagine e la colleghi alla VM. Questo scenario ti consente di creare un disco di avvio, ad esempio da un'immagine. Puoi anche creare e collegare dischi dati da un'immagine.

Crea un manifest che definisca VirtualMachineDisk e VirtualMachine, ad esempio my-vm.yaml,nell'editor che preferisci:
```
nano my-vm.yaml
```

Copia e incolla la seguente definizione YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: VM_NAME-boot-dv
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv

Questo esempio crea un disco 20Gi (20 gibibyte) denominato VM_NAME-boot-dv utilizzando un'immagine Ubuntu pubblica. Nella sezione spec.disks della VM, il disco è impostato su boot: true.

Salva e chiudi il manifest nell'editor.
Crea la VM e il disco utilizzando kubectl:
```
kubectl apply -f my-vm.yaml
```

Disco esistente

In questo scenario, crei un disco vuoto e lo colleghi alla VM. Questo scenografico ti consente di creare un disco dati per archiviare i dati dell'applicazione.

Crea un manifest VirtualMachine, ad esempio my-vm.yaml,nell'editor di tua scelta:
```
nano my-vm.yaml
```

Copia e incolla la seguente definizione YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: EXISTING_DISK_NAME

In questo esempio è collegato un disco esistente denominato EXISTING_DISK_NAME.

Nella sezione spec.disks della VM, devi anche collegare un disco di avvio, ad esempio da un'immagine, come mostrato nella sezione precedente.

Salva e chiudi il manifest della VM nell'editor.
Crea la VM utilizzando kubectl:
```
kubectl apply -f my-vm.yaml
```

Crea e collega dischi a una VM esistente

Se hai una VM esistente, puoi creare e collegare i dischi per supportare i cicli di vita delle applicazioni. La VM deve essere in stato di arresto prima di collegare un disco.

Disco vuoto

In questo scenario, crei un disco vuoto e lo colleghi alla VM. Questo scenografico ti consente di creare un disco dati per archiviare i dati dell'applicazione.

Utilizza kubectl per arrestare la VM, se necessario:
```
kubectl virt stop vm VM_NAME
```
Sostituisci VM_NAME con il nome della VM che vuoi arrestare.
Modifica la risorsa VM esistente, ad esempio my-vm:
```
kubectl edit gvm VM_NAME
```

Aggiorna il manifest YAML VirtualMachine per aggiungere una sezione VirtualMachineDisk in alto, quindi collega il disco alla fine della sezione spec.disks della VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

Questo esempio crea un disco 10Gi vuoto (10 gibibyte) denominato DISK_NAME.

Salva e chiudi il manifest della VM aggiornato nell'editor.
Usa kubectl per avviare la VM:
```
kubectl virt start vm VM_NAME
```
Sostituisci VM_NAME con il nome della VM che vuoi avviare.

Dall'immagine

In questo scenario, crei un disco da un'immagine di origine e lo colleghi alla VM.

Utilizza kubectl per arrestare la VM, se necessario:
```
kubectl virt stop vm VM_NAME
```
Sostituisci VM_NAME con il nome della VM che vuoi arrestare.
Modifica la risorsa VM esistente, ad esempio my-vm:
```
kubectl edit gvm VM_NAME
```

Aggiorna il manifest VirtualMachine per aggiungere una sezione VirtualMachineDisk in alto, quindi collega il disco alla fine della sezione spec.disks della VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
  source:
    http:
      url: http://example.com/my-disk-img.qcow2
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

Questo esempio crea un disco 10Gi (10 gibibyte) denominato DISK_NAME dall'origine HTTP http://example.com/my-disk-img.qcow2.

Salva e chiudi il manifest della VM aggiornato nell'editor.
Usa kubectl per avviare la VM:
```
kubectl virt start vm VM_NAME
```
Sostituisci VM_NAME con il nome della VM che vuoi avviare.

Crea un disco

In questo scenario, crei le risorse del disco separatamente dalle risorse VM. Questo scenario ti consente di creare i dischi in anticipo e di collegarli alle VM in base alle tue esigenze.

Disco vuoto

Per creare un disco vuoto, completa i passaggi seguenti.

Crea un manifest VirtualMachineDisk, ad esempio my-disk.yaml, nell'editor preferito:
```
nano my-disk.yaml
```
Copia e incolla la seguente definizione YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
```
Questo esempio crea un disco 10Gi vuoto (10 gibibyte) denominato DISK_NAME.
Salva e chiudi il manifest del disco nell'editor.
Crea il disco utilizzando kubectl:
```
kubectl apply -f my-disk.yaml
```

Dall'immagine

Per creare un disco da un'immagine, completa i seguenti passaggi.

Crea un manifest VirtualMachineDisk, ad esempio my-disk.yaml, nell'editor preferito:
```
nano my-disk.yaml
```

Copia e incolla la seguente definizione YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img

Questo esempio crea un disco 20Gi (20 gibibyte) denominato DISK_NAME utilizzando un'immagine Ubuntu pubblica.

Salva e chiudi il manifest del disco nell'editor.
Crea il disco utilizzando kubectl:
```
kubectl apply -f my-disk.yaml
```

Passaggi successivi

Crea e utilizza le credenziali per importare immagini da Cloud Storage.
Crea e utilizza classi di archiviazione in cluster Anthos su Bare Metal.
Quando non hai più bisogno di VM o delle relative risorse su disco virtuali, elimina una VM nei cluster Anthos su Bare Metal.