VM 중지 및 다시 시작

Linux Windows

---

이 문서에서는 가상 머신(VM) 인스턴스를 수동으로 중지 및 다시 시작하는 방법과 VM을 재설정하거나 재부팅하는 방법을 설명합니다.

• VM을 더 이상 사용하지 않거나 하나 이상의 속성을 수정하려면 VM을 중지합니다. 예를 들어 VM의 이름을 바꾸거나 머신 유형을 변경하거나 연결된 디스크를 추가 또는 제거하거나 최소 CPU 플랫폼을 변경하려는 경우입니다. VM을 중지한 후 재개하여 워크로드를 다시 시작하거나 더 이상 필요하지 않은 VM을 삭제합니다.

• 예를 들어 VM이 응답하지 않거나 게스트 운영체제(OS)가 비정상 종료된 경우 VM을 재설정합니다. VM을 재설정한 후 워크로드를 재개할 수 있습니다.

• 예를 들어 VM의 메모리를 완전히 삭제하고 원래 부팅 상태로 다시 초기화하려는 경우 게스트 OS 내에서 VM을 재부팅합니다. 게스트 OS 내에서 VM을 재부팅한 후 워크로드를 재개할 수 있습니다.

시작하기 전에

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

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

  콘솔

  Google Cloud 콘솔을 사용하여 Google Cloud 서비스 및 API에 액세스할 때는 인증을 설정할 필요가 없습니다.

  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

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

  PHP

  로컬 개발 환경에서 이 페이지의 PHP 샘플을 사용하려면 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

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

  REST

  로컬 개발 환경에서 이 페이지의 REST API 샘플을 사용하려면 gcloud CLI에 제공한 사용자 인증 정보를 사용합니다.

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

  gcloud init

필요한 역할

VM을 중지하고 다시 시작하는 데 필요한 권한을 얻으려면 관리자에게 프로젝트에 대한 Compute 인스턴스 관리자(v1)(roles/compute.instanceAdmin.v1) IAM 역할을 부여해 달라고 요청하세요. 역할 부여에 대한 자세한 내용은 액세스 관리를 참조하세요.

이 사전 정의된 역할에는 VM을 중지하고 다시 시작하는 데 필요한 권한이 포함되어 있습니다. 필요한 정확한 권한을 보려면 필수 권한 섹션을 펼치세요.

필수 권한

VM을 중지하고 다시 시작하려면 다음 권한이 필요합니다.

• VM 중지: VM에 대한 compute.instances.stop 권한
• 게스트 OS 내에서 VM 중지: 인스턴스 수준 공개 SSH 키를 사용하는 경우 VM에 대한 compute.instances.setMetadata 권한
• VM 다시 시작: VM에 대한 compute.instances.start 권한
• 암호화 키를 사용하는 VM 다시 시작: VM에 대한 compute.instances.startWithEncryptionKey 권한
• VM 재설정: VM에 대한 compute.instances.reset 권한
• 게스트 OS 내에서 VM 재부팅: VM에 대한 compute.instances.setMetadata 권한

커스텀 역할이나 다른 사전 정의된 역할을 사용하여 이 권한을 부여받을 수도 있습니다.

VM 중지

실행 중인 VM을 중지하면 다음과 같은 결과가 발생합니다.

1. Compute Engine은 ACPI 종료 신호를 VM에 전송하고 게스트 OS가 완전 종료를 수행할 때까지 잠시 기다립니다. 그런 다음 Compute Engine이 먼저 VM 상태를 STOPPING으로 설정한 다음 1분 내에 TERMINATED로 전환합니다.

2. VM은 전원 켜짐 상태로 재설정되고 내부 IP, MAC 주소, 구성 설정, 메타데이터를 유지합니다. 그러나 VM은 메모리 내 데이터와 VM 상태를 잃게 됩니다. 메모리 내 데이터와 VM 상태를 유지해야 하는 경우 대신 VM을 일시정지합니다.

또한 VM에 리소스를 연결한 경우 해당 리소스는 수동으로 분리하거나 VM을 삭제할 때까지 연결된 상태로 유지됩니다. VM에 로컬 SSD 디스크가 연결된 경우 VM을 중지하면 기본적으로 로컬 SSD 디스크의 모든 데이터가 삭제됩니다. 로컬 SSD 디스크에서 데이터를 유지하려면 --discard-local-ssd=false 플래그가 있는 gcloud CLI를 사용하여 VM을 중지해야 합니다. 자세한 내용은 로컬 SSD로 VM 중지를 참조하세요.

VM을 중지하려면 이 문서에 설명된 방법 중 하나를 선택합니다.

• Google Cloud를 통해 VM 중지

• 게스트 OS 내에서 VM을 중지합니다.

VM을 중지한 후에는 다시 시작하거나 삭제할 수 있습니다. VM을 다시 시작하지 않으려면 VM을 삭제하는 것이 좋습니다.

Google Cloud를 통해 VM 중지

한 번에 두 개 이상의 VM을 중지하려면 Google Cloud 콘솔을 사용합니다.

콘솔

하나 이상의 VM을 중지하려면 다음을 수행합니다.

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

   VM 인스턴스로 이동

2. 중지할 VM을 선택합니다.

3. 중지를 클릭한 다음 중지를 클릭하여 확인합니다.

gcloud

VM을 중지하려면 gcloud compute instances stop 명령어를 사용합니다.

gcloud compute instances stop VM_NAME \
    --project=PROJECT_ID \
    --zone=ZONE

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

미리보기

이 제품 또는 기능에는 서비스별 약관의 일반 서비스 약관 섹션에 있는 'GA 이전 제공 서비스 약관'이 적용됩니다. GA 이전 제품 및 기능은 '있는 그대로' 제공되며 지원이 제한될 수 있습니다. 자세한 내용은 출시 단계 설명을 참조하세요.

VM에 로컬 SSD 디스크를 연결하고 VM을 중지한 후 로컬 SSD 데이터를 유지하려면 --discard-local-ssd=false 플래그와 함께 gcloud beta compute instances stop 명령어를 사용합니다.

gcloud beta compute instances stop VM_NAME \
    --discard-local-ssd=false \
    --project=PROJECT_ID \
    --zone=ZONE

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: %w", 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: %w", err)
	}

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

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

	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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StopInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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, 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()) {

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

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

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

Node.js

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

PHP

compute/instances/src/stop_instance.php

GitHub에서 보기 의견 보내기

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StopInstanceRequest;

/**
 * Stops a running Google Compute Engine instance.
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function stop_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StopInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->stop($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s stopped successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to stop instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/stop.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 stop_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    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()

    operation = instance_client.stop(
        project=project_id, zone=zone, instance=instance_name
    )
    wait_for_extended_operation(operation, "instance stopping")

REST

VM을 중지하려면 instances.stop 메서드에 POST 요청을 수행합니다.

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

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

게스트 OS 내에서 VM 중지

VM에 연결되었을 때 게스트 OS 내에서 VM을 중지하려면 다음 탭 중 하나를 선택합니다.

Linux

Linux VM을 중지하려면 다음 방법 중 하나를 선택합니다.

• ACPI 종료 신호를 VM에 보내기 전에 VM에서 종료 스크립트를 실행할 수 있도록 허용하는 완전 종료의 경우 다음 명령어를 실행합니다.

  sudo shutdown -h now
  

• 그렇지 않은 경우 강제로 종료하려면 다음 명령어를 실행합니다.

  sudo poweroff
  

Windows

Windows VM을 중지하려면 다음 방법 중 하나를 선택합니다.

• ACPI 종료 신호를 VM에 보내기 전에 VM에서 종료 스크립트를 실행할 수 있도록 허용하는 완전 종료의 경우 다음 명령어를 실행합니다.

  shutdown /s
  

• 그렇지 않은 경우 강제로 종료하려면 다음 명령어를 실행합니다.

  shutdown /f
  

VM 다시 시작

VM이 TERMINATED 상태인 경우에만 중지된 VM을 다시 시작할 수 있습니다. VM을 다시 시작하려면 이 문서에 설명된 다음 방법 중 하나를 선택합니다.

• 암호화된 디스크가 없는 VM 다시 시작(기본값)

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

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

암호화된 디스크를 사용하지 않는 중지된 VM을 다시 시작합니다(기본값). 한 번에 두 개 이상의 VM을 다시 시작하려면 Google Cloud 콘솔을 사용합니다.

콘솔

하나 이상의 VM을 다시 시작하려면 다음을 수행합니다.

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

   VM 인스턴스로 이동

2. VM을 1개 이상 선택하세요.

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

gcloud

VM을 다시 시작하려면 gcloud compute instances start 명령어를 사용합니다.

gcloud compute instances start VM_NAME \
    --project=PROJECT_ID \
    --zone=ZONE

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: 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: %w", 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: %w", err)
	}

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

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

	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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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, 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()) {

      // 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(3, TimeUnit.MINUTES);

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

Node.js

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

PHP

compute/instances/src/start_instance.php

GitHub에서 보기 의견 보내기

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StartInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Start the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StartInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->start($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to start instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/start.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 start_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    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()

    operation = instance_client.start(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "instance start")

REST

VM을 다시 시작하려면 instances.start 메서드에 POST 요청을 수행합니다.

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

다음을 바꿉니다.

• VM_NAME: 다시 시작할 VM의 이름

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

암호화된 디스크를 사용하는 VM 다시 시작

고객 제공 암호화 키를 사용하는 중지된 VM을 다시 시작하여 VM에 연결된 영구 디스크를 암호화할 수 있습니다.

콘솔

암호화된 디스크를 사용하는 VM을 다시 시작하려면 다음을 수행합니다.

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

   VM 인스턴스로 이동

2. 다시 시작할 VM을 선택합니다.

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

4. 이 VM에 연결된 각 암호화된 디스크에 대한 암호화 키를 지정한 다음 시작을 클릭합니다.

gcloud

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

gcloud compute instances start VM_NAME \
    --csek-key-file=ENCRYPTION_KEY_FILE \
    --project=PROJECT_ID \
    --zone=ZONE

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• ENCRYPTION_KEY_FILE: 고객 제공 암호화 키가 포함된 JSON 파일의 상대 경로입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

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: %w", 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: %w", 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: %w", err)
	}

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

	fmt.Fprintf(w, "Instance with encryption key started\n")

	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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartEncryptedInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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, 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()) {

      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(3, TimeUnit.MINUTES);

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

}

Node.js

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

PHP

compute/instances/src/start_instance_with_encryption_key.php

GitHub에서 보기 의견 보내기

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\CustomerEncryptionKey;
use Google\Cloud\Compute\V1\CustomerEncryptionKeyProtectedDisk;
use Google\Cloud\Compute\V1\GetInstanceRequest;
use Google\Cloud\Compute\V1\InstancesStartWithEncryptionKeyRequest;
use Google\Cloud\Compute\V1\StartWithEncryptionKeyInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with encrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
 * @param string $key Bytes object representing a raw base64 encoded key to your instance's boot disk.
 *                    For more information about disk encryption see:
 *                    https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance_with_encryption_key(
    string $projectId,
    string $zone,
    string $instanceName,
    string $key
) {
    // Initiate the InstancesClient.
    $instancesClient = new InstancesClient();

    // Get data about the instance.
    $request = (new GetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $instanceData = $instancesClient->get($request);

    // Use `setRawKey` to send over the key to unlock the disk
    // To use a key stored in KMS, you need to use `setKmsKeyName` and `setKmsKeyServiceAccount`
    $customerEncryptionKey = (new CustomerEncryptionKey())
        ->setRawKey($key);

    /** @var \Google\Cloud\Compute\V1\AttachedDisk */
    $disk = $instanceData->getDisks()[0];

    // Prepare the information about disk encryption.
    $diskData = (new CustomerEncryptionKeyProtectedDisk())
        ->setSource($disk->getSource())
        ->setDiskEncryptionKey($customerEncryptionKey);

    // Set request with one disk.
    $instancesStartWithEncryptionKeyRequest = (new InstancesStartWithEncryptionKeyRequest())
        ->setDisks(array($diskData));

    // Start the instance with encrypted disk.
    $request2 = (new StartWithEncryptionKeyInstanceRequest())
        ->setInstance($instanceName)
        ->setInstancesStartWithEncryptionKeyRequestResource($instancesStartWithEncryptionKeyRequest)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->startWithEncryptionKey($request2);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s started successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Starting instance failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/start_encrypted.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 start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
) -> None:
    """
    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()

    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]

    operation = instance_client.start_with_encryption_key(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    wait_for_extended_operation(operation, "instance start (with encrypted disk)")

REST

암호화된 디스크를 사용하는 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이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

• VM_NAME: VM의 이름입니다.

• DISK_URL: 고객 제공 암호화 키로 암호화된 연결 디스크의 전체 리소스 이름에 해당하는 리소스 URL입니다.

• ENCRYPTION_TYPE: 사용 중인 디스크 암호화 유형이며 다음 rawKey, kmsKeyName, rsaEncryptedKey 중 하나일 수 있습니다. rsaEncryptedKey 유형을 사용하는 경우 v1 API 대신 베타 API에 POST 요청을 수행해야 합니다.

• ENCRYPTION_KEY: VM에 연결된 영구 디스크를 암호화하는 데 사용되는 암호화 키입니다. rawKey 또는 rsaEncryptedKey 키는 base64로 인코딩되어야 합니다. 또한 rsaEncryptedKey 키를 준비하려면 RSA 키 래핑을 참조하세요.

VM 재설정

실행 중인 VM 재설정은 재설정 버튼을 누르거나 전원 버튼을 길게 눌러 컴퓨터의 초기화를 수행하는 것과 유사합니다. VM을 재설정할 때 VM에 게스트 OS를 완전히 종료하기 위한 시간이 부여되지 않습니다. 이로 인해 디스크의 파일 시스템이 손상될 수 있습니다. Google Cloud는 게스트 OS가 비정상 종료되어 다른 옵션이 없는 경우에만 VM을 재설정하는 것이 좋습니다. VM을 다시 초기화하고 완전 종료를 수행하려면 이 문서의 VM 재부팅을 참조하세요.

VM을 재설정하면 다음과 같은 결과가 발생합니다.

• VM은 원래의 메타데이터, 이미지, 영구 디스크를 사용하여 초기 부팅 상태로 다시 초기화됩니다.

• 데이터를 백업하지 않으면 VM에서 머신의 메모리 콘텐츠를 강제로 삭제합니다.

• 이 프로세스 동안 VM 상태는 RUNNING으로 유지됩니다.

VM을 재설정해도 VM 속성은 변경되지 않습니다. VM은 임시 IP, 고정 외부 IP, 영구 디스크, 로컬 SSD 디스크(있는 경우), 머신 유형을 유지합니다.

콘솔

실행 중인 VM을 1개 이상 재설정하려면 다음을 수행합니다.

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

   VM 인스턴스로 이동

2. 재설정할 VM을 선택합니다.

3. 재설정을 클릭한 후 재설정을 다시 클릭합니다.

gcloud

실행 중인 VM을 재설정하려면 gcloud compute instances reset 명령어를 사용합니다.

gcloud compute instances reset VM_NAME \
    --project=PROJECT_ID \
    --zone=ZONE

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: 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 running 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: %w", 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: %w", err)
	}

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

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

	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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ResetInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 running Google Compute Engine instance (with unencrypted disks).
  public static void resetInstance(String project, String zone, String instanceName)
      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()) {

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

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

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

}

Node.js

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

PHP

compute/instances/src/reset_instance.php

GitHub에서 보기 의견 보내기

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\ResetInstanceRequest;

/**
 * Reset a running Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to reset.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function reset_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->reset($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s reset successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to reset instance: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

compute/client_library/snippets/instances/reset.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 reset_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    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()

    operation = instance_client.reset(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "instance reset")

REST

실행 중인 VM을 재설정하려면 instances.reset 메서드에 POST 요청을 수행합니다.

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

다음을 바꿉니다.

• VM_NAME: VM의 이름입니다.

• PROJECT_ID: VM이 있는 프로젝트의 ID

• ZONE: VM이 있는 영역입니다.

VM 재부팅

게스트 OS 내에서 VM을 재부팅하면 다음과 같은 결과가 발생합니다.

• VM은 원래의 메타데이터, 이미지, 영구 디스크를 사용하여 초기 부팅 상태로 다시 초기화됩니다.

• 데이터를 백업하지 않으면 VM에서 머신의 메모리 콘텐츠를 완전 삭제합니다.

• 이 프로세스 동안 VM 상태는 RUNNING으로 유지됩니다.

VM을 재설정하는 것과 비교하여 게스트 OS 내에서 VM을 재부팅하면 ACPI 종료 신호를 VM에 보내기 전에 VM이 실행 중인 모든 태스크를 완료할 때까지 기다립니다. 이렇게 하면 VM이 완전 종료를 수행할 수 있습니다.

VM을 재부팅해도 VM 속성은 변경되지 않습니다. VM은 임시 IP, 고정 외부 IP, 영구 디스크, 로컬 SSD 디스크(있는 경우), 머신 유형을 유지합니다.

Linux

Linux VM을 재설정하려면 다음 명령어를 실행하여 게스트 OS를 재부팅합니다.

sudo reboot

Windows

Windows VM을 재설정하려면 다음 명령어를 실행하여 게스트 OS를 재부팅합니다.

shutdown /r /t 0

선택적으로 VM 종료 및 다시 시작 프로세스를 모니터링하려면 Windows 부팅 관리자 메뉴를 사용 설정합니다.

청구

VM이 중지되고 Compute Engine이 상태를 TERMINATED로 설정하면 CPU 사용에 대한 요금이 더 이상 발생하지 않습니다. 그러나 영구 디스크 및 외부 IP 주소와 같이 VM에 연결된 리소스에 대해서는 요금이 계속 발생합니다.

VM에 연결된 리소스에 대한 요금이 청구되지 않도록 하려면 다음 중 하나를 수행합니다.

• 중지된 VM에서 해당 리소스를 분리합니다.

• VM을 삭제합니다. 이 작업을 수행하면 VM에 연결된 모든 리소스도 삭제됩니다.

다음 단계

• VM 자동 시작 및 중지 일정 예약 방법 알아보기

• VM 런타임 제한 방법 알아보기

• VM이 예기치 않게 종료된 후 다음 중 하나를 수행하여 문제를 해결하는 방법에 대해 알아봅니다.

  • VM 종료 및 재부팅 문제 해결

  • 대화형 직렬 콘솔을 사용하여 VM 문제 해결

• VM에서 머신 유형을 변경하는 방법 알아보기