Spostamento di un'istanza VM tra zone o regioni

Linux Windows

Questo documento descrive come spostare un'istanza di una macchina virtuale (VM) tra zone o regioni.

Prima di iniziare

Leggi la documentazione relativa alle zone.
Configurare l'autenticazione.

Seleziona la scheda relativa a come intendi utilizzare gli esempi di questa pagina:
gcloud
1. Installa Google Cloud CLI, quindi inizializzalo eseguendo il comando seguente:
```
gcloud init
```
  Nota: se hai installato lgcloud CLI in precedenza, assicurati di avere la versione più recente eseguendo gcloud components update.
2. Imposta una regione e una zona predefinite.
Go

Per utilizzare gli esempi di Go in questa pagina da un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Java

Per utilizzare gli esempi di Java in questa pagina da un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Node.js

Per utilizzare gli esempi di Node.js in questa pagina da un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Python

Per utilizzare gli esempi di Python in questa pagina da un ambiente di sviluppo locale, installa e inizializza l'interfaccia alla gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Requisiti

Questa sezione elenca i requisiti per lo spostamento di una VM tra zone e regioni:

Quota del progetto. Il progetto deve avere una quota sufficiente per eseguire le seguenti operazioni:
- Creare nuovi snapshot.
- Promuovi eventuali indirizzi IP esterni temporanei.
- Crea nuovi dischi e VM nella regione di destinazione.
  
  Ad esempio, se hai tre dischi collegati alla VM da spostare, hai bisogno di una quota sufficiente per creare tre snapshot di disco permanente temporanei e tre nuovi dischi. Dopo aver creato i nuovi dischi, puoi eliminare gli snapshot temporanei.
Controlla la pagina Quote per assicurarti di disporre di una quota sufficiente per le risorse precedenti. Per saperne di più, consulta Informazioni sulle quote.
Dischi permanenti. I dischi permanenti collegati alla VM che vuoi spostare non sono collegati ad altre VM.
SSD locali. Le unità SSD locali sono destinate all'archiviazione temporanea e i dati sulle SSD locali non vengono conservati tramite terminazioni manuali delle VM. Se devi conservare i dati degli SSD locali, replicali utilizzando un'opzione di archiviazione durevole come i dischi permanenti.
GPU. Se la tua VM include GPU, verifica che quelle che vuoi utilizzare siano disponibili nella zona di destinazione della VM. Per un elenco delle GPU e delle zone in cui sono disponibili, consulta GPU su Compute Engine.
Subnet. Se vuoi spostare la tua VM tra regioni, ad esempio tra us-west1-a e asia-south1-b, e la tua VM appartiene a una subnet, devi selezionare una nuova subnet per la VM. Per istruzioni su come creare subnet, consulta Aggiunta di subnet.

Nota: il metodo di spostamento di una VM descritto in questa sezione funziona anche per le VM in stato CHIUSO o per la VM schermata che utilizzano il firmware UEFI.

Limitazione

Se sposti una VM tra regioni, non puoi conservare l'indirizzo IP temporaneo interno o esterno della VM. Devi scegliere un nuovo indirizzo IP quando ricrei la VM.

Proprietà della risorsa

Per spostare la VM, devi arrestarla, spostarla nella zona o nella regione di destinazione e quindi riavviarla. Dopo aver spostato la VM, aggiorna tutti i riferimenti esistenti alla risorsa originale, ad esempio VM di destinazione o pool di destinazione che rimandano alla VM precedente.

Durante lo spostamento, alcune proprietà generate dal server della VM e dei dischi cambiano.

Proprietà che cambiano per le VM

La tabella seguente descrive le proprietà che cambiano per le VM:

Nome proprietà	Modifiche
Indirizzo IP interno	Generalmente viene assegnato un nuovo indirizzo IP interno, ma la VM potrebbe mantenere l'indirizzo IP interno originale.
Indirizzo IP esterno	Se la VM si sposta tra zone nella stessa regione, l'indirizzo IP esterno rimane lo stesso. Altrimenti, scegli un indirizzo IP esterno diverso per l'istanza VM.
Piattaforma CPU	A seconda della piattaforma CPU disponibile nella zona di destinazione, la VM potrebbe avere una piattaforma CPU diversa dopo lo spostamento. Per un elenco completo delle piattaforme CPU in ogni zona, consulta Regioni e zone disponibili.
Rete/sottorete	Se la VM appartiene a una subnet e stai spostando una VM tra regioni, devi scegliere una nuova subnet per la VM. Le VM che si spostano tra zone nella stessa regione mantengono la stessa subnet.

Proprietà che cambiano per i dischi

La tabella seguente descrive le proprietà che cambiano per i dischi:

Nome proprietà	Modifiche
Snapshot di origine	Lo snapshot di origine del nuovo disco è impostato sullo snapshot temporaneo creato durante lo spostamento.
ID snapshot di origine	L'ID snapshot di origine è impostato sull'ID dello snapshot temporaneo.
Immagine di origine	Il campo dell'immagine di origine è vuoto.
ID immagine	L'ID immagine è vuoto.
Timestamp ultimo scollegamento	L'ultimo timestamp scollegato è vuoto.
Timestamp ultimo allegato	L'ultimo timestamp collegato diventa quello di quando il nuovo disco è stato collegato alla nuova istanza.

Modifica delle proprietà per VM e dischi

La tabella seguente descrive le proprietà che cambiano sia per le VM che per i dischi:

Nome proprietà	Modifiche
ID	Viene generato un nuovo ID risorsa.
Timestamp creazione	Viene generato un nuovo timestamp di creazione.
URL delle risorse di zona	Tutti gli URL delle risorse della zona cambiano in modo da riflettere la zona di destinazione. Il seguente elenco mostra gli URL delle risorse che cambiano: L'URL del disco di origine di una VM L'URL del tipo di macchina di una VM URL con link self-link URL zona URL tipi di disco Tutti gli URL delle VM elencate nell'elenco `users[]` di un disco

Spostare una VM tra zone o regioni

Per spostare una VM tra zone o regioni, puoi fare quanto segue:

Crea un'immagine macchina della VM di origine.
Crea una VM dall'immagine macchina in una zona o regione diversa.

Gli esempi seguenti mostrano come spostare una VM tra zone.

gcloud

In questo esempio, sposterai da europe-west1-c a us-west1-b una VM denominata myinstance con due dischi permanenti denominati mybootdisk e mydatadisk.

Identifica i dischi associati alla VM che vuoi spostare:
```
gcloud compute instances describe myinstance --format="list(name,status,disks)"
```
In questo esempio, troverai i seguenti due dischi associati alla VM myinstance:
- Un disco di avvio chiamato mybootdisk
- Un disco dati chiamato mydatadisk
Imposta lo stato di eliminazione automatica di mybootdisk e mydatadisk su false per assicurarti che i dischi non vengano eliminati automaticamente quando la VM viene eliminata.
```
gcloud compute instances set-disk-auto-delete myinstance --zone europe-west1-c \
    --disk mybootdisk --no-auto-delete
```
Se lo stato è stato aggiornato, gcloud compute restituisce la risposta Updated [...]. Se lo stato di eliminazione automatica era già impostato su false, gcloud compute restituisce:
```
No change requested; skipping update for [myinstance].
```
(Facoltativo) Salva i metadati della VM.

Quando elimini la VM, vengono rimossi anche i relativi metadati. Puoi salvare queste informazioni in un file separato, quindi riapplicare i metadati della VM alla nuova VM.

Descrivi i metadati della tua VM in questo modo:
```
gcloud compute instances describe myinstance --zone europe-west1-c
```
Salva i contenuti in un file separato.
Crea backup dei tuoi dati utilizzando gli snapshot di disco permanente.

Per precauzione, crea backup dei dati mentre i dischi permanenti sono ancora collegati alla VM utilizzando gli snapshot di disco permanente. Prima di acquisire uno snapshot, assicurati che sia coerente con lo stato del disco permanente attenendoti alle best practice per gli snapshot.

Nota: se esegui una VM Windows, la VM deve essere terminata prima di poter creare uno snapshot. Segui i passaggi per creare uno snapshot per una VM Windows.

Dopo aver cancellato i buffer del disco, crea gli snapshot:
```
gcloud compute disks snapshot mybootdisk mydatadisk \
    --snapshot-names backup-mybootsnapshot,backup-mydatasnapshot \
    --zone europe-west1-c 
```
Per verificare che lo snapshot sia stato creato, esegui gcloud compute snapshots list.
(Facoltativo) Se vuoi spostare una VM tra zone della stessa regione e vuoi conservarne l'indirizzo IP interno o esterno temporaneo, promuovi l'indirizzo IP interno o esterno a un indirizzo IP statico, che potrai riutilizzare in seguito.

Nota: se sposti la VM tra regioni diverse, non puoi conservare l'indirizzo IP temporaneo interno o esterno di una VM . Devi scegliere un nuovo indirizzo IP quando ricrei la VM.

Eliminare la VM.

L'eliminazione della VM ne determina l'arresto pulito e scollega tutti i dischi permanenti.

gcloud compute instances delete myinstance --zone europe-west1-c

gcloud ti chiede di confermare l'eliminazione:

The following VMs are deleted. Any attached disks configured to be auto-deleted are deleted unless they are attached to any other VMs or the `--keep-disks` flag is given and specifies them for keeping. Deleting a disk is irreversible and any data on the disk is lost. — [myinstance] in [europe-west1-c]

Do you want to continue (Y/n)?

Poiché hai disattivato lo stato di eliminazione automatica per i dischi in precedenza in questo processo, inserisci Y per continuare e ignora l'avviso.

Quindi, crea un altro snapshot sia del disco di avvio sia del disco dati.

gcloud compute disks snapshot mybootdisk mydatadisk \
    --snapshot-names mybootsnapshot,mydatasnapshot \
    --zone europe-west1-c

Created [.../mydatasnapshot].
Created [.../mybootsnapshot].

(Facoltativo) Elimina i dischi permanenti.

Se prevedi di riutilizzare i nomi dei dischi permanenti per i nuovi dischi, devi eliminare i dischi esistenti per rilasciarli. L'eliminazione dei dischi consente inoltre di risparmiare sui costi di archiviazione su disco permanente.

Se non prevedi di riutilizzare gli stessi nomi dei dischi, non è necessario eliminarli.
```
gcloud compute disks delete mybootdisk mydatadisk --zone europe-west1-c
```

Crea nuovi dischi permanenti in us-west1-b dagli snapshot che hai creato. Per prima cosa, crea il disco di avvio.

gcloud compute disks create mybootdiskb --source-snapshot mybootsnapshot \
    --zone us-west1-b

Created [.../mybootdiskb].
NAME        ZONE           SIZE_GB TYPE        STATUS
mybootdiskb us-west1-b     100     pd-standard READY

Quindi crea il disco dati.

gcloud compute disks create mydatadiskb --source-snapshot mydatasnapshot \
    --zone us-west1-b

Created [.../mydatadiskb].
NAME        ZONE           SIZE_GB TYPE        STATUS
mydatadiskb us-west1-b 4000    pd-standard READY

Ricrea la VM in us-west1-b.
- Se hai scelto di salvare i metadati della VM in un file, ad esempio myinstance.describe, puoi utilizzarli per impostare gli stessi metadati sulla VM.
- Se la tua VM aveva un indirizzo IP esterno statico, puoi riassegnarlo alla nuova VM specificando l'opzione --address [ADDRESS]. Se sposti una VM tra regioni, devi scegliere un indirizzo IP esterno diverso per la nuova istanza VM.
- Se la tua VM aveva un indirizzo IP interno statico, puoi riassegnarlo alla nuova VM specificando l'opzione --private-network-ip ADDRESS. Se sposti una VM tra regioni, devi scegliere un indirizzo IP interno diverso per la nuova istanza VM.
- Se la tua VM includeva GPU, aggiungile alla VM utilizzando l'opzione --accelerator.
- Se la VM utilizza una subnet specifica, aggiungi il flag --subnet [SUBNET_NAME].
Per un elenco completo dei flag aggiuntivi, vedi gcloud compute instances create.
```
gcloud compute instances create myinstanceb --machine-type n1-standard-4 \
    --zone us-west1-b \
    --disk name=mybootdiskb,boot=yes,mode=rw \
    --disk name=mydatadiskb,mode=rw 
```
```
Created [.../myinstanceb].
NAME        ZONE           MACHINE_TYPE  INTERNAL_IP    EXTERNAL_IP     STATUS
myinstanceb us-west1-b     n1-standard-4 10.240.173.229 146.148.112.106 RUNNING
```
(Facoltativo) Elimina gli snapshot dei disco permanente.

Dopo aver confermato che le macchine virtuali vengono spostate, risparmia sui costi di archiviazione eliminando gli snapshot temporanei che hai creato.
```
gcloud compute snapshots delete mybootsnapshot mydatasnapshot
```
Se non hai più bisogno degli snapshot di backup, elimina anche questi:
```
gcloud compute snapshots delete backup-mybootsnapshot backup-mydatasnapshot
```

Go

Ottieni i dettagli della VM e identifica i dischi collegati alla VM.

compute/get_instance.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// getInstance prints a name of a VM instance in the given zone in the specified project.
func getInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	reqInstance := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, reqInstance)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	fmt.Fprintf(w, "Instance: %s\n", instance.GetName())

	return nil
}

Imposta lo stato di eliminazione automatica del disco di avvio e del disco dati su false per assicurarti che i dischi non vengano eliminati automaticamente quando la VM viene eliminata.

compute/disks/set_disk_autodelete.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// setDiskAutodelete sets the autodelete flag of a disk to given value.
func setDiskAutoDelete(
	w io.Writer,
	projectID, zone, instanceName, diskName string, autoDelete bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b"
	// instanceName := "your_instance_name"
	// diskName := "your_disk_name"
	// autoDelete := true

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	getInstanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	diskExists := false

	for _, disk := range instance.GetDisks() {
		if disk.GetDeviceName() == diskName {
			diskExists = true
			break
		}
	}

	if !diskExists {
		return fmt.Errorf(
			"instance %s doesn't have a disk named %s attached",
			instanceName,
			diskName,
		)
	}

	req := &computepb.SetDiskAutoDeleteInstanceRequest{
		Project:    projectID,
		Zone:       zone,
		Instance:   instanceName,
		DeviceName: diskName,
		AutoDelete: autoDelete,
	}

	op, err := instancesClient.SetDiskAutoDelete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to set disk autodelete field: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "disk autoDelete field updated.\n")

	return nil
}

Crea backup dei tuoi dati utilizzando gli snapshot di disco permanente.

Per precauzione, crea backup dei dati mentre i dischi permanenti sono ancora collegati alla VM utilizzando gli snapshot di disco permanente. Prima di acquisire uno snapshot, assicurati che sia coerente con lo stato del disco permanente attenendoti alle best practice per gli snapshot.

Dopo aver cancellato i buffer del disco, crea gli snapshot:

compute/snapshots/create_snapshot.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

	snapshotsClient, err := compute.NewSnapshotsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewSnapshotsRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

	if zone != "" {
		disksClient, err := compute.NewDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewDisksRESTClient: %w", err)
		}
		defer disksClient.Close()

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

		disk, err = regionDisksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	}

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

	op, err := snapshotsClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create snapshot: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Snapshot created\n")

	return nil
}

Eliminare la VM dalla zona di origine.

compute/delete_instance.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// deleteInstance sends a delete request to the Compute Engine API and waits for it to complete.
func deleteInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	req := &computepb.DeleteInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance deleted\n")

	return nil
}

Quindi, crea un altro snapshot sia del disco di avvio sia dei dischi dati.

compute/snapshots/create_snapshot.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createSnapshot creates a snapshot of a disk.
func createSnapshot(
	w io.Writer,
	projectID, diskName, snapshotName, zone, region, location, diskProjectID string,
) error {
	// projectID := "your_project_id"
	// diskName := "your_disk_name"
	// snapshotName := "your_snapshot_name"
	// zone := "europe-central2-b"
	// region := "eupore-central2"
	// location = "eupore-central2"
	// diskProjectID = "YOUR_DISK_PROJECT_ID"

	ctx := context.Background()

	snapshotsClient, err := compute.NewSnapshotsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewSnapshotsRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	if zone == "" && region == "" {
		return fmt.Errorf("you need to specify `zone` or `region` for this function to work")
	}

	if zone != "" && region != "" {
		return fmt.Errorf("you can't set both `zone` and `region` parameters")
	}

	if diskProjectID == "" {
		diskProjectID = projectID
	}

	disk := &computepb.Disk{}
	locations := []string{}
	if location != "" {
		locations = append(locations, location)
	}

	if zone != "" {
		disksClient, err := compute.NewDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewDisksRESTClient: %w", err)
		}
		defer disksClient.Close()

		getDiskReq := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err = disksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	} else {
		regionDisksClient, err := compute.NewRegionDisksRESTClient(ctx)
		if err != nil {
			return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
		}
		defer regionDisksClient.Close()

		getDiskReq := &computepb.GetRegionDiskRequest{
			Project: projectID,
			Region:  region,
			Disk:    diskName,
		}

		disk, err = regionDisksClient.Get(ctx, getDiskReq)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}
	}

	req := &computepb.InsertSnapshotRequest{
		Project: projectID,
		SnapshotResource: &computepb.Snapshot{
			Name:             proto.String(snapshotName),
			SourceDisk:       proto.String(disk.GetSelfLink()),
			StorageLocations: locations,
		},
	}

	op, err := snapshotsClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create snapshot: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Snapshot created\n")

	return nil
}

(Facoltativo) Elimina i dischi permanenti.

Se prevedi di riutilizzare i nomi dei dischi permanenti per i nuovi dischi, devi eliminare i dischi esistenti per rilasciarli. L'eliminazione dei dischi consente inoltre di risparmiare sui costi di archiviazione su disco permanente.

Se non prevedi di riutilizzare gli stessi nomi dei dischi, non è necessario eliminarli.

compute/disks/delete_disk.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// deleteDisk deletes a disk from a project.
func deleteDisk(w io.Writer, projectID, zone, diskName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b"
	// diskName := "your_disk_name"

	ctx := context.Background()
	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.DeleteDiskRequest{
		Project: projectID,
		Zone:    zone,
		Disk:    diskName,
	}

	op, err := disksClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete disk: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk deleted\n")

	return nil
}

Crea nuovi dischi permanenti nella zona di destinazione dagli snapshot che hai creato. Per prima cosa crea il disco di avvio, poi i dischi dati.

compute/disks/create_disk_from_snapshot.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

	ctx := context.Background()
	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Ricrea la VM con i nuovi dischi nella zona di destinazione.

compute/instances/create-start-instance/create_instance_with_existing_disks.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// createWithExistingDisks create a new VM instance using selected disks.
// The first disk in diskNames will be used as boot disk.
func createWithExistingDisks(
	w io.Writer,
	projectID, zone, instanceName string,
	diskNames []string,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// diskNames := []string{"boot_disk", "disk1", "disk2"}

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	disks := [](*computepb.Disk){}

	for _, diskName := range diskNames {
		reqDisk := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err := disksClient.Get(ctx, reqDisk)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}

		disks = append(disks, disk)
	}

	attachedDisks := [](*computepb.AttachedDisk){}

	for _, disk := range disks {
		attachedDisk := &computepb.AttachedDisk{
			Source: proto.String(disk.GetSelfLink()),
		}
		attachedDisks = append(attachedDisks, attachedDisk)
	}

	attachedDisks[0].Boot = proto.Bool(true)

	instanceResource := &computepb.Instance{
		Name:        proto.String(instanceName),
		Disks:       attachedDisks,
		MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
		NetworkInterfaces: []*computepb.NetworkInterface{
			{
				Name: proto.String("global/networks/default"),
			},
		},
	}

	req := &computepb.InsertInstanceRequest{
		Project:          projectID,
		Zone:             zone,
		InstanceResource: instanceResource,
	}

	op, err := instancesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance created\n")

	return nil
}

(Facoltativo) Elimina gli snapshot dei dischi temporanei. Dopo aver confermato che le macchine virtuali vengono spostate, risparmia sui costi di archiviazione eliminando gli snapshot temporanei che hai creato.

compute/snapshots/delete_snapshot.go

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// deleteSnapshot deletes a snapshot of a disk.
func deleteSnapshot(w io.Writer, projectID, snapshotName string) error {
	// projectID := "your_project_id"
	// snapshotName := "your_snapshot_name"

	ctx := context.Background()
	snapshotsClient, err := compute.NewSnapshotsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewSnapshotsRESTClient: %w", err)
	}
	defer snapshotsClient.Close()

	req := &computepb.DeleteSnapshotRequest{
		Project:  projectID,
		Snapshot: snapshotName,
	}

	op, err := snapshotsClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete snapshot: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Snapshot deleted\n")

	return nil
}

Java

Ottieni i dettagli della VM e identifica i dischi collegati alla VM.

compute/cloud-client/src/main/java/compute/GetInstance.java

Visualizza su GitHub Feedback


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import java.io.IOException;

public class GetInstance {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone you want to use. For example: 'us-west3-b'.
    String zone = "europe-central2-b";

    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";

    getInstance(projectId, zone, instanceName);
  }

  // Prints information about a VM instance in the given zone in the specified project.
  public static void getInstance(String projectId, String zone, String instanceName)
      throws IOException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Instance instance = instancesClient.get(projectId, zone, instanceName);

      System.out.printf("Retrieved the instance %s", instance.toString());
    }
  }
}

Imposta lo stato di eliminazione automatica del disco di avvio e del disco dati su false per assicurarti che i dischi non vengano eliminati automaticamente quando la VM viene eliminata.

compute/cloud-client/src/main/java/compute/disks/SetDiskAutodelete.java

Visualizza su GitHub Feedback


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SetDiskAutoDeleteInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SetDiskAutodelete {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // The zone of the disk that you want to modify.
    String zone = "europe-central2-b";

    // Name of the instance the disk is attached to.
    String instanceName = "YOUR_INSTANCE_NAME";

    // The name of the disk for which you want to modify the autodelete flag.
    String diskName = "YOUR_DISK_NAME";

    // The new value of the autodelete flag.
    boolean autoDelete = true;

    setDiskAutodelete(projectId, zone, instanceName, diskName, autoDelete);
  }

  // Sets the autodelete flag of a disk to given value.
  public static void setDiskAutodelete(String projectId, String zone, String instanceName,
      String diskName, boolean autoDelete)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // Retrieve the instance given by the instanceName.
      Instance instance = instancesClient.get(projectId, zone, instanceName);

      // Check if the instance contains a disk that matches the given diskName.
      boolean diskNameMatch = instance.getDisksList()
          .stream()
          .anyMatch(disk -> disk.getDeviceName().equals(diskName));

      if (!diskNameMatch) {
        throw new Error(
            String.format("Instance %s doesn't have a disk named %s attached", instanceName,
                diskName));
      }

      // Create the request object.
      SetDiskAutoDeleteInstanceRequest request = SetDiskAutoDeleteInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstance(instanceName)
          .setDeviceName(diskName)
          // Update the autodelete property.
          .setAutoDelete(autoDelete)
          .build();

      // Wait for the update instance operation to complete.
      Operation response = instancesClient.setDiskAutoDeleteAsync(request)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Failed to update Disk autodelete field!" + response);
        return;
      }
      System.out.println(
          "Disk autodelete field updated. Operation Status: " + response.getStatus());
    }
  }
}

Crea backup dei tuoi dati utilizzando gli snapshot di disco permanente.

Dopo aver cancellato i buffer del disco, crea gli snapshot:

compute/cloud-client/src/main/java/compute/disks/CreateSnapshot.java

Visualizza su GitHub Feedback


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.RegionDisksClient;
import com.google.cloud.compute.v1.Snapshot;
import com.google.cloud.compute.v1.SnapshotsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // You need to pass `zone` or `region` parameter relevant to the disk you want to
    // snapshot, but not both. Pass `zone` parameter for zonal disks and `region` for
    // regional disks.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // Name of the snapshot that you want to create.
    String snapshotName = "YOUR_SNAPSHOT_NAME";

    // The zone of the source disk from which you create the snapshot (for zonal disks).
    String zone = "europe-central2-b";

    // The region of the source disk from which you create the snapshot (for regional disks).
    String region = "your-disk-region";

    // The Cloud Storage multi-region or the Cloud Storage region where you
    // want to store your snapshot.
    // You can specify only one storage location. Available locations:
    // https://cloud.google.com/storage/docs/locations#available-locations
    String location = "europe-central2";

    // Project ID or project number of the Cloud project that
    // hosts the disk you want to snapshot. If not provided, the value will be defaulted
    // to 'projectId' value.
    String diskProjectId = "YOUR_DISK_PROJECT_ID";

    createSnapshot(projectId, diskName, snapshotName, zone, region, location, diskProjectId);
  }

  // Creates a snapshot of a disk.
  public static void createSnapshot(String projectId, String diskName, String snapshotName,
      String zone, String region, String location, String diskProjectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `snapshotsClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (SnapshotsClient snapshotsClient = SnapshotsClient.create()) {

      if (zone.isEmpty() && region.isEmpty()) {
        throw new Error("You need to specify 'zone' or 'region' for this function to work");
      }

      if (!zone.isEmpty() && !region.isEmpty()) {
        throw new Error("You can't set both 'zone' and 'region' parameters");
      }

      // If Disk's project id is not specified, then the projectId parameter will be used.
      if (diskProjectId.isEmpty()) {
        diskProjectId = projectId;
      }

      // If zone is not empty, use the DisksClient to create a disk.
      // Else, use the RegionDisksClient.
      Disk disk;
      if (!zone.isEmpty()) {
        DisksClient disksClient = DisksClient.create();
        disk = disksClient.get(projectId, zone, diskName);
      } else {
        RegionDisksClient regionDisksClient = RegionDisksClient.create();
        disk = regionDisksClient.get(diskProjectId, region, diskName);
      }

      // Set the snapshot properties.
      Snapshot snapshotResource;
      if (!location.isEmpty()) {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .addStorageLocations(location)
            .build();
      } else {
        snapshotResource = Snapshot.newBuilder()
            .setName(snapshotName)
            .setSourceDisk(disk.getSelfLink())
            .build();
      }

      // Wait for the operation to complete.
      Operation operation = snapshotsClient.insertAsync(projectId, snapshotResource)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Snapshot creation failed!" + operation);
        return;
      }

      // Retrieve the created snapshot.
      Snapshot snapshot = snapshotsClient.get(projectId, snapshotName);
      System.out.printf("Snapshot created: %s", snapshot.getName());

    }
  }
}

Eliminare la VM dalla zona di origine.

Spostamento di un'istanza VM tra zone o regioni

Prima di iniziare

gcloud

Go

Java

Node.js

Python

Requisiti

Limitazione

Proprietà della risorsa

Proprietà che cambiano per le VM

Proprietà che cambiano per i dischi

Modifica delle proprietà per VM e dischi

Spostare una VM tra zone o regioni

gcloud

Go

Java