暂停或恢复 Compute Engine 实例

Linux Windows

---

本文档说明如何暂停或恢复 Compute Engine 实例。如需详细了解如何暂停、停止或重置实例，请参阅暂停、停止或重置 Compute Engine 实例。

如果您希望保留 Compute Engine 实例，但不想在未使用实例时产生费用，则可以暂停实例。暂停实例会保留实例，并将实例内存中的内容迁移到存储空间。恢复实例后，Compute Engine 会将实例内存从存储空间迁移回实例，然后实例会重新开始运行。

暂停 Compute Engine 实例适用于以下情况：

• 在关停期间（例如晚上或周末）未充分使用的开发和测试环境，您希望保留这些环境，以节省费用或者实现比创建新实例更快的初始化速度。

• 在实例启动完成后、准备处理第一个请求之前需要进行长时间初始化的应用，例如虚拟开发者工作站或复杂的 Java 应用。

准备工作

• 如果您尚未设置身份验证，请进行设置。身份验证是通过其进行身份验证以访问 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. Install the Google Cloud CLI, then initialize it by running the following command:

     gcloud init

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Go

  如需在本地开发环境中使用本页面上的 Go 示例，请安装并初始化 gcloud CLI，然后使用您的用户凭据设置应用默认凭据。

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  如需了解详情，请参阅 Set up authentication for a local development environment。 如需了解详情，请参阅身份验证文档中的为本地开发环境设置 ADC。

  Java

  如需在本地开发环境中使用本页面上的 Java 示例，请安装并初始化 gcloud CLI，然后使用您的用户凭据设置应用默认凭据。

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  如需了解详情，请参阅 Set up authentication for a local development environment。 如需了解详情，请参阅身份验证文档中的为本地开发环境设置 ADC。

  Node.js

  如需在本地开发环境中使用本页面上的 Node.js 示例，请安装并初始化 gcloud CLI，然后使用您的用户凭据设置应用默认凭据。

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  如需了解详情，请参阅 Set up authentication for a local development environment。 如需了解详情，请参阅身份验证文档中的为本地开发环境设置 ADC。

  PHP

  如需在本地开发环境中使用本页面上的 PHP 示例，请安装并初始化 gcloud CLI，然后使用您的用户凭据设置应用默认凭据。

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  如需了解详情，请参阅 Set up authentication for a local development environment。

  Python

  如需在本地开发环境中使用本页面上的 Python 示例，请安装并初始化 gcloud CLI，然后使用您的用户凭据设置应用默认凭据。

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  如需了解详情，请参阅 Set up authentication for a local development environment。 如需了解详情，请参阅身份验证文档中的为本地开发环境设置 ADC。

  REST

  如需在本地开发环境中使用本页面上的 REST API 示例，请使用您提供给 gcloud CLI 的凭据。

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

  如需了解详情，请参阅 Google Cloud 身份验证文档中的使用 REST 时进行身份验证。

所需的角色

如需获得暂停或恢复计算实例所需的权限，请让管理员为您授予实例的 Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) IAM 角色。如需详细了解如何授予角色，请参阅管理对项目、文件夹和组织的访问权限。

此预定义角色包含暂停或恢复计算实例所需的权限。如需查看所需的确切权限，请展开所需权限部分：

所需权限

您需要具备以下权限才能暂停或恢复计算实例：

• 暂停实例：compute.instances.suspend
• 恢复实例：compute.instances.resume

您也可以使用自定义角色或其他预定义角色来获取这些权限。

限制

暂停计算实例时，需要遵守以下限制：

• 只有在客户机操作系统支持的情况下，您才能暂停实例。如需了解详情，请参阅操作系统详细信息。

• 只有在暂停实例之前配置操作系统的情况下，您才能暂停使用 Debian 8 或 9 作为客户机操作系统的实例。

• 在 Compute Engine 自动将其状态转换为 TERMINATED 之前，您最多只能将实例暂停 60 天。

• 您可以暂停 Spot 虚拟机或抢占式实例，但如果 Compute Engine 在暂停操作完成之前抢占实例，Compute Engine 会结束暂停操作并抢占实例。

• 您无法暂停挂接了 GPU 的实例。

• 您无法暂停裸金属实例。

• 您无法暂停机密虚拟机。

• 您无法使用客户机环境中内置的标准过程暂停实例。不支持 Ubuntu 16.04 或更高版本中的 systemctl suspend 等命令。如果调用这些命令，Compute Engine 会忽略客户机内信号。

• 您无法暂停内存超过 208 GB 的实例。

• 您无法暂停挂接了受 CSEK 保护的磁盘的实例。

在 Debian 8 或 9 中启用暂停操作

如果计算实例运行 Debian 8 和 9 作为其客户机操作系统，则在暂停实例之前，您必须通过执行以下操作之一来启用暂停和恢复操作：

• 建议：配置 ACPID

• 安装 D-Bus

配置 ACPID

如需在 Debian 8 或 9 中启用暂停和恢复操作，您可以将高级配置和电源接口事件守护程序 (ACPID) 配置为处理睡眠按钮事件。启用深度睡眠按钮事件后，您可以添加用于处理睡眠事件的 Shell 脚本，如本部分所述。

如需将 ACPID 配置为支持暂停和恢复操作，请执行以下操作：

1. 如果您尚未连接到 Linux 实例，请先连接。

2. 在 acpi 文件夹中创建 events 文件夹：

   sudo mkdir -p /etc/acpi/events/
   

3. 将 ACPID 配置为处理睡眠按钮事件：

   cat <<EOF | sudo tee /etc/acpi/events/sleepbtn-acpi-support
   event=button[ /]sleep
   action=/etc/acpi/sleepbtn-acpi-support.sh
   EOF
   

4. 创建休眠事件处理脚本：

   cat <<EOF | sudo tee /etc/acpi/sleepbtn-acpi-support.sh
   #!/bin/sh
   echo mem > /sys/power/state
   EOF
   

5. 设置脚本的权限：

   sudo chmod 755 /etc/acpi/sleepbtn-acpi-support.sh
   

6. 如需使更改生效，请重启 ACPID：

   sudo systemctl restart acpid.service
   

安装 D-Bus

如需在 Debian 8 或 9 中启用暂停和恢复操作，您可以安装 D-Bus。

如需在计算实例的客户机操作系统（使用 Debian 8 或 9 时）中安装 D-Bus，请执行以下操作：

1. 如果您尚未连接到 Linux 实例，请先连接。

2. 安装 D-Bus：

   sudo apt-get install dbus
   

3. 如需使更改生效，请重启 logind：

   sudo systemctl restart systemd-logind.service
   

暂停实例

如果计算实例的客户机操作系统使用的是 Debian 8 或 9，则在暂停实例之前，您必须按照文档中所述配置客户机操作系统，以支持暂停和恢复操作。

如需暂停实例，请根据实例是否挂接了本地 SSD 磁盘，使用以下方法之一：

• 如果您的实例没有挂接任何本地 SSD 磁盘，请参阅暂停没有本地 SSD 磁盘的实例。

• 如果您的实例挂接了任何本地 SSD 磁盘，并且您要舍弃或保留（预览版）磁盘的本地 SSD 数据，请参阅暂停具有本地 SSD 磁盘的实例。

暂停没有本地 SSD 磁盘的实例

您可以同时暂停多个计算实例或单个实例。对于多个实例，请使用 Google Cloud 控制台；对于位于同一可用区中的实例，请使用 Google Cloud CLI。对于单个实例，请选择以下任一选项：

控制台

1. 在 Google Cloud 控制台中，前往虚拟机实例页面。

   进入“虚拟机实例”

2. 选择一个或多个要暂停的实例。

3. 点击 暂停，然后点击暂停进行确认。

gcloud

如需暂停单个可用区中的一个或多个实例，请使用 gcloud compute instances suspend 命令：

gcloud compute instances suspend 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"
)

// suspendInstance suspends a running Google Compute Engine instance.
func suspendInstance(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.SuspendInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Suspend(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to suspend 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 suspended\n")

	return nil
}

Java

import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SuspendInstance {

  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 suspend.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    suspendInstance(project, zone, instanceName);
  }

  // Suspend a running Google Compute Engine instance.
  // For limitations and compatibility on which instances can be suspended,
  // see: https://cloud.google.com/compute/docs/instances/suspend-resume-instance#limitations
  public static void suspendInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Operation operation = instancesClient.suspendAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(Status.SUSPENDED.toString())) {
        System.out.println("Cannot suspend instance. Try again!");
        return;
      }

      System.out.printf("Instance suspended successfully ! %s", instanceName);
    }
  }
}

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');

// Suspends a running Google Compute Engine instance.
async function suspendInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

suspendInstance();

PHP

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

/**
 * Suspend 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 suspend.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function suspend_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Suspend the running Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new SuspendInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->suspend($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s suspended successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to suspend 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 suspend_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Suspend 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 you want to suspend.
    """
    instance_client = compute_v1.InstancesClient()

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

    wait_for_extended_operation(operation, "suspend instance")

REST

如需暂停实例，请向 instances.suspend 方法发出 POST 请求：

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

替换以下内容：

• PROJECT_ID：实例所在项目的 ID。

• ZONE：实例所在的区域。

• INSTANCE_NAME：实例的名称。

暂停具有本地 SSD 磁盘的实例

根据您要同时暂停的计算实例数量以及是否需要保留其挂接的本地 SSD 磁盘中的数据，执行以下操作：

• 如需保留挂接到实例（不包括 Z3 实例）的本地 SSD 磁盘的数据，请使用 gcloud CLI 或 REST API 暂停实例。

  注意：Compute Engine 使用永久性存储来存储您的本地 SSD 数据。在暂停实例之前，请确保您有足够的配额来满足所用存储空间的需求。否则，暂停实例将失败。如需了解详情，请参阅停止或暂停具有本地 SSD 磁盘的虚拟机。

• 如需同时暂停多个实例，请使用 Google Cloud 控制台或 gcloud CLI（对于位于同一可用区中的实例）。

如需暂停一个或多个挂接了本地 SSD 磁盘的实例，请选择以下选项之一：

控制台

1. 在 Google Cloud 控制台中，前往虚拟机实例页面。

   进入“虚拟机实例”

2. 选择一个或多个要暂停的实例。

3. 点击 暂停，然后点击暂停进行确认。

gcloud

在暂停单个可用区中挂接了本地 SSD 磁盘的一个或多个实例时，请指定是舍弃还是保留本地 SSD 数据，如下所示：

• 如需舍弃本地 SSD 数据，请使用带有 --discard-local-ssd=true 标志的 gcloud compute instances suspend 命令：

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

• 如需保留本地 SSD 数据，请使用带有 --discard-local-ssd=false 标志的 gcloud beta compute instances suspend 命令：

  Preview — The --discard-local-ssd=false flag

  This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

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

替换以下内容：

• INSTANCE_NAMES：以空格分隔的实例名称列表，例如 instance-01 instance-02 instance-03。

• ZONE：实例所在的可用区。

REST

暂停挂接了本地 SSD 磁盘的实例时，请指定是舍弃还是保留本地 SSD 数据，如下所示：

• 如需舍弃本地 SSD 数据，请向 instances.suspend 方法发出 POST 请求。在请求网址中添加 discardLocalSsd 查询参数并设置为 true：

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

• 如需保留本地 SSD 数据，请向 beta.instances.suspend 方法发出 POST 请求。在请求网址中添加 discardLocalSsd 查询参数并设置为 false：

  Preview — The discardLocalSsd=false query parameter

  This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

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

替换以下内容：

• PROJECT_ID：实例所在项目的 ID。

• ZONE：实例所在的区域。

• INSTANCE_NAME：实例的名称。

恢复已暂停的实例

在恢复已暂停的计算实例之前，请考虑以下事项：

• 只有在实例所在的可用区中有足够的容量时，您才能恢复实例。这通常不是问题。如果您在恢复实例时遇到问题，请稍后重试。

• 如果您将本地 SSD 磁盘挂接到实例，并选择在暂停实例时保留本地 SSD 数据，则可能需要在恢复实例后重新装载本地 SSD 磁盘。如需了解详情，请参阅如何在 Linux 实例或 Windows 实例上重新装载非启动磁盘。

您可以同时恢复多个实例或单个实例。对于多个实例，请使用 Google Cloud 控制台；对于位于同一可用区中的实例，请使用 gcloud CLI。对于单个实例，请选择以下任一选项：

控制台

1. 在 Google Cloud 控制台中，前往虚拟机实例页面。

   进入“虚拟机实例”

2. 选择一个或多个要恢复的已暂停实例。

3. 点击 启动/恢复，然后点击启动。

gcloud

如需恢复单个可用区中一个或多个已暂停的实例，请使用 gcloud compute instances resume 命令：

gcloud compute instances resume 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"
)

// resumeInstance resumes a suspended Google Compute Engine instance
// (with unencrypted disks).
func resumeInstance(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()

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

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

	if instance.GetStatus() != "SUSPENDED" {
		return fmt.Errorf(
			"only suspended instances can be resumed, instance %s is in %s state",
			instanceName,
			instance.GetStatus(),
		)
	}

	resumeInstanceReq := &computepb.ResumeInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Resume(ctx, resumeInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to resume 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 resumed\n")

	return nil
}

Java

import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ResumeInstance {

  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 resume.

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resumeInstance(project, zone, instanceName);
  }

  // Resume a suspended Google Compute Engine instance (with unencrypted disks).
  // Instance state changes to RUNNING, if successfully resumed.
  public static void resumeInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      String currentInstanceState = instancesClient.get(project, zone, instanceName).getStatus();

      // Check if the instance is currently suspended.
      if (!currentInstanceState.equalsIgnoreCase(Status.SUSPENDED.toString())) {
        throw new RuntimeException(
            String.format("Only suspended instances can be resumed. Instance %s is in %s state.",
                instanceName, currentInstanceState));
      }

      Operation operation = instancesClient.resumeAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(
              Status.RUNNING.toString())) {
        System.out.println("Cannot resume instance. Try again!");
        return;
      }

      System.out.printf("Instance resumed successfully ! %s", instanceName);
    }
  }
}

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');

// Resumes a suspended Google Compute Engine instance (with unencrypted disks).
async function resumeInstance() {
  const instancesClient = new compute.InstancesClient();

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

  if (instance.status !== 'SUSPENDED') {
    throw new Error(
      'Only suspended instances can be resumed.' +
        `Instance ${instanceName} is in ${instance.status} state.`
    );
  }

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

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

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

resumeInstance();

PHP

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

/**
 * Resume a suspended 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 resume.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function resume_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Resume the suspended Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResumeInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->resume($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s resumed successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to resume 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 resume_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Resume a suspended 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 you want to resume.
    """
    instance_client = compute_v1.InstancesClient()

    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    if instance.status != compute_v1.Instance.Status.SUSPENDED.name:
        raise RuntimeError(
            f"Only suspended instances can be resumed. "
            f"Instance {instance_name} is in {instance.status} state."
        )

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

    wait_for_extended_operation(operation, "instance resumption")

REST

如需恢复已暂停的实例，请向 instances.resume 方法发出 POST 请求：

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

替换以下内容：

• INSTANCE_NAME：要恢复的已暂停实例的名称。

• PROJECT_ID：已暂停的实例所在项目的 ID。

• ZONE：已暂停的实例所在的可用区。

后续步骤

• 删除 Compute Engine 实例

• 停止或重启 Compute Engine 实例

• 排查虚拟机暂停问题