使用快照进行恢复

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

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

准备工作

  • 如果您尚未设置身份验证，请进行设置。身份验证是通过其进行身份验证以访问 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
    2. Set a default region and zone.

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

      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.disks.create 权限
    • 针对实例的 compute.instances.attachDisk 权限
    • 针对要挂接的磁盘的 compute.disks.use 权限
    • 针对项目的 compute.snapshots.useReadOnly、compute.snapshots.create 或 compute.disks.createSnapshot 权限
  • 如需通过启动磁盘和非启动磁盘快照创建实例，您至少需要拥有以下权限：
    • 针对项目的 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 \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE

    如需创建区域级磁盘，请执行以下操作：

    gcloud compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --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
    • 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/v1/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"
}

    替换以下内容：

    • PROJECT_ID：您的项目 ID
    • ZONE：您的实例和新磁盘所在的地区
    • DISK_NAME：新磁盘的名称
    • SNAPSHOT_NAME：要恢复的磁盘的来源快照
    • REGION：区域级磁盘所在的区域，例如 europe-west1
    • 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. 选择您的项目并点击继续。

  3. 点击创建实例。

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

  5. 可选操作：更改此实例的可用区。如果您选择任意，Google Cloud 会根据机器类型和可用性为您自动选择可用区。

  6. 为您的虚拟机选择机器配置。

  7. 在启动磁盘部分，点击更改，然后执行以下操作：

    1. 点击快照标签页。
    2. 在快照列表中，点击一个快照。
    3. 指定启动磁盘类型和大小。
    4. 可选：对于高级配置选项，点击显示高级配置。
    5. 如需确认您的启动磁盘选项，请点击选择。

  8. 在防火墙部分中，如需允许 HTTP 或 HTTPS 流量流向实例，请选择允许 HTTP 流量或允许 HTTPS 流量。

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

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

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. 在挂接设置部分中，选择磁盘的挂接模式和删除规则。如需详细了解如何添加新磁盘，请参阅 添加永久性磁盘或 添加 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：您要恢复到实例上新磁盘的相应非启动磁盘快照的名称