Tutorial: crea e gestisci una VM Linux in VM Runtime su Google Distributed Cloud

Questo tutorial mostra come creare e gestire una macchina virtuale (VM) Linux in una nuova installazione di VM Runtime su Google Distributed Cloud. Scopri il processo per creare e definire le dipendenze di base, come StorageClass e rete virtuale, per poi creare una VM che utilizza queste risorse. Poi imparerai a modificare la VM, ad esempio aggiungere un nuovo disco.

Obiettivi

Configurazione delle dipendenze di base
- Crea un StorageClass per il runtime VM su Google Distributed Cloud
- Crea una rete virtuale da utilizzare per le tue VM
Crea un disco di avvio di una macchina virtuale
Crea una VM
Modifica una VM per aggiungere un nuovo disco virtuale

Prima di iniziare

Per completare questo tutorial, devi avere accesso alle risorse e agli strumenti seguenti:

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 `StorageClass`

Puoi utilizzare un valore StorageClass per definire il tipo di archiviazione da rendere disponibile alle VM. Classi di archiviazione diverse potrebbero essere mappate a tipi diversi di hardware, file system o prestazioni di archiviazione.

Non rientra nell'ambito di questo tutorial per fornire istruzioni specifiche per ogni StorageClass e partner di archiviazione.

I partner di archiviazione Anthos Ready forniscono driver qualificati CSI (Container Storage Interface) che installano e configurano le risorse personalizzate richieste per l'archiviazione. Per installare il driver CSI nel cluster, rivedi l'elenco dei partner di archiviazione supportati e segui le relative istruzioni.

Dopo aver installato il driver CSI per la tua piattaforma di archiviazione, nel cluster sono disponibili una o più classi di archiviazione. In questo tutorial utilizzerai una di queste classi per creare un disco rigido virtuale.

L'esempio di base riportato di seguito NFS StorageClass utilizza il driver CSI di NFS. Devi definire l'indirizzo e il percorso del server NFS da utilizzare in StorageClass. Tutti i nodi nel tuo cluster possono quindi connettersi e utilizzare questo spazio di archiviazione NFS:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

In questo tutorial, utilizza il nome di StorageClass nel tuo cluster.

Il runtime VM su Google Distributed Cloud genera automaticamente un profilo di archiviazione per ogni StorageClass in un cluster. Il profilo di archiviazione ha lo stesso nome del profilo StorageClass associato. I profili di archiviazione offrono opzioni di configurazione aggiuntive associate a ogni StorageClass. Per ulteriori informazioni sui profili di archiviazione, incluse le istruzioni di configurazione, consulta Configurare i profili di archiviazione.

Crea una rete virtuale

Le VM si connettono a una rete virtuale tramite un'interfaccia di rete virtuale. La rete virtuale consente loro di comunicare con altre VM nel cluster o con risorse esterne al cluster.

In questo tutorial, creerai una rete virtuale di base di livello 2 (L2) che può utilizzare un server DHCP esterno. Quando abiliti l'utilizzo di un server DHCP esterno, puoi saltare la configurazione delle impostazioni DNS e del gateway se sono fornite da DHCP.

Per creare una rete che utilizza un server DHCP esterno, segui questi passaggi:

Crea un file manifest Network, ad esempio dhcp-network.yaml, nell'editor che preferisci:
```
nano dhcp-network.yaml
```
Copia e incolla il seguente manifest YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Sostituisci i seguenti valori:
- NETWORK_NAME: il nome della rete.
- INTERFACE_NAME: il nome dell'interfaccia sul nodo GKE su Bare Metal a cui collegare la rete. Tutti i nodi devono avere lo stesso nome di interfaccia.
In questo manifest di Network sono impostati i seguenti valori:
- I carichi di lavoro possono avere solo un collegamento L2 a questa rete. Questa è l'unica rete type che puoi creare nel runtime VM su Google Distributed Cloud.
- Nella rete è abilitato un DHCP esterno. Il server DHCP esterno è responsabile dell'allocazione degli indirizzi IPv4, delle route, del gateway e della configurazione DNS per i carichi di lavoro connessi a questa rete.
Salva e chiudi il manifest di Network nell'editor.
Crea la rete utilizzando kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Crea un disco di avvio di una VM

Una VM può utilizzare un'immagine disco precreata o eseguire l'avvio da un'immagine ISO per installare manualmente il sistema operativo. Queste immagini disco sono archiviate e accessibili tramite HTTP o in Cloud Storage e sono accessibili tramite un Secret.

In questo tutorial, creerai un disco di avvio dall'immagine cloud pubblica di Ubuntu Server 20.04 utilizzando HTTP.

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

Crea un file manifest VirtualMachineDisk, ad esempio my-disk.yaml, nell'editor che preferisci:
```
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
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Sostituisci i seguenti valori:
- DISK_NAME: il nome che vuoi assegnare al disco. Questo esempio crea un disco 20Gi (20 gibibyte) denominato DISK_NAME utilizzando un'immagine pubblica Ubuntu Server 20.04.
- STORAGE_CLASS_NAME: il valore StorageClass che vuoi utilizzare per VirtualMachineDisk.
  - Utilizza kubectl get storageclass per elencare cosa è disponibile nel tuo cluster.
Nota: potrebbero essere necessari 15-20 minuti per scaricare questa immagine pubblica, creare il VirtualMachineDisk e applicare l'immagine del sistema operativo al nuovo disco. La procedura di creazione di VirtualMachineDisk è molto più veloce quando utilizzi un'immagine archiviata in locale. Per la maggior parte degli scenari di produzione, utilizza un repository di immagini HTTP locale anziché eseguire ogni volta il pull da un'origine pubblica esterna.
Salva e chiudi il manifest di VirtualMachineDisk nell'editor.
Crea il disco utilizzando kubectl:
```
kubectl apply -f my-disk.yaml
```

Crea una VM

Ora puoi creare una VM con una rete virtuale e un disco di avvio creati nelle sezioni precedenti. La VM si connette alla rete virtuale e si avvia dal disco virtuale. Le istruzioni seguenti creano una VM applicando direttamente un file manifest YAML VirtualMachine con l'interfaccia a riga di comando kubectl.

Crea un manifest che definisca un 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:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
Sostituisci i seguenti valori:
- VM_NAME: il nome della VM.
- VCPU_NUMBER: il numero facoltativo di vCPU da assegnare alla VM. Senza questa impostazione, viene assegnato il valore predefinito di 2 vCPU.
  - Puoi assegnare da 1 a 96 vCPU a una VM.
- MEMORY_SIZE: la quantità di memoria facoltativa da assegnare alla VM. Senza questa impostazione, viene assegnato il valore predefinito di 4 GiB di memoria.
  - Puoi assegnare tra 1 M e 1 T di memoria a una VM. Per ulteriori informazioni, consulta Unità di risorse di memoria.
- NETWORK_NAME: il nome della rete creata in una sezione precedente.
- DISK_NAME: il nome del disco di avvio creato nella sezione precedente. Questo 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
```
La creazione della VM può richiedere alcuni minuti. Controlla lo stato della VM con il comando kubectl:
```
kubectl get gvm VM_NAME
```
Il seguente output di esempio mostra la VM in stato Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Connettiti alla VM

Quando la VM è in esecuzione, connettiti alla console della VM. Questa connessione della console consente di eseguire attività di base, ad esempio configurare ulteriormente la VM o installare un'applicazione.

Per accedere a una VM dalla console, utilizza kubectl:
```
kubectl virt ssh VM_NAME
```
Dopo aver eseguito la connessione alla console della VM, esci dalla sessione VM e dalla console:
```
Ctrl + ]
```

Modifica la VM

Durante il ciclo di vita della VM, potresti voler modificare la VM. Ad esempio, potresti voler aggiungere spazio di archiviazione per installare un'applicazione su un disco dedicato o utilizzare spazio di archiviazione aggiuntivo per l'applicazione.

In questo tutorial crea un disco vuoto e collegalo alla VM. Questo scenario ti consente di creare un disco dati per archiviare i dati dell'applicazione.

Crea un file manifest VirtualMachineDisk, ad esempio my-data-disk.yaml, nell'editor che preferisci:
```
nano my-data-disk.yaml
```
Copia e incolla la seguente definizione YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Sostituisci i seguenti valori:
- DATA_DISK_NAME: il nome che vuoi assegnare al disco dati. In questo esempio viene creato un disco 10Gi (10 gibibyte).
- STORAGE_CLASS_NAME: il valore StorageClass che vuoi utilizzare per VirtualMachineDisk.
  - Utilizza kubectl get storageclass per elencare cosa è disponibile nel tuo cluster.
Salva e chiudi il manifest del disco nell'editor.
Crea il disco utilizzando kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Utilizza kubectl per arrestare la VM prima di collegare il nuovo disco virtuale:
```
kubectl virt stop VM_NAME
```

Modifica la risorsa VM:

kubectl edit gvm VM_NAME

Aggiorna il manifest YAML VirtualMachine per collegare il disco alla fine della sezione spec.disks della VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME

Sostituisci DATA_DISK_NAME con il nome del disco creato nel passaggio precedente.

Salva e chiudi il manifest della VM aggiornato nell'editor.
Usa kubectl per avviare la VM:
```
kubectl virt start VM_NAME
```

Esegui la pulizia

Per eliminare le risorse create in questo tutorial, completa questi passaggi:

Elimina la VM:
```
kubectl delete -f my-vm.yaml
```

Elimina le tue risorse VirtualMachineDisk:

kubectl delete -f my-data-disk.yaml
kubectl delete -f my-disk.yaml

Se non vuoi mantenere le dipendenze di base nel cluster, completa questi passaggi:

Elimina la rete virtuale:

kubectl delete -f use-dhcp-network.yaml

Per rimuovere il driver CSI dal cluster, segui le istruzioni del tuo partner di archiviazione.