영역 또는 리전 간 VM 인스턴스 이동

Linux Windows

---

이 문서에서는 영역 또는 리전 간에 가상 머신(VM) 인스턴스를 이동하는 방법을 설명합니다.

시작하기 전에

• 영역 문서를 참조하세요.
• 아직 인증을 설정하지 않았다면 설정합니다. 인증은 Google Cloud 서비스 및 API에 액세스하기 위해 ID를 확인하는 프로세스입니다. 로컬 개발 환경에서 코드 또는 샘플을 실행하려면 다음과 같이 Compute Engine에 인증하면 됩니다.
  

  이 페이지의 샘플 사용 방법에 대한 탭을 선택하세요.

  gcloud

  1. Google Cloud CLI를 설치한 후 다음 명령어를 실행하여 초기화합니다.

     gcloud init

     참고: gcloud CLI를 이전에 설치했으면 gcloud components update를 실행하여 최신 버전을 사용할 수 있는지 확인합니다.
  2. 기본 리전 및 영역을 설정합니다.

  Go

  로컬 개발 환경에서 이 페이지의 Go 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

  1. Google Cloud CLI를 설치합니다.

  2. gcloud CLI를 초기화하려면 다음 명령어를 실행합니다.

     gcloud init

  3. Google 계정의 로컬 인증 사용자 인증 정보를 만듭니다.

     gcloud auth application-default login

  자세한 내용은 로컬 개발 환경의 인증 설정를 참조하세요.

  Java

  로컬 개발 환경에서 이 페이지의 Java 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

  1. Google Cloud CLI를 설치합니다.

  2. gcloud CLI를 초기화하려면 다음 명령어를 실행합니다.

     gcloud init

  3. Google 계정의 로컬 인증 사용자 인증 정보를 만듭니다.

     gcloud auth application-default login

  자세한 내용은 로컬 개발 환경의 인증 설정를 참조하세요.

  Node.js

  로컬 개발 환경에서 이 페이지의 Node.js 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

  1. Google Cloud CLI를 설치합니다.

  2. gcloud CLI를 초기화하려면 다음 명령어를 실행합니다.

     gcloud init

  3. Google 계정의 로컬 인증 사용자 인증 정보를 만듭니다.

     gcloud auth application-default login

  자세한 내용은 로컬 개발 환경의 인증 설정를 참조하세요.

  Python

  로컬 개발 환경에서 이 페이지의 Python 샘플을 사용하려면 gcloud CLI를 설치 및 초기화한 다음 사용자 인증 정보로 애플리케이션 기본 사용자 인증 정보를 설정하세요.

  1. Google Cloud CLI를 설치합니다.

  2. gcloud CLI를 초기화하려면 다음 명령어를 실행합니다.

     gcloud init

  3. Google 계정의 로컬 인증 사용자 인증 정보를 만듭니다.

     gcloud auth application-default login

  자세한 내용은 로컬 개발 환경의 인증 설정를 참조하세요.

요구사항

이 섹션에서는 영역 및 리전 간 VM 이동을 위한 요구사항을 보여줍니다.

• 프로젝트 할당량. 프로젝트에는 다음을 수행하기 위해 충분한 할당량이 있어야 합니다.

  • 새 스냅샷을 만듭니다.
  • 모든 임시 외부 IP 주소를 승격합니다.

  • 대상 리전에 새 VM 및 디스크를 만듭니다.

    예를 들어 이동할 VM에 디스크가 3개 연결되어 있는 경우 임시 영구 디스크 스냅샷 3개와 새 디스크 3개를 위한 공간이 충분히 할당되어 있어야 합니다. 새 디스크를 만든 후에는 임시 스냅샷을 삭제해도 됩니다.

  할당량 페이지에서 이전 리소스에 할당량이 충분히 있는지 확인합니다. 자세한 내용은 할당량 이해를 참조하세요.

• 영구 디스크. 이동하려는 VM에 연결된 영구 디스크는 다른 VM에 연결되지 않습니다.

• 로컬 SSD. 로컬 SSD는 임시 스토리지용이며 로컬 SSD의 데이터는 수동 VM 종료 시 보전되지 않습니다. 로컬 SSD 데이터를 보존해야 하는 경우 영구 디스크와 같은 내구성 있는 스토리지 옵션을 사용하여 복제하세요.

• GPU. VM에 GPU가 포함된 경우 사용하려는 GPU를 VM의 대상 영역에서 사용할 수 있는지 확인하세요. GPU와 GPU를 사용할 수 있는 영역의 목록은 Compute Engine의 GPU를 참조하세요.

• 서브네트워크. us-west1-a 및 asia-south1-b 사이와 같이 리전 간에 VM을 이동하려는 경우 VM이 서브네트워크에 속해 있으면 VM에 대해 새로운 서브네트워크를 선택해야 합니다. 서브넷을 만드는 방법에 대한 자세한 내용은 서브넷 추가를 참조하세요.

  참고: 이 섹션에 설명된 VM을 이동하는 방법은 TERMINATED 상태의 VM 또는 UEFI 펌웨어를 사용하는 보안 VM에도 사용 가능합니다.

제한사항

리전 간에 VM을 이동하는 경우 VM의 임시 내부 또는 외부 IP 주소를 보존할 수 없습니다. VM을 다시 만들 때는 새 IP 주소를 선택해야 합니다.

리소스 속성

VM을 이동하려면 VM을 종료하고, 이를 대상 영역 또는 리전으로 이동하고, 다시 시작해야 합니다. VM을 이동한 후에는 원본 리소스에 대한 기존 참조(예: 기존 VM을 가리키는 대상 VM 또는 대상 풀)를 업데이트해야 합니다.

이동하는 동안 서버에서 생성되는 VM과 디스크의 일부 속성이 변경됩니다.

변경되는 VM 속성

다음 표에서는 변경되는 VM 속성을 설명합니다.

속성 이름	변경사항
내부 IP 주소	일반적으로 새 내부 IP 주소가 할당되지만 VM이 원래의 내부 IP 주소를 유지할 수도 있습니다.
외부 IP 주소	같은 리전 내의 영역 간에 VM을 이동하는 경우 외부 IP 주소가 동일하게 유지됩니다. 그렇지 않으면 VM 인스턴스의 다른 외부 IP 주소를 선택하세요.
CPU 플랫폼	대상 영역에 사용할 수 있는 CPU 플랫폼에 따라, VM을 이동한 후 VM의 CPU 플랫폼이 달라질 수 있습니다. 각 영역에 있는 CPU 플랫폼의 전체 목록은 사용 가능한 리전 및 영역을 참조하세요.
네트워크/서브네트워크	VM이 서브네트워크에 속하고 서로 다른 리전 간에 이동하는 경우에는 VM의 새로운 서브네트워크도 선택해야 합니다. 동일한 리전 내의 영역 간을 이동하는 VM은 동일한 서브네트워크를 유지합니다.

변경되는 디스크 속성

다음 표에서는 변경되는 디스크 속성을 설명합니다.

속성 이름	변경사항
소스 스냅샷	새로운 디스크의 소스 스냅샷은 이동 중에 생성된 임시 스냅샷으로 설정됩니다.
소스 스냅샷 ID	소스 스냅샷 ID는 임시 스냅샷의 ID로 설정됩니다.
소스 이미지	소스 이미지 필드가 비어 있습니다.
이미지 ID	이미지 ID가 비어 있습니다.
마지막으로 분리된 타임스탬프	마지막으로 분리된 타임스탬프가 비어 있습니다.
마지막으로 연결된 타임스탬프	마지막으로 연결된 타임스탬프가 새 인스턴스에 새 디스크가 연결되었을 때의 타임스탬프로 변경됩니다.

VM과 디스크에서 모두 변경되는 속성

다음 표에서는 VM과 디스크에서 모두 변경되는 속성을 설명합니다.

속성 이름	변경사항
ID	새 리소스 ID가 생성됩니다.
생성 타임스탬프	새 생성 타임스탬프가 생성됩니다.
영역 리소스 URL	모든 영역 리소스 URL이 대상 영역을 반영하도록 변경됩니다. 다음 목록은 변경되는 리소스 URL을 보여줍니다. VM의 소스 디스크 URL VM의 머신 유형 URL 자체 링크 URL 영역 URL 디스크 유형 URL 디스크의 users[] 목록에 나열된 VM의 URL

영역 또는 리전 간 VM 이동

영역 또는 리전 간에 VM을 이동하려면 다음을 수행할 수 있습니다.

1. 소스 VM의 머신 이미지를 만듭니다.
2. 다른 영역 또는 리전의 머신 이미지에서 VM을 만듭니다.

다음 예시에서는 영역 간에 VM을 이동하는 방법을 보여줍니다.

gcloud

이 예시에서는 mybootdisk 및 mydatadisk라는 영구 디스크 두 개가 포함된 myinstance라는 VM을 europe-west1-c에서 us-west1-b로 이동합니다.

1. 이동할 VM과 연결된 디스크를 확인합니다.

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

   이 예시에서는 myinstance VM에 연결된 디스크 두 개를 볼 수 있습니다.

   • 부팅 디스크 mybootdisk
   • 데이터 디스크 mydatadisk

2. VM이 삭제될 때 디스크가 자동으로 삭제되지 않도록 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을 삭제하면 VM 메타데이터도 삭제됩니다. 이 정보를 별도의 파일에 저장한 다음 VM 메타데이터를 새로운 VM에 다시 적용할 수 있습니다.

   VM의 메타데이터를 다음과 같이 설명합니다.

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

   내용을 별도의 파일에 저장합니다.

4. 영구 디스크 스냅샷을 사용하여 데이터 백업을 만듭니다.

   예방 조치로 영구 디스크 스냅샷을 사용하여 영구 디스크가 VM에 연결되어 있는 동안 데이터 백업을 생성합니다. 스냅샷을 만들기 전에 스냅샷 권장사항을 준수하여 영구 디스크 상태와 일치하는지 확인합니다.

   참고: Windows VM을 실행하는 경우 스냅샷을 만들려면 먼저 VM을 종료해야 합니다. Windows VM용 스냅샷 만들기의 단계를 따르세요.

   디스크 버퍼를 삭제한 후 다음과 같이 스냅샷을 만듭니다.

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

   스냅샷이 생성되었는지 확인하려면 gcloud compute snapshots list를 실행합니다.

5. (선택사항) 같은 리전 내의 영역 간에 VM을 이동하고 임시 내부 또는 외부 IP 주소를 보존하려면 내부 또는 외부 IP 주소를 고정 IP 주소로 승격한 후 나중에 다시 사용할 수 있습니다.

   참고: VM을 리전 간에 이동하는 경우 VM의 임시 내부 또는 외부 IP 주소를 보존할 수 없습니다 . VM을 다시 만들 때는 새 IP 주소를 선택해야 합니다.

6. VM을 삭제합니다.

   참고: 이전 단계에서 Windows VM을 이미 종료했다면 이 단계를 건너뛰세요.

   VM을 삭제하면 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. 그런 다음 부팅 디스크와 데이터 디스크의 또 다른 스냅샷을 만듭니다.

   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. 만든 스냅샷에서 us-west1-b에 새 영구 디스크를 만듭니다. 먼저 부팅 디스크를 만듭니다.

   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. us-west1-b에서 VM을 다시 만듭니다.

    • VM 메타데이터를 파일(예: myinstance.describe)에 저장하도록 선택한 경우 이 파일을 사용하여 VM에 동일한 메타데이터를 설정할 수 있습니다.

    • VM에 고정 외부 IP 주소가 있는 경우 --address [ADDRESS] 옵션을 지정하여 해당 주소를 새 VM에 다시 할당할 수 있습니다. VM을 리전 간에 이동하는 경우에는 새 VM 인스턴스의 다른 외부 IP 주소를 선택해야 합니다.

    • VM에 고정 내부 IP 주소가 있는 경우 --private-network-ip ADDRESS 옵션을 지정하여 해당 주소를 새 VM에 다시 할당할 수 있습니다. VM을 리전 간에 이동하는 경우에는 새 VM 인스턴스의 다른 내부 IP 주소를 선택해야 합니다.

    • VM에 GPU가 포함되어 있는 경우 --accelerator 옵션을 사용하여 VM에 GPU를 추가합니다.

    • 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. (선택 사항) 영구 디스크 스냅샷을 삭제합니다.

    가상 머신이 이동한 것을 확인한 후에는 만든 임시 스냅샷을 삭제하여 스토리지 비용을 절약하세요.

    gcloud compute snapshots delete mybootsnapshot mydatasnapshot

    백업 스냅샷이 더 이상 필요하지 않으면 해당 스냅샷도 삭제합니다.

    gcloud compute snapshots delete backup-mybootsnapshot backup-mydatasnapshot

Go

1. VM 세부정보를 가져오고 VM에 연결된 디스크를 확인합니다.

   compute/get_instance.go

   GitHub에서 보기 의견 보내기

   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
   }
   

2. VM이 삭제될 때 디스크가 자동으로 삭제되지 않도록 부팅 디스크와 데이터 디스크의 자동 삭제 상태를 false로 설정합니다.

   compute/disks/set_disk_autodelete.go

   GitHub에서 보기 의견 보내기

   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
   }
   

3. 영구 디스크 스냅샷을 사용하여 데이터 백업을 만듭니다.

   예방 조치로 영구 디스크 스냅샷을 사용하여 영구 디스크가 VM에 연결되어 있는 동안 데이터 백업을 생성합니다. 스냅샷을 만들기 전에 스냅샷 권장사항을 준수하여 영구 디스크 상태와 일치하는지 확인합니다.

   참고: Windows VM을 실행하는 경우 스냅샷을 만들려면 먼저 VM을 종료해야 합니다. Windows VM용 스냅샷 만들기의 단계를 따르세요.

   디스크 버퍼를 삭제한 후 다음과 같이 스냅샷을 만듭니다.

   compute/snapshots/create_snapshot.go

   GitHub에서 보기 의견 보내기

   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
   }
   

4. 소스 영역에서 VM을 삭제합니다.

   compute/delete_instance.go

   GitHub에서 보기 의견 보내기

   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
   }
   

5. 그런 다음 부팅 디스크와 데이터 디스크의 또 다른 스냅샷을 만듭니다.

   compute/snapshots/create_snapshot.go

   GitHub에서 보기 의견 보내기

   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
   }
   

6. (선택사항) 영구 디스크를 삭제합니다.

   영구 디스크의 이름을 새로운 디스크에 다시 사용하려면 기존 디스크를 삭제하여 해당 이름을 사용할 수 있게 만들어야 합니다. 디스크를 삭제하면 영구 디스크 스토리지 비용도 절약됩니다.

   동일한 디스크 이름을 다시 사용하지 않는 경우에는 이를 삭제하지 않아도 됩니다.

   compute/disks/delete_disk.go

   GitHub에서 보기 의견 보내기

   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
   }
   

7. 만든 스냅샷의 대상 영역에 새 영구 디스크를 만듭니다. 먼저 부팅 디스크를 만든 후 데이터 디스크를 만듭니다.

   compute/disks/create_disk_from_snapshot.go

   GitHub에서 보기 의견 보내기

   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
   }
   

8. 대상 영역에 새 디스크를 사용하여 VM을 다시 만듭니다.

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

   GitHub에서 보기 의견 보내기

   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
   }
   

9. (선택사항) 임시 디스크 스냅샷을 삭제합니다. 가상 머신이 이동한 것을 확인한 후에는 만든 임시 스냅샷을 삭제하여 스토리지 비용을 절약하세요.

   compute/snapshots/delete_snapshot.go

   GitHub에서 보기 의견 보내기

   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
   }
   

자바

1. VM 세부정보를 가져오고 VM에 연결된 디스크를 확인합니다.

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

   GitHub에서 보기 의견 보내기

   
   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. VM이 삭제될 때 디스크가 자동으로 삭제되지 않도록 부팅 디스크와 데이터 디스크의 자동 삭제 상태를 false로 설정합니다.

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

   GitHub에서 보기 의견 보내기

   
   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. 영구 디스크 스냅샷을 사용하여 데이터 백업을 만듭니다.

   예방 조치로 영구 디스크 스냅샷을 사용하여 영구 디스크가 VM에 연결되어 있는 동안 데이터 백업을 생성합니다. 스냅샷을 만들기 전에 스냅샷 권장사항을 준수하여 영구 디스크 상태와 일치하는지 확인합니다.

   참고: Windows VM을 실행하는 경우 스냅샷을 만들려면 먼저 VM을 종료해야 합니다. Windows VM용 스냅샷 만들기의 단계를 따르세요.

   디스크 버퍼를 삭제한 후 다음과 같이 스냅샷을 만듭니다.

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

   GitHub에서 보기 의견 보내기

   
   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을 삭제합니다.

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

   GitHub에서 보기 의견 보내기

   
   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. 그런 다음 부팅 디스크와 데이터 디스크의 또 다른 스냅샷을 만듭니다.

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

   GitHub에서 보기 의견 보내기

   
   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. (선택사항) 영구 디스크를 삭제합니다.

   영구 디스크의 이름을 새로운 디스크에 다시 사용하려면 기존 디스크를 삭제하여 해당 이름을 사용할 수 있게 만들어야 합니다. 디스크를 삭제하면 영구 디스크 스토리지 비용도 절약됩니다.

   동일한 디스크 이름을 다시 사용하지 않는 경우에는 이를 삭제하지 않아도 됩니다.

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

   GitHub에서 보기 의견 보내기

   
   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. 만든 스냅샷의 대상 영역에 새 영구 디스크를 만듭니다. 먼저 부팅 디스크를 만든 후 데이터 디스크를 만듭니다.

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

   GitHub에서 보기 의견 보내기

   
   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. 대상 영역에 새 디스크를 사용하여 VM을 다시 만듭니다.

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

   GitHub에서 보기 의견 보내기

   
   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. (선택사항) 임시 디스크 스냅샷을 삭제합니다. 가상 머신이 이동한 것을 확인한 후에는 만든 임시 스냅샷을 삭제하여 스토리지 비용을 절약하세요.

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

   GitHub에서 보기 의견 보내기

   
   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 세부정보를 가져오고 VM에 연결된 디스크를 확인합니다.

   compute/getInstance.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. VM이 삭제될 때 디스크가 자동으로 삭제되지 않도록 부팅 디스크와 데이터 디스크의 자동 삭제 상태를 false로 설정합니다.

   compute/disks/setDiskAutodelete.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. 영구 디스크 스냅샷을 사용하여 데이터 백업을 만듭니다.

   예방 조치로 영구 디스크 스냅샷을 사용하여 영구 디스크가 VM에 연결되어 있는 동안 데이터 백업을 생성합니다. 스냅샷을 만들기 전에 스냅샷 권장사항을 준수하여 영구 디스크 상태와 일치하는지 확인합니다.

   참고: Windows VM을 실행하는 경우 스냅샷을 만들려면 먼저 VM을 종료해야 합니다. Windows VM용 스냅샷 만들기의 단계를 따르세요.

   디스크 버퍼를 삭제한 후 다음과 같이 스냅샷을 만듭니다.

   compute/snapshots/createSnapshot.js

   GitHub에서 보기 의견 보내기

   /**
    * 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을 삭제합니다.

   compute/deleteInstance.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. 그런 다음 부팅 디스크와 데이터 디스크의 또 다른 스냅샷을 만듭니다.

   compute/snapshots/createSnapshot.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. (선택사항) 영구 디스크를 삭제합니다.

   영구 디스크의 이름을 새로운 디스크에 다시 사용하려면 기존 디스크를 삭제하여 해당 이름을 사용할 수 있게 만들어야 합니다. 디스크를 삭제하면 영구 디스크 스토리지 비용도 절약됩니다.

   동일한 디스크 이름을 다시 사용하지 않는 경우에는 이를 삭제하지 않아도 됩니다.

   compute/disks/deleteDisk.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. 만든 스냅샷의 대상 영역에 새 영구 디스크를 만듭니다. 먼저 부팅 디스크를 만든 후 데이터 디스크를 만듭니다.

   compute/disks/createDiskFromSnapshot.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. 대상 영역에 새 디스크를 사용하여 VM을 다시 만듭니다.

   compute/instances/create-start-instance/createInstanceWithExistingDisks.js

   GitHub에서 보기 의견 보내기

   /**
    * 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. (선택사항) 임시 디스크 스냅샷을 삭제합니다. 가상 머신이 이동한 것을 확인한 후에는 만든 임시 스냅샷을 삭제하여 스토리지 비용을 절약하세요.

   compute/snapshots/deleteSnapshot.js

   GitHub에서 보기 의견 보내기

   /**
    * 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();

Python

1. VM 세부정보를 가져오고 VM에 연결된 디스크를 확인합니다.

   compute/client_library/snippets/instances/get.py

   GitHub에서 보기 의견 보내기

   from google.cloud import compute_v1
   
   def get_instance(project_id: str, zone: str, instance_name: str) -> compute_v1.Instance:
       """
       Get information about a VM instance in the given zone in the specified project.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone you want to use. For example: “us-west3-b”
           instance_name: name of the VM instance you want to query.
       Returns:
           An Instance object.
       """
       instance_client = compute_v1.InstancesClient()
       instance = instance_client.get(
           project=project_id, zone=zone, instance=instance_name
       )
   
       return instance
   
   

2. VM이 삭제될 때 디스크가 자동으로 삭제되지 않도록 부팅 디스크와 데이터 디스크의 자동 삭제 상태를 false로 설정합니다.

   compute/client_library/snippets/disks/autodelete_change.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def set_disk_autodelete(
       project_id: str, zone: str, instance_name: str, disk_name: str, autodelete: bool
   ) -> None:
       """
       Set the autodelete flag of a disk to given value.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone in which is the disk you want to modify.
           instance_name: name of the instance the disk is attached to.
           disk_name: the name of the disk which flag you want to modify.
           autodelete: the new value of the autodelete flag.
       """
       instance_client = compute_v1.InstancesClient()
       instance = instance_client.get(
           project=project_id, zone=zone, instance=instance_name
       )
   
       for disk in instance.disks:
           if disk.device_name == disk_name:
               break
       else:
           raise RuntimeError(
               f"Instance {instance_name} doesn't have a disk named {disk_name} attached."
           )
   
       disk.auto_delete = autodelete
   
       operation = instance_client.update(
           project=project_id,
           zone=zone,
           instance=instance_name,
           instance_resource=instance,
       )
   
       wait_for_extended_operation(operation, "disk update")
   
   

3. 영구 디스크 스냅샷을 사용하여 데이터 백업을 만듭니다.

   예방 조치로 영구 디스크 스냅샷을 사용하여 영구 디스크가 VM에 연결되어 있는 동안 데이터 백업을 생성합니다. 스냅샷을 만들기 전에 스냅샷 권장사항을 준수하여 영구 디스크 상태와 일치하는지 확인합니다.

   참고: Windows VM을 실행하는 경우 스냅샷을 만들려면 먼저 VM을 종료해야 합니다. Windows VM용 스냅샷 만들기의 단계를 따르세요.

   디스크 버퍼를 삭제한 후 다음과 같이 스냅샷을 만듭니다.

   compute/client_library/snippets/snapshots/create.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def create_snapshot(
       project_id: str,
       disk_name: str,
       snapshot_name: str,
       *,
       zone: str | None = None,
       region: str | None = None,
       location: str | None = None,
       disk_project_id: str | None = None,
   ) -> compute_v1.Snapshot:
       """
       Create a snapshot of a disk.
   
       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.
   
       Args:
           project_id: project ID or project number of the Cloud project you want
               to use to store the snapshot.
           disk_name: name of the disk you want to snapshot.
           snapshot_name: name of the snapshot to be created.
           zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
           region: name of the region in which is the disk you want to snapshot (for regional disks).
           location: 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
           disk_project_id: project ID or project number of the Cloud project that
               hosts the disk you want to snapshot. If not provided, will look for
               the disk in the `project_id` project.
   
       Returns:
           The new snapshot instance.
       """
       if zone is None and region is None:
           raise RuntimeError(
               "You need to specify `zone` or `region` for this function to work."
           )
       if zone is not None and region is not None:
           raise RuntimeError("You can't set both `zone` and `region` parameters.")
   
       if disk_project_id is None:
           disk_project_id = project_id
   
       if zone is not None:
           disk_client = compute_v1.DisksClient()
           disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
       else:
           regio_disk_client = compute_v1.RegionDisksClient()
           disk = regio_disk_client.get(
               project=disk_project_id, region=region, disk=disk_name
           )
   
       snapshot = compute_v1.Snapshot()
       snapshot.source_disk = disk.self_link
       snapshot.name = snapshot_name
       if location:
           snapshot.storage_locations = [location]
   
       snapshot_client = compute_v1.SnapshotsClient()
       operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)
   
       wait_for_extended_operation(operation, "snapshot creation")
   
       return snapshot_client.get(project=project_id, snapshot=snapshot_name)
   
   

4. 소스 영역에서 VM을 삭제합니다.

   compute/client_library/snippets/instances/delete.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def delete_instance(project_id: str, zone: str, machine_name: str) -> None:
       """
       Send an instance deletion request to the Compute Engine API and wait for it to complete.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone you want to use. For example: “us-west3-b”
           machine_name: name of the machine you want to delete.
       """
       instance_client = compute_v1.InstancesClient()
   
       print(f"Deleting {machine_name} from {zone}...")
       operation = instance_client.delete(
           project=project_id, zone=zone, instance=machine_name
       )
       wait_for_extended_operation(operation, "instance deletion")
       print(f"Instance {machine_name} deleted.")
   
   

5. 그런 다음 부팅 디스크와 데이터 디스크의 또 다른 스냅샷을 만듭니다.

   compute/client_library/snippets/snapshots/create.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def create_snapshot(
       project_id: str,
       disk_name: str,
       snapshot_name: str,
       *,
       zone: str | None = None,
       region: str | None = None,
       location: str | None = None,
       disk_project_id: str | None = None,
   ) -> compute_v1.Snapshot:
       """
       Create a snapshot of a disk.
   
       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.
   
       Args:
           project_id: project ID or project number of the Cloud project you want
               to use to store the snapshot.
           disk_name: name of the disk you want to snapshot.
           snapshot_name: name of the snapshot to be created.
           zone: name of the zone in which is the disk you want to snapshot (for zonal disks).
           region: name of the region in which is the disk you want to snapshot (for regional disks).
           location: 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
           disk_project_id: project ID or project number of the Cloud project that
               hosts the disk you want to snapshot. If not provided, will look for
               the disk in the `project_id` project.
   
       Returns:
           The new snapshot instance.
       """
       if zone is None and region is None:
           raise RuntimeError(
               "You need to specify `zone` or `region` for this function to work."
           )
       if zone is not None and region is not None:
           raise RuntimeError("You can't set both `zone` and `region` parameters.")
   
       if disk_project_id is None:
           disk_project_id = project_id
   
       if zone is not None:
           disk_client = compute_v1.DisksClient()
           disk = disk_client.get(project=disk_project_id, zone=zone, disk=disk_name)
       else:
           regio_disk_client = compute_v1.RegionDisksClient()
           disk = regio_disk_client.get(
               project=disk_project_id, region=region, disk=disk_name
           )
   
       snapshot = compute_v1.Snapshot()
       snapshot.source_disk = disk.self_link
       snapshot.name = snapshot_name
       if location:
           snapshot.storage_locations = [location]
   
       snapshot_client = compute_v1.SnapshotsClient()
       operation = snapshot_client.insert(project=project_id, snapshot_resource=snapshot)
   
       wait_for_extended_operation(operation, "snapshot creation")
   
       return snapshot_client.get(project=project_id, snapshot=snapshot_name)
   
   

6. (선택사항) 영구 디스크를 삭제합니다.

   영구 디스크의 이름을 새로운 디스크에 다시 사용하려면 기존 디스크를 삭제하여 해당 이름을 사용할 수 있게 만들어야 합니다. 디스크를 삭제하면 영구 디스크 스토리지 비용도 절약됩니다.

   동일한 디스크 이름을 다시 사용하지 않는 경우에는 이를 삭제하지 않아도 됩니다.

   compute/client_library/snippets/disks/delete.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def delete_disk(project_id: str, zone: str, disk_name: str) -> None:
       """
       Deletes a disk from a project.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone in which is the disk you want to delete.
           disk_name: name of the disk you want to delete.
       """
       disk_client = compute_v1.DisksClient()
       operation = disk_client.delete(project=project_id, zone=zone, disk=disk_name)
       wait_for_extended_operation(operation, "disk deletion")
   
   

7. 만든 스냅샷의 대상 영역에 새 영구 디스크를 만듭니다. 먼저 부팅 디스크를 만든 후 데이터 디스크를 만듭니다.

   compute/client_library/snippets/disks/create_from_snapshot.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def create_disk_from_snapshot(
       project_id: str,
       zone: str,
       disk_name: str,
       disk_type: str,
       disk_size_gb: int,
       snapshot_link: str,
   ) -> compute_v1.Disk:
       """
       Creates a new disk in a project in given zone.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone in which you want to create the disk.
           disk_name: name of the disk you want to create.
           disk_type: 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"
           disk_size_gb: size of the new disk in gigabytes
           snapshot_link: a link to the snapshot you want to use as a source for the new disk.
               This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"
   
       Returns:
           An unattached Disk instance.
       """
       disk_client = compute_v1.DisksClient()
       disk = compute_v1.Disk()
       disk.zone = zone
       disk.size_gb = disk_size_gb
       disk.source_snapshot = snapshot_link
       disk.type_ = disk_type
       disk.name = disk_name
       operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)
   
       wait_for_extended_operation(operation, "disk creation")
   
       return disk_client.get(project=project_id, zone=zone, disk=disk_name)
   
   

8. 대상 영역에 새 디스크를 사용하여 VM을 다시 만듭니다.

   compute/client_library/snippets/instances/create_start_instance/create_with_existing_disks.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import re
   import sys
   from typing import Any
   import warnings
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def get_disk(project_id: str, zone: str, disk_name: str) -> compute_v1.Disk:
       """
       Gets a disk from a project.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone where the disk exists.
           disk_name: name of the disk you want to retrieve.
       """
       disk_client = compute_v1.DisksClient()
       return disk_client.get(project=project_id, zone=zone, disk=disk_name)
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def create_instance(
       project_id: str,
       zone: str,
       instance_name: str,
       disks: list[compute_v1.AttachedDisk],
       machine_type: str = "n1-standard-1",
       network_link: str = "global/networks/default",
       subnetwork_link: str = None,
       internal_ip: str = None,
       external_access: bool = False,
       external_ipv4: str = None,
       accelerators: list[compute_v1.AcceleratorConfig] = None,
       preemptible: bool = False,
       spot: bool = False,
       instance_termination_action: str = "STOP",
       custom_hostname: str = None,
       delete_protection: bool = False,
   ) -> compute_v1.Instance:
       """
       Send an instance creation request to the Compute Engine API and wait for it to complete.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone to create the instance in. For example: "us-west3-b"
           instance_name: name of the new virtual machine (VM) instance.
           disks: a list of compute_v1.AttachedDisk objects describing the disks
               you want to attach to your new instance.
           machine_type: machine type of the VM being created. This value uses the
               following format: "zones/{zone}/machineTypes/{type_name}".
               For example: "zones/europe-west3-c/machineTypes/f1-micro"
           network_link: name of the network you want the new instance to use.
               For example: "global/networks/default" represents the network
               named "default", which is created automatically for each project.
           subnetwork_link: name of the subnetwork you want the new instance to use.
               This value uses the following format:
               "regions/{region}/subnetworks/{subnetwork_name}"
           internal_ip: internal IP address you want to assign to the new instance.
               By default, a free address from the pool of available internal IP addresses of
               used subnet will be used.
           external_access: boolean flag indicating if the instance should have an external IPv4
               address assigned.
           external_ipv4: external IPv4 address to be assigned to this instance. If you specify
               an external IP address, it must live in the same region as the zone of the instance.
               This setting requires `external_access` to be set to True to work.
           accelerators: a list of AcceleratorConfig objects describing the accelerators that will
               be attached to the new instance.
           preemptible: boolean value indicating if the new instance should be preemptible
               or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
           spot: boolean value indicating if the new instance should be a Spot VM or not.
           instance_termination_action: What action should be taken once a Spot VM is terminated.
               Possible values: "STOP", "DELETE"
           custom_hostname: Custom hostname of the new VM instance.
               Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
           delete_protection: boolean value indicating if the new virtual machine should be
               protected against deletion or not.
       Returns:
           Instance object.
       """
       instance_client = compute_v1.InstancesClient()
   
       # Use the network interface provided in the network_link argument.
       network_interface = compute_v1.NetworkInterface()
       network_interface.network = network_link
       if subnetwork_link:
           network_interface.subnetwork = subnetwork_link
   
       if internal_ip:
           network_interface.network_i_p = internal_ip
   
       if external_access:
           access = compute_v1.AccessConfig()
           access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
           access.name = "External NAT"
           access.network_tier = access.NetworkTier.PREMIUM.name
           if external_ipv4:
               access.nat_i_p = external_ipv4
           network_interface.access_configs = [access]
   
       # Collect information into the Instance object.
       instance = compute_v1.Instance()
       instance.network_interfaces = [network_interface]
       instance.name = instance_name
       instance.disks = disks
       if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
           instance.machine_type = machine_type
       else:
           instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
   
       instance.scheduling = compute_v1.Scheduling()
       if accelerators:
           instance.guest_accelerators = accelerators
           instance.scheduling.on_host_maintenance = (
               compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
           )
   
       if preemptible:
           # Set the preemptible setting
           warnings.warn(
               "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
           )
           instance.scheduling = compute_v1.Scheduling()
           instance.scheduling.preemptible = True
   
       if spot:
           # Set the Spot VM setting
           instance.scheduling.provisioning_model = (
               compute_v1.Scheduling.ProvisioningModel.SPOT.name
           )
           instance.scheduling.instance_termination_action = instance_termination_action
   
       if custom_hostname is not None:
           # Set the custom hostname for the instance
           instance.hostname = custom_hostname
   
       if delete_protection:
           # Set the delete protection bit
           instance.deletion_protection = True
   
       # Prepare the request to insert an instance.
       request = compute_v1.InsertInstanceRequest()
       request.zone = zone
       request.project = project_id
       request.instance_resource = instance
   
       # Wait for the create operation to complete.
       print(f"Creating the {instance_name} instance in {zone}...")
   
       operation = instance_client.insert(request=request)
   
       wait_for_extended_operation(operation, "instance creation")
   
       print(f"Instance {instance_name} created.")
       return instance_client.get(project=project_id, zone=zone, instance=instance_name)
   
   def create_with_existing_disks(
       project_id: str, zone: str, instance_name: str, disk_names: list[str]
   ) -> compute_v1.Instance:
       """
       Create a new VM instance using selected disks. The first disk in disk_names will
       be used as boot disk.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           zone: name of the zone to create the instance in. For example: "us-west3-b"
           instance_name: name of the new virtual machine (VM) instance.
           disk_names: list of disk names to be attached to the new virtual machine.
               First disk in this list will be used as the boot device.
   
       Returns:
           Instance object.
       """
       assert len(disk_names) >= 1
       disks = [get_disk(project_id, zone, disk_name) for disk_name in disk_names]
       attached_disks = []
       for disk in disks:
           adisk = compute_v1.AttachedDisk()
           adisk.source = disk.self_link
           attached_disks.append(adisk)
       attached_disks[0].boot = True
       instance = create_instance(project_id, zone, instance_name, attached_disks)
       return instance
   
   

9. (선택사항) 임시 디스크 스냅샷을 삭제합니다. 가상 머신이 이동한 것을 확인한 후에는 만든 임시 스냅샷을 삭제하여 스토리지 비용을 절약하세요.

   compute/client_library/snippets/snapshots/delete.py

   GitHub에서 보기 의견 보내기

   from __future__ import annotations
   
   import sys
   from typing import Any
   
   from google.api_core.extended_operation import ExtendedOperation
   from google.cloud import compute_v1
   
   def wait_for_extended_operation(
       operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
   ) -> Any:
       """
       Waits for the extended (long-running) operation to complete.
   
       If the operation is successful, it will return its result.
       If the operation ends with an error, an exception will be raised.
       If there were any warnings during the execution of the operation
       they will be printed to sys.stderr.
   
       Args:
           operation: a long-running operation you want to wait on.
           verbose_name: (optional) a more verbose name of the operation,
               used only during error and warning reporting.
           timeout: how long (in seconds) to wait for operation to finish.
               If None, wait indefinitely.
   
       Returns:
           Whatever the operation.result() returns.
   
       Raises:
           This method will raise the exception received from `operation.exception()`
           or RuntimeError if there is no exception set, but there is an `error_code`
           set for the `operation`.
   
           In case of an operation taking longer than `timeout` seconds to complete,
           a `concurrent.futures.TimeoutError` will be raised.
       """
       result = operation.result(timeout=timeout)
   
       if operation.error_code:
           print(
               f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
               file=sys.stderr,
               flush=True,
           )
           print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
           raise operation.exception() or RuntimeError(operation.error_message)
   
       if operation.warnings:
           print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
           for warning in operation.warnings:
               print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
   
       return result
   
   def delete_snapshot(project_id: str, snapshot_name: str) -> None:
       """
       Delete a snapshot of a disk.
   
       Args:
           project_id: project ID or project number of the Cloud project you want to use.
           snapshot_name: name of the snapshot to delete.
       """
   
       snapshot_client = compute_v1.SnapshotsClient()
       operation = snapshot_client.delete(project=project_id, snapshot=snapshot_name)
   
       wait_for_extended_operation(operation, "snapshot deletion")
   
   

다음 단계

• 프로젝트의 기본 영역/리전을 변경하는 방법 알아보기
• 라이브 마이그레이션에 대해 알아보기
• VM 상태 확인
• VM을 Compute Engine으로 마이그레이션에 대해 알아보기