停止或重新啟動 Compute Engine 執行個體

Linux Windows

本文說明如何停止或重新啟動 Compute Engine 執行個體。如要進一步瞭解如何暫停、停止或重設執行個體，請參閱「暫停、停止或重設 Compute Engine 執行個體」。

如果您不再使用執行個體，或要修改執行個體的屬性 (例如變更機器類型，或移除任何已附加及掛接的磁碟)，停止執行個體就很有用。停止執行個體後，您可以執行下列操作：

• 重新啟動即可繼續執行工作負載。

• 如果不再需要，請刪除。

如要自動停止或重新啟動執行個體，請改為參閱下列文章：

• 排定 VM 執行個體的啟動與停止時間

• 限制 VM 的執行時間

事前準備

• 如果尚未設定驗證，請先完成設定。 驗證可確認您的身分，以便存取 Google Cloud 服務和 API。如要從本機開發環境執行程式碼或範例，可以選取下列任一選項，向 Compute Engine 進行驗證：

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. 安裝 Google Cloud CLI。 完成後，執行下列指令來初始化 Google Cloud CLI：

     gcloud init

     若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

     注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。
  2. Set a default region and zone.

  Go

  如要在本機開發環境中使用本頁面的 Go 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  詳情請參閱 Set up authentication for a local development environment。

  Java

  如要在本機開發環境中使用本頁面的 Java 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  詳情請參閱 Set up authentication for a local development environment。

  Node.js

  如要在本機開發環境中使用本頁面的 Node.js 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  詳情請參閱 Set up authentication for a local development environment。

  PHP

  如要在本機開發環境中使用本頁面的 PHP 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  詳情請參閱 Set up authentication for a local development environment。

  Python

  如要在本機開發環境中使用本頁面的 Python 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  詳情請參閱 Set up authentication for a local development environment。

  REST

  如要在本機開發環境中使用本頁的 REST API 範例，請使用您提供給 gcloud CLI 的憑證。

  安裝 Google Cloud CLI。

  若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

  注意：如果您先前已安裝 gcloud CLI，請執行 gcloud components update，確認目前使用的是最新版本。

  詳情請參閱 Google Cloud 驗證說明文件中的「使用 REST 進行驗證」。

必要的角色

如要取得停止或重新啟動 Compute 執行個體所需的權限，請要求管理員在專案中授予 Compute 執行個體管理員 (v1) (roles/compute.instanceAdmin.v1) IAM 角色。如要進一步瞭解如何授予角色，請參閱「管理專案、資料夾和組織的存取權」。

這個預先定義的角色具備停止或重新啟動運算執行個體所需的權限。如要查看確切的必要權限，請展開「Required permissions」(必要權限) 部分：

所需權限

如要停止或重新啟動運算執行個體，您必須具備下列權限：

• 如要停止執行個體，請執行下列操作： compute.instances.stop 執行個體
• 如要從客層 OS 停止執行個體： compute.instances.setMetadata (如果執行個體使用執行個體層級公開 SSH 金鑰)。
• 如要重新啟動執行個體，請按照下列指示操作： compute.instances.start 執行個體
• 如要重新啟動使用加密金鑰的執行個體： compute.instances.startWithEncryptionKey 在執行個體上

您或許還可透過自訂角色或其他預先定義的角色取得這些權限。

停止執行個體

停止運算執行個體時，或 Compute Engine 因排定動作而停止執行個體時，執行個體會保留附加資源、設定、內部 IP 位址、MAC 位址和中繼資料。不過，執行個體會遺失記憶體內資料和應用程式狀態。如要保留這些狀態，請改為暫停執行個體。

重要事項： 停止執行個體後，系統仍會繼續收取附加資源的費用。為避免產生不必要的費用，請卸離並刪除不再需要的資源。

您可以透過下列方法停止執行個體，具體取決於執行個體是否已連接本機 SSD 磁碟，以及您要如何處理任何關機指令碼：

• 停止沒有本機 SSD 磁碟的執行個體

  您可以同時停止一或多個未連接任何本機 SSD 磁碟的執行個體。執行個體中的所有關機指令碼都必須在預設關機期限內完成執行。

• 停止具有本機 SSD 磁碟的執行個體

  同時停止一或多個附加本機 SSD 磁碟的執行個體時，您可以選擇捨棄或保留 (預先發布) 這些磁碟上的資料。執行個體中的任何關機指令碼都必須在預設關機期限內完成執行。

• 從訪客 OS 停止執行個體

  這個方法可讓您在關閉指令碼執行完畢後停止單一執行個體，或在啟用安全關機後停止執行個體 (不安全關機)，或結束進行中的安全關機程序。除非您手動將任何已連結本機 SSD 磁碟的資料備份到持久儲存空間磁碟區，否則從客層 OS 停止執行個體時，這些磁碟上的所有資料都會遭到捨棄。

停止沒有本機 SSD 硬碟的執行個體

視停止執行個體時要執行的操作而定，請使用下列選項：

• 如果您已在執行個體中啟用正常關機，可以使用 Google Cloud 主控台、gcloud CLI 或 REST API 停止執行個體，不必正常關機，也可以結束進行中的正常關機程序。

• 如要同時停止多個執行個體，請使用 Google Cloud 控制台，或針對位於相同區域的執行個體使用 gcloud CLI。

如要停止一或多個執行個體，請選取下列其中一個選項：

控制台

1. 前往 Google Cloud 控制台的「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 選取要停止的執行個體。

3. 按一下 「停止」。如果沒有「停止」選項，請依序點選 「更多動作」> 「停止」。

4. 在對話方塊中執行下列操作：

   1. 選用：如要停止執行個體，但不正常關閉執行個體，或結束進行中的正常關機程序，請選取「Skip graceful shutdown (if applicable)」(略過正常關機程序 (如適用)) 核取方塊。

   2. 按一下「停止」確認操作。

gcloud

如要停止同一區域中的一或多個執行個體，請使用 gcloud compute instances stop 指令：

gcloud compute instances stop INSTANCE_NAMES \
    --zone=ZONE

更改下列內容：

• INSTANCE_NAMES：以空格分隔的執行個體名稱清單，例如 instance-01 instance-02 instance-03。

• ZONE：執行個體所在的可用區。

(選用) 如果您在一或多個執行個體中啟用安全關機，則可以停止執行個體，而不安全關機，或手動結束進行中的安全關機。做法是使用加上 --no-graceful-shutdown 旗標的 gcloud beta compute instances stop 指令：

預先發布版 — The --no-graceful-shutdown flag

這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

gcloud beta compute instances stop INSTANCE_NAMES \
    --no-graceful-shutdown \
    --zone=ZONE

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// 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
}

Java

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

/**
 * 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

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

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

如要停止執行個體，請對 instances.stop 方法發出 POST 要求：

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

更改下列內容：

• INSTANCE_NAME：執行個體的名稱。

• PROJECT_ID：執行個體所在的專案 ID。

• ZONE：執行個體所在的區域。

如果已在執行個體中啟用安全關機功能，您可以停止執行個體，不必安全關機，也可以手動結束進行中的安全關機程序。如要這麼做，請對 instances.stop 方法發出 POST 要求。在要求網址中加入 noGracefulShutdown=true 查詢參數：

預先發布版 — The noGracefulShutdown query parameter

這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?noGracefulShutdown=true

停止具有本機 SSD 磁碟的執行個體

視您想在停止運算執行個體時執行的操作而定，請使用下列選項：

• 如果您已在執行個體中啟用正常關機，則可以使用 Google Cloud 主控台、gcloud CLI 或 REST API 停止執行個體，不必正常關機，也可以結束進行中的正常關機程序。

• 如要保留連結至執行個體的本機 SSD 磁碟資料 (使用 Titanium SSD 的機器類型除外)，請使用 gcloud CLI 或 REST API 停止執行個體。

  注意： 如果您選擇保留本機 SSD 資料，Compute Engine 會在執行個體停止時，將本機 SSD 資料儲存在耐用儲存空間中。因此，請務必先確認您有足夠的磁碟配額來儲存本機 SSD 資料，再停止執行個體。

• 如要同時停止多個執行個體，請使用 Google Cloud 控制台，或針對位於相同區域的執行個體使用 gcloud CLI。

如要停止一或多個已連結本機 SSD 磁碟的執行個體，請選取下列其中一個選項：

控制台

1. 前往 Google Cloud 控制台的「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 選取要停止的執行個體。

3. 按一下 「停止」。如果沒有「停止」選項，請依序點選 「更多動作」> 「停止」。

4. 在對話方塊中執行下列操作：

   1. 選用：如要停止執行個體，但不正常關閉執行個體，或結束進行中的正常關機程序，請選取「Skip graceful shutdown (if applicable)」(略過正常關機程序 (如適用)) 核取方塊。

   2. 按一下「停止」確認操作。

gcloud

停止同一區域中一或多個已連結本機 SSD 磁碟的執行個體時，請指定是否要捨棄或保留本機 SSD 資料，方法如下：

• 如要捨棄本機 SSD 資料，請使用 gcloud compute instances stop 指令並加上 --discard-local-ssd=true 旗標：

  gcloud compute instances stop INSTANCE_NAMES \
      --discard-local-ssd=true \
      --zone=ZONE
  

• 如要保留本機 SSD 資料，請搭配 --discard-local-ssd=false 旗標使用 gcloud beta compute instances stop 指令：

  預先發布版 — The --discard-local-ssd=false flag

  這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

  gcloud beta compute instances stop INSTANCE_NAMES \
      --discard-local-ssd=false \
      --zone=ZONE
  

更改下列內容：

• INSTANCE_NAMES：以空格分隔的執行個體名稱清單，例如 instance-01 instance-02 instance-03。

• ZONE：執行個體所在的可用區。

如果在一或多個執行個體中啟用安全關機，您可以停止執行個體，而不安全關機，也可以結束進行中的安全關機。做法是使用加上 --no-graceful-shutdown 旗標的 gcloud beta compute instances stop 指令：

預先發布版 — The --no-graceful-shutdown flag

這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=DISCARD_LOCAL_SSD \
    --no-graceful-shutdown \
    --zone=ZONE

請將 DISCARD_LOCAL_SSD 換成 true，捨棄本機 SSD 磁碟中的資料，或換成 false，保留資料。

REST

停止已連結本機 SSD 磁碟的執行個體時，請指定是否要捨棄或保留本機 SSD 資料，方法如下：

• 如要捨棄本機 SSD 資料，請對 instances.stop 方法發出 POST 要求。在要求網址中，加入設為 true 的 discardLocalSsd 查詢參數：

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=true
  

• 如要保留本機 SSD 資料，請對 beta.instances.stop 方法發出 POST 要求。在要求網址中，加入設為 false 的 discardLocalSsd 查詢參數：

  預先發布版 — The discardLocalSsd=false query parameter

  這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

  POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=false
  

更改下列內容：

• PROJECT_ID：執行個體所在的專案 ID。

• ZONE：執行個體所在的區域。

• INSTANCE_NAME：執行個體的名稱。

如果已在執行個體中啟用安全關機功能，您可以選擇停止執行個體，而不安全關機，也可以手動結束進行中的安全關機程序。如要這麼做，請對 instances.stop 方法發出 POST 要求。在要求網址中加入 noGracefulShutdown=true 查詢參數：

預先發布版 — The noGracefulShutdown query parameter

這項功能 適用《服務專屬條款》。 正式發布前的功能是按照「原樣」提供，支援範圍可能有限。 詳情請參閱推出階段說明。

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?discardLocalSsd=DISCARD_LOCAL_SSD&noGracefulShutdown=true

請將 DISCARD_LOCAL_SSD 換成 true，捨棄本機 SSD 磁碟中的資料，或換成 false，保留資料。

從客體 OS 停止執行個體

如果運算執行個體已連結本機 SSD 磁碟，關閉訪客 OS 時，系統會自動捨棄本機 SSD 資料。如要保留這項資料，請在停止執行個體前，手動將資料複製到永久儲存空間選項。

如要從客層 OS 停止執行個體，請選取下列任一選項：

Linux

1. 如果尚未連線，請連線至執行個體。

2. 如要停止執行個體，請選取下列其中一種方法：

   • 如要執行乾淨關機作業，讓執行個體在關閉客體 OS 前執行關機指令碼，請執行下列指令：

     sudo shutdown -h now
     

   • 否則，如要強制關機，請執行下列指令：

     sudo poweroff
     

Windows

1. 如果尚未連線至執行個體，請使用下列其中一種方法：

   • PowerShell

   • 遠端桌面通訊協定 (RDP)

   • Secure Shell (SSH)

   • 特殊管理控制台 (SAC)

2. 如要停止執行個體，請選取下列其中一種方法：

   • 如要乾淨地停止執行個體，並讓執行個體在關閉客體 OS 前執行關機指令碼，請執行下列指令：

     shutdown /s
     

   • 如要強制關機，請執行下列指令：

     shutdown /f
     

重新啟動執行個體

您可以重新啟動已完全停止的運算執行個體 (執行個體狀態為 TERMINATED)。

如果您在停止執行個體時選擇保留本機 SSD 磁碟的資料，則可能需要在重新啟動執行個體後重新掛接本機 SSD 磁碟。如要進一步瞭解如何掛接本機 SSD 磁碟，請參閱「格式化並掛接本機 SSD 裝置」。

如要重新啟動執行個體，請根據執行個體是否已連結加密磁碟，使用下列其中一種方法：

• 如果執行個體未附加加密磁碟，請參閱重新啟動未附加加密磁碟的執行個體。

• 否則，請參閱「重新啟動具有加密磁碟的執行個體」。

重新啟動沒有加密磁碟的執行個體

如要同時重新啟動不同區域的多個執行個體，請使用Google Cloud 控制台。如要移動位於同一區域的執行個體，可以使用 gcloud CLI。否則，如要處理其他重新啟動情況，請選取下列任一選項：

控制台

1. 前往 Google Cloud 控制台的「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 選取一或多個執行個體。

3. 按一下「啟動 / 繼續」圖示 。

gcloud

如要重新啟動同一區域中的一或多個執行個體，請使用 gcloud compute instances start 指令：

gcloud compute instances start INSTANCE_NAMES \
    --zone=ZONE

更改下列內容：

• INSTANCE_NAMES：以空格分隔的執行個體名稱清單，例如 instance-01 instance-02 instance-03。

• ZONE：執行個體所在的可用區。

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// 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
}

Java

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

/**
 * 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

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

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

如要重新啟動執行個體，請對 instances.start 方法發出 POST 要求：

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

更改下列內容：

• INSTANCE_NAME：要重新啟動的執行個體名稱。

• PROJECT_ID：執行個體所在的專案 ID。

• ZONE：執行個體所在的區域。

重新啟動具有加密磁碟的執行個體

重新啟動已停止的運算執行個體時，如果該執行個體已連結使用客戶提供的加密金鑰加密的磁碟，您必須提供加密金鑰資訊。

如要同時重新啟動不同區域的多個執行個體，請使用Google Cloud 控制台。如要移動位於同一區域的執行個體，可以使用 gcloud CLI。否則，如要處理其他重新啟動情況，請選取下列任一選項：

控制台

1. 前往 Google Cloud 控制台的「VM instances」(VM 執行個體) 頁面。

   前往 VM 執行個體

2. 選取要重新啟動的執行個體。

3. 按一下「啟動 / 繼續」圖示 。

4. 為連接到執行個體的每個加密磁碟指定加密金鑰，然後按一下「啟動」。

gcloud

如要重新啟動同一區域中一或多個使用加密磁碟的執行個體，請使用 gcloud compute instances start 指令，並加上 --csek-key-file 旗標。如果您使用的是 RSA 包裝金鑰，請改用 gcloud beta compute instances start 指令並加上 --csek-key-file 標記：

gcloud compute instances start INSTANCE_NAMES \
    --csek-key-file=ENCRYPTION_KEY_FILE \
    --zone=ZONE

更改下列內容：

• INSTANCE_NAMES：以空格分隔的執行個體名稱清單，例如 instance-01 instance-02 instance-03。

• ENCRYPTION_KEY_FILE：包含客戶提供加密金鑰的 JSON 檔案相對路徑。只有在執行個體使用相同的客戶提供加密金鑰時，才能同時重新啟動多個執行個體。

• ZONE：執行個體所在的可用區。

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"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
}

Java

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

/**
 * 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

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

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

如要重新啟動使用加密磁碟的執行個體，請對 instances.startWithEncryptionKey 方法發出 POST 要求：

POST  https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/startWithEncryptionKey

{
  "disks": [
    {
      "source": "DISK_URL",
      "diskEncryptionKey": {
        "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
      }
    }
  ]
}

更改下列內容：

• PROJECT_ID：執行個體所在的專案 ID。

• ZONE：執行個體所在的區域。

• INSTANCE_NAME：執行個體的名稱。

• DISK_URL：資源網址，對應於已連接磁碟的完整資源名稱，該磁碟已使用客戶提供的加密金鑰加密。

• ENCRYPTION_TYPE：您使用的磁碟加密類型，可以是下列其中一種：rawKey、kmsKeyName 或 rsaEncryptedKey。如果您使用 rsaEncryptedKey 型別，請對 beta.instances.startWithEncryptionKey 方法發出 POST 要求。

• ENCRYPTION_KEY：用來加密連結至執行個體的永久磁碟的加密金鑰。rawKey 或 rsaEncryptedKey 金鑰必須採用 base64 編碼。此外，如要準備 rsaEncryptedKey 金鑰，請參閱「RSA 金鑰包裝」。

後續步驟

• 排解 VM 關機和重新啟動的問題

• 使用序列埠主控台排解問題

• 編輯運算執行個體的機器類型

• 刪除 Compute Engine 執行個體