使用快照进行恢复

磁盘可以是用于在计算实例上启动和运行操作系统的启动磁盘，也可以是仅供实例用于存储数据的非启动磁盘。

您可以使用快照通过以下方式备份和恢复磁盘数据：

准备工作

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

      gcloud init

      If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

    2. Set a default region and zone.

      3. Go

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

      1. Install the Google Cloud CLI.

      2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

        gcloud init

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

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

      Java

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

      1. Install the Google Cloud CLI.

      2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

        gcloud init

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

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

      Node.js

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

      1. Install the Google Cloud CLI.

      2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

        gcloud init

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

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

      Python

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

      1. Install the Google Cloud CLI.

      2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

        gcloud init

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

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

      REST

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

        After installing the Google Cloud CLI, initialize it by running the following command: 

        gcloud init

        If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

所需的角色

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

此预定义角色可提供从快照进行恢复所需的权限。如需查看所需的确切权限，请展开所需权限部分：

所需权限

使用快照进行恢复需要以下权限：

  • 通过全球范围快照（默认）创建磁盘：
    • 针对项目的 compute.disks.create 权限
    • 针对实例的 compute.instances.attachDisk 权限
    • 针对要挂接的磁盘的 compute.disks.use 权限
    • 针对项目的 compute.snapshots.useReadOnly、compute.snapshots.create 或 compute.disks.createSnapshot 权限
  • （预览版）通过区域范围快照创建磁盘：
    • 针对项目的 compute.disks.create 权限
    • 针对实例的 compute.instances.attachDisk 权限
    • 针对要挂接的磁盘的 compute.disks.use 权限
    • 针对项目的 compute.snapshots.useReadOnly 权限
  • 如需通过启动磁盘和非启动磁盘快照创建实例，您至少需要具备以下权限：
    • 针对项目的 compute.instances.create 权限
    • 快照的 compute.snapshots.useReadOnly 权限
    • 针对项目的 compute.disks.create 权限
    • 针对磁盘的 compute.disks.use 权限
    • 针对实例的 compute.instances.attachDisk 权限

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

限制

  • 新磁盘的大小至少应与快照最初的来源磁盘的大小相同。如果您创建的磁盘容量大于快照最初的来源磁盘，则必须调整该磁盘上的文件系统大小才能添加额外的磁盘可用空间。您可能需要使用其他文件系统大小调整工具，具体取决于您的操作系统和文件系统类型。如需了解详情，请参阅操作系统文档。

  • 您可以通过给定快照创建新的可用区级或区域级磁盘（每十分钟最多创建一次）。如果您想要发出大量创建磁盘快照的请求，可以在 60 分钟内最多发出 6 个请求。通过快照创建区域级磁盘时，此限制不适用。如需了解详情，请参阅快照频率限制。

通过快照创建磁盘，并可选择将其挂接到实例

如果您使用快照备份了启动磁盘或非启动磁盘，则可以根据该快照创建新磁盘。

控制台

  1. 在 Google Cloud 控制台中，前往快照页面。

    转到“快照”

  2. 找到要恢复的快照的名称。

  3. 转到磁盘页面。

    转到“磁盘”页面

  4. 点击创建新磁盘。

  5. 指定以下配置参数：

    • 磁盘的名称。
    • 磁盘的类型。
    • （可选）您可以覆盖所选的默认区域和地区。 您可以选择任何区域和地区，无论来源快照存储在什么位置。

  6. 在来源类型下方，点击快照。

  7. 选择要恢复的快照的名称。

  8. 选择新磁盘的大小（以 GB 为单位）。此数字必须等于或大于快照最初的来源磁盘大小。

  9. 点击创建以创建磁盘。

（可选）您随后可以将非启动磁盘挂接到实例。

gcloud

  1. 使用 gcloud compute snapshots list 命令查找要恢复的快照的名称：

    gcloud compute snapshots list

  2. 使用 gcloud compute snapshots describe 命令查找要恢复的快照的大小：

    gcloud compute snapshots describe SNAPSHOT_NAME

    将 SNAPSHOT_NAME 替换为要恢复的快照的名称。

  3. 使用 gcloud compute disks create 命令通过快照创建新的区域级或可用区级磁盘。您可以添加 --type 标志来指定要创建的磁盘类型。

    • 如需通过全球范围快照创建可用区级磁盘，请执行以下操作：
    gcloud compute disks create DISK_NAME \
    --zone=ZONE \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
    • （预览版）如需通过区域范围快照创建可用区级磁盘，请执行以下操作：
    gcloud beta compute disks create DISK_NAME \
    --zone=ZONE \
    --source-snapshot=SNAPSHOT_NAME \
    --source-snapshot-region=SOURCE_REGION \
    --type=DISK_TYPE
    • 如需通过全球范围快照创建区域级磁盘，请执行以下操作：
    gcloud beta compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE \
    --region=REGION \
    --replica-zones=ZONE1,ZONE2
    • （预览版）如需通过区域范围快照创建区域级磁盘，请执行以下操作：
    gcloud beta compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --source-snapshot-region=SOURCE_REGION \
    --type=DISK_TYPE \
    --region=REGION \
    --replica-zones=ZONE1,ZONE2

    替换以下内容：

    • DISK_NAME：新磁盘的名称
    • DISK_SIZE：新磁盘的大小（以吉比字节 [GiB] 为单位）。此数字必须等于或大于快照最初的来源磁盘大小。
    • SNAPSHOT_NAME：要恢复的快照的名称
    • DISK_TYPE：磁盘的类型，例如pd-ssd、 hyperdisk-throughput 或 hyperdisk-balanced-high-availability
    • REGION：区域级磁盘将驻留的区域，例如 europe-west1
    • SOURCE_REGION：来源快照的范围所限的区域
    • ZONE：新磁盘将驻留的可用区
    • ZONE1,ZONE2：两个磁盘副本所在区域内的可用区，例如 europe-west1-b 和 europe-west1-c

  4. 可选：使用 gcloud compute instances attach-disk 命令将新磁盘挂接到现有实例：

    gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME

    替换以下内容：

    • INSTANCE_NAME：实例的名称
    • DISK_NAME：通过快照创建的磁盘的名称

Go

Go

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Go API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

	ctx := context.Background()
	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

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

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Java

Java

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Java 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Java API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
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 CreateDiskFromSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    // For example: "zones/us-west3-b/diskTypes/pd-ssd"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      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 `disksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (DisksClient disksClient = DisksClient.create()) {

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Disk creation failed!" + response);
        return;
      }
      System.out.println("Disk created. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Node.js

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Node.js API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Disk created.');
}

createDiskFromSnapshot();

Python

Python

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Python API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

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 create_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

REST

  1. 构建对 snapshots.list 的 GET 请求，以在您的项目中显示快照列表。

    GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots

    将 PROJECT_ID 替换为您的项目 ID。

  2. 构建 POST 请求以使用相应的 disks.insert 方法创建可用区级磁盘或区域级磁盘：

    请求应包含 name、sizeGb 和 type 属性。如需使用快照恢复磁盘，您必须添加 sourceSnapshot 属性。

    • 如需通过全球范围快照创建可用区级磁盘，请执行以下操作：
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "SNAPSHOT_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "zones/ZONE/diskTypes/DISK_TYPE"
}
    • （预览版）如需通过区域范围快照创建可用区级磁盘，请执行以下操作：
    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "projects/PROJECT_ID/regions/SOURCE_REGION/snapshots/SNAPSHOT_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "projects/PROJECT_ID/zones/ZONE/diskTypes/DISK_TYPE",
  "zone": "projects/PROJECT_ID/zones/ZONE"
}
    • 如需通过全球范围快照创建区域级磁盘，请执行以下操作：
    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "SNAPSHOT_NAME",
  "region": "projects/PROJECT_ID/regions/REGION",
  "replicaZones": [
     "projects/PROJECT_ID/zones/ZONE1",
     "projects/PROJECT_ID/zones/ZONE2"
  ],
  "sizeGb": "DISK_SIZE",
  "type": "zones/ZONE/diskTypes/DISK_TYPE"
}
    • （预览版）如需通过区域范围快照创建区域级磁盘，请执行以下操作：
    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "projects/PROJECT_ID/regions/SOURCE_REGION/snapshots/SNAPSHOT_NAME",
  "replicaZones": [
     "projects/PROJECT_ID/zones/ZONE1",
     "projects/PROJECT_ID/zones/ZONE2"
  ],
  "sizeGb": "DISK_SIZE",
  "type": "projects/PROJECT_ID/regions/REGION/diskTypes/DISK_TYPE"
}

    替换以下内容：

    • PROJECT_ID：您的项目 ID
    • ZONE：您的实例和新磁盘所在的可用区
    • DISK_NAME：新磁盘的名称
    • SNAPSHOT_NAME：要恢复的磁盘的来源快照
    • REGION：区域级磁盘将驻留的区域，例如 europe-west1
    • SOURCE_REGION：来源快照的范围所限的区域
    • ZONE1 和 ZONE2：新磁盘副本应位于的可用区
    • DISK_SIZE：新磁盘的大小（以吉比字节 [GiB] 为单位）。此数字必须等于或大于快照最初的来源磁盘大小。
    • DISK_TYPE：磁盘类型的完整或部分网址，例如PROJECT_ID/zones/ZONE/diskTypes/pd-ssd、PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced 或 PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced-high-availability

  3. 可选。将新磁盘挂接到现有实例。

    构建一个对 instances.attachDisk 方法的 POST 请求，并在其中添加您刚刚通过快照创建的磁盘的网址。

    对于可用区级磁盘：

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk
{
  "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}

    对于区域级磁盘：

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk
{
  "source": "/compute/v1/projects/PROJECT_ID/regions/REGION/disks/DISK_NAME"
}

    替换以下内容：

    • PROJECT_ID：您的项目 ID
    • ZONE：您的实例和新磁盘所在的可用区
    • REGION：区域级磁盘所在的区域。此区域必须与计算实例所在的区域相同。
    • INSTANCE_NAME：您要在其中添加新磁盘的实例的名称
    • DISK_NAME：新磁盘的名称

创建新磁盘并将其挂接到实例后，您必须装载该磁盘，以便操作系统可以使用可用的存储空间。

通过现有磁盘创建实例

您可以通过快照创建启动磁盘和数据磁盘，然后将这些磁盘挂接到新的计算实例。

Go

Go

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Go API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createWithExistingDisks create a new VM instance using selected disks.
// The first disk in diskNames will be used as boot disk.
func createWithExistingDisks(
	w io.Writer,
	projectID, zone, instanceName string,
	diskNames []string,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// diskNames := []string{"boot_disk", "disk1", "disk2"}

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

	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	disks := [](*computepb.Disk){}

	for _, diskName := range diskNames {
		reqDisk := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err := disksClient.Get(ctx, reqDisk)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}

		disks = append(disks, disk)
	}

	attachedDisks := [](*computepb.AttachedDisk){}

	for _, disk := range disks {
		attachedDisk := &computepb.AttachedDisk{
			Source: proto.String(disk.GetSelfLink()),
		}
		attachedDisks = append(attachedDisks, attachedDisk)
	}

	attachedDisks[0].Boot = proto.Bool(true)

	instanceResource := &computepb.Instance{
		Name:        proto.String(instanceName),
		Disks:       attachedDisks,
		MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
		NetworkInterfaces: []*computepb.NetworkInterface{
			{
				Name: proto.String("global/networks/default"),
			},
		},
	}

	req := &computepb.InsertInstanceRequest{
		Project:          projectID,
		Zone:             zone,
		InstanceResource: instanceResource,
	}

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

	return nil
}

Java

Java

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Java 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Java API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 


import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceWithExistingDisks {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "europe-central2-b";

    // Name of the new virtual machine (VM) instance.
    String instanceName = "YOUR_INSTANCE_NAME";

    // Array of disk names to be attached to the new virtual machine.
    // First disk in this list will be used as the boot disk.
    List<String> diskNames = List.of("your-boot-disk", "another-disk1", "another-disk2");

    createInstanceWithExistingDisks(projectId, zone, instanceName, diskNames);
  }

  // Create a new VM instance using the selected disks.
  // The first disk in diskNames will be used as the boot disk.
  public static void createInstanceWithExistingDisks(String projectId, String zone,
      String instanceName, List<String> diskNames)
      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();
        DisksClient disksClient = DisksClient.create()) {

      if (diskNames.size() == 0) {
        throw new Error("At least one disk should be provided");
      }

      // Create the list of attached disks to be used in instance creation.
      List<AttachedDisk> attachedDisks = new ArrayList<>();
      for (int i = 0; i < diskNames.size(); i++) {
        String diskName = diskNames.get(i);
        Disk disk = disksClient.get(projectId, zone, diskName);
        AttachedDisk attDisk = null;

        if (i == 0) {
          // Make the first disk in the list as the boot disk.
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .setBoot(true)
              .build();
        } else {
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .build();
        }
        attachedDisks.add(attDisk);
      }

      // Create the instance.
      Instance instance = Instance.newBuilder()
          .setName(instanceName)
          // Add the attached disks to the instance.
          .addAllDisks(attachedDisks)
          .setMachineType(String.format("zones/%s/machineTypes/n1-standard-1", zone))
          .addNetworkInterfaces(
              NetworkInterface.newBuilder().setName("global/networks/default").build())
          .build();

      // Create the insert instance request.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instance)
          .build();

      // Wait for the create operation to complete.
      Operation response = instancesClient.insertAsync(insertInstanceRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed!" + response);
        return;
      }
      System.out.println("Operation Status: " + response.getStatus());

    }
  }
}

Node.js

Node.js

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Node.js API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

/**
 * 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 diskNames = ['boot_disk', 'disk1', 'disk2'];

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

async function createWithExistingDisks() {
  const instancesClient = new compute.InstancesClient();
  const disksClient = new compute.DisksClient();

  if (diskNames.length < 1) {
    throw new Error('At least one disk should be provided');
  }

  const disks = [];
  for (const diskName of diskNames) {
    const [disk] = await disksClient.get({
      project: projectId,
      zone,
      disk: diskName,
    });
    disks.push(disk);
  }

  const attachedDisks = [];

  for (const disk of disks) {
    attachedDisks.push({
      source: disk.selfLink,
    });
  }

  attachedDisks[0].boot = true;

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: attachedDisks,
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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 created.');
}

createWithExistingDisks();

Python

Python

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Python API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def get_disk(project_id: str, zone: str, disk_name: str) -> compute_v1.Disk:
    """
    Gets a disk from a project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone where the disk exists.
        disk_name: name of the disk you want to retrieve.
    """
    disk_client = compute_v1.DisksClient()
    return disk_client.get(project=project_id, zone=zone, disk=disk_name)


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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_existing_disks(
    project_id: str, zone: str, instance_name: str, disk_names: list[str]
) -> compute_v1.Instance:
    """
    Create a new VM instance using selected disks. The first disk in disk_names will
    be used as boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disk_names: list of disk names to be attached to the new virtual machine.
            First disk in this list will be used as the boot device.

    Returns:
        Instance object.
    """
    assert len(disk_names) >= 1
    disks = [get_disk(project_id, zone, disk_name) for disk_name in disk_names]
    attached_disks = []
    for disk in disks:
        adisk = compute_v1.AttachedDisk()
        adisk.source = disk.self_link
        attached_disks.append(adisk)
    attached_disks[0].boot = True
    instance = create_instance(project_id, zone, instance_name, attached_disks)
    return instance

通过启动磁盘快照创建实例

如果您创建了计算实例的启动磁盘的快照，则可以使用该快照创建新实例。

如需使用相同的启动磁盘快速创建多个实例，请创建自定义映像，然后通过该映像创建实例，而不是使用快照创建实例。

如需创建具有通过快照创建的区域级启动磁盘的计算实例，请使用 Google Cloud CLI 或 REST。

控制台

  1. 在 Google Cloud 控制台中，前往创建实例页面。

    转到“创建实例”

    如果出现提示，请选择您的项目并点击继续。 系统会显示创建实例页面，并显示机器配置窗格。

  2. 在机器配置窗格中，执行以下操作：

    1. 在名称字段中，指定实例的名称。如需了解详情，请参阅资源命名惯例。

    2. 可选：在可用区字段中，为此实例选择可用区。

      默认选择为不限。如果您不更改此默认选择，Google 会根据机器类型和可用性为您自动选择可用区。

    3. 为您的实例选择机器家族。然后， Google Cloud 控制台会显示适用于所选机器家族的机器系列。以下机器家族选项可供选择：

      • 通用
      • 计算优化
      • 内存优化
      • 存储优化
      • GPU 数量

    4. 在系列列中，选择实例的机器系列。

      如果您在上一步中选择 GPU 作为机器家族，请选择所需的 GPU 类型。然后，系统会为所选 GPU 类型自动选择机器系列。

    5. 在机器类型部分中，为实例选择机器类型。

  3. 在导航菜单中，点击操作系统和存储空间。在显示的操作系统和存储空间窗格中，执行以下操作来配置启动磁盘：

    1. 点击更改。系统会显示启动磁盘窗格，并显示公共映像标签页。
    2. 点击快照。系统会显示快照标签页。
    3. 在快照列表中，选择要使用的快照。
    4. 在启动磁盘类型列表中，选择启动磁盘的类型。
    5. 在大小 (GB) 字段中，指定启动磁盘的大小。
    6. 可选：对于高级配置选项，展开 显示高级配置部分。
    7. 如需确认您的启动磁盘选项并返回操作系统和存储空间窗格，请点击选择。

  4. 在导航菜单中，点击网络。在显示的网络窗格中，执行以下操作：

    1. 前往防火墙部分。
    2. 如需允许 HTTP 或 HTTPS 流量流向实例，请选择允许 HTTP 流量或允许 HTTPS 流量。

    Google Cloud 控制台会向您的实例中添加网络标记，并创建对应的入站流量防火墙规则，该规则允许 tcp:80 (HTTP) 或 tcp:443 (HTTPS) 上的所有传入流量。网络标记可将防火墙规则与实例相关联。如需了解详情，请参阅虚拟私有云文档中的防火墙规则概览。

  5. 可选：指定其他配置选项。如需了解详情，请参阅实例创建期间的配置选项。

  6. 要创建并启动该实例，请点击创建。

gcloud

可用区级启动磁盘

使用 gcloud compute instances create 命令并添加 --source-snapshot 标志：

   gcloud compute instances create INSTANCE_NAME  

       --source-snapshot=BOOT_SNAPSHOT_NAME  

       --boot-disk-size=BOOT_DISK_SIZE  

       --boot-disk-type=BOOT_DISK_TYPE  

       --boot-disk-device-name=BOOT_DISK_NAME

替换以下内容：

  • INSTANCE_NAME：新实例的名称
  • BOOT_SNAPSHOT_NAME：要恢复到新实例启动磁盘的启动磁盘快照的名称

  • BOOT_DISK_SIZE（可选）：新启动磁盘的大小（以 GiB 为单位）

    该大小必须等于或大于用于创建快照的来源磁盘的大小。

  • BOOT_DISK_TYPE（可选）：启动磁盘的类型，例如 PROJECT_ID/zones/ZONE/diskTypes/pd-ssd 或 PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced

  • BOOT_DISK_NAME：此实例的新启动磁盘的名称

区域级启动磁盘

使用 gcloud compute instances create 命令并在 source-snapshot、replica-zones 和 boot 属性中添加 --create-disk 标志。

  gcloud compute instances create INSTANCE_NAME 

      --zone=ZONE 

      --create-disk=^:^name=DISK_NAME:source-snapshot=BOOT_SNAPSHOT_NAME:boot=true:type=BOOT_DISK_TYPE:replica-zones=ZONE,REMOTE_ZONE

字符 ^:^ 指定使用英文冒号 : 作为各个磁盘属性之间的分隔符。这是必需的，以便您在为 replica-zones 指定可用区时可以使用英文逗号 ,。

替换以下内容：

  • INSTANCE_NAME：新实例的名称
  • ZONE：要在其中创建实例的可用区
  • DISK_NAME（可选）：磁盘的名称
  • BOOT_SNAPSHOT_NAME：要恢复到新实例启动磁盘的启动磁盘快照的名称。
  • BOOT_DISK_TYPE（可选）：启动磁盘的类型，例如 pd-ssd 或 hyperdisk-balanced-high-availability
  • REMOTE_ZONE：启动磁盘复制到的区域。replica-zones 属性需要两个可用区（以英文逗号分隔），并且其中一个可用区必须与实例的可用区相同。

Go

Go

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Go API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createInstanceFromSnapshot creates a new VM instance with boot disk created from a snapshot.
func createInstanceFromSnapshot(w io.Writer, projectID, zone, instanceName, snapshotLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// snapshotLink := "projects/project_name/global/snapshots/snapshot_name"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:     proto.Int64(11),
						SourceSnapshot: proto.String(snapshotLink),
						DiskType:       proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

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

	return nil
}

Java

Java

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Java 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Java API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param diskSnapshot disk snapshot to use when creating this disk. You must have read access to
   * this disk. This value uses the following format:
   * "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return AttachedDisk object configured to be created using the specified snapshot.
   */
  private static AttachedDisk diskFromSnapshot(String diskType, int diskSizeGb, boolean boot,
      String diskSnapshot) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceSnapshot(diskSnapshot)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with boot disk created from a snapshot.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param snapshotName link to the snapshot you want to use as the source of your boot disk in the
   * form of: "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return Instance object.
   */
  public static Instance createFromSnapshot(String project, String zone, String instanceName,
      String snapshotName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromSnapshot(diskType, 11, true, snapshotName));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

Node.js

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Node.js API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

/**
 * 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 snapshotLink = 'projects/YOUR_PROJECT/global/snapshots/YOUR_SNAPSHOT_NAME';

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

// Creates a new VM instance with boot disk created from a snapshot.
async function createInstanceFromSnapshot() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '11',
            sourceSnapshot: snapshotLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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 created.');
}

createInstanceFromSnapshot();

Python

Python

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Compute Engine Python API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。 

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def disk_from_snapshot(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_snapshot: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses a disk snapshot as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_snapshot: disk snapshot to use when creating this disk. You must have read access to this disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified snapshot.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_snapshot = source_snapshot
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk


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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_from_snapshot(
    project_id: str, zone: str, instance_name: str, snapshot_link: str
):
    """
    Create a new VM instance with boot disk created from a snapshot. The
    new boot disk will have 20 gigabytes.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        snapshot_link: link to the snapshot you want to use as the source of your
            boot disk in the form of: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_snapshot(disk_type, 20, True, snapshot_link)]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

当您使用 API 根据快照创建实例时，需要遵循以下限制：

  • 只能将一个磁盘用作启动磁盘。
  • 必须将启动磁盘作为该实例的第一个磁盘挂接。
  • 如果您指定了 source 属性，则不能同时指定 initializeParams 属性。提供 source 表示启动磁盘已存在，但 initializeParams 属性指示 Compute Engine 应创建新启动磁盘。

可用区级启动磁盘

如需通过启动磁盘快照创建实例，请使用 instances.insert 方法，并在 disks 属性下指定 sourceSnapshot 字段。您可以选择为新启动磁盘指定 diskSizeGb 和 diskType 属性。
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "INSTANCE_NAME",
  "machineType": "machineTypes/MACHINE_TYPE",
  "disks": [{
     "boot": true,
     "initializeParams": {
       "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
       "diskSizeGb": "BOOT_DISK_SIZE",
       "diskType": "BOOT_DISK_TYPE"
      }
   }],
  "networkInterfaces": [
    {
       "nicType": "GVNIC"
    }
  ]
}
替换以下内容：
  • PROJECT_ID：您的项目 ID
  • ZONE：您要在其中创建新实例的可用区
  • INSTANCE_NAME：您要将快照恢复到的实例的名称
  • MACHINE_TYPE：实例的机器类型
  • BOOT_SNAPSHOT_NAME：您要用于创建新实例启动磁盘的快照的名称

  • BOOT_DISK_SIZE（可选）：新启动磁盘的大小（以吉比字节 [GiB] 为单位）

    该大小必须等于或大于用于创建快照的来源磁盘的大小。

  • BOOT_DISK_TYPE（可选）：启动磁盘的类型，例如 PROJECT_ID/zones/ZONE/diskTypes/pd-ssd 或 PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced

区域级启动磁盘

如需在使用启动磁盘快照作为来源的情况下，创建具有区域级启动磁盘的计算实例，请使用 instances.insert 方法，并在 disks 属性中指定 sourceSnapshot 和 replicaZones 字段。 
   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
     "name": "INSTANCE_NAME",
     "disks": [
       {
         "boot": true,
         "initializeParams": {
            "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
            "replicaZones": [
                "projects/PROJECT_ID/zones/ZONE",
                "projects/PROJECT_ID/zones/REMOTE_ZONE"
              ],
            "diskType": "BOOT_DISK_TYPE"
         }
       }
     ],
     "networkInterfaces": [
       {
         "nicType": "GVNIC"
       }
     ]
   }

替换以下内容：

  • PROJECT_ID：您的项目 ID
  • ZONE：您要在其中创建实例的可用区的名称
  • INSTANCE_NAME：实例的名称
  • BOOT_SNAPSHOT_NAME：启动磁盘快照的名称
  • REMOTE_ZONE：区域级磁盘的远程可用区

  • BOOT_DISK_TYPE（可选）：启动磁盘的类型，例如 PROJECT_ID/zones/ZONE/diskTypes/pd-ssd 或 PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced-high-availability

通过非启动磁盘快照创建计算实例

如果您使用快照备份了非启动磁盘，则可以根据该快照创建具有额外非启动磁盘的实例。

控制台

从控制台将非启动快照恢复到新实例时，首根据每个快照创建一个磁盘。然后，在创建实例时，挂接新磁盘。

  1. 将每个非启动快照恢复到新磁盘。

    1. 在 Google Cloud 控制台中，前往磁盘页面。

      转到“磁盘”

    2. 点击创建磁盘。

    3. 指定磁盘的名称。如需了解详情，请参阅资源命名惯例。

    4. 选择此磁盘的区域和地区。 磁盘和实例必须位于同一可用区（对于可用区级磁盘）或同一区域（对于区域级磁盘）。

    5. 选择磁盘类型。

    6. 在来源类型下，选择快照。

    7. 在新的来源快照字段下，选择要恢复到新磁盘的非启动快照。

    8. 如需创建磁盘，请点击创建。

    重复上述步骤，通过要恢复的每个快照创建磁盘。

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

    转到虚拟机实例

  3. 选择您的项目并点击继续。

  4. 点击创建实例。

  5. 为您的实例指定名称。如需了解详情，请参阅资源命名惯例。

  6. 为此实例选择区域和地区。 磁盘和实例必须位于同一可用区（对于可用区级磁盘）或同一区域（对于区域级磁盘）。

  7. 为您的实例选择机器类型。

  8. 如果要允许传入的外部流量，请更改实例的防火墙规则。

  9. 如需将磁盘挂接到实例，请展开高级选项部分，然后执行以下操作：

    1. 展开磁盘部分。
    2. 点击挂接现有磁盘。
    3. 在磁盘列表中，选择要挂接到此实例的磁盘。
    4. 在挂接设置部分中，选择磁盘的挂接模式和删除规则。如需详细了解如何添加新磁盘，请参阅添加 Persistent Disk 或添加 Hyperdisk。
    5. 点击保存。

    针对您要挂接的每个磁盘，重复上述步骤。

  10. 要创建并启动该实例，请点击创建。

gcloud

使用 gcloud compute instances create 命令来创建实例。 对于要恢复的每个非启动快照，请添加 --create-disk 标志并指定 source-snapshot。

例如，如需将两个非启动磁盘快照恢复到新实例，请使用以下命令：

gcloud compute instances create INSTANCE_NAME \
    --create-disk source-snapshot=SNAPSHOT_1_NAME,name=DISK_1_NAME,size=DISK_1_SIZE,type=DISK_1_TYPE \
    --create-disk source-snapshot=SNAPSHOT_2_NAME,name=DISK_2_NAME,size=DISK_2_SIZE,type=DISK_2_TYPE

替换以下内容：

  • INSTANCE_NAME：新实例的名称
  • SNAPSHOT_1_NAME 和 SNAPSHOT_2_NAME：您要恢复的非启动磁盘快照的名称
  • DISK_1_NAME 和 DISK_2_NAME：为此实例创建的新的非启动磁盘的名称

  • DISK_1_SIZE 和 DISK_2_SIZE（可选）：每个新的非启动磁盘的大小（以吉比字节 [GiB] 为单位）

    该大小必须等于或大于用于创建快照的来源磁盘的大小。

  • DISK_1_TYPE 和 DISK_2_TYPE（可选）：要创建的磁盘类型，例如pd-ssd 或 hyperdisk-balanced

REST

使用 REST 将非启动快照恢复到新实例时，需要遵循以下限制：

  • 只有一个磁盘可以作为启动磁盘。
  • 必须将启动磁盘作为该实例的第一个磁盘挂接。
  • 如果您指定了 source 属性，则不能同时指定 initializeParams 属性。提供 source 表示启动磁盘已存在，但 initializeParams 属性指示 Compute Engine 应创建新启动磁盘。

创建对 instances.insert 方法的 POST 请求，并在 initializeParams 属性下指定 sourceSnapshot 字段。通过为要创建的每个非启动磁盘重复 initializeParams 属性，您可以添加多个非启动磁盘。对于您创建的任何磁盘，您可以选择指定 diskSizeGb 和 diskType 属性。

例如，如需将两个非启动磁盘快照恢复到新实例，请发出以下请求：

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "INSTANCE_NAME",
  "machineType": "machineTypes/MACHINE_TYPE",
  "networkInterfaces": [
    {
      "nicType": "GVNIC"
    }
  ],
  "disks": [
    {
      "autoDelete": "true",
      "boot": "true",
      "diskSizeGb": "BOOT_DISK_SIZE",
      "diskType": "BOOT_DISK_TYPE",
      "initializeParams": {
         "sourceImage": "projects/IMAGE_PROJECT/global/images/family/IMAGE_FAMILY"
      }
    },
    {
      "deviceName": "DEVICE_1_NAME",
      "initializeParams": {
         "sourceSnapshot": "global/snapshots/SNAPSHOT_1_NAME",
         "diskSizeGb": "DISK_1_SIZE",
         "diskType": "DISK_1_TYPE"
      }
    },
    {
      "deviceName": "DEVICE_2_NAME",
      "initializeParams": {
         "sourceSnapshot": "global/snapshots/SNAPSHOT_2_NAME",
         "diskSizeGb": "DISK_2_SIZE",
         "diskType": "DISK_2_TYPE"
      }
    }
  ]
}

替换以下内容：

  • PROJECT_ID：您的项目 ID
  • ZONE：要在其中创建实例的可用区
  • INSTANCE_NAME：新实例的名称
  • MACHINE_TYPE：实例的机器类型

  • DISK_SIZE（可选）：相应磁盘的大小（以吉比字节 [GiB] 为单位）

    如果提供此属性，则它必须等于或大于用于创建快照的来源磁盘的大小。

  • DISK_TYPE（可选）：相应磁盘的类型的完整或部分网址，例如PROJECT_ID/zones/ZONE/diskTypes/pd-ssd 或 PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced

  • IMAGE_PROJECT：包含映像的项目。 例如：debian-cloud

  • IMAGE_FAMILY：映像系列。这会通过该系列中最新的未弃用操作系统映像创建实例。例如，如果您指定 "sourceImage": "projects/debian-cloud/global/images/family/debian-11"，则 Compute Engine 会使用 Debian 11 映像系列中最新版本的操作系统映像创建实例。

  • DEVICE_NAME（可选）：实例的客户机操作系统中显示的设备名称

  • SNAPSHOT_NAME：要恢复到实例上新磁盘的对应非启动磁盘快照的名称