暂停或恢复 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。

  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。

  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。

  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。

  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 作为客机操作系统的实例。

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

• 您可以暂停 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. 点击 Suspend（暂停），然后点击 Suspend（暂停）进行确认。

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 磁盘的数据，请执行以下操作：

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

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

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

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

控制台

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

   转到“虚拟机实例”

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

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

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 命令：

  预览 — The --discard-local-ssd=false flag

  此功能须遵守服务专用条款的“通用服务条款”部分中的“非正式版产品条款”。 非正式版功能“按原样”提供，可能只能获得有限的支持。 如需了解详情，请参阅发布阶段说明。

  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：

  预览 — The discardLocalSsd=false query parameter

  此功能须遵守服务专用条款的“通用服务条款”部分中的“非正式版产品条款”。 非正式版功能“按原样”提供，可能只能获得有限的支持。 如需了解详情，请参阅发布阶段说明。

  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 实例

• 排查虚拟机暂停问题