העברת מופע של מכונה וירטואלית בין אזורים

gcloud

בדוגמה הזו, מעבירים מכונה וירטואלית בשם myinstance עם שני דיסקים קשיחים קבועים בשמות mybootdisk ו-mydatadisk, מ-europe-west1-c ל-us-west1-b.

1. מזהים את הדיסקים שמשויכים למכונת ה-VM שרוצים להעביר:

   gcloud compute instances describe myinstance --format="list(name,status,disks)"
   

   בדוגמה הזו, אפשר לראות את שני הדיסקים המשויכים למכונה הווירטואלית myinstance:

   • דיסק אתחול בשם mybootdisk
   • דיסק נתונים בשם mydatadisk

2. מגדירים את מצב המחיקה האוטומטית של mybootdisk ו-mydatadisk ל-false כדי לוודא שהדיסקים לא יימחקו אוטומטית כשהמכונה הווירטואלית תימחק.

   gcloud compute instances set-disk-auto-delete myinstance --zone europe-west1-c \
       --disk mybootdisk --no-auto-delete

   אם המצב עודכן, gcloud compute מחזירה את התשובה Updated [...]. אם המצב של המחיקה האוטומטית כבר הוגדר כ-false, הפונקציה gcloud compute מחזירה:

   No change requested; skipping update for [myinstance].

3. (אופציונלי) שמירת המטא-נתונים של המכונה הווירטואלית.

   כשמוחקים את המכונה הווירטואלית, נמחקים גם המטא-נתונים שלה. אפשר לשמור את המידע הזה בקובץ נפרד, ואז להחיל מחדש את המטא-נתונים של מכונת ה-VM על מכונת ה-VM החדשה.

   כך מתארים את המטא-נתונים של המכונה הווירטואלית:

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

   שומרים את התוכן בקובץ נפרד.

4. כדי ליצור גיבויים של הנתונים, אפשר להשתמש בקובצי snapshot של דיסקים לאחסון מתמיד.

   כאמצעי זהירות, כדאי ליצור גיבויים של הנתונים בזמן שהדיסקים לאחסון מתמיד עדיין מחוברים למכונה הווירטואלית באמצעות קובצי snapshot של הדיסקים לאחסון מתמיד. לפני שמצלמים תמונת מצב, חשוב לוודא שהיא עקבית עם המצב של הדיסק הקשיח הקבוע. לשם כך, צריך לפעול בהתאם לשיטות המומלצות לצילום תמונות מצב.

   אחרי שמנקים את מאגרי הדיסק, יוצרים את קובצי ה-snapshot:

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

   כדי לוודא שקובץ ה-snapshot נוצר, מריצים את הפקודה gcloud compute snapshots list.

5. (אופציונלי) אם מעבירים מכונה וירטואלית בין אזורים באותו אזור, ורוצים לשמור את כתובת ה-IP הפנימית או החיצונית הארעית שלה, אפשר להפוך את כתובת ה-IP הפנימית או החיצונית לכתובת IP סטטית, שאפשר לעשות בה שימוש חוזר בהמשך.

6. מוחקים את ה-VM.

   מחיקה של מכונה וירטואלית גורמת לסגירה שלה בצורה מסודרת ולניתוק של כל הדיסקים הקבועים.

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

   gcloud תופיע בקשה לאשר את המחיקה:

   
   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)?

   מכיוון שהשבתתם את מצב המחיקה האוטומטית של הדיסקים בשלב מוקדם יותר בתהליך הזה, מזינים Y כדי להמשיך ומתעלמים מהאזהרה.

7. לאחר מכן, יוצרים עוד קובץ snapshot של דיסק האתחול ושל דיסק הנתונים.

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

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

8. (אופציונלי) מוחקים את הדיסקים של אחסון מתמיד.

   אם אתם מתכננים לעשות שימוש חוזר בשמות של דיסקים קשיחים קבועים עבור הדיסקים החדשים, אתם צריכים למחוק את הדיסקים הקיימים כדי שהשמות יהיו זמינים. מחיקת הדיסקים חוסכת גם בעלויות של אחסון בדיסק מתמיד.

   אם אתם לא מתכננים להשתמש שוב באותם שמות של דיסקים, אתם לא צריכים למחוק אותם.

   gcloud compute disks delete mybootdisk mydatadisk --zone europe-west1-c

9. יוצרים דיסקים חדשים של אחסון מתמיד (persistent disks) ב-us-west1-b מקובצי ה-snapshot שיצרתם. קודם יוצרים את דיסק האתחול.

   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

   לאחר מכן יוצרים את דיסק הנתונים.

   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

10. יוצרים מחדש את ה-VM ב-us-west1-b.

    • אם בחרתם לשמור את המטא-נתונים של המכונה הווירטואלית בקובץ, למשל myinstance.describe, תוכלו להשתמש בו כדי להגדיר את אותם מטא-נתונים במכונה הווירטואלית.

    • אם למכונה הווירטואלית הייתה כתובת IP חיצונית סטטית, אפשר להקצות מחדש את הכתובת הזו למכונה הווירטואלית החדשה באמצעות האפשרות --address [ADDRESS]. אם מעבירים מכונה וירטואלית בין אזורים, צריך לבחור כתובת IP חיצונית שונה למופע החדש של המכונה הווירטואלית.

    • אם למכונה הווירטואלית הייתה כתובת IP פנימית סטטית, אפשר להקצות מחדש את הכתובת הזו למכונה הווירטואלית החדשה באמצעות האפשרות --private-network-ip ADDRESS. אם מעבירים מכונה וירטואלית בין אזורים, צריך לבחור כתובת IP פנימית שונה עבור המכונה הווירטואלית החדשה.

    • אם המכונה הווירטואלית כוללת יחידות GPU, מוסיפים יחידות GPU למכונה הווירטואלית באמצעות האפשרות --accelerator.

    • אם ה-VM משתמש ברשת משנה ספציפית, מוסיפים את הדגל --subnet [SUBNET_NAME].

    רשימה מלאה של דגלים נוספים מופיעה במאמר 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

11. (אופציונלי) מוחקים את תמונות המצב של Persistent Disk.

    אחרי שמוודאים שהמכונות הווירטואליות הועברו, מוחקים את התמונות הזמניות שנוצרו כדי לחסוך בעלויות האחסון.

    gcloud compute snapshots delete mybootsnapshot mydatasnapshot

    אם אין לכם יותר צורך בתמונות המצב של הגיבוי, אתם יכולים למחוק גם אותן:

    gcloud compute snapshots delete backup-mybootsnapshot backup-mydatasnapshot

המשך

1. מקבלים את הפרטים של מכונת ה-VM ומזהים את הדיסקים שמצורפים אליה.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   )
   
   // 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
   }
   

2. מגדירים את מצב המחיקה האוטומטית של דיסק האתחול ודיסק הנתונים לערך false כדי לוודא שהדיסקים לא יימחקו אוטומטית כשמחקתם את המכונה הווירטואלית.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   )
   
   // 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
   }
   

3. כדי ליצור גיבויים של הנתונים, אפשר להשתמש בקובצי snapshot של דיסקים לאחסון מתמיד.

   כאמצעי זהירות, כדאי ליצור גיבויים של הנתונים בזמן שהדיסקים לאחסון מתמיד עדיין מחוברים למכונה הווירטואלית באמצעות קובצי snapshot של הדיסקים לאחסון מתמיד. לפני שמצלמים תמונת מצב, חשוב לוודא שהיא עקבית עם המצב של הדיסק הקשיח הקבוע. לשם כך, צריך לפעול בהתאם לשיטות המומלצות לצילום תמונות מצב.

   אחרי שמנקים את מאגרי הדיסק, יוצרים את קובצי ה-snapshot:

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   	"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
   }
   

4. מוחקים את ה-VM מאזור המקור.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   )
   
   // 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
   }
   

5. לאחר מכן, יוצרים עוד קובץ snapshot של דיסק האתחול ושל דיסקי הנתונים.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   	"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
   }
   

6. (אופציונלי) מוחקים את הדיסקים של אחסון מתמיד.

   אם אתם מתכננים לעשות שימוש חוזר בשמות של דיסקים קשיחים קבועים עבור הדיסקים החדשים, אתם צריכים למחוק את הדיסקים הקיימים כדי שהשמות יהיו זמינים. מחיקת הדיסקים חוסכת גם בעלויות של אחסון בדיסק מתמיד.

   אם אתם לא מתכננים להשתמש שוב באותם שמות של דיסקים, אתם לא צריכים למחוק אותם.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   )
   
   // 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
   }
   

7. יוצרים דיסקים חדשים של אחסון מתמיד באזור היעד מתוך קובצי ה-snapshot שיצרתם. קודם יוצרים את דיסק האתחול, ואז את דיסקי הנתונים.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   	"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
   }
   

8. יוצרים מחדש את המכונה הווירטואלית עם הדיסקים החדשים באזור היעד.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   	"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
   }
   

9. (אופציונלי) מוחקים את תמונות המצב הזמניות של הדיסק. אחרי שמאשרים שהמכונות הווירטואליות הועברו, אפשר למחוק את התמונות הזמניות שנוצרו כדי לחסוך בעלויות אחסון.

   import (
   	"context"
   	"fmt"
   	"io"
   
   	compute "cloud.google.com/go/compute/apiv1"
   	computepb "cloud.google.com/go/compute/apiv1/computepb"
   )
   
   // 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

1. מקבלים את הפרטים של מכונת ה-VM ומזהים את הדיסקים שמצורפים אליה.

   
   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());
       }
     }
   }

2. מגדירים את מצב המחיקה האוטומטית של דיסק האתחול ודיסק הנתונים לערך false כדי לוודא שהדיסקים לא יימחקו אוטומטית כשמחקתם את המכונה הווירטואלית.

   
   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());
       }
     }
   }

3. כדי ליצור גיבויים של הנתונים, אפשר להשתמש בקובצי snapshot של דיסקים לאחסון מתמיד.

   כאמצעי זהירות, כדאי ליצור גיבויים של הנתונים בזמן שהדיסקים לאחסון מתמיד עדיין מחוברים למכונה הווירטואלית באמצעות קובצי snapshot של הדיסקים לאחסון מתמיד. לפני שמצלמים תמונת מצב, חשוב לוודא שהיא עקבית עם המצב של הדיסק הקשיח הקבוע. לשם כך, צריך לפעול בהתאם לשיטות המומלצות לצילום תמונות מצב.

   אחרי שמנקים את מאגרי הדיסק, יוצרים את קובצי ה-snapshot:

   
   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());
   
       }
     }
   }

4. מוחקים את ה-VM מאזור המקור.

   
   import com.google.api.gax.longrunning.OperationFuture;
   import com.google.cloud.compute.v1.DeleteInstanceRequest;
   import com.google.cloud.compute.v1.InstancesClient;
   import com.google.cloud.compute.v1.Operation;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class DeleteInstance {
   
     public static void main(String[] args)
         throws IOException, InterruptedException, ExecutionException, TimeoutException {
       // TODO(developer): Replace these variables before running the sample.
       String project = "your-project-id";
       String zone = "zone-name";
       String instanceName = "instance-name";
       deleteInstance(project, zone, instanceName);
     }
   
     // Delete the instance specified by `instanceName`
     // if it's present in the given project and zone.
     public static void deleteInstance(String project, String zone, String instanceName)
         throws IOException, InterruptedException, ExecutionException, 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()) {
   
         System.out.printf("Deleting instance: %s ", instanceName);
   
         // Describe which instance is to be deleted.
         DeleteInstanceRequest deleteInstanceRequest = DeleteInstanceRequest.newBuilder()
             .setProject(project)
             .setZone(zone)
             .setInstance(instanceName).build();
   
         OperationFuture<Operation, Operation> operation = instancesClient.deleteAsync(
             deleteInstanceRequest);
         // Wait for the operation to complete.
         Operation response = operation.get(3, TimeUnit.MINUTES);
   
         if (response.hasError()) {
           System.out.println("Instance deletion failed ! ! " + response);
           return;
         }
         System.out.println("Operation Status: " + response.getStatus());
       }
     }
   }

5. לאחר מכן, יוצרים עוד קובץ snapshot של דיסק האתחול ושל דיסקי הנתונים.

   
   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());
   
       }
     }
   }

6. (אופציונלי) מוחקים את הדיסקים של אחסון מתמיד.

   אם אתם מתכננים לעשות שימוש חוזר בשמות של דיסקים קשיחים קבועים עבור הדיסקים החדשים, אתם צריכים למחוק את הדיסקים הקיימים כדי שהשמות יהיו זמינים. מחיקת הדיסקים חוסכת גם בעלויות של אחסון בדיסק מתמיד.

   אם אתם לא מתכננים להשתמש שוב באותם שמות של דיסקים, אתם לא צריכים למחוק אותם.

   
   import com.google.cloud.compute.v1.DeleteDiskRequest;
   import com.google.cloud.compute.v1.DisksClient;
   import com.google.cloud.compute.v1.Operation;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class DeleteDisk {
   
     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 from where you want to delete the disk.
       String zone = "europe-central2-b";
   
       // Name of the disk you want to delete.
       String diskName = "YOUR_DISK_NAME";
   
       deleteDisk(projectId, zone, diskName);
     }
   
     // Deletes a disk from a project.
     public static void deleteDisk(String projectId, String zone, String diskName)
         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 `disksClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (DisksClient disksClient = DisksClient.create()) {
   
         // Create the request object.
         DeleteDiskRequest deleteDiskRequest = DeleteDiskRequest.newBuilder()
             .setProject(projectId)
             .setZone(zone)
             .setDisk(diskName)
             .build();
   
         // Wait for the delete disk operation to complete.
         Operation response = disksClient.deleteAsync(deleteDiskRequest)
             .get(3, TimeUnit.MINUTES);
   
         if (response.hasError()) {
           System.out.println("Disk deletion failed!" + response);
           return;
         }
         System.out.println("Operation Status: " + response.getStatus());
       }
     }
   }

7. יוצרים דיסקים חדשים של אחסון מתמיד באזור היעד מתוך קובצי ה-snapshot שיצרתם. קודם יוצרים את דיסק האתחול, ואז את דיסקי הנתונים.

   
   import com.google.cloud.compute.v1.Disk;
   import com.google.cloud.compute.v1.DisksClient;
   import com.google.cloud.compute.v1.InsertDiskRequest;
   import com.google.cloud.compute.v1.Operation;
   import java.io.IOException;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateDiskFromSnapshot {
   
     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";
   
       // Name of the zone in which you want to create the disk.
       String zone = "europe-central2-b";
   
       // Name of the disk you want to create.
       String diskName = "YOUR_DISK_NAME";
   
       // The type of disk you want to create. This value uses the following format:
       // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
       // For example: "zones/us-west3-b/diskTypes/pd-ssd"
       String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);
   
       // Size of the new disk in gigabytes.
       long diskSizeGb = 10;
   
       // The full path and name of the snapshot that you want to use as the source for the new disk.
       // This value uses the following format:
       // "projects/{projectName}/global/snapshots/{snapshotName}"
       String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
           "SNAPSHOT_NAME");
   
       createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
     }
   
     // Creates a new disk in a project in given zone, using a snapshot.
     public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
         String diskType, long diskSizeGb, String snapshotLink)
         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 `disksClient.close()` method on the client to safely
       // clean up any remaining background resources.
       try (DisksClient disksClient = DisksClient.create()) {
   
         // Set the disk properties and the source snapshot.
         Disk disk = Disk.newBuilder()
             .setName(diskName)
             .setZone(zone)
             .setSizeGb(diskSizeGb)
             .setType(diskType)
             .setSourceSnapshot(snapshotLink)
             .build();
   
         // Create the insert disk request.
         InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
             .setProject(projectId)
             .setZone(zone)
             .setDiskResource(disk)
             .build();
   
         // Wait for the create disk operation to complete.
         Operation response = disksClient.insertAsync(insertDiskRequest)
             .get(3, TimeUnit.MINUTES);
   
         if (response.hasError()) {
           System.out.println("Disk creation failed!" + response);
           return;
         }
         System.out.println("Disk created. Operation Status: " + response.getStatus());
       }
     }
   }

8. יוצרים מחדש את המכונה הווירטואלית עם הדיסקים החדשים באזור היעד.

   
   import com.google.cloud.compute.v1.AttachedDisk;
   import com.google.cloud.compute.v1.Disk;
   import com.google.cloud.compute.v1.DisksClient;
   import com.google.cloud.compute.v1.InsertInstanceRequest;
   import com.google.cloud.compute.v1.Instance;
   import com.google.cloud.compute.v1.InstancesClient;
   import com.google.cloud.compute.v1.NetworkInterface;
   import com.google.cloud.compute.v1.Operation;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.TimeoutException;
   
   public class CreateInstanceWithExistingDisks {
   
     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";
   
       // Name of the zone to create the instance in. For example: "us-west3-b"
       String zone = "europe-central2-b";
   
       // Name of the new virtual machine (VM) instance.
       String instanceName = "YOUR_INSTANCE_NAME";
   
       // Array of disk names to be attached to the new virtual machine.
       // First disk in this list will be used as the boot disk.
       List<String> diskNames = List.of("your-boot-disk", "another-disk1", "another-disk2");
   
       createInstanceWithExistingDisks(projectId, zone, instanceName, diskNames);
     }
   
     // Create a new VM instance using the selected disks.
     // The first disk in diskNames will be used as the boot disk.
     public static void createInstanceWithExistingDisks(String projectId, String zone,
         String instanceName, List<String> diskNames)
         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();
           DisksClient disksClient = DisksClient.create()) {
   
         if (diskNames.size() == 0) {
           throw new Error("At least one disk should be provided");
         }
   
         // Create the list of attached disks to be used in instance creation.
         List<AttachedDisk> attachedDisks = new ArrayList<>();
         for (int i = 0; i < diskNames.size(); i++) {
           String diskName = diskNames.get(i);
           Disk disk = disksClient.get(projectId, zone, diskName);
           AttachedDisk attDisk = null;
   
           if (i == 0) {
             // Make the first disk in the list as the boot disk.
             attDisk = AttachedDisk.newBuilder()
                 .setSource(disk.getSelfLink())
                 .setBoot(true)
                 .build();
           } else {
             attDisk = AttachedDisk.newBuilder()
                 .setSource(disk.getSelfLink())
                 .build();
           }
           attachedDisks.add(attDisk);
         }
   
         // Create the instance.
         Instance instance = Instance.newBuilder()
             .setName(instanceName)
             // Add the attached disks to the instance.
             .addAllDisks(attachedDisks)
             .setMachineType(String.format("zones/%s/machineTypes/n1-standard-1", zone))
             .addNetworkInterfaces(
                 NetworkInterface.newBuilder().setName("global/networks/default").build())
             .build();
   
         // Create the insert instance request.
         InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
             .setProject(projectId)
             .setZone(zone)
             .setInstanceResource(instance)
             .build();
   
         // Wait for the create operation to complete.
         Operation response = instancesClient.insertAsync(insertInstanceRequest)
             .get(3, TimeUnit.MINUTES);
   
         if (response.hasError()) {
           System.out.println("Instance creation failed!" + response);
           return;
         }
         System.out.println("Operation Status: " + response.getStatus());
   
       }
     }
   }

9. (אופציונלי) מוחקים את תמונות המצב הזמניות של הדיסק. אחרי שמאשרים שהמכונות הווירטואליות הועברו, אפשר למחוק את התמונות הזמניות שנוצרו כדי לחסוך בעלויות אחסון.

   
   import com.google.cloud.compute.v1.Operation;
   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 DeleteSnapshot {
   
     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";
   
       // Name of the snapshot to be deleted.
       String snapshotName = "YOUR_SNAPSHOT_NAME";
   
       deleteSnapshot(projectId, snapshotName);
     }
   
     // Delete a snapshot of a disk.
     public static void deleteSnapshot(String projectId, String snapshotName)
         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()) {
   
         Operation operation = snapshotsClient.deleteAsync(projectId, snapshotName)
             .get(3, TimeUnit.MINUTES);
   
         if (operation.hasError()) {
           System.out.println("Snapshot deletion failed!" + operation);
           return;
         }
   
         System.out.println("Snapshot deleted!");
       }
     }
   }

Node.js

1. מקבלים את הפרטים של מכונת ה-VM ומזהים את הדיסקים שמצורפים אליה.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b'
   // const instanceName = 'YOUR_INSTANCE_NAME'
   
   const compute = require('@google-cloud/compute');
   
   async function getInstance() {
     const instancesClient = new compute.InstancesClient();
   
     const [instance] = await instancesClient.get({
       project: projectId,
       zone,
       instance: instanceName,
     });
   
     console.log(
       `Instance ${instanceName} data:\n${JSON.stringify(instance, null, 4)}`
     );
   }
   getInstance();

2. מגדירים את מצב המחיקה האוטומטית של דיסק האתחול ודיסק הנתונים לערך false כדי לוודא שהדיסקים לא יימחקו אוטומטית כשמחקתם את המכונה הווירטואלית.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b';
   // const instanceName = 'YOUR_INSTANCE_NAME';
   // const diskName = 'YOUR_DISK_NAME';
   // const autoDelete = true;
   
   const compute = require('@google-cloud/compute');
   
   async function setDiskAutodelete() {
     const instancesClient = new compute.InstancesClient();
   
     const [instance] = await instancesClient.get({
       project: projectId,
       zone,
       instance: instanceName,
     });
   
     if (!instance.disks.some(disk => disk.deviceName === diskName)) {
       throw new Error(
         `Instance ${instanceName} doesn't have a disk named ${diskName} attached.`
       );
     }
   
     const [response] = await instancesClient.setDiskAutoDelete({
       project: projectId,
       zone,
       instance: instanceName,
       deviceName: diskName,
       autoDelete,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.ZoneOperationsClient();
   
     // Wait for the update instance operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
         zone: operation.zone.split('/').pop(),
       });
     }
   
     console.log('Disk autoDelete field updated.');
   }
   
   setDiskAutodelete();

3. כדי ליצור גיבויים של הנתונים, אפשר להשתמש בקובצי snapshot של דיסקים לאחסון מתמיד.

   כאמצעי זהירות, כדאי ליצור גיבויים של הנתונים בזמן שהדיסקים לאחסון מתמיד עדיין מחוברים למכונה הווירטואלית באמצעות קובצי snapshot של הדיסקים לאחסון מתמיד. לפני שמצלמים תמונת מצב, חשוב לוודא שהיא עקבית עם המצב של הדיסק הקשיח הקבוע. לשם כך, צריך לפעול בהתאם לשיטות המומלצות לצילום תמונות מצב.

   אחרי שמנקים את מאגרי הדיסק, יוצרים את קובצי ה-snapshot:

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const diskName = 'YOUR_DISK_NAME';
   // const snapshotName = 'YOUR_SNAPSHOT_NAME';
   // const zone = 'europe-central2-b';
   // const region = '';
   // const location = 'europe-central2';
   // let diskProjectId = 'YOUR_DISK_PROJECT_ID';
   
   const compute = require('@google-cloud/compute');
   
   async function createSnapshot() {
     const snapshotsClient = new compute.SnapshotsClient();
   
     let disk;
   
     if (!zone && !region) {
       throw new Error(
         'You need to specify `zone` or `region` for this function to work.'
       );
     }
   
     if (zone && region) {
       throw new Error("You can't set both `zone` and `region` parameters");
     }
   
     if (!diskProjectId) {
       diskProjectId = projectId;
     }
   
     if (zone) {
       const disksClient = new compute.DisksClient();
       [disk] = await disksClient.get({
         project: diskProjectId,
         zone,
         disk: diskName,
       });
     } else {
       const regionDisksClient = new compute.RegionDisksClient();
       [disk] = await regionDisksClient.get({
         project: diskProjectId,
         region,
         disk: diskName,
       });
     }
   
     const snapshotResource = {
       name: snapshotName,
       sourceDisk: disk.selfLink,
     };
   
     if (location) {
       snapshotResource.storageLocations = [location];
     }
   
     const [response] = await snapshotsClient.insert({
       project: projectId,
       snapshotResource,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.GlobalOperationsClient();
   
     // Wait for the create snapshot operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
       });
     }
   
     console.log('Snapshot created.');
   }
   
   createSnapshot();

4. מוחקים את ה-VM מאזור המקור.

   /**
    * TODO(developer): Uncomment these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b'
   // const instanceName = 'YOUR_INSTANCE_NAME';
   
   const compute = require('@google-cloud/compute');
   
   // Delete the instance specified by `instanceName` if it's present in the given project and zone.
   async function deleteInstance() {
     const instancesClient = new compute.InstancesClient();
   
     console.log(`Deleting ${instanceName} from ${zone}...`);
   
     const [response] = await instancesClient.delete({
       project: projectId,
       zone,
       instance: instanceName,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.ZoneOperationsClient();
   
     // Wait for the delete operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
         zone: operation.zone.split('/').pop(),
       });
     }
   
     console.log('Instance deleted.');
   }
   
   deleteInstance();

5. לאחר מכן, יוצרים עוד קובץ snapshot של דיסק האתחול ושל דיסקי הנתונים.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const diskName = 'YOUR_DISK_NAME';
   // const snapshotName = 'YOUR_SNAPSHOT_NAME';
   // const zone = 'europe-central2-b';
   // const region = '';
   // const location = 'europe-central2';
   // let diskProjectId = 'YOUR_DISK_PROJECT_ID';
   
   const compute = require('@google-cloud/compute');
   
   async function createSnapshot() {
     const snapshotsClient = new compute.SnapshotsClient();
   
     let disk;
   
     if (!zone && !region) {
       throw new Error(
         'You need to specify `zone` or `region` for this function to work.'
       );
     }
   
     if (zone && region) {
       throw new Error("You can't set both `zone` and `region` parameters");
     }
   
     if (!diskProjectId) {
       diskProjectId = projectId;
     }
   
     if (zone) {
       const disksClient = new compute.DisksClient();
       [disk] = await disksClient.get({
         project: diskProjectId,
         zone,
         disk: diskName,
       });
     } else {
       const regionDisksClient = new compute.RegionDisksClient();
       [disk] = await regionDisksClient.get({
         project: diskProjectId,
         region,
         disk: diskName,
       });
     }
   
     const snapshotResource = {
       name: snapshotName,
       sourceDisk: disk.selfLink,
     };
   
     if (location) {
       snapshotResource.storageLocations = [location];
     }
   
     const [response] = await snapshotsClient.insert({
       project: projectId,
       snapshotResource,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.GlobalOperationsClient();
   
     // Wait for the create snapshot operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
       });
     }
   
     console.log('Snapshot created.');
   }
   
   createSnapshot();

6. (אופציונלי) מוחקים את הדיסקים של אחסון מתמיד.

   אם אתם מתכננים לעשות שימוש חוזר בשמות של דיסקים קשיחים קבועים עבור הדיסקים החדשים, אתם צריכים למחוק את הדיסקים הקיימים כדי שהשמות יהיו זמינים. מחיקת הדיסקים חוסכת גם בעלויות של אחסון בדיסק מתמיד.

   אם אתם לא מתכננים להשתמש שוב באותם שמות של דיסקים, אתם לא צריכים למחוק אותם.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b';
   // const diskName = 'YOUR_DISK_NAME';
   
   const compute = require('@google-cloud/compute');
   
   async function deleteDisk() {
     const disksClient = new compute.DisksClient();
   
     const [response] = await disksClient.delete({
       project: projectId,
       zone,
       disk: diskName,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.ZoneOperationsClient();
   
     // Wait for the create disk operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
         zone: operation.zone.split('/').pop(),
       });
     }
   
     console.log('Disk deleted.');
   }
   
   deleteDisk();

7. יוצרים דיסקים חדשים של אחסון מתמיד באזור היעד מתוך קובצי ה-snapshot שיצרתם. קודם יוצרים את דיסק האתחול, ואז את דיסקי הנתונים.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b';
   // const diskName = 'YOUR_DISK_NAME';
   // const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
   // const diskSizeGb = 10;
   // const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';
   
   const compute = require('@google-cloud/compute');
   
   async function createDiskFromSnapshot() {
     const disksClient = new compute.DisksClient();
   
     const [response] = await disksClient.insert({
       project: projectId,
       zone,
       diskResource: {
         sizeGb: diskSizeGb,
         name: diskName,
         zone,
         type: diskType,
         sourceSnapshot: snapshotLink,
       },
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.ZoneOperationsClient();
   
     // Wait for the create disk operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
         zone: operation.zone.split('/').pop(),
       });
     }
   
     console.log('Disk created.');
   }
   
   createDiskFromSnapshot();

8. יוצרים מחדש את המכונה הווירטואלית עם הדיסקים החדשים באזור היעד.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const zone = 'europe-central2-b';
   // const instanceName = 'YOUR_INSTANCE_NAME';
   // const diskNames = ['boot_disk', 'disk1', 'disk2'];
   
   const compute = require('@google-cloud/compute');
   
   async function createWithExistingDisks() {
     const instancesClient = new compute.InstancesClient();
     const disksClient = new compute.DisksClient();
   
     if (diskNames.length < 1) {
       throw new Error('At least one disk should be provided');
     }
   
     const disks = [];
     for (const diskName of diskNames) {
       const [disk] = await disksClient.get({
         project: projectId,
         zone,
         disk: diskName,
       });
       disks.push(disk);
     }
   
     const attachedDisks = [];
   
     for (const disk of disks) {
       attachedDisks.push({
         source: disk.selfLink,
       });
     }
   
     attachedDisks[0].boot = true;
   
     const [response] = await instancesClient.insert({
       project: projectId,
       zone,
       instanceResource: {
         name: instanceName,
         disks: attachedDisks,
         machineType: `zones/${zone}/machineTypes/n1-standard-1`,
         networkInterfaces: [
           {
             name: 'global/networks/default',
           },
         ],
       },
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.ZoneOperationsClient();
   
     // Wait for the create operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
         zone: operation.zone.split('/').pop(),
       });
     }
   
     console.log('Instance created.');
   }
   
   createWithExistingDisks();

9. (אופציונלי) מוחקים את תמונות המצב הזמניות של הדיסק. אחרי שמאשרים שהמכונות הווירטואליות הועברו, אפשר למחוק את התמונות הזמניות שנוצרו כדי לחסוך בעלויות אחסון.

   /**
    * TODO(developer): Uncomment and replace these variables before running the sample.
    */
   // const projectId = 'YOUR_PROJECT_ID';
   // const snapshotName = 'YOUR_SNAPSHOT_NAME';
   
   const compute = require('@google-cloud/compute');
   
   async function deleteSnapshot() {
     const snapshotsClient = new compute.SnapshotsClient();
   
     const [response] = await snapshotsClient.delete({
       project: projectId,
       snapshot: snapshotName,
     });
     let operation = response.latestResponse;
     const operationsClient = new compute.GlobalOperationsClient();
   
     // Wait for the create disk operation to complete.
     while (operation.status !== 'DONE') {
       [operation] = await operationsClient.wait({
         operation: operation.name,
         project: projectId,
       });
     }
   
     console.log('Snapshot deleted.');
   }
   
   deleteSnapshot();