VM 중지 및 시작

Linux Windows

---

이 페이지에서는 가상 머신(VM) 인스턴스를 중지하거나 시작하는 방법을 설명합니다. Compute Engine은 STOP 및 TERMINATE를 상호 교환하며 사용합니다. VM을 일시정지하고 재개하려면 VM 정지 및 재개를 읽어보세요. VM 중지 및 일시정지에 대한 자세한 내용은 VM 인스턴스 수명 주기를 참조하세요.

더 이상 필요 없는 VM은 일시적으로 중지하고 나중에 다시 시작할 수 있습니다. 중지된 VM은 해당 영구 디스크, 내부 IP, MAC 주소를 유지하지만, 게스트 OS를 종료하고 해당 애플리케이션 상태를 유지하지 않습니다. 게스트 OS 및 애플리케이션 상태를 유지해야 하는 경우 대신 VM을 일시정지합니다. 기본적으로 중지된 VM은 전원 켜짐 상태로 재설정되고 데이터는 저장되지 않습니다. 머신 유형을 변경하거나 연결된 디스크를 추가 또는 제거하거나 최소 CPU 플랫폼을 변경하거나 GPU를 추가 또는 제거하거나 머신 유형 권장사항을 적용하려면 VM을 중지합니다.

VM을 중지하면 Compute Engine이 VM에 ACPI 종료 신호를 전송합니다. 최신 게스트 운영체제(OS)는 종료 신호에 대한 응답으로 종료하기 전에 완전 종료를 수행하도록 구성되어 있습니다. Compute Engine에서는 게스트 OS가 종료를 마칠 때까지 잠시 기다린 후 VM을 TERMINATED 상태로 전환합니다.

시작하기 전에

• 이 가이드의 명령줄 예시를 사용하려면 다음을 수행하세요.
  1. gcloud 명령줄 도구 최신 버전으로 설치하거나 업데이트합니다.
  2. 기본 리전 및 영역을 설정합니다.
• 이 가이드의 API 예를 사용하려면 API 액세스를 설정합니다.

제한사항

로컬 SSD가 연결된 VM을 중지했다가 다시 시작할 수 없습니다. 하지만 VM에서 로컬 SSD를 사용하는 경우 Compute Engine은 게스트 OS 내부에서 VM이 종료되는 것을 방지하지 못합니다. 게스트 OS를 통해 로컬 SSD를 사용하여 VM을 종료하면 VM을 다시 시작할 수 없으며 로컬 SSD의 데이터가 손실됩니다. VM을 삭제하기 전에 중요한 데이터를 로컬 SSD에서 영구 디스크나 다른 VM으로 마이그레이션해야 합니다.

결제

TERMINATED 상태의 VM에는 초 단위 사용 요금이 청구되지 않으며 리전 CPU 할당량에 포함되지 않습니다. 하지만 영구 디스크 및 외부 IP 주소와 같이 VM에 연결된 모든 리소스는 삭제될 때까지 요금이 청구됩니다. 연결된 리소스에 대해 요금이 청구되지 않도록 하려면 중지된 VM이 해당 리소스를 분리하도록 구성한 다음 리소스를 삭제할 수 있습니다.

사용하지 않는 VM을 중지하여 활성 상태가 아닌 VM에 대한 요금 청구를 방지할 수 있습니다. 준비가 되면 동일한 VM 속성, 메타데이터, 리소스를 사용하여 동일한 VM을 다시 시작할 수 있습니다.

VM 중지

이 작업에 필요한 권한

이 태스크를 수행하려면 다음과 같은 권한이 있어야 합니다.

• VM에 대한 compute.instances.stop 권한

VM을 중지하려면 Google Cloud Console, gcloud 도구, Compute Engine API를 사용합니다.

Console

1. Cloud Console에서 VM 인스턴스 페이지로 이동합니다.

   VM 인스턴스로 이동

2. 중지할 VM을 하나 이상 선택합니다.

3. 중지를 클릭합니다.

gcloud

VM을 중지하려면 gcloud compute instances stop 명령어를 사용하여 중지할 VM을 한 개 이상 지정합니다.

gcloud compute instances stop VM_NAME

VM_NAME을 중지할 VM의 이름으로 바꿉니다.

API

VM을 중지하려면 instances.stop 메서드를 사용하여 POST 요청을 만듭니다.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop

다음을 바꿉니다.

• PROJECT_ID: VM이 있는 프로젝트입니다.
• ZONE: VM이 있는 영역입니다.
• VM_NAME: 중지할 VM의 이름입니다.

Go

compute/stop_instance.go

GitHub에서 보기

import (
	"context"
	"fmt"
	"io"

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

// stopInstance stops a started Google Compute Engine instance
func stopInstance(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: %v", err)
	}
	defer instancesClient.Close()

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

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

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance stopped\n")
			break
		}
	}

	return nil
}

자바

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

GitHub에서 보기

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StopInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to stop.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    stopInstance(project, zone, instanceName);
  }

  // Stops a started Google Compute Engine instance.
  public static void stopInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* 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()) {

      StopInstanceRequest stopInstanceRequest = StopInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.stopAsync(
          stopInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance stopped successfully ! ");
      }
    }
  }
}

Node.js

samples/stopInstance.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 stopInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.stop({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance stopped.');
}

stopInstance();

Python

samples/snippets/sample_start_stop.py

GitHub에서 보기

from google.cloud import compute_v1

def stop_instance(project_id: str, zone: str, instance_name: str):
    """
    Stops a running Google Compute Engine instance.

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to stop.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.stop_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

TERMINATED VM은 구성 설정 및 인스턴스 메타데이터와 함께 여전히 존재하지만 메모리 내 데이터와 가상 머신 상태는 손실됩니다. 종료된 VM에 연결된 모든 리소스는 수동으로 해당 리소스를 분리하거나 VM을 삭제할 때까지 계속 연결되어 있습니다.

VM이 TERMINATED 상태라면 VM을 다시 시작하거나 삭제할 수 있습니다. VM을 다시 시작하지 않으려면 VM을 삭제합니다.

OS를 통한 VM 중지

이 작업에 필요한 권한

이 작업을 수행하려면 다음과 같은 권한이 있어야 합니다.

• 인스턴스 수준 공개 SSH 키를 사용하는 경우 VM에 대한 compute.instances.setMetadata
• 프로젝트 수준 SSH 키를 사용하는 경우 프로젝트에 대한 compute.projects.setCommonInstanceMetadata

원하는 경우 sudo shutdown -h now 또는 sudo poweroff 명령어를 사용하여 게스트 OS를 통해 VM을 중지할 수 있습니다. 로컬 SSD를 사용하는 VM을 중지하려면 다음 명령어를 사용합니다. VM에 로그인한 상태에서 다음 명령어 중 하나를 실행합니다.

sudo shutdown -h now

sudo poweroff

암호화된 디스크가 없는 중지된 VM 다시 시작

이 작업에 필요한 권한

이 태스크를 수행하려면 다음과 같은 권한이 있어야 합니다.

• VM에 대한 compute.instances.start 권한

중지된 VM을 시작하려면 instances().start 메서드를 사용합니다. 이 메서드는 TERMINATED 상태의 중지된 VM을 부팅합니다.

start 메서드는 TERMINATED 상태의 VM을 다시 시작하는 반면 reset() 및 sudo reboot와 같은 메서드는 현재 실행 중인 VM에서만 작동합니다. VM이 TERMINATED 상태이면 선점형 VM을 포함한 거의 모든 VM이 다시 시작될 수 있습니다.

참고: 새 VM이나 종료된 VM의 시작(또는 다시 시작) 절차를 설명하는 VM 상태의 진행 과정을 살펴볼 수 있습니다.

Console

1. Google Cloud Console에서 VM 인스턴스 페이지로 이동합니다.

   VM 인스턴스로 이동

2. 중지할 VM을 하나 이상 선택합니다.

3. 시작/재개를 클릭합니다.

gcloud

VM을 시작하려면 gcloud compute instances start 명령어를 사용하고 시작할 VM을 한 개 이상 지정합니다.

gcloud compute instances start VM_NAME

VM_NAME을 시작할 VM의 이름으로 바꿉니다.

API

VM을 시작하려면 instances.start 메서드를 사용하여 POST 요청을 만듭니다.

POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/start

다음을 바꿉니다.

• PROJECT_ID: VM이 있는 프로젝트입니다.
• ZONE: VM이 있는 영역입니다.
• VM_NAME: 시작할 VM의 이름입니다.

Go

compute/start_instance.go

GitHub에서 보기

import (
	"context"
	"fmt"
	"io"

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

// startInstance starts a stopped Google Compute Engine instance (with unencrypted disks).
func startInstance(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: %v", err)
	}
	defer instancesClient.Close()

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

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

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance started\n")
			break
		}
	}

	return nil
}

자바

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

GitHub에서 보기

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StartInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start. */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    startInstance(project, zone, instanceName);
  }

  // Starts a stopped Google Compute Engine instance (with unencrypted disks).
  public static void startInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* 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()) {

      // Create the request.
      StartInstanceRequest startInstanceRequest = StartInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startAsync(
          startInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance started successfully ! ");
      }
    }
  }
}

Node.js

samples/startInstance.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 startInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.start({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance started.');
}

startInstance();

Python

samples/snippets/sample_start_stop.py

GitHub에서 보기

from google.cloud import compute_v1

def start_instance(project_id: str, zone: str, instance_name: str):
    """
    Starts a stopped Google Compute Engine instance (with unencrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.start_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

암호화된 디스크가 있는 VM 다시 시작

이 작업에 필요한 권한

이 태스크를 수행하려면 다음과 같은 권한이 있어야 합니다.

• VM에 대한 compute.instances.startWithEncryptionKey 권한

다시 시작하려는 VM이 고객 제공 암호화 키를 사용하는 경우 VM을 다시 시작하려고 할 때 이러한 키를 제공해야 합니다.

Console

1. Google Cloud Console에서 VM 인스턴스 페이지로 이동합니다.

   VM 인스턴스로 이동

2. 시작하려는 VM을 선택합니다.

3. 시작/재개를 클릭합니다. 이 VM에 연결된 기기의 암호화 키를 지정할 수 있는 창이 열립니다.

4. 이 VM에 연결된 각 암호화된 디스크의 암호화 키를 지정합니다.

5. 시작을 클릭하여 VM을 시작합니다.

gcloud

암호화 키를 사용하는 VM을 시작하려면 --csek-key-file 플래그와 함께 gcloud compute instances start 명령어를 사용합니다. RSA 래핑 키를 사용하는 경우 gcloud beta 명령어를 사용합니다.

gcloud compute instances start VM_NAME \
    --csek-key-file ENCRYPTION_KEY_FILE

다음을 바꿉니다.

• VM_NAME: 시작할 VM의 이름입니다.
• ENCRYPTION_KEY_FILE: 암호화 키가 포함된 JSON 파일의 상대 경로입니다. 이 키는 VM에 연결된 영구 디스크를 암호화하는 데 사용됩니다. 자세한 내용은 암호화 키 파일 형식을 참조하세요.

API

암호화 키가 있는 VM을 시작하려면 instances.startWithEncryptionKey 메서드를 사용하여 POST 요청을 만듭니다.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/startWithEncryptionKey
    {
      "disks": [
        {
           "source": "DISK_URL",
           "diskEncryptionKey": {
             "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
           }
        }
      ]
    }
 

다음을 바꿉니다.

• PROJECT_ID: VM이 있는 프로젝트입니다.
• ZONE: VM이 있는 영역입니다.
• VM_NAME: 시작할 VM의 이름입니다.
• DISK_URL: 고객 제공 암호화 키로 암호화된 연결 디스크의 전체 리소스 이름에 해당하는 리소스 URL입니다.
• ENCRYPTION_TYPE: 사용 중인 디스크 암호화 유형(rawKey, kmsKeyName 또는 rsaEncryptedKey). rsaEncryptedKey를 사용하는 경우 v1 API 대신 베타 API를 사용해야 합니다.
• ENCRYPTION_KEY: VM에 연결된 영구 디스크를 암호화하는 데 사용되는 암호화 키입니다. rawKey 또는 rsaEncryptedKey 유형의 키는 base64로 인코딩되어야 합니다. RSA 키 래핑의 안내에 따라 rsaEncryptedKey 유형의 키를 준비합니다.

Go

compute/start_instance_with_enc_key.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"
)

// startInstanceWithEncKey starts a stopped Google Compute Engine instance (with encrypted disks).
func startInstanceWithEncKey(w io.Writer, projectID, zone, instanceName, key string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// key := "your_encryption_key"

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

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

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

	req := &computepb.StartWithEncryptionKeyInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		InstancesStartWithEncryptionKeyRequestResource: &computepb.InstancesStartWithEncryptionKeyRequest{
			Disks: []*computepb.CustomerEncryptionKeyProtectedDisk{
				{
					Source: proto.String(instance.GetDisks()[0].GetSource()),
					DiskEncryptionKey: &computepb.CustomerEncryptionKey{
						RawKey: proto.String(key),
					},
				},
			},
		},
	}

	op, err := instancesClient.StartWithEncryptionKey(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance with encryption key: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance with encryption key started\n")
			break
		}
	}

	return nil
}

자바

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

GitHub에서 보기

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.CustomerEncryptionKey;
import com.google.cloud.compute.v1.CustomerEncryptionKeyProtectedDisk;
import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesStartWithEncryptionKeyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartWithEncryptionKeyInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StartEncryptedInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start.
       key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    String key = "raw-key";

    startEncryptedInstance(project, zone, instanceName, key);
  }

  // Starts a stopped Google Compute Engine instance (with encrypted disks).
  public static void startEncryptedInstance(String project, String zone, String instanceName,
      String key)
      throws IOException, ExecutionException, InterruptedException {
    /* 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()) {

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      Instance instance = instancesClient.get(getInstanceRequest);

      // Prepare the information about disk encryption.
      CustomerEncryptionKeyProtectedDisk protectedDisk = CustomerEncryptionKeyProtectedDisk
          .newBuilder()
          /* Use raw_key to send over the key to unlock the disk
             To use a key stored in KMS, you need to provide:
             `kms_key_name` and `kms_key_service_account`
           */
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setRawKey(key).build())
          .setSource(instance.getDisks(0).getSource())
          .build();

      InstancesStartWithEncryptionKeyRequest startWithEncryptionKeyRequest =
          InstancesStartWithEncryptionKeyRequest.newBuilder()
              .addDisks(protectedDisk).build();

      StartWithEncryptionKeyInstanceRequest encryptionKeyInstanceRequest =
          StartWithEncryptionKeyInstanceRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setInstance(instanceName)
              .setInstancesStartWithEncryptionKeyRequestResource(startWithEncryptionKeyRequest)
              .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startWithEncryptionKeyAsync(
          encryptionKeyInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Encrypted instance started successfully ! ");
      }
    }
  }

}

Node.js

samples/startInstanceWithEncKey.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 key = 'YOUR_KEY_STRING'

const compute = require('@google-cloud/compute');

async function startInstanceWithEncryptionKey() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  const [response] = await instancesClient.startWithEncryptionKey({
    project: projectId,
    zone,
    instance: instanceName,
    instancesStartWithEncryptionKeyRequestResource: {
      disks: [
        {
          source: instance.disks[0].source,
          diskEncryptionKey: {
            rawKey: key,
          },
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance with encryption key started.');
}

startInstanceWithEncryptionKey();

Python

samples/snippets/sample_start_stop.py

GitHub에서 보기

from google.cloud import compute_v1

def start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
):
    """
    Starts a stopped Google Compute Engine instance (with encrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
        key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    instance_data = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    # Prepare the information about disk encryption
    disk_data = compute_v1.CustomerEncryptionKeyProtectedDisk()
    disk_data.source = instance_data.disks[0].source
    disk_data.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    # Use raw_key to send over the key to unlock the disk
    # To use a key stored in KMS, you need to provide `kms_key_name` and `kms_key_service_account`
    disk_data.disk_encryption_key.raw_key = key
    enc_data = compute_v1.InstancesStartWithEncryptionKeyRequest()
    enc_data.disks = [disk_data]

    op = instance_client.start_with_encryption_key_unary(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

VM 재설정

이 작업에 필요한 권한

이 태스크를 수행하려면 다음과 같은 권한이 있어야 합니다.

• VM에 대한 compute.instances.reset 권한

VM 재설정을 수행하는 것은 재설정 버튼을 누르거나 전원 버튼을 길게 눌러 컴퓨터의 초기화를 수행하는 것과 유사합니다. VM을 강제로 재설정하면 머신의 메모리 콘텐츠가 완전히 삭제되고 VM이 초기 상태로 재설정됩니다. VM은 게스트 OS의 완전 종료를 수행하지 않으며, 이 절차 동안 VM은 RUNNING 상태로 유지됩니다.

참고: VM을 재설정해도 VM의 속성은 아무것도 바뀌지 않습니다. VM은 임시 IP, 고정 외부 IP, 영구 디스크, 로컬 SSD(있는 경우), 머신 유형을 유지합니다. 그러나 데이터를 백업하지 않으면 메모리에 저장된 모든 데이터가 재설정됩니다.

실행 중인 VM을 재설정하려면 Google Cloud Console, gcloud 도구 또는 Compute Engine API를 사용합니다.

Console

1. Google Cloud Console에서 VM 인스턴스 페이지로 이동합니다.

   VM 인스턴스로 이동

2. 재설정할 VM을 하나 이상 선택합니다.

3. 재설정을 클릭합니다.

gcloud

실행 중인 VM을 재설정하려면 gcloud compute instances reset 명령어를 사용하고 재설정하려는 VM을 한 개 이상 지정합니다.

gcloud compute instances reset VM_NAME

VM_NAME을 재설정할 VM의 이름으로 바꿉니다.

API

VM을 재설정하려면 instances.reset 메서드를 사용하여 POST 요청을 만듭니다.

 POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/reset

다음을 바꿉니다.

• PROJECT_ID: VM이 있는 프로젝트입니다.
• ZONE: VM이 있는 영역입니다.
• VM_NAME: 재설정할 VM의 이름입니다.

Go

compute/reset_instance.go

GitHub에서 보기

import (
	"context"
	"fmt"
	"io"

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

// resetInstance resets a stopped Google Compute Engine instance (with unencrypted disks).
func resetInstance(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: %v", err)
	}
	defer instancesClient.Close()

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

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

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance reset\n")
			break
		}
	}

	return nil
}

자바

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

GitHub에서 보기

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResetInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class ResetInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to reset.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resetInstance(project, zone, instanceName);
  }

  // Resets a stopped Google Compute Engine instance (with unencrypted disks).
  public static void resetInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* 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()) {

      ResetInstanceRequest resetInstanceRequest = ResetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.resetAsync(
          resetInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance reset successfully ! ");
      }
    }
  }

}

Node.js

samples/resetInstance.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 resetInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.reset({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Instance reset.');
}

resetInstance();

Python

samples/snippets/sample_start_stop.py

GitHub에서 보기

from google.cloud import compute_v1

def reset_instance(project_id: str, zone: str, instance_name: str):
    """
    Resets a stopped Google Compute Engine instance (with unencrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to reset.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.reset_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

reset 명령어를 실행하면 VM이 종료된 후 후속 영역 작업이 DONE을 반환합니다.

기타 재시작 방법

이 작업에 필요한 권한

이 작업을 수행하려면 다음과 같은 권한이 있어야 합니다.

• VM의 compute.instances.setMetadata(VM에 연결하려는 경우)

다음 메서드를 사용하여 VM을 재설정할 수도 있습니다.

• sudo reboot(Linux에만 해당): VM 내에서 이 메서드를 호출합니다. 이 메서드는 메모리를 완전히 삭제하고 VM을 원래의 메타데이터, 이미지, 영구 디스크로 다시 초기화합니다. 이 명령어는 업데이트된 이미지 버전을 가져오지 않으며 VM은 동일한 임시 IP 주소를 유지합니다. 컴퓨터 다시 시작과 유사합니다.
• Windows VM 재부팅: 앞 예시의 sudo reboot와 비슷하게 시작 날짜 메뉴를 사용하여 Windows VM을 재부팅할 수 있습니다. 시작 메뉴에서 로그아웃 옆에 있는 화살표를 클릭하고 다시 시작을 클릭합니다.

다음 단계

• VM 자동 시작 및 중지 일정 예약 방법 알아보기
• VM 종료 및 재부팅 문제 해결 방법 알아보기
• 대화형 직렬 콘솔을 사용하여 VM 문제를 해결하기
• 머신 유형 변경 방법 알아보기