配置永久性磁盘异步复制

---

本文档介绍了如何配置异步复制。异步复制对于实现低 RPO 和低 RTO 的灾难恢复非常有用。

如需启用异步磁盘复制，请完成以下步骤：

1. 设置磁盘复制对以配置异步复制。
2. 手动开始复制，以在主磁盘与辅助磁盘之间开始复制数据。

限制

• 辅助磁盘在创建时必须为空白磁盘。您不能通过映像、快照或其他磁盘创建辅助磁盘。
• Hyperdisk ML 或 Hyperdisk Throughput 不支持异步复制。
• 您无法在 Google Cloud 控制台中为 Hyperdisk 配置异步复制。您必须使用 Google Cloud CLI、Terraform 或 REST。

准备工作

• 选择区域对。
• （可选）创建一致性组。
• 如果您尚未设置身份验证，请进行设置。身份验证是通过其进行身份验证以访问 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.

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

  Terraform

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

  1. Install the Google Cloud CLI.

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

  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.

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

  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 时进行身份验证。

设置磁盘复制对

在磁盘之间复制数据之前，您需要完成以下任务来配置复制：

1. 选择区域对以及主要区域和次要区域。
2. 可选：如果您需要跨一组磁盘协调复制，请在主要区域中创建一致性组。您必须先将主磁盘添加到一致性组，然后才能开始复制。
3. 创建或选择主磁盘。您可以视需要将这些磁盘添加到一致性组。
4. 创建新的空白辅助磁盘。

磁盘要求

磁盘必须满足以下要求，才能用作异步复制的主磁盘或辅助磁盘：

• 磁盘类型：您必须使用以下磁盘类型之一：
  • 平衡永久性磁盘
  • 高性能 (SSD) 永久性磁盘
  • 平衡 Hyperdisk
  • Hyperdisk Balanced 高可用性
  • Hyperdisk Extreme
• 大小：小于或等于 64 TiB。
• 加密类型： Google-owned and Google-managed encryption keys 或客户管理的加密密钥 (CMEK)。
• 多写入者模式：您可以为处于多写入者模式的 Hyperdisk Balanced 和 Hyperdisk Balanced 高可用性磁盘启用异步复制。对于所有其他磁盘类型，磁盘必须处于读写模式。
• 位置：位于受支持的区域（或受支持区域内的可用区）。

创建或选择主磁盘

主磁盘是挂接到工作负载在其中运行的虚拟机的启动磁盘或数据磁盘。您可以使用满足磁盘要求的任何已有磁盘作为主磁盘，也可以创建新磁盘。如果您想将现有磁盘用作主磁盘，则无需对该磁盘执行任何其他配置。继续创建辅助磁盘，以完成异步复制配置。

创建主磁盘

使用以下文档之一中介绍的方法创建主磁盘。

• 在创建虚拟机时创建主启动磁盘。（可选）使用 gcloud CLI 或 REST 创建虚拟机并指定以下其中一项，以将磁盘添加到一致性组：

  • 如果您使用 gcloud CLI 创建虚拟机，请指定 --create-disk 标志：

    --create-disk=disk-resource-policy=projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME
    

  • 如果您使用 REST 创建虚拟机，请指定 resourcePolicies 属性：

    "disks":
    {
    …
    "resourcePolicies": "projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME"
    }
    

• 在创建虚拟机时创建主数据磁盘。（可选）使用 gcloud CLI 或 REST 创建虚拟机并指定以下其中一项，以将磁盘添加到一致性组：

  • 如果您使用 gcloud CLI 创建虚拟机，请指定 --create-disk 标志：

    --create-disk=disk-resource-policy=projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME
    

  • 如果您使用 REST 创建虚拟机，请指定 resourcePolicies 属性：

    "disks":
    {
    …
    "resourcePolicies": "projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME"
    }
    

• 在不创建虚拟机的情况下创建主数据磁盘。（可选）使用Google Cloud 控制台、gcloud CLI 或 REST 创建虚拟机并指定以下其中一项，以将磁盘添加到一致性组：

  • 如果您使用 Google Cloud 控制台创建磁盘，请从一致性组下拉菜单中选择一致性组。

  • 如果您使用 gcloud CLI 创建磁盘，请指定 --resource-policies 标志：

    --resource-policies=projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME
    

  • 如果您使用 REST 创建磁盘，请指定 resourcePolicies 属性：

    "disks":
    {
    …
    "resourcePolicies": "projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME"
    }
    

  替换以下内容：

  • PROJECT：包含一致性组的项目
  • REGION：一致性组所在的区域
  • CONSISTENCY_GROUP_NAME：要将磁盘添加到的一致性组的名称

创建辅助磁盘

辅助磁盘是与主磁盘位于不同区域的数据磁盘，它从主磁盘接收复制的数据并向主磁盘写入复制的数据。配置异步复制时，您必须创建一个引用主磁盘的新空白辅助磁盘。

如需创建与主磁盘具有相同属性的辅助磁盘，请按照创建与主磁盘相同的辅助磁盘中的步骤操作。

注意：在创建辅助磁盘时，Compute Engine 只会将属性从主磁盘复制到辅助磁盘一次。如果您在创建辅助磁盘后修改主磁盘的标签、客机操作系统功能或其他属性，Compute Engine 不会将这些更改复制到辅助磁盘。

如需创建与主磁盘不同的辅助磁盘，请参阅创建自定义辅助磁盘。

创建与主磁盘相同的辅助磁盘

本部分介绍了如何创建与主磁盘相同的辅助磁盘。

• 对于永久性磁盘异步复制，您可以使用Google Cloud 控制台、gcloud CLI 或 REST 创建辅助磁盘。

• 对于 Hyperdisk 异步复制，您可以使用 gcloud CLI、Terraform 或 REST。

控制台

注意：使用 Google Cloud 控制台创建辅助磁盘时，复制会立即启动。如果您需要将辅助磁盘的相应主磁盘添加到一致性组，则必须先执行此操作，然后再创建辅助磁盘。

通过执行以下操作，创建辅助磁盘并开始复制：

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

   转到“磁盘”

2. 点击主磁盘的名称。系统随即会打开管理磁盘页面。

3. 点击创建辅助磁盘。

4. 在名称字段中，输入磁盘的名称。

5. 在位置部分中，执行以下操作之一：

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

     1. 选择区域级。
     2. 在区域字段中，选择与主磁盘的区域相对应的区域。
     3. 在可用区字段中，选择主可用区。
     4. 在副本可用区字段中，选择副本可用区。

   • 如需创建可用区磁盘，请执行以下操作：

     1. 选择单个可用区。
     2. 在区域字段中，选择与主磁盘的区域相对应的区域。
     3. 在可用区字段中，选择一个可用区。

6. 点击创建。Compute Engine 会创建磁盘并开始复制。

gcloud

使用 gcloud compute disks create 命令创建辅助磁盘：

gcloud compute disks create SECONDARY_DISK_NAME \
    --SECONDARY_LOCATION_FLAG=SECONDARY_LOCATION \
    --size=SIZE \
    --primary-disk=PRIMARY_DISK_NAME \
    --PRIMARY_DISK_LOCATION_FLAG=PRIMARY_LOCATION \
    --primary-disk-project=PRIMARY_DISK_PROJECT

如需创建区域级辅助磁盘，请另外指定 --replica-zones 标志：

--replica-zones=ZONE_1,ZONE_2

替换以下内容：

• SECONDARY_DISK_NAME：辅助磁盘的名称。
• SECONDARY_LOCATION_FLAG：辅助磁盘的位置标志。如需创建区域级辅助磁盘，请使用 --region。如需创建可用区级辅助磁盘，请使用 --zone。
• SECONDARY_LOCATION：辅助磁盘的区域或可用区。
  • 如需创建区域级磁盘，请使用与主磁盘的区域相对应的区域。
  • 如需创建可用区级磁盘，请使用与主磁盘的区域相对应的区域内的可用区。
• SIZE：新磁盘的大小（以 GB 为单位）。 该大小必须与主磁盘的大小相同。可接受的大小范围介于 10 GB 到 2,000 GB 之间（以 1 GB 为增量）。
• PRIMARY_DISK_NAME：辅助磁盘从中接收数据的主磁盘的名称。
• PRIMARY_LOCATION_FLAG：主磁盘的位置标志。
  • 对于区域级主磁盘，请使用 --primary-disk-region。
  • 对于可用区级主磁盘，请使用 --primary-disk-zone。
• PRIMARY_LOCATION：主磁盘的区域或可用区。
  • 对于区域级磁盘，请使用区域。
  • 对于可用区级磁盘，请使用可用区。
• PRIMARY_PROJECT：包含主磁盘的项目。
• ZONE_1：区域级磁盘复制到的可用区之一。必须是指定区域内的可用区，并且必须与 ZONE_2 不同。
• ZONE_2：区域级磁盘复制到的可用区之一。必须是指定区域内的可用区，并且必须与 ZONE_1 不同。

Go

使用以下代码示例之一创建可用区级或区域级辅助磁盘：

创建可用区级辅助磁盘

import (
	"context"
	"fmt"
	"io"

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

// createSecondaryDisk creates a new secondary disk in a project in given zone.
// Note: secondary disk should be located in a different region, but within the same continent.
// More details: https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
func createSecondaryDisk(
	w io.Writer,
	projectID, zone, diskName, primaryDiskName, primaryZone string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "europe-west4-b"
	// diskName := "your_disk_name"
	// primaryDiskName := "your_disk_name2"
	// primaryDiskZone := "europe-west2-b"
	// diskSizeGb := 20

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

	primaryFullDiskName := fmt.Sprintf("projects/%s/zones/%s/disks/%s", projectID, primaryZone, primaryDiskName)

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:   proto.String(diskName),
			Zone:   proto.String(zone),
			SizeGb: proto.Int64(diskSizeGb),
			AsyncPrimaryDisk: &computepb.DiskAsyncReplication{
				Disk: proto.String(primaryFullDiskName),
			},
		},
	}

	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
}

创建区域级辅助磁盘

import (
	"context"
	"fmt"
	"io"

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

// createRegionalSecondaryDisk creates a new secondary disk in a project in given region.
// Note: secondary disk should be located in a different region, but within the same continent.
// More details: https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
func createRegionalSecondaryDisk(
	w io.Writer,
	projectID, region, diskName, primaryDiskName, primaryRegion string,
	replicaZones []string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// region := "europe-west1"
	// diskName := "your_disk_name"
	// primaryDiskName := "your_disk_name2"
	// primaryDiskRegion := "europe-west4"
	// replicaZones := []string{"europe-west1-a", "europe-west1-b"}
	// diskSizeGb := 200

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

	primaryFullDiskName := fmt.Sprintf("projects/%s/regions/%s/disks/%s", projectID, primaryRegion, primaryDiskName)

	// Exactly two replica zones must be specified
	replicaZoneURLs := []string{
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[0]),
		fmt.Sprintf("projects/%s/zones/%s", projectID, replicaZones[1]),
	}

	req := &computepb.InsertRegionDiskRequest{
		Project: projectID,
		Region:  region,
		DiskResource: &computepb.Disk{
			Name:   proto.String(diskName),
			Region: proto.String(region),
			// The size must be at least 200 GB
			SizeGb: proto.Int64(diskSizeGb),
			AsyncPrimaryDisk: &computepb.DiskAsyncReplication{
				Disk: proto.String(primaryFullDiskName),
			},
			ReplicaZones: replicaZoneURLs,
		},
	}

	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

使用以下代码示例之一创建可用区级或区域级辅助磁盘：

创建可用区级辅助磁盘

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DiskAsyncReplication;
import com.google.cloud.compute.v1.DisksClient;
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 CreateDiskSecondaryZonal {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The project that contains the primary disk.
    String primaryProjectId = "PRIMARY_PROJECT_ID";
    // The project that contains the secondary disk.
    String secondaryProjectId = "SECONDARY_PROJECT_ID";
    // Name of the primary disk you want to use.
    String primaryDiskName = "PRIMARY_DISK_NAME";
    // Name of the zone in which your primary disk is located.
    // Learn more about zones and regions:
    // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
    String primaryDiskZone = "us-central1-a";
    // Name of the disk you want to create.
    String secondaryDiskName = "SECONDARY_DISK_NAME";
    // Name of the zone in which you want to create the secondary disk.
    String secondaryDiskZone = "us-east1-c";
    // Size of the new disk in gigabytes.
    long diskSizeGb = 30L;
    // The type of the disk you want to create. This value uses the following format:
    // "projects/{projectId}/zones/{zone}/diskTypes/
    // (pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    String diskType = String.format(
        "projects/%s/zones/%s/diskTypes/pd-balanced", secondaryProjectId, secondaryDiskZone);

    createDiskSecondaryZonal(primaryProjectId, secondaryProjectId, primaryDiskName,
        secondaryDiskName, primaryDiskZone, secondaryDiskZone, diskSizeGb,  diskType);
  }

  // Creates a secondary disk in a specified zone.
  public static Operation.Status createDiskSecondaryZonal(String primaryProjectId,
       String secondaryProjectId, String primaryDiskName, String secondaryDiskName,
       String primaryDiskZone, String secondaryDiskZone, long diskSizeGb, String diskType)
      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.
    try (DisksClient disksClient = DisksClient.create()) {
      String primaryDiskSource = String.format("projects/%s/zones/%s/disks/%s",
          primaryProjectId, primaryDiskZone, primaryDiskName);

      DiskAsyncReplication asyncReplication = DiskAsyncReplication.newBuilder()
          .setDisk(primaryDiskSource)
          .build();
      Disk disk = Disk.newBuilder()
          .setName(secondaryDiskName)
          .setZone(secondaryDiskZone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setAsyncPrimaryDisk(asyncReplication)
          .build();

      Operation response = disksClient.insertAsync(secondaryProjectId, secondaryDiskZone, disk)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error creating secondary disks! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

创建区域级辅助磁盘

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DiskAsyncReplication;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.RegionDisksClient;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateDiskSecondaryRegional {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The project that contains the primary disk.
    String primaryProjectId = "PRIMARY_PROJECT_ID";
    // The project that contains the secondary disk.
    String secondaryProjectId = "SECONDARY_PROJECT_ID";
    // Name of the primary disk you want to use.
    String primaryDiskName = "PRIMARY_DISK_NAME";
    // Name of the disk you want to create.
    String secondaryDiskName = "SECONDARY_DISK_NAME";
    // Name of the region in which your primary disk is located.
    // Learn more about zones and regions:
    // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
    String primaryDiskRegion = "us-central1";
    // Name of the region in which you want to create the secondary disk.
    String secondaryDiskRegion = "us-east1";
    // Size of the new disk in gigabytes.
    // Learn more about disk requirements:
    // https://cloud.google.com/compute/docs/disks/async-pd/configure?authuser=0#disk_requirements
    long diskSizeGb = 30L;
    // The type of the disk you want to create. This value uses the following format:
    // "projects/{projectId}/zones/{zone}/diskTypes/
    // (pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    String diskType = String.format(
        "projects/%s/regions/%s/diskTypes/pd-balanced", secondaryProjectId, secondaryDiskRegion);

    createDiskSecondaryRegional(primaryProjectId, secondaryProjectId, primaryDiskName,
        secondaryDiskName, primaryDiskRegion, secondaryDiskRegion, diskSizeGb, diskType);
  }

  // Creates a secondary disk in a specified region.
  public static Status createDiskSecondaryRegional(String projectId,
       String secondaryProjectId, String primaryDiskName, String secondaryDiskName,
       String primaryDiskRegion, String secondaryDiskRegion, long diskSizeGb, String diskType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    List<String> replicaZones = Arrays.asList(
        String.format("projects/%s/zones/%s-c", secondaryProjectId, secondaryDiskRegion),
        String.format("projects/%s/zones/%s-b", secondaryProjectId, secondaryDiskRegion));

    String primaryDiskSource = String.format("projects/%s/regions/%s/disks/%s",
        projectId, primaryDiskRegion, primaryDiskName);

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (RegionDisksClient disksClient = RegionDisksClient.create()) {
      DiskAsyncReplication asyncReplication = DiskAsyncReplication.newBuilder()
          .setDisk(primaryDiskSource)
          .build();

      Disk disk = Disk.newBuilder()
          .addAllReplicaZones(replicaZones)
          .setName(secondaryDiskName)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setRegion(secondaryDiskRegion)
          .setAsyncPrimaryDisk(asyncReplication)
          .build();

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

      if (response.hasError()) {
        throw new Error("Error creating secondary disks! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js

使用以下代码示例之一创建可用区级或区域级辅助磁盘：

创建可用区级辅助磁盘

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a diskClient
const disksClient = new computeLib.DisksClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project for the secondary disk.
const secondaryProjectId = await disksClient.getProjectId();

// The zone for the secondary disk. The primary and secondary disks must be in different regions.
// secondaryLocation = 'us-central1-a';

// The name of the secondary disk.
// secondaryDiskName = 'secondary-disk-name';

// The project that contains the primary disk.
const primaryProjectId = await disksClient.getProjectId();

// The zone for the primary disk.
// primaryLocation = 'us-central1-b';

// The name of the primary disk that the secondary disk receives data from.
// primaryDiskName = 'primary-disk-name';

// The disk type. Must be one of `pd-ssd` or `pd-balanced`.
const diskType = `zones/${secondaryLocation}/diskTypes/pd-balanced`;

// The size of the secondary disk in gigabytes.
const diskSizeGb = 10;

// Create a secondary disk identical to the primary disk.
async function callCreateComputeSecondaryDisk() {
  // Create a secondary disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: secondaryDiskName,
    zone: secondaryLocation,
    type: diskType,
    asyncPrimaryDisk: new compute.DiskAsyncReplication({
      // Make sure that the primary disk supports asynchronous replication.
      // Only certain persistent disk types, like `pd-balanced` and `pd-ssd`, are eligible.
      disk: `projects/${primaryProjectId}/zones/${primaryLocation}/disks/${primaryDiskName}`,
    }),
  });

  const [response] = await disksClient.insert({
    project: secondaryProjectId,
    zone: secondaryLocation,
    diskResource: disk,
  });

  let operation = response.latestResponse;

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

  console.log(`Secondary disk: ${secondaryDiskName} created.`);
}

await callCreateComputeSecondaryDisk();

创建区域级辅助磁盘

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a regionDisksClient
const regionDisksClient = new computeLib.RegionDisksClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project for the secondary disk.
const secondaryProjectId = await regionDisksClient.getProjectId();

// The region for the secondary disk.
// secondaryLocation = 'us-central1';

// The name of the secondary disk.
// secondaryDiskName = 'secondary-disk-name';

// The project that contains the primary disk.
const primaryProjectId = await regionDisksClient.getProjectId();

// The region for the primary disk.
// primaryLocation = 'us-central2';

// The name of the primary disk that the secondary disk receives data from.
// primaryDiskName = 'primary-disk-name';

// The disk type. Must be one of `pd-ssd` or `pd-balanced`.
const diskType = `regions/${secondaryLocation}/diskTypes/pd-balanced`;

// The size of the secondary disk in gigabytes.
const diskSizeGb = 10;

// Create a secondary disk identical to the primary disk.
async function callCreateComputeRegionalSecondaryDisk() {
  // Create a secondary disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: secondaryDiskName,
    region: secondaryLocation,
    type: diskType,
    replicaZones: [
      `zones/${secondaryLocation}-a`,
      `zones/${secondaryLocation}-b`,
    ],
    asyncPrimaryDisk: new compute.DiskAsyncReplication({
      // Make sure that the primary disk supports asynchronous replication.
      // Only certain persistent disk types, like `pd-balanced` and `pd-ssd`, are eligible.
      disk: `projects/${primaryProjectId}/regions/${primaryLocation}/disks/${primaryDiskName}`,
    }),
  });

  const [response] = await regionDisksClient.insert({
    project: secondaryProjectId,
    diskResource: disk,
    region: secondaryLocation,
  });

  let operation = response.latestResponse;

  // Wait for the create secondary disk operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await regionOperationsClient.wait({
      operation: operation.name,
      project: secondaryProjectId,
      region: secondaryLocation,
    });
  }

  console.log(`Secondary disk: ${secondaryDiskName} created.`);
}

await callCreateComputeRegionalSecondaryDisk();

Python

使用以下代码示例之一创建可用区级或区域级辅助磁盘：

创建可用区级辅助磁盘

from __future__ import annotations

import sys
from typing import Any

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


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_secondary_disk(
    primary_disk_name: str,
    primary_disk_project: str,
    primary_disk_zone: str,
    secondary_disk_name: str,
    secondary_disk_project: str,
    secondary_disk_zone: str,
    disk_size_gb: int,
    disk_type: str = "pd-ssd",
) -> compute_v1.Disk:
    """Create a secondary disk with a primary disk as a source.
    Args:
        primary_disk_name (str): The name of the primary disk.
        primary_disk_project (str): The project of the primary disk.
        primary_disk_zone (str): The location of the primary disk.
        secondary_disk_name (str): The name of the secondary disk.
        secondary_disk_project (str): The project of the secondary disk.
        secondary_disk_zone (str): The location of the secondary disk.
        disk_size_gb (int): The size of the disk in GB. Should be the same as the primary disk.
        disk_type (str): The type of the disk. Must be one of pd-ssd or pd-balanced.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.name = secondary_disk_name
    disk.size_gb = disk_size_gb
    disk.type = f"zones/{primary_disk_zone}/diskTypes/{disk_type}"
    disk.async_primary_disk = compute_v1.DiskAsyncReplication(
        disk=f"projects/{primary_disk_project}/zones/{primary_disk_zone}/disks/{primary_disk_name}"
    )

    operation = disk_client.insert(
        project=secondary_disk_project, zone=secondary_disk_zone, disk_resource=disk
    )
    wait_for_extended_operation(operation, "create_secondary_disk")

    secondary_disk = disk_client.get(
        project=secondary_disk_project,
        zone=secondary_disk_zone,
        disk=secondary_disk_name,
    )
    return secondary_disk

创建区域级辅助磁盘

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_secondary_region_disk(
    primary_disk_name: str,
    primary_disk_project: str,
    primary_disk_region: str,
    secondary_disk_name: str,
    secondary_disk_project: str,
    secondary_disk_region: str,
    disk_size_gb: int,
    disk_type: str = "pd-ssd",
) -> compute_v1.Disk:
    """Create a secondary disk in replica zones with a primary region disk as a source .
    Args:
        primary_disk_name (str): The name of the primary disk.
        primary_disk_project (str): The project of the primary disk.
        primary_disk_region (str): The location of the primary disk.
        secondary_disk_name (str): The name of the secondary disk.
        secondary_disk_project (str): The project of the secondary disk.
        secondary_disk_region (str): The location of the secondary disk.
        disk_size_gb (int): The size of the disk in GB. Should be the same as the primary disk.
        disk_type (str): The type of the disk. Must be one of pd-ssd or pd-balanced.
    """
    disk_client = compute_v1.RegionDisksClient()
    disk = compute_v1.Disk()
    disk.name = secondary_disk_name
    disk.size_gb = disk_size_gb
    disk.type = f"regions/{primary_disk_region}/diskTypes/{disk_type}"
    disk.async_primary_disk = compute_v1.DiskAsyncReplication(
        disk=f"projects/{primary_disk_project}/regions/{primary_disk_region}/disks/{primary_disk_name}"
    )

    # Set the replica zones for the secondary disk. By default, in b and c zones.
    disk.replica_zones = [
        f"zones/{secondary_disk_region}-b",
        f"zones/{secondary_disk_region}-c",
    ]

    operation = disk_client.insert(
        project=secondary_disk_project,
        region=secondary_disk_region,
        disk_resource=disk,
    )
    wait_for_extended_operation(operation, "create_secondary_region_disk")
    secondary_disk = disk_client.get(
        project=secondary_disk_project,
        region=secondary_disk_region,
        disk=secondary_disk_name,
    )
    return secondary_disk

REST

使用以下方法之一创建可用区或区域辅助磁盘：

• 如需创建可用区级辅助磁盘，请使用 disks.insert 方法：

  POST https://compute.googleapis.com/compute/v1/projects/SECONDARY_DISK_PROJECT/zones/SECONDARY_DISK_LOCATION/disks
  
  {
  "name": "SECONDARY_DISK_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "DISK_TYPE"
  "asyncPrimaryDisk": {
    "disk": "projects/PRIMARY_DISK_PROJECT/PRIMARY_DISK_LOCATION_PARAMETER/PRIMARY_DISK_LOCATION/disks/PRIMARY_DISK_NAME"
    }
  }
  

• 如需创建区域级辅助磁盘，请使用 regionDisks.insert 方法：

  POST https://compute.googleapis.com/compute/v1/projects/SECONDARY_DISK_PROJECT/regions/SECONDARY_DISK_LOCATION/disks
  
  {
  "name": "SECONDARY_DISK_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "DISK_TYPE"
  "asyncPrimaryDisk": {
    "disk": "projects/PRIMARY_DISK_PROJECT/PRIMARY_DISK_LOCATION_PARAMETER/PRIMARY_DISK_LOCATION/disks/PRIMARY_DISK_NAME"
    }
  }
  

替换以下内容：

• SECONDARY_DISK_PROJECT：辅助磁盘的项目。
• SECONDARY_DISK_LOCATION：辅助磁盘的区域或可用区。
  • 对于区域级磁盘，请使用区域。
  • 对于可用区级磁盘，请使用可用区。
• SECONDARY_DISK_NAME：辅助磁盘的名称。
• DISK_SIZE：辅助磁盘的大小。必须与主磁盘的大小相同。
• PRIMARY_DISK_PROJECT：包含主磁盘的项目。
• PRIMARY_DISK_LOCATION_PARAMETER：主磁盘的位置参数。
  • 对于区域级主磁盘，请使用 regions。
  • 对于可用区级主磁盘，请使用 zones。
• PRIMARY_DISK_LOCATION：主磁盘的区域或可用区。对于区域级磁盘，请使用区域。对于可用区级磁盘，请使用可用区。
• PRIMARY_DISK_NAME：辅助磁盘从中接收数据的主磁盘的名称。

注意：您不能通过快照、映像或磁盘创建辅助磁盘。请勿将 sourceSnapshot、sourceImage 或 sourceDisk 字段添加到您的请求。

Terraform

如需创建与主磁盘相同的辅助磁盘，请使用 compute_disk 资源。

resource "google_compute_disk" "secondary_disk" {
  name = "secondary-disk"
  type = "pd-ssd"
  zone = "europe-west3-a"

  async_primary_disk {
    disk = google_compute_disk.primary_disk.id
  }

  physical_block_size_bytes = 4096
}

如需了解如何应用或移除 Terraform 配置，请参阅基本 Terraform 命令。

创建自定义辅助磁盘

本部分介绍了如何创建自定义辅助磁盘，即其属性与主磁盘不同的辅助磁盘。

如果主磁盘是启动磁盘，您无法更改或移除主磁盘的任何客机操作系统功能。您只能添加更多客机操作系统功能。如需了解详情，请参阅辅助磁盘自定义。

您可以使用 gcloud CLI、REST 或 Terraform 创建自定义辅助磁盘。您无法通过 Google Cloud 控制台自定义辅助磁盘。

gcloud

如需创建自定义辅助磁盘，请使用创建与主磁盘相同的辅助磁盘中所述的 gcloud compute disks create 命令。使用其他标志自定义辅助磁盘的属性。

以下示例展示了如何自定义辅助磁盘：

• 如需指定其他客机操作系统功能，请使用 --guest-os-features 参数。

   --guest-os-features=UEFI_COMPATIBLE,GVNIC,MULTI_IP_SUBNET
   

• 如需为辅助磁盘分配其他标签，请使用 --labels 参数。

    --labels=secondary-disk-for-replication=yes
    

Go

import (
	"context"
	"fmt"
	"io"

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

// createCustomSecondaryDisk creates a new secondary disk in a project in given zone.
// Note: secondary disk should be located in a different region, but within the same continent.
// More details: https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
func createCustomSecondaryDisk(
	w io.Writer,
	projectID, zone, diskName, primaryDiskName, primaryZone string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-central1-a"
	// diskName := "your_disk_name"
	// primaryDiskName := "your_disk_name2"
	// primaryDiskZone := "us-east1-b"
	// diskSizeGb := 20

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

	primaryFullDiskName := fmt.Sprintf("projects/%s/zones/%s/disks/%s", projectID, primaryZone, primaryDiskName)

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:   proto.String(diskName),
			Zone:   proto.String(zone),
			SizeGb: proto.Int64(diskSizeGb),
			AsyncPrimaryDisk: &computepb.DiskAsyncReplication{
				Disk: proto.String(primaryFullDiskName),
			},
			// More about guest features: https://cloud.google.com/compute/docs/images/create-custom#guest-os-features
			GuestOsFeatures: []*computepb.GuestOsFeature{
				{Type: proto.String("UEFI_COMPATIBLE")},
				{Type: proto.String("GVNIC")},
				{Type: proto.String("MULTI_IP_SUBNET")},
			},
			// The secondary disk automatically inherits the labels of the primary disk.
			Labels: map[string]string{
				"secondary-disk-for-replication": "yes",
			},
		},
	}

	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

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DiskAsyncReplication;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.GuestOsFeature;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSecondaryCustomDisk {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The project that contains the primary disk.
    String primaryProjectId = "PRIMARY_PROJECT_ID";
    // The project that contains the secondary disk.
    String secondaryProjectId = "SECONDARY_PROJECT_ID";
    // Name of the primary disk you want to use.
    String primaryDiskName = "PRIMARY_DISK_NAME";
    // Name of the zone in which your primary disk is located.
    // Learn more about zones and regions:
    // https://cloud.google.com/compute/docs/disks/async-pd/about#supported_region_pairs
    String primaryDiskZone = "us-central1-a";
    // Name of the disk you want to create.
    String secondaryDiskName = "SECONDARY_DISK_NAME";
    // Name of the zone in which you want to create the secondary disk.
    String secondaryDiskZone = "us-east1-c";
    // Size of the new disk in gigabytes.
    long diskSizeGb = 30L;
    // The type of the disk you want to create. This value uses the following format:
    // "projects/{projectId}/zones/{zone}/diskTypes/
    // (pd-standard|pd-ssd|pd-balanced|pd-extreme)".
    String diskType = String.format(
        "projects/%s/zones/%s/diskTypes/pd-balanced", secondaryProjectId, secondaryDiskZone);

    createSecondaryCustomDisk(primaryProjectId, secondaryProjectId, primaryDiskName,
        secondaryDiskName, primaryDiskZone, secondaryDiskZone, diskSizeGb,  diskType);
  }

  // Creates a secondary disk with specified custom parameters.
  public static Status createSecondaryCustomDisk(String primaryProjectId, String secondaryProjectId,
      String primaryDiskName, String secondaryDiskName, String primaryDiskZone,
      String secondaryDiskZone, long diskSizeGb, String diskType)
      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.
    try (DisksClient disksClient = DisksClient.create()) {
      String primaryDiskSource = String.format("projects/%s/zones/%s/disks/%s",
          primaryProjectId, primaryDiskZone, primaryDiskName);

      DiskAsyncReplication asyncReplication = DiskAsyncReplication.newBuilder()
          .setDisk(primaryDiskSource)
          .build();

      // Define the guest OS features.
      List<GuestOsFeature> guestOsFeatures = Arrays.asList(
          GuestOsFeature.newBuilder().setType("UEFI_COMPATIBLE").build(),
          GuestOsFeature.newBuilder().setType("GVNIC").build(),
          GuestOsFeature.newBuilder().setType("MULTI_IP_SUBNET").build());

      // Define the labels.
      Map<String, String> labels = new HashMap<>();
      labels.put("secondary-disk-for-replication", "yes");

      Disk disk = Disk.newBuilder()
          .setName(secondaryDiskName)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setZone(secondaryDiskZone)
          .addAllGuestOsFeatures(guestOsFeatures)
          .putAllLabels(labels)
          .setAsyncPrimaryDisk(asyncReplication)
          .build();

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

      if (response.hasError()) {
        throw new Error("Error creating secondary custom disks! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// If you want to create regional disk, you should use: RegionDisksClient and RegionOperationsClient.
// Instantiate a diskClient
const disksClient = new computeLib.DisksClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project for the secondary disk.
const secondaryProjectId = await disksClient.getProjectId();

// The zone or region for the secondary disk. The primary and secondary disks must be in different regions.
// If you use RegionDisksClient- define region, if DisksClient- define zone.
// secondaryLocation = 'us-central1-a';

// The name of the secondary disk.
// secondaryDiskName = 'secondary-disk-name';

// The project that contains the primary disk.
const primaryProjectId = await disksClient.getProjectId();

// The zone or region for the primary disk.
// If you use RegionDisksClient- define region, if DisksClient- define zone.
// primaryLocation = 'us-central1-b';

// The name of the primary disk that the secondary disk receives data from.
// primaryDiskName = 'primary-disk-name';

// The disk type. Must be one of `pd-ssd` or `pd-balanced`.
const diskType = `zones/${secondaryLocation}/diskTypes/pd-balanced`;

// The size of the secondary disk in gigabytes.
const diskSizeGb = 10;

// Create a secondary disk identical to the primary disk.
async function callCreateComputeSecondaryDisk() {
  // Create a secondary disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: secondaryDiskName,
    // If you use RegionDisksClient, pass region as an argument instead of zone
    zone: secondaryLocation,
    type: diskType,
    asyncPrimaryDisk: new compute.DiskAsyncReplication({
      // Make sure that the primary disk supports asynchronous replication.
      // Only certain persistent disk types, like `pd-balanced` and `pd-ssd`, are eligible.
      disk: `projects/${primaryProjectId}/zones/${primaryLocation}/disks/${primaryDiskName}`,
    }),
    // Specify additional guest OS features.
    // To learn more about OS features, open: `https://cloud.google.com/compute/docs/disks/async-pd/configure?authuser=0#secondary2`.
    // You don't need to include the guest OS features of the primary disk.
    // The secondary disk automatically inherits the guest OS features of the primary disk.
    guestOsFeatures: [
      new compute.GuestOsFeature({
        type: 'NEW_FEATURE_ID_1',
      }),
    ],
    // Assign additional labels to the secondary disk.
    // You don't need to include the labels of the primary disk.
    // The secondary disk automatically inherits the labels from the primary disk
    labels: {
      key: 'value',
    },
  });

  const [response] = await disksClient.insert({
    project: secondaryProjectId,
    // If you use RegionDisksClient, pass region as an argument instead of zone
    zone: secondaryLocation,
    diskResource: disk,
  });

  let operation = response.latestResponse;

  // Wait for the create secondary disk operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await zoneOperationsClient.wait({
      operation: operation.name,
      project: secondaryProjectId,
      // If you use RegionOperationsClient, pass region as an argument instead of zone
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log(`Custom secondary disk: ${secondaryDiskName} created.`);
}

await callCreateComputeSecondaryDisk();

Python

from __future__ import annotations

import sys
from typing import Any

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


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_secondary_custom_disk(
    primary_disk_name: str,
    primary_disk_project: str,
    primary_disk_zone: str,
    secondary_disk_name: str,
    secondary_disk_project: str,
    secondary_disk_zone: str,
    disk_size_gb: int,
    disk_type: str = "pd-ssd",
) -> compute_v1.Disk:
    """Creates a custom secondary disk whose properties differ from the primary disk.
    Args:
        primary_disk_name (str): The name of the primary disk.
        primary_disk_project (str): The project of the primary disk.
        primary_disk_zone (str): The location of the primary disk.
        secondary_disk_name (str): The name of the secondary disk.
        secondary_disk_project (str): The project of the secondary disk.
        secondary_disk_zone (str): The location of the secondary disk.
        disk_size_gb (int): The size of the disk in GB. Should be the same as the primary disk.
        disk_type (str): The type of the disk. Must be one of pd-ssd or pd-balanced.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.name = secondary_disk_name
    disk.size_gb = disk_size_gb
    disk.type = f"zones/{primary_disk_zone}/diskTypes/{disk_type}"
    disk.async_primary_disk = compute_v1.DiskAsyncReplication(
        disk=f"projects/{primary_disk_project}/zones/{primary_disk_zone}/disks/{primary_disk_name}"
    )

    # Add guest OS features to the secondary dis
    # For possible values, visit:
    # https://cloud.google.com/compute/docs/images/create-custom#guest-os-features
    disk.guest_os_features = [compute_v1.GuestOsFeature(type="MULTI_IP_SUBNET")]

    # Assign additional labels to the secondary disk
    disk.labels = {
        "source-disk": primary_disk_name,
        "secondary-disk-for-replication": "true",
    }

    operation = disk_client.insert(
        project=secondary_disk_project, zone=secondary_disk_zone, disk_resource=disk
    )
    wait_for_extended_operation(operation, "create_secondary_disk")

    secondary_disk = disk_client.get(
        project=secondary_disk_project,
        zone=secondary_disk_zone,
        disk=secondary_disk_name,
    )
    return secondary_disk

REST

如需创建自定义辅助磁盘，请使用创建与主磁盘相同的辅助磁盘中所述的方法。指定其他字段以自定义辅助磁盘的属性。

以下示例展示了如何自定义辅助磁盘：

• 如需指定其他客机操作系统功能，请使用 guestOsFeatures 字段。您只能指定其他客机操作系统功能；您无法更改或移除从主磁盘复制的任何客机操作系统功能。

  "guestOsFeatures": [
    {
      "type": "NEW_FEATURE_ID_1"
    },
    {
      "type": "NEW_FEATURE_ID_1"
    }
  ]
  

• 如需为辅助磁盘分配其他标签，请使用 labels 字段。

    "labels": [
      {
        "key": "value"
      },
    ]
  

Terraform

如需创建自定义辅助磁盘，请使用创建与主磁盘相同的辅助磁盘中所述的方法。您可以指定其他字段来自定义辅助磁盘的属性。

以下示例展示了如何自定义辅助磁盘：

• 如需指定其他客机操作系统功能，请使用 guest_os_features 字段。您只能指定其他客机操作系统功能；您无法更改或移除从主磁盘复制的任何客机操作系统功能。

  guest_os_features {
    type = "SECURE_BOOT"
  }
  guest_os_features {
    type = "MULTI_IP_SUBNET"
  }
  guest_os_features {
    type = "WINDOWS"
  }
  

• 如需为辅助磁盘分配其他标签，请使用 labels 字段。

    labels = {
      environment = "dev"
    }
  

开始复制

创建主磁盘和辅助磁盘后，您必须开始复制，以开始将数据从主磁盘复制到辅助磁盘。

后续步骤

• 了解如何管理使用异步复制的磁盘。
• 了解如何管理复制。
• 了解如何管理一致性组。
• 了解如何监控异步复制性能。