Per informazioni sulla versione, consulta le note di rilascio di Distributed Cloud connesso.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Gestisci le macchine virtuali

Questa pagina descrive come gestire le macchine virtuali nel deployment di Google Distributed Cloud connected che esegue VM Runtime su Google Distributed Cloud. Prima di completare i passaggi di questa pagina, devi avere familiarità con VM Runtime su GDC. Per un elenco dei sistemi operativi guest supportati, vedi Sistemi operativi guest verificati per VM Runtime su GDC.

Per scoprire in che modo le macchine virtuali fungono da componente essenziale della piattaforma Distributed Cloud connected, consulta Estendere GKE Enterprise per gestire le VM edge on-premise.

I cluster Google Distributed Cloud connessi supportano i webhook delle macchine virtuali. In questo modo, Distributed Cloud connesso può convalidare le richieste degli utenti effettuate al server API Kubernetes locale. Le richieste rifiutate generano informazioni dettagliate sul motivo del rifiuto.

Configura Symcloud Storage

Google Distributed Cloud connected utilizza Rakuten Symcloud Storage come soluzione di archiviazione. Symcloud Storage è una soluzione di terze parti che funge da livello di astrazione dell'archiviazione locale su ogni nodo Distributed Cloud connesso e rende la sua archiviazione locale disponibile per i carichi di lavoro in esecuzione su altri nodi Distributed Cloud connessi.

Symcloud Storage viene implementato da Google Cloud Marketplace ed è soggetto ai termini ivi indicati. Google fornisce un supporto limitato per l'utilizzo di Symcloud Storage con Distributed Cloud connesso e potrebbe coinvolgere il fornitore di terze parti per ricevere assistenza. Gli aggiornamenti software per Symcloud Storage sono inclusi negli aggiornamenti software connessi a Distributed Cloud.

Configura il cluster Google Distributed Cloud connesso come segue per abilitare Symcloud Storage per le macchine virtuali. Per saperne di più, consulta Installare Symcloud Storage su un nodo Distributed Cloud connesso.

Crea lo spazio dei nomi robin-admin con il seguente comando:
```
kubectl create ns robin-admin
```
Ottieni il file di licenza di Symcloud Storage e applicalo al cluster con il comando seguente:
```
kubectl apply -f LICENSE_FILE
```
Sostituisci LICENSE_FILE con il percorso del file di licenza.

Verifica che Symcloud Storage sia in esecuzione con questo comando:

kubectl describe robincluster

Il comando restituisce un output simile al seguente:

 Name:         robin
 Namespace:
 Labels:       app.kubernetes.io/instance=robin
               app.kubernetes.io/managed-by=robin.io
               app.kubernetes.io/name=robin
 Annotations:  <none>
 API Version:  manage.robin.io/v1
 Kind:         RobinCluster
 Metadata:
   …
 Spec:
   …
 Status:
   …
   Phase:             Ready
   …

Crea la classe di archiviazione robin-block-immediate applicando la seguente configurazione al cluster:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: robin-block-immediate
parameters:
  faultdomain: host
  replication: "3"
  blocksize:   "512"
provisioner: robin
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true

Crea la classe snapshot del volume robin-snapshotclass applicando la seguente configurazione al cluster:

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: robin-snapshotclass
  labels:
    app.kubernetes.io/instance: robin
    app.kubernetes.io/managed-by: robin.io
    app.kubernetes.io/name: robin
  annotations:
    snapshot.storage.kubernetes.io/is-default-class: "true"
driver: robin
deletionPolicy: Delete

Modifica storageprofile per la classe di archiviazione robin-block-immediate con i seguenti contenuti e applicala al cluster:

apiVersion: cdi.kubevirt.io/v1beta1
kind: StorageProfile
metadata:
  name: robin-block-immediate
spec:
  claimPropertySets:
   – accessModes:
     – ReadWriteMany
  volumeMode: Block

Installa lo strumento di gestione `virtctl`

Per gestire le macchine virtuali nel cluster Distributed Cloud connesso, devi utilizzare lo strumento client virtctl. Per installare lo strumento, completa i seguenti passaggi:

Installa lo strumento client virtctl come plug-in kubectl:

export VERSION=v1.3.1-anthos1.35-gke.39
gcloud storage cp gs://anthos-baremetal-release/virtctl/${VERSION}/linux-amd64/virtctl ./virtctl
sudo mv ./virtctl /usr/local/bin/virtctl
cd /usr/local/bin
sudo ln -s virtctl kubectl-virt
sudo chmod a+x virtctl
cd -

Verifica che il plug-in virt sia installato:
```
kubectl plugin list
```
Se il plug-in è stato installato correttamente, l'output del comando elenca kubectl-virt tra i plug-in.

Crea un bucket Cloud Storage per le immagini VM

Completa i passaggi descritti in questa sezione per creare un bucket Cloud Storage per le immagini delle macchine virtuali. Il bucket utilizza la federazione delle identità per i workload per concedere a un service account Kubernetes l'accesso diretto al bucket. Se hai già un repository di immagini consolidato, salta questa sezione.

Per ridurre il rischio di identità identiche in un parco risorse multicluster, segui le linee guida riportate in Best practice per la federazione delle identità per i workload del parco risorse quando completi i passaggi di questa sezione.

Completa i passaggi descritti in Crea bucket per creare un bucket.
Crea un ServiceAccount Kubernetes nello spazio dei nomi della macchina virtuale di destinazione:
```
export VM_NAMESPACE=NAMESPACE
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
kubectl create serviceaccount ${KUBERNETES_SERVICEACCOUNT} -n ${VM_NAMESPACE}
```
Sostituisci quanto segue:
- NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
- KUBERNETES_SERVICEACCOUNT: un nome significativo per questo service account Kubernetes.
Trova il nome del pool di identità del workload e del provider di identità del tuo cluster:
```
gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"
```
Sostituisci quanto segue:
- MEMBERSHIP_ID: il nome dell'appartenenza del parco risorse del cluster. In genere è il nome del cluster.
- FLEET_PROJECT_ID: l'ID del progetto Google Cloud host del parco risorse.
Il comando restituisce un output simile al seguente:
```
IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL
```
Nell'output, prendi nota dei seguenti valori:
- IDENTITY_PROVIDER: il provider di identità per questo cluster.
- WORKLOAD_IDENTITY_POOL: è il nome del pool di identità del workload associato al tuo parco progetti. Il nome ha il formato FLEET_PROJECT_ID.svc.id.goog. Per saperne di più sul comando in questo passaggio, consulta Utilizzare la federazione delle identità per i workload del parco risorse nelle applicazioni.
Concedi il ruolo Storage Object Viewer (roles/storage.objectViewer) sul bucket al service account Kubernetes:
```
export BUCKET_PROJECT_ID=BUCKET_PROJECT_ID
export FLEET_PROJECT_NUMBER=FLEET_PROJECT_NUMBER
export KUBERNETES_SERVICEACCOUNT=KUBERNETES_SERVICEACCOUNT
export VM_NAMESPACE=NAMESPACE
export WI_POOL=WORKLOAD_IDENTITY_POOL
gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
   --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
   --role="roles/storage.objectViewer" \
   --project=${BUCKET_PROJECT_ID} \
   --condition="IAM_CONDITION" \
   --condition-from-file="IAM_CONDITION_FILE"
```
Sostituisci quanto segue:
- BUCKET_PROJECT_ID: l'ID del progetto Google Cloud che ospita il bucket.
- FLEET_PROJECT_NUMBER: il numero del progetto host del progetto Google Cloud .
- KUBERNETES_SERVICEACCOUNT: il nome del service account Kubernetes di destinazione.
- NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
- WORKLOAD_IDENTITY_POOL: il nome del pool di identità del workload del cluster.
- IAM_CONDITION: facoltativo; specifica le condizioni IAM da utilizzare per limitare l'accesso a cluster specifici all'interno del parco risorse. Se omesso o impostato su None, non vengono applicate condizioni IAM.
- IAM_CONDITION_FILE: facoltativo; specifica il file contenente le condizioni IAM per limitare l'accesso a cluster specifici all'interno del parco risorse. Se omesso, non vengono applicate condizioni IAM, a meno che non venga specificato il flag --condition e impostato su un valore diverso da None.
Archivia le immagini nel bucket.

Hai anche la possibilità di utilizzare il metodo precedente utilizzando un segreto generato dalla chiave attiva del account di servizio Google. Per saperne di più, consulta Crea un bucket Cloud Storage per le immagini delle macchine virtuali.

Limitare l'accesso al bucket con le condizioni IAM

Le condizioni IAM ti consentono di specificare a quali cluster nel parco risorse può accedere al bucket. Se non vengono specificate condizioni IAM, tutti i cluster nel parco risorse con lo stesso ServiceAccount Kubernetes nello stesso spazio dei nomi possono accedere al bucket, il che comporta un rischio di identità identica. Se non specifichi le condizioni IAM, puoi anche ripristinare il meccanismo di accesso legacy che utilizza un secret generato dalla chiave attiva di un account di servizio Google. Di seguito è riportato un esempio di come configurare e applicare le condizioni IAM per limitare l'accesso al bucket:

Crea il file di condizione IAM:

cat <<EOF > iam_condition.yaml
> expression: request.auth.claims.google.providerId == '$IDENTITY_PROVIDER'
title: allow_only_this_cluster
> EOF

Applica il file delle condizioni IAM quando concedi l'accesso Kubernetes ServiceAccount al bucket:

gcloud storage buckets add-iam-policy-binding gs://${BUCKET_PROJECT_ID}-vm-images \
  --project="${BUCKET_PROJECT_ID}" \
  --role="roles/storage.objectViewer" \
  --member="principal://iam.googleapis.com/projects/${FLEET_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${WI_POOL}/subject/ns/${VM_NAMESPACE}/sa/${KUBERNETES_SERVICEACCOUNT}" \
  --condition-from-file=iam_condition.yaml

Crea un disco della macchina virtuale da un'immagine della macchina virtuale

Completa i passaggi descritti in questa sezione per creare un disco della macchina virtuale da un'immagine della macchina virtuale.

Crea un disco da un'immagine archiviata in Cloud Storage

Crea un disco della macchina virtuale da una macchina virtuale archiviata nel bucket Cloud Storage applicando la seguente configurazione al cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   source:
     gcs:
       url: gs://${BUCKET_PROJECT_ID}-vm-images/IMAGE_FILE_PATH
       serviceAccount: KUBERNETES_SERVICEACCOUNT
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Sostituisci quanto segue:

DISK_NAME: il nome del disco di questa macchina virtuale.
NAMESPACE: lo spazio dei nomi della macchina virtuale di destinazione.
IMAGE_FILE_PATH: il percorso completo e il nome del file immagine della macchina virtuale. Fai clic con il tasto destro del mouse sull'immagine nella console Google Cloud e seleziona Copia URI gsutil per ottenere questo percorso.
KUBERNETES_SERVICEACCOUNT: il service account Kubernetes per il download delle immagini delle macchine virtuali che hai creato in precedenza.
DISK_SIZE: le dimensioni del disco di destinazione. Questo valore deve essere maggiore del valore virtual-size del file immagine della macchina virtuale. Puoi trovare questo valore con il comando qemu-img info DISK_SIZE.

Se non specifichi un valore storageClassName, viene utilizzato il valore predefinito specificato nella risorsa VMRuntime.

Crea un disco da un'immagine archiviata su un servizio di terze parti

Puoi anche utilizzare http, https, S3 o un registro delle immagini per archiviare le immagini delle macchine virtuali. Se il tuo servizio di archiviazione richiede credenziali per l'accesso, convertile in un secret e specificalo utilizzando il campo secretRef.

Ad esempio:

source:
    http/s3/registry:
       url:
       secretRef: "SECRET_NAME" # optional

Sostituisci SECRET_NAME con il nome del tuo secret.

Per saperne di più, consulta Origine HTTP/S3/GCS/Registro.

Crea un disco vuoto

Crea un disco della macchina virtuale vuoto applicando la seguente configurazione al cluster:

 apiVersion: vm.cluster.gke.io/v1
 kind: VirtualMachineDisk
 metadata:
   name: DISK_NAME
   namespace: NAMESPACE
 spec:
   size: DISK_SIZE
   storageClassName: robin-block-immediate

Sostituisci quanto segue:

DISK_NAME: il nome del disco di questa macchina virtuale.
NAMESPACE: lo spazio dei nomi di destinazione.
DISK_SIZE: le dimensioni del disco desiderate in gibibyte. Questo valore deve essere maggiore del valore virtual-size del file immagine della macchina virtuale. Puoi trovare questo valore con il comando qemu-img info DISK_SIZE.

Se non specifichi un valore storageClassName, viene utilizzato il valore predefinito specificato nella risorsa VMRuntime.

Configura il networking virtuale

Segui i passaggi descritti in Networking per configurare il networking virtuale per le tue macchine virtuali.

Creare una macchina virtuale

Completa i passaggi descritti in questa sezione per creare una macchina virtuale nel deployment del server Google Distributed Cloud connesso. Le istruzioni in questa sezione sono esempi pensati per illustrare le configurazioni per diversi scenari. Per informazioni dettagliate sulla configurazione delle macchine virtuali, consulta Crea una VM con risorse CPU e memoria specifiche utilizzando VM Runtime su GDC.

L'allocazione delle risorse per le VM è vincolata dai profili hardware del deployment connesso a Distributed Cloud, ad esempio hardware G1 o G2. Non puoi dimensionare una singola VM in modo che sia più grande della macchina fisica Distributed Cloud connessa su cui viene eseguita.

Crea una macchina virtuale utilizzando la console Google Cloud

Per creare una macchina virtuale utilizzando la console Google Cloud , segui questi passaggi:

Nella console Google Cloud , vai alla pagina Cluster.
Vai a Cluster
Seleziona il progetto Google Cloud di destinazione.
(Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:
1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.
2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.
3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.
4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.
Vai alla pagina Macchine virtuali.
Vai a Macchine virtuali
Fai clic su CREA.
Nella sezione Nozioni di base, segui questi passaggi:
1. Nel campo Nome, inserisci un nome significativo per la macchina virtuale.
2. Nel campo Seleziona cluster, seleziona il cluster di destinazione per la macchina virtuale.
3. Nel campo Spazio dei nomi, seleziona lo spazio dei nomi di destinazione.
4. Nel campo Tipo di sistema operativo, seleziona il sistema operativo di destinazione.
5. (Facoltativo) Se vuoi aggiungere una o più etichette alla configurazione di questa macchina virtuale, fai clic su AGGIUNGI ETICHETTA.
Nella sezione Configurazione macchina, esegui una delle seguenti operazioni:
- Se vuoi specificare il numero di vCPU e la quantità di memoria per questa macchina virtuale, seleziona Configurazione personalizzata e inserisci i valori target, poi fai clic su AVANTI.
- Se vuoi utilizzare un numero predeterminato di vCPU e una quantità di memoria per questa macchina virtuale, seleziona Configurazione standard e seleziona una configurazione della macchina dall'elenco a discesa Tipo di macchina, poi fai clic su AVANTI.
Nella sezione Spazio di archiviazione, esegui una delle seguenti operazioni:
- Se vuoi creare un nuovo disco virtuale per questa macchina virtuale, seleziona Aggiungi un nuovo disco e inserisci un nome significativo nel campo Nome, una dimensione in gigabyte nel campo GiB e un URL nel campo Immagine.
- Se vuoi utilizzare un disco virtuale esistente per questa macchina virtuale, seleziona Seleziona un disco esistente e seleziona l'immagine disco di destinazione dall'elenco a discesa Seleziona un disco.
- Specifica se vuoi che il disco sia di sola lettura e se verrà eliminato automaticamente quando questa macchina virtuale viene eliminata utilizzando le caselle di controllo Sola lettura e Eliminazione automatica.
- Specifica un driver del disco virtuale nell'elenco a discesa Driver.
- Per aggiungere un altro disco a questa macchina virtuale, fai clic su AGGIUNGI UN DISCO nella sezione Dischi aggiuntivi.
- Fai clic su AVANTI.
Nella sezione Rete, segui questi passaggi:
1. Nella sottosezione Interfaccia di rete predefinita, specifica il nome dell'interfaccia di rete principale per questa macchina virtuale nel campo Nome interfaccia.
2. Seleziona il tipo di rete corrispondente dall'elenco a discesa Tipo di rete.
3. Specifica se consentire l'accesso esterno a questa interfaccia di rete utilizzando la casella di controllo Consenti accesso esterno. Se attivi questa opzione, devi inserire un elenco separato da virgole di porte da esporre esternamente nel campo Porte esposte.
4. Se vuoi aggiungere una o più interfacce di rete secondarie a questa macchina virtuale, fai clic su AGGIUNGI UN'INTERFACCIA DI RETE.
5. Fai clic su AVANTI.
Nella sezione Opzioni avanzate, utilizza la casella di controllo Riavvio automatico all'aggiornamento per specificare se riavviare questa macchina virtuale dopo l'aggiornamento del software Distributed Cloud connesso sul cluster di destinazione.
Nella sezione Firmware, segui questi passaggi:
1. Seleziona il tipo di firmware di destinazione nel campo Tipo di bootloader. Se selezioni il firmware UEFI, hai la possibilità di abilitare l'avvio protetto utilizzando la casella di controllo Avvio protetto.
2. Specifica un numero di serie per questa macchina virtuale nel campo Seriale.
3. Specifica un UUID (Universally Unique Identifier) per questa macchina virtuale nel campo UUID.
Nella sezione Cloud-init, specifica un valore segreto dei dati utente nel campo User data secret.
Fai clic su CREA VM per creare la macchina virtuale.

Crea una macchina virtuale da un file YAML

Per creare una macchina virtuale da un file di configurazione YAML:

Nella console Google Cloud , vai alla pagina Cluster.
Vai a Cluster
Seleziona il progetto Google Cloud di destinazione.
(Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:
1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.
2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.
3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.
4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.
Vai alla pagina Macchine virtuali.
Vai a Macchine virtuali
Fai clic su CREA CON YAML.
Nel campo Seleziona cluster, seleziona il cluster di destinazione per la macchina virtuale.
Incolla la configurazione della macchina virtuale in formato YAML nel campo YAML. Per informazioni dettagliate sui campi YAML supportati, consulta il riferimento alla specifica della macchina virtuale.
Fai clic su CREA.

Crea una macchina virtuale da un'immagine disco avviabile

Per creare una macchina virtuale da un'immagine disco avviabile, applica la seguente configurazione al cluster. Per personalizzare questa configurazione, ad esempio le opzioni di CPU, memoria o rete, consulta le Specifiche di riferimento per le macchine virtuali:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: my-virtual-machine
  namespace: NAMESPACE
spec:
  osType: Linux/Windows
  # guestEnvironment: {} # uncomment this line to disable guest environment
  priorityClassName: PRIORITY_CLASS
  compute:
    cpu:
      vcpus: 6
    memory:
      capacity: 8Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      ipAddresses:
        - IP_ADDRESS/PREFIX
  disks:
    - virtualMachineDiskName: DISK_NAME
      boot: true
    - virtualMachineDiskName: DISK_NAME

Sostituisci quanto segue:

NAMESPACE: lo spazio dei nomi di destinazione.
PRIORITY_CLASS: la classe di priorità per questa macchina virtuale. Una classe di priorità è un intervallo di valori di priorità. Utilizza kubectl get priorityclass per visualizzare un elenco delle classi di priorità supportate. Una priorità di pianificazione più elevata riduce la possibilità di espulsione della VM quando le risorse del nodo sono limitate. Se omesso, la macchina virtuale riceve il valore di priorità più basso predefinito.
NETWORK_NAME: il nome della rete L2 a cui collegare l'interfaccia VM.
DISK_NAME: i nomi dei dischi di questa macchina virtuale.
vcpus: il numero di vCPU da assegnare alla VM.
capacity: la quantità di memoria da assegnare alla VM. Ad esempio, 4Gi o 8Gi.
ipAddresses: facoltativo; fornisce l'assegnazione di IP statici per la macchina virtuale. Se la rete L2 sottostante supporta il DHCP esterno, puoi omettere ipAddresses per consentire l'allocazione dinamica.

Utilizza l'API `cloud-init` per inizializzare le VM

L'API cloud-init è un modo standard per inizializzare una VM cloud. Utilizza cloud-init per configurare file, utenti e altri aspetti della tua VM.

Per garantire la compatibilità, convalida le routine di avvio di cloud-init. Prima di utilizzare la configurazione in produzione, applicala a una VM di test per assicurarti che venga inizializzata correttamente.

I seguenti esempi sono generici e devono essere testati nel tuo ambiente.

Automatizzare la configurazione delle VM con i dati utente `cloud-init`

VM Runtime su GDC supporta i dati utente cloud-init per le VM Linux. Puoi specificare i dati utente come stringa di testo normale, stringa con codifica Base64 o facendo riferimento a un secret Kubernetes.

Per assicurarti che la VM venga inizializzata correttamente, convalida tutte le configurazioni dei dati utente prima di eseguirne il deployment in un ambiente di produzione.

L'esempio seguente mostra un manifest VirtualMachine che include dati utente cloud-init in testo normale per eseguire un comando all'avvio della VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  osType: Linux
  cloudInit:
    noCloud:
      userData: |
        #cloud-config
        runcmd:
          - echo "Hello World" > /tmp/hello.txt

Sostituisci VM_NAME con il nome della macchina virtuale.

Per creare la VM con i dati cloud-init, salva il manifest come vm-cloud-init.yaml e applicalo al cluster eseguendo il comando kubectl apply:

kubectl apply -f vm-cloud-init.yaml

Risoluzione dei problemi `cloud-init`

Se riscontri problemi con cloud-init, controlla i log all'interno della VM. Di solito puoi trovare i log nelle seguenti directory:

/var/log/cloud-init.log
/var/log/cloud-init-output.log

Crea una macchina virtuale da un'immagine del disco ottico ISO

Puoi creare una macchina virtuale (VM) Windows che si avvia da un'immagine ISO utilizzando VM Runtime su GDC. Questa funzionalità ti consente di eseguire la migrazione di applicazioni aziendali legacy basate su Windows, software di terze parti specializzati o sistemi point-of-sale personalizzati direttamente ai cluster connessi di Distributed Cloud.

Le immagini utilizzate per i dischi VM vengono importate da un bucket di immagini connesso a Distributed Cloud. Prima di creare i manifest, devi scaricare l'ISO di installazione di Windows e l'ISO dei driver KubeVirt virtio e caricarli nel bucket delle immagini. Ti consigliamo di conservare una copia verificata dell'ISO dei driver in un repository interno o di preconfigurarla in Cloud Storage per garantire build di macchine virtuali affidabili e ripetibili.

Creare i manifest

Per l'avvio da un'immagine ISO di Windows, sono necessari i seguenti manifest:

Un VirtualMachineDisk contenente il file ISO di Windows.
Un VirtualMachineDisk contenente i driver KubeVirt Windows virtio.
Un VirtualMachineDisk vuoto che funga da disco di avvio in cui verrà installato Windows.

Gli esempi seguenti mostrano i manifest VirtualMachineDisk per i tre dischi richiesti.

Nei manifest, sostituisci quanto segue:

BUCKET_PROJECT_ID: l'ID progetto in cui si trova il bucket delle immagini.
KUBERNETES_SERVICEACCOUNT: il service account Kubernetes con le autorizzazioni per leggere dal bucket.

Il PVC size richiesto nei manifest deve essere sempre maggiore o uguale alla dimensione virtuale esatta dell'ISO.

Disco ISO di Windows

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-iso
spec:
  size: 10Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/windows.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

Disco dei driver VirtIO

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: virtio-driver
spec:
  size: 1Gi
  storageClassName: robin-block-immediate
  diskType: cdrom
  source:
    gcs:
      url: gs://BUCKET_PROJECT_ID-vm-images/virtio-win.iso
      serviceAccount: KUBERNETES_SERVICEACCOUNT

Disco di avvio vuoto

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: windows-vm-boot-dv
spec:
  size: 40Gi
  storageClassName: robin-block-immediate

Crea i dischi

Per creare questi dischi, salva i manifest VirtualMachineDisk e applicali al cluster eseguendo il comando kubectl apply:

kubectl apply -f windows-iso.yaml
kubectl apply -f virtio-driver.yaml
kubectl apply -f windows-vm-boot-dv.yaml

Crea una VM Windows

Per creare una VM Windows, crea un manifest che definisca la VM e faccia riferimento ai dischi. La VM si avvia dal disco ISO per iniziare l'installazione.

L'esempio seguente mostra un manifest VirtualMachine:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  labels:
    kubevirt.io/vm: windows-vm
  name: windows-vm
spec:
  osType: Windows
  disks:
    - virtualMachineDiskName: windows-vm-boot-dv
      boot: true
    - virtualMachineDiskName: windows-iso
    - virtualMachineDiskName: virtio-driver
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
      ipAddresses:
        - IP_ADDRESS/PREFIX

Per creare la VM, salva il manifest come windows-vm.yaml e applicalo al cluster eseguendo il comando kubectl apply:

kubectl apply -f windows-vm.yaml

Connetti e completa l'installazione

Per connetterti e completare l'installazione, segui questi passaggi:

Per connetterti alla VM utilizzando VNC, utilizza lo strumento virtctl o il plug-in kubectl virt:
```
virtctl vnc windows-vm
```
In alternativa, se hai installato virtctl come plug-in kubectl:
```
kubectl virt vnc windows-vm
```
Per maggiori informazioni su virtctl, consulta la documentazione di KubeVirt.
Segui le istruzioni visualizzate dal programma di installazione di Windows. Quando richiesto, seleziona Installazione personalizzata.
Quando richiesto, carica i driver virtio per l'archiviazione e la rete, sfogliando il disco virtio-driver collegato.
Completa l'installazione.

Accesso tramite Remote Desktop Protocol

Dopo aver installato e attivato Remote Desktop Protocol (RDP) nel sistema operativo guest, puoi accedere alla VM tramite RDP.

Poiché la macchina virtuale è collegata a una rete L2, è raggiungibile direttamente dall'esterno del cluster utilizzando l'indirizzo IP assegnato (ad esempio, 10.223.237.10). Connettiti a questo indirizzo IP sulla porta 3389 utilizzando un client RDP. Assicurati che l'indirizzo IP interno L2 sia raggiungibile dalla macchina client tramite le regole di routing e firewall aziendali.

Crea una macchina virtuale con supporto GPU

Completa i passaggi descritti in questa pagina per creare una macchina virtuale configurata per soddisfare i requisiti aziendali, quindi completa i passaggi descritti in Configura una macchina virtuale per utilizzare le risorse GPU.

Riferimento alle specifiche della macchina virtuale

La tabella seguente descrive i campi chiave nella specifica VirtualMachine. Utilizza questi campi quando configuri un manifest YAML della macchina virtuale da applicare al cluster utilizzando kubectl apply o quando utilizzi l'opzione Crea con YAML nella console Google Cloud .

Campo	Descrizione	Obbligatorio
`apiVersion`	Deve essere `vm.cluster.gke.io/v1`.	Obbligatorio
`kind`	Deve essere `VirtualMachine`.	Obbligatorio
`metadata.name`	Un nome univoco per la macchina virtuale.	Obbligatorio
`metadata.namespace`	Lo spazio dei nomi Kubernetes in cui viene eseguita la VM.	Obbligatorio
`spec.osType`	Il tipo di sistema operativo guest. Valori supportati: `Linux` e `Windows`.	Obbligatorio
`spec.guestEnvironment`	Configura l'ambiente guest. Se omesso, l'ambiente ospite è attivo per impostazione predefinita. Per disattivare, imposta il valore su `{}`.	Facoltativo
`spec.priorityClassName`	La classe di priorità per la VM. Una priorità più alta riduce la possibilità di espulsione.	Facoltativo
`spec.compute`	Configura le risorse di computing per la VM.	Obbligatorio
`spec.compute.cpu.vcpus`	Numero di vCPU da allocare. I valori accettati sono compresi tra 1 e 96.	Obbligatorio
`spec.compute.memory.capacity`	Capacità di memoria, ad esempio `8Gi`.	Obbligatorio
`spec.interfaces`	Elenco delle interfacce di rete per la VM.	Obbligatorio
`spec.interfaces[].name`	Nome dell'interfaccia, ad esempio `eth0`.	Obbligatorio
`spec.interfaces[].networkName`	Nome della subnet a cui connettersi, che corrisponde a una risorsa `Network` nel cluster.	Obbligatorio
`spec.interfaces[].ipAddresses`	Indirizzi IP statici da assegnare a questa interfaccia. Se la subnet non ha DHCP abilitato, devi specificare un indirizzo IP statico.	Facoltativo
`spec.disks`	Elenco dei dischi da collegare alla VM.	Obbligatorio
`spec.disks[].virtualMachineDiskName`	Nome della risorsa `VirtualMachineDisk`.	Obbligatorio
`spec.disks[].boot`	Imposta `true` per il disco di avvio. Solo un disco può essere contrassegnato come avviabile.	Facoltativo

Accedere a una macchina virtuale

Completa i passaggi descritti in questa sezione per accedere a una macchina virtuale in esecuzione nel deployment del server Google Distributed Cloud connesso.

Requisiti di rete per l'accesso diretto

Per accedere a una macchina virtuale direttamente dalla tua rete locale senza utilizzare un servizio Kubernetes LoadBalancer, devi configurare i componenti di rete logici e fisici. Distributed Cloud connesso gestisce automaticamente le risorse di rete nel cluster, ma devi configurare la rete esterna e l'interfaccia VM.

Configura la subnet (VLAN): crea una subnet con un ID VLAN specifico utilizzando l'API Distributed Cloud Edge Network, utilizzando gcloud o l'API. Distributed Cloud connected sincronizza automaticamente questa configurazione con il cluster. Non è necessario creare manualmente le risorse di rete Kubernetes. Consulta la pagina Creare e gestire subnet.
Configura la rete locale: l'amministratore di rete deve configurare gli switch e i router fisici connessi ai server Google Distributed Cloud connessi per:
- Consenti l'ID VLAN configurato sulle porte dello switch (trunking VLAN).
- Attiva il routing tra la rete locale e la subnet. Se Border Gateway Protocol (BGP), un protocollo di routing dinamico, è configurato sui router connessi a Distributed Cloud, queste route vengono annunciate automaticamente dopo la creazione della subnet. In caso contrario, devi configurare route statiche sui router fisici per instradare il traffico per l'intervallo IP (CIDR) della subnet ai nodi connessi di Distributed Cloud.
Configura l'interfaccia VM: nella configurazione YAML VirtualMachine, configura la VM in modo che utilizzi questa subnet specificando il nome della rete nel campo spec.interfaces. Per ulteriori informazioni, consulta Riferimento alle specifiche delle macchine virtuali.

Ottenere le credenziali di accesso per le VM Linux

Se non disponi già delle credenziali per accedere alla macchina virtuale, completa i passaggi di questa sezione per ottenerle utilizzando la funzionalità dell'ambiente guest Linux.

Attiva l'ambiente guest Linux per la macchina virtuale di destinazione applicando la seguente configurazione al cluster:

kind: VirtualMachine
metadata:
 name: my-virtual-machine
 namespace: my-vm-namespace
spec:
 osType: Linux
 guestEnvironment: // enabled by default; disable with guestEnvironment: {}
   accessManagement:
    enable: true

Genera un file id_rsa.pub contenente una coppia di chiavi SSH con il seguente comando:
```
ssh-keygen -t rsa
```
Crea una risorsa VirtualMachineAccessRequest applicando la seguente configurazione al cluster:
```
apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachineAccessRequest
metadata:
 name: RESOURCE_NAME
 namespace: NAMESPACE
spec:
  vm: VM_NAME
  user: USER_NAME
  ssh:
    key: RSA_KEY
    ttl: 2h
```
Sostituisci quanto segue:
- RESOURCE_NAME: un nome descrittivo per questa risorsa di richiesta di accesso alla macchina virtuale.
- NAMESPACE: lo spazio dei nomi di destinazione.
- VM_NAME: il nome della macchina virtuale di destinazione.
- USER_NAME: il nome dell'utente a cui viene concesso l'accesso.
- RSA_KEY: i contenuti del file id_rsa.pub generato nel passaggio precedente.
Per controllare lo stato della richiesta di accesso, esegui il comando kubectl get:
```
kubectl get vmar
```
Quando il comando restituisce lo stato Configured, vai al passaggio successivo.
Accedi alla macchina virtuale con SSH. Se la macchina virtuale è connessa alla tua rete locale, accedi direttamente tramite SSH:
```
ssh USERNAME@VM_IP_ADDRESS -i PATH_TO_KEY
```
Sostituisci quanto segue:
- USERNAME: il nome utente con cui accedere, ad esempio l'utente configurato nella risorsa VirtualMachineAccessRequest.
- VM_IP_ADDRESS: l'indirizzo IP della macchina virtuale.
- PATH_TO_KEY: il percorso della chiave SSH privata corrispondente alla chiave pubblica generata nei passaggi precedenti.

Utilizzare RDP per accedere a una VM Windows

Per accedere a una VM Windows utilizzando Remote Desktop Protocol (RDP) dalla tua rete locale, attiva RDP nel sistema operativo guest, assicurati che la VM sia accessibile dalla rete e configura le credenziali utente.

Prerequisiti

Attiva RDP in Windows: RDP deve essere attivato nel sistema operativo guest Windows. Se RDP non è ancora abilitato, utilizza una console Virtual Network Computing (VNC) per accedere direttamente allo schermo della VM e abilitarlo. Il comando kubectl virt vnc apre una finestra del visualizzatore grafico sulla workstation locale e richiede l'installazione di un client visualizzatore VNC, ad esempio Remote Viewer o VNC Viewer, sulla workstation:

kubectl virt vnc VM_NAME -n NAMESPACE

Sostituisci quanto segue:

VM_NAME: il nome della VM Windows.
NAMESPACE: lo spazio dei nomi della VM.

Connettiti utilizzando RDP

Per ottenere l'indirizzo IP della VM, esegui il comando kubectl get:
```
kubectl get vmi VM_NAME -n NAMESPACE -o jsonpath='{.status.interfaces[*].ipAddress}'
```
Sostituisci quanto segue:
- VM_NAME: il nome della VM Windows.
- NAMESPACE: lo spazio dei nomi della VM.
Prendi nota dell'indirizzo IP appartenente alla subnet di cui è stato eseguito il routing dall'output.
Utilizza un client RDP standard, ad esempio Connessione Desktop remoto su Windows o Remmina su Linux, per connetterti all'indirizzo IP recuperato sulla porta 3389.
Utilizza il nome utente e la password per accedere.

Avviare, riavviare o arrestare una macchina virtuale

Utilizza i seguenti comandi per avviare, riavviare o arrestare una macchina virtuale:

Avvia una macchina virtuale: kubectl virt start vmVM_NAME-nNAMESPACE
Riavvia una macchina virtuale: kubectl virt restart vmVM_NAME-nNAMESPACE
Arrestare una macchina virtuale: kubectl virt stop vmVM_NAME-nNAMESPACE

Sostituisci quanto segue:

VM_NAME: il nome della macchina virtuale di destinazione.
NAMESPACE: lo spazio dei nomi di destinazione.

Avviare o arrestare una macchina virtuale utilizzando la console Google Cloud

Nella console Google Cloud , vai alla pagina Cluster.
Vai a Cluster
Seleziona il progetto Google Cloud di destinazione.
(Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:
1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.
2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.
3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.
4. Nella finestra di dialogo visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.
Vai alla pagina Macchine virtuali.
Vai a Macchine virtuali
Nell'elenco delle macchine virtuali, seleziona le caselle di controllo per le macchine virtuali di destinazione.
Nella parte superiore della pagina, fai clic su AVVIA o INTERROMPI, a seconda dei casi.

Visualizzare lo stato di una macchina virtuale utilizzando la console Google Cloud

Nella console Google Cloud , vai alla pagina Cluster.
Vai a Cluster
Seleziona il progetto Google Cloud di destinazione.
(Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:
1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.
2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.
3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.
4. Nella finestra di dialogo popup visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.
Vai alla pagina Macchine virtuali.
Vai a Macchine virtuali
Fai clic sulla macchina virtuale di destinazione.
Nella pagina visualizzata, fai clic sulle schede Dettagli, Eventi e YAML per visualizzare le informazioni corrispondenti su questa macchina virtuale.

Modificare una macchina virtuale

Per modificare una macchina virtuale, devi eliminarla e ricrearla con la configurazione aggiornata.

Elimina una macchina virtuale utilizzando la console Google Cloud

Nella console Google Cloud , vai alla pagina Cluster.
Vai a Cluster
Seleziona il progetto Google Cloud di destinazione.
(Facoltativo) Se non l'hai ancora fatto, accedi al cluster di destinazione:
1. Nel riquadro di navigazione a sinistra, fai clic su Cluster.
2. Nell'elenco Anthos Managed Clusters, fai clic sul cluster di destinazione.
3. Nel riquadro delle informazioni a destra, fai clic su ACCEDI.
4. Nella finestra di dialogo visualizzata, seleziona il metodo di autenticazione che preferisci, inserisci le tue credenziali e fai clic su ACCEDI.
vai alla pagina Macchine virtuali.
Vai a Macchine virtuali
Nell'elenco delle macchine virtuali, seleziona la casella di controllo della macchina virtuale di destinazione.
Nella parte superiore della pagina, fai clic su ELIMINA.
Nella finestra di dialogo di conferma visualizzata, inserisci il nome della macchina virtuale e fai clic su ELIMINA.

Gestisci le macchine virtuali Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Configura Symcloud Storage

Installa lo strumento di gestione virtctl

Crea un bucket Cloud Storage per le immagini VM

Limitare l'accesso al bucket con le condizioni IAM

Crea un disco della macchina virtuale da un'immagine della macchina virtuale

Crea un disco da un'immagine archiviata in Cloud Storage

Crea un disco da un'immagine archiviata su un servizio di terze parti

Crea un disco vuoto

Configura il networking virtuale

Creare una macchina virtuale

Crea una macchina virtuale utilizzando la console Google Cloud

Crea una macchina virtuale da un file YAML

Crea una macchina virtuale da un'immagine disco avviabile

Utilizza l'API cloud-init per inizializzare le VM

Automatizzare la configurazione delle VM con i dati utente cloud-init

Risoluzione dei problemi cloud-init

Crea una macchina virtuale da un'immagine del disco ottico ISO

Creare i manifest

Crea i dischi

Crea una VM Windows

Connetti e completa l'installazione

Accesso tramite Remote Desktop Protocol

Crea una macchina virtuale con supporto GPU

Riferimento alle specifiche della macchina virtuale

Accedere a una macchina virtuale

Requisiti di rete per l'accesso diretto

Ottenere le credenziali di accesso per le VM Linux

Utilizzare RDP per accedere a una VM Windows

Prerequisiti

Connettiti utilizzando RDP

Avviare, riavviare o arrestare una macchina virtuale

Avviare o arrestare una macchina virtuale utilizzando la console Google Cloud

Visualizzare lo stato di una macchina virtuale utilizzando la console Google Cloud

Modificare una macchina virtuale

Elimina una macchina virtuale utilizzando la console Google Cloud

Passaggi successivi

Gestisci le macchine virtuali

Installa lo strumento di gestione `virtctl`

Utilizza l'API `cloud-init` per inizializzare le VM

Automatizzare la configurazione delle VM con i dati utente `cloud-init`

Risoluzione dei problemi `cloud-init`