Google 會運用 AI 技術將內容翻譯成你偏好的語言，但可能會出錯。

使用副本複製磁碟

本文說明磁碟複製的運作方式，以及如何建立磁碟複製。磁碟複製功能可讓您在相同位置 (可用區或區域) 建立現有磁碟的可用副本。在需要現有磁碟副本並立即連接至 VM 的情況下，建立磁碟副本，例如：

複製正式環境資料來建立測試環境，以便進行偵錯，不會干擾正式環境
對磁碟執行非破壞性惡意軟體掃描，不會影響生產工作負載的效能
建立資料庫備份驗證副本
將非開機磁碟資料移至新專案
在水平擴展 VM 時複製磁碟

如要為資料啟用災難復原功能，請使用標準快照備份磁碟，而非使用磁碟副本。如要定期擷取磁碟內容，但不想建立新磁碟，請使用即時快照，因為這比建立副本更節省儲存空間。如需其他磁碟保護選項，請參閱「資料保護選項」。

事前準備

如果尚未設定驗證，請先完成設定。驗證可確認您的身分，以便存取 Google Cloud 服務和 API。如要從本機開發環境執行程式碼或範例，請選取下列其中一個選項，向 Compute Engine 進行驗證：
選取這個頁面上範例的預計用途分頁：
控制台

使用 Google Cloud 控制台存取 Google Cloud 服務和 API 時，您不需要設定驗證機制。
gcloud
1. 安裝 Google Cloud CLI。完成後，執行下列指令來初始化 Google Cloud CLI：
  gcloud init
  如果您使用外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。
  
  注意：如果您已經安裝 gcloud CLI，請務必執行 gcloud components update，確認您安裝的是最新版本。
設定預設區域和可用區。

Terraform

如要在本機開發環境中使用本頁的 Terraform 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

安裝 Google Cloud CLI。
如果您使用外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。
如果您使用的是本機殼層，請為使用者帳戶建立本機驗證憑證：
```
gcloud auth application-default login
```
如果您使用 Cloud Shell，則不需要執行這項操作。

如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已使用聯合身分登入 gcloud CLI。

詳情請參閱「設定本機開發環境的驗證機制」。

Go

如要在本機開發環境中使用本頁的 Go 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

安裝 Google Cloud CLI。
如果您使用外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。
如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：
```
gcloud auth application-default login
```
如果您使用 Cloud Shell，則不需要執行這項操作。

如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已使用聯合身分登入 gcloud CLI。

詳情請參閱「為本機開發環境設定驗證機制」。

Java

如要在本機開發環境中使用本頁的 Java 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

安裝 Google Cloud CLI。
若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。
如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：
```
gcloud auth application-default login
```
如果您使用 Cloud Shell，則不需要執行這項操作。

如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已使用聯合身分登入 gcloud CLI。

詳情請參閱「設定本機開發環境的驗證機制」。

Python

如要在本機開發環境中使用本頁的 Python 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

安裝 Google Cloud CLI。
若您採用的是外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。
如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證：
```
gcloud auth application-default login
```
如果您使用的是 Cloud Shell，則不必執行這項操作。

如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已使用聯合身分登入 gcloud CLI。

詳情請參閱「設定本機開發環境的驗證機制」。

REST

如要在本機開發環境中使用本頁的 REST API 範例，請使用您提供給 gcloud CLI 的憑證。

安裝 Google Cloud CLI。

如果您使用外部識別資訊提供者 (IdP)，請先使用聯合身分登入 gcloud CLI。

詳情請參閱 Google Cloud 驗證說明文件中的「使用 REST 進行驗證」一節。

用途摘要

除了複製磁碟以進行快速測試和偵錯外，您也可以從可用區磁碟建立區域性本機副本，為可用區磁碟啟用高可用性。從可用區磁碟建立區域性磁碟時，區域性磁碟會在同一區域內的兩個可用區中，建立磁碟副本。建立區域磁碟後，請改用新的區域磁碟，而非可用區磁碟。萬一某個可用區發生中斷，您仍可透過其他可用區的副本存取資料。

下表摘要說明 Compute Engine 支援的不同類型副本。

複製類型	使用時機	支援的磁碟類型
從可用區磁碟建立可用區複製項目	在同一個可用區中建立磁碟的相同副本，以執行下列任一工作：複製現有磁碟並用於新的 VM，藉此水平擴展工作負載。使用正式環境資料的暫存、偵錯或測試環境。掃描正式環境中的磁碟，檢查是否有惡意軟體。將磁碟移至新專案。	永久磁碟：標準、平衡和 SSD 永久磁碟 Hyperdisk：所有 Hyperdisk 類型，但 Hyperdisk Balanced High Availability 除外
可用區磁碟的區域性副本	在其他可用區中新增資料副本，讓可用區工作負載具備高可用性。掃描生產環境中的磁碟是否含有惡意軟體。	永久磁碟：標準、平衡和 SSD 永久磁碟 Hyperdisk：Hyperdisk Extreme 和 Hyperdisk Balanced
區域磁碟的區域複製作業	在相同區域中建立區域磁碟的相同副本，用於：測試或水平擴展區域性高可用性 (HA) 工作負載。在執行管理工作或測試時，維持兩個可用區之間的資料備援。建立高可用性資料庫磁碟區的副本以供驗證。	永久磁碟：區域平衡型、SSD 和標準永久磁碟 Hyperdisk：Hyperdisk Balanced High Availability

磁碟複製的運作方式

複製磁碟時，您會建立新磁碟，其中包含來源磁碟上的所有資料。即使現有磁碟已連接至 VM 執行個體，您仍可建立磁碟複製。複製磁碟後，您可以刪除來源磁碟，不必擔心會連帶刪除副本。

根據預設，磁碟的複製項目會沿用其大小、效能限制、類型，以及確切的可用區或區域。您可以變更部分屬性，方法如下：

大小：你可以建立比來源磁碟大的副本，但不能建立比來源磁碟小的副本。
效能：如果是 Hyperdisk 磁碟區，您可以為複製作業指定不同的效能限制。可用區 Hyperdisk 磁碟區的區域性本機副本為 Hyperdisk Balanced High Availability 磁碟區，效能限制可能不同。
位置：根據預設，系統會在相同可用區建立可用區磁碟的本機副本，並在相同區域建立區域磁碟的本機副本。不過，如要建立可用區磁碟的區域性副本，可以指定第二個可用區，該可用區必須與可用區磁碟位於同一區域。新副本也稱為「區域副本」，在來源磁碟的可用區和您指定的第二個可用區中，各有一個副本。
類型：可用區 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區的區域性本機副本是 Hyperdisk Balanced High Availability 磁碟區。

資料磁碟的複製延遲

Compute Engine 通常會在十秒內，複製開發人員規模的資料 (非開機) 磁碟，最多可達 32 GiB。以 1 TiB 為基準，企業級資料磁碟的複製作業通常會在 1 分鐘內完成。

複製的磁碟可以附加至執行個體，並在建立後立即達到完整效能，免除初始化延遲，大幅加快安全掃描和開發測試環境設定等大規模工作流程。

從可用區 Hyperdisk 磁碟區複製的區域 Hyperdisk 磁碟區

現有可用區 Hyperdisk 磁碟區的區域性副本一律是新的 Hyperdisk Balanced High Availability 磁碟區。這是因為 Hyperdisk Balanced High Availability 是唯一支援的區域性 Hyperdisk。從可用區 Hyperdisk 建立區域性 Hyperdisk 的方式，取決於 Hyperdisk 的類型。

如果是可用區 Hyperdisk ML 和 Hyperdisk Throughput 磁碟區，您無法透過複製來源磁碟來建立區域磁碟。您必須依據可用區磁碟的快照，建立新的 Hyperdisk Balanced High Availability 磁碟區。
如果是可用區 Hyperdisk Balanced 和 Hyperdisk Extreme 磁碟區，請建立可用區 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區的區域性本機副本，藉此建立新的 Hyperdisk Balanced High Availability 磁碟區。

從可用區磁碟複製的 Hyperdisk Balanced High Availability 磁碟區效能

從 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區建立新的 Hyperdisk Balanced High Availability 磁碟區時，新磁碟會沿用來源磁碟的大小，但您也可以指定其他大小。

新磁碟的最大佈建效能可能低於來源磁碟，因為 Hyperdisk Extreme 和 Hyperdisk Balanced 的效能限制高於 Hyperdisk Balanced High Availability，如下表所示。

Hyperdisk 類型	每秒輸入/輸出作業數 (IOPS) 上限	最大處理量 ( MiB/秒)
Hyperdisk Balanced High Availability	100,000	2,400
Hyperdisk Balanced	160,000	2,400
Hyperdisk Extreme	350,000	5,000

您可以為新的區域性磁碟指定限制，但不得超過 Hyperdisk Balanced High Availability 提供的最高效能限制，也就是 100,000 IOPS 和 2,400 MiB/s。

如未指定新磁碟的效能限制，Compute Engine 會根據 Hyperdisk Balanced High Availability 磁碟區的大小，以預設 IOPS 和處理量佈建磁碟。如需預設限制，請參閱「Hyperdisk Balanced High Availability 的預設大小和效能限制」。

如要達到 100,000 IOPS，Hyperdisk Balanced High Availability 磁碟區的大小至少須為 200 GiB，因此您可能也需要增加區域性本機副本的佈建大小。

範例

假設有一個 150 GiB 的 Hyperdisk Extreme 磁碟區 hdx-1，佈建了 180,000 IOPS。

如果您建立 hdx-1 的區域性副本，但未指定新的大小或效能限制，Compute Engine 會建立 150 GiB 的 Hyperdisk Balanced High Availability 磁碟區，並套用該大小的預設 IOPS 限制：3,900 IOPS。

如果不增加大小，則區域複製最多可指定 75,000 IOPS。

從可用區 Persistent Disk 磁碟區複製的區域性 Persistent Disk 磁碟區

從可用區永久磁碟複製的區域性永久磁碟區，與複製來源的類型相同。舉例來說，如果您複製區域性標準永久磁碟，就會建立地區性標準永久磁碟區。

不過，Persistent Disk 磁碟區的區域性副本大小和效能限制，可能與區域來源磁碟不同，如下所示。

效能限制較低：Persistent Disk 的區域性複製可能具有比來源磁碟更低的 IOPS 和處理量效能限制。這是因為可用區永久磁碟提供更高的執行個體效能上限。舉例來說，可用區平衡型永久磁碟的執行個體寫入 IOPS 上限為 80,000，但區域性平衡型永久磁碟的寫入 IOPS 上限為 60,000。

如需詳細的效能限制，請比較可用區永久磁碟的效能限制和區域永久磁碟的效能限制。
區域性標準永久磁碟的大小下限為 200 GiB：區域性標準永久磁碟的大小下限為 200 GiB。因此，如要建立 10 到 199 GiB 可用區標準永久磁碟區的區域複製磁碟，您必須為區域磁碟指定至少 200 GiB 的大小。

支援的磁碟類型

如果複製項目與來源磁碟位於相同位置 (可用區或區域)，您可以複製所有 Persistent Disk 和 Hyperdisk 類型。

只有下列磁碟類型支援將可用區磁碟複製到區域磁碟：

Google Cloud Hyperdisk：
- Hyperdisk Balanced
- Hyperdisk Extreme
如要從 Hyperdisk ML 或 Hyperdisk Throughput 磁碟區建立區域磁碟，請先建立快照，然後從快照建立 Hyperdisk Balanced High Availability 磁碟區。
Persistent Disk：
- 平衡型永久磁碟
- SSD 永久磁碟
- 標準永久磁碟

限制

磁碟複製功能有下列限制：

您無法透過複製可用區 Hyperdisk ML 或 Hyperdisk Throughput 磁碟區，建立 Hyperdisk Balanced High Availability 磁碟區。如要為這些 Hyperdisk 類型建立 Hyperdisk Balanced High Availability 磁碟區，請完成「將可用區磁碟變更為區域性 Hyperdisk Balanced High Availability 磁碟區」一文中的步驟。
您無法複製儲存空間集區中的磁碟。
您無法在不同可用區中，建立現有可用區磁碟的可用區磁碟副本。
複製磁碟的大小至少須與來源磁碟相同。如果您使用 Google Cloud 控制台建立副本，則無法指定磁碟大小，副本會與來源磁碟大小相同。
如果您是透過 Google Cloud 控制台複製 Hyperdisk 或 Persistent Disk 磁碟區，則無法為複製的磁碟指定佈建效能。
如果您使用客戶提供的加密金鑰 (CSEK) 或客戶自行管理的加密金鑰 (CMEK) 加密來源磁碟，則必須使用相同的金鑰加密複製磁碟。詳情請參閱「建立加密來源磁碟的複製項目」。
建立來源磁碟的副本時，無法刪除來源磁碟。
建立副本時，來源磁碟所連結的運算執行個體無法開機。
如果來源磁碟已標示為與其連結的 VM 一併刪除，則在建立複製磁碟時，您無法刪除 VM。
每 30 秒最多可建立一個指定來源磁碟或其副本的副本。
您最多可以同時複製 1,000 個來源磁碟或其副本。超過此限制會傳回 internalError。不過，如果您建立磁碟複製，並在之後刪除，則刪除的磁碟複製不會計入這項限制。
磁碟複製完成後，該磁碟或其副本的任何後續副本，都會計入原始來源磁碟同時複製 1,000 個磁碟的限制，以及每 30 秒最多建立一個副本的限制。
如果透過複製可用區磁碟來建立區域磁碟，每 15 分鐘最多可複製 1 TiB 的容量，爆發要求限制為 257 TiB。
您無法從區域磁碟建立可用區磁碟副本。
如要從可用區來源磁碟建立區域磁碟副本，區域磁碟副本的其中一個副本可用區必須與來源磁碟的可用區相符。
建立完成後，區域磁碟副本平均會在 3 分鐘內可用。不過，磁碟可能需要數十分鐘才能完成複製，並達到復原點目標 (RPO) 接近零的狀態。
如果可用區磁碟是依據映像檔建立，則無法用於建立區域磁碟複製。

錯誤訊息

如果超過複製頻率限制，要求會失敗並顯示下列錯誤：

RATE LIMIT: ERROR: (gcloud.compute.disks.create) Could not fetch resource:
 - Operation rate exceeded for resource RESOURCE. Too frequent operations from the source resource.

建立磁碟副本

本節說明如何複製現有磁碟，並建立磁碟副本。

如需詳細步驟，請參閱本文的下列任一節，瞭解如何建立不同類型的磁碟副本：

如要複製磁碟以進行快速測試、偵錯或水平擴展，請在與來源相同的地點建立磁碟本機副本
如要讓可用區磁碟具備高可用性，請依據可用區磁碟建立區域磁碟本機副本
建立加密來源磁碟的副本

這項工作需要的權限

如要執行這項工作，您必須具備下列權限：

專案的 compute.disks.create 權限
compute.disks.useReadOnly 來源磁碟

在與來源相同的位置建立磁碟副本

您可以使用Google Cloud 控制台、Google Cloud CLI、REST 或 Cloud 用戶端程式庫，複製與來源磁碟位於相同可用區或區域的現有可用區或區域磁碟。

Google Cloud 控制台

前往 Google Cloud 控制台的「Disks」(磁碟) 頁面。

前往「Disks」(磁碟)
在磁碟清單中，找到要複製的磁碟。
在「Actions」(動作) 欄中，按一下選單按鈕，然後選取「Clone disk」(複製磁碟)。

在隨即顯示的「複製磁碟」面板中，執行下列操作：
1. 在「Name」(名稱) 欄位中，指定複製磁碟的名稱。
2. 選用：如果是可用區磁碟，請在「位置」下方，確認已選取「單一可用區」。
3. 在「屬性」下方，查看複製磁碟的其他詳細資料。
4. 按一下「Create」(建立)，完成建立複製磁碟。

Google Cloud CLI

如要複製可用區來源磁碟並建立新的可用區磁碟，請執行 disks create 指令，並指定 --source-disk 旗標：

gcloud compute disks create TARGET_DISK_NAME \
    --description="cloned disk" \
    --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME

更改下列內容：

TARGET_DISK_NAME：新磁碟的名稱。
PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
SOURCE_DISK_NAME：來源磁碟的名稱。

Terraform

如要建立磁碟副本，請使用 google_compute_disk 資源。

resource "google_compute_disk" "default" {
  name  = "disk-name1"
  type  = "pd-ssd"
  zone  = "us-central1-a"
  image = "debian-13-trixie-v20260908"
  labels = {
    environment = "dev"
  }
  physical_block_size_bytes = 4096
}

如要瞭解如何套用或移除 Terraform 設定，請參閱「基本 Terraform 指令」。

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"
)

// createDiskFromDisk creates a new disk with the contents of
// an already existitng disk. Type, and size and zone may differ.
func createDiskFromDisk(
	w io.Writer,
	projectID, zone, diskName, diskType, sourceDiskLink 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"
	// sourceDiskLink := "projects/your_project_id/global/disks/disk_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),
			SourceDisk: proto.String(sourceDiskLink),
			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

在試用這個範例之前，請先按照「使用用戶端程式庫的 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.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateFromSource {

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    createDiskFromDisk(project, zone, diskName, diskType, diskSizeGb, diskLink);
  }

  // Creates a disk in a project in a given zone.
  public static void createDiskFromDisk(String project, String zone, String diskName,
      String diskType, int diskSizeGb, String diskLink)
      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()) {

      // Create the disk.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setType(diskType)
          .setName(diskName)
          .build();

      // Wait for the insert instance operation to complete.
      Operation operation = disksClient.insertAsync(project, zone, disk)
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk created from source. Operation Status: " + operation.getStatus());
    }
  }
}

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_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
) -> compute_v1.Disk:
    """
    Creates a disk in a project in a 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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"

    Returns:
        An attachable disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_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

如要複製可用區來源磁碟並建立新的可用區磁碟，請向 compute.disks.insert 方法提出 POST 要求。在要求主體中，指定 name 和 sourceDisk 參數。磁碟副本會從來源磁碟繼承所有省略的屬性。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
}

更改下列內容：

PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
TARGET_DISK_NAME：新磁碟的名稱。
SOURCE_DISK_NAME：來源磁碟的名稱

從可用區磁碟建立區域性磁碟副本

您可以複製下列任一類型的現有可用區磁碟，建立新的區域磁碟：

Hyperdisk Balanced
Hyperdisk Extreme
標準、平衡型和 SSD 永久磁碟

如果來源磁碟是 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區，區域性磁碟一律為 Hyperdisk Balanced High Availability 磁碟區，不會沿用區域性磁碟的相同佈建效能。如要設定區域磁碟的佈建效能，您必須使用 Google Cloud CLI 或 REST 複製磁碟。如果使用 Google Cloud 控制台複製磁碟，您無法指定效能限制，系統會根據磁碟大小佈建預設限制。

控制台

前往 Google Cloud 控制台的「Disks」(磁碟) 頁面。

前往「Disks」(磁碟)
在磁碟清單中，找出要複製的區域 Persistent Disk 磁碟區。
在「動作」欄中，按一下選單按鈕，然後選取「複製磁碟」。

在隨即顯示的「複製磁碟」面板中，執行下列操作：
1. 在「Name」(名稱) 欄位中，指定複製磁碟的名稱。
2. 在「位置」下方選取「區域」，然後選取新區域複製磁碟的次要副本可用區。
3. 在「Properties」(屬性) 下方，查看複製磁碟的其他詳細資料。
4. 按一下「建立」，即可完成複製磁碟的建立作業。

gcloud

如要從可用區磁碟建立區域磁碟副本，請執行 gcloud compute disks create 指令，並指定 --region 和 --replica-zones 參數。

如果可用區磁碟是 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區，請指定 --disk-type=hyperdisk-balanced-high-availability 旗標，因為區域磁碟必須是 Hyperdisk Balanced High Availability 磁碟區。

如要複製 Persistent Disk 磁碟區，請省略 --disk-type 旗標。

gcloud compute disks create TARGET_DISK_NAME \
  --description="zonal to regional cloned disk" \
  --region=CLONED_REGION \
  --source-disk=SOURCE_DISK_NAME \
  --source-disk-zone=SOURCE_DISK_ZONE \
  --replica-zones=SOURCE_DISK_ZONE,REPLICA_ZONE_2 \
  --project=PROJECT_ID \
  [ --disk-type=hyperdisk-balanced-high-availability ] \
  [ --provisioned-iops=IOPS_LIMIT ] \
  [ --provisioned-throughput=THROUGHPUT_LIMIT ]

更改下列內容：

TARGET_DISK_NAME：新區域磁碟副本的名稱。
CLONED_REGION：來源和複製磁碟的區域。
SOURCE_DISK_NAME：要複製的可用區磁碟名稱。
SOURCE_DISK_ZONE：來源磁碟的可用區。這也會是區域性磁碟副本的第一個副本可用區。
REPLICA_ZONE_2：新區域磁碟副本的第二個副本可用區。
PROJECT_ID：要複製磁碟的專案 ID。
IOPS_LIMIT：選用：如要建立區域 Hyperdisk Balanced High Availability 磁碟，可以指定磁碟可處理的 IOPS 數量，最多 100,000 IOPS。
THROUGHPUT_LIMIT：選用：如要建立區域性 Hyperdisk Balanced High Availability 磁碟，您可以指定磁碟可提供的最大處理量 (MiB/秒)，最高可達 2,400 MiB/秒。

Terraform

如要從可用區磁碟建立區域性磁碟本機副本，請使用下列資源。如果來源磁碟是 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區，請將 type 引數設為 hyperdisk-balanced-high-availability。

google_compute_region_disk

resource "google_compute_region_disk" "regiondisk" {
  name                      = "region-disk-name"
  snapshot                  = google_compute_snapshot.snapdisk.id
  type                      = "pd-ssd"
  region                    = "us-central1"
  physical_block_size_bytes = 4096
  size                      = 11

  replica_zones = ["us-central1-a", "us-central1-f"]
}

如要瞭解如何套用或移除 Terraform 設定，請參閱「基本 Terraform 指令」。

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"
)

// createRegionalDiskFromDisk creates a new regional disk with the contents of
// an already existitng zonal disk. Disk type and size may differ.
func createRegionalDiskFromDisk(
	w io.Writer,
	projectID, region string, replicaZones []string,
	diskName, diskType, sourceDiskLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// region := "us-west3" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "regions/us-west3/diskTypes/pd-ssd"
	// sourceDiskLink := "projects/your_project_id/global/disks/disk_name"
	// diskSizeGb := 120

	// 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]),
	}

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

	req := &computepb.InsertRegionDiskRequest{
		Project: projectID,
		Region:  region,
		DiskResource: &computepb.Disk{
			Name:         proto.String(diskName),
			Region:       proto.String(region),
			Type:         proto.String(diskType),
			SourceDisk:   proto.String(sourceDiskLink),
			SizeGb:       proto.Int64(diskSizeGb),
			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

在試用這個範例之前，請先按照「使用用戶端程式庫的 Compute Engine 快速入門導覽課程」中的 Java 設定操作說明進行操作。詳情請參閱「Compute Engine Java API 參考文件」。

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。


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

public class RegionalCreateFromSource {

  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 project = "YOUR_PROJECT_ID";

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

    // An iterable collection of zone names in which you want to keep
    // the new disks' replicas. One of the replica zones of the clone must match
    // the zone of the source disk.
    List<String> replicaZones = new ArrayList<>();

    // 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_NAME");

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

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // 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}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", "PROJECT_NAME",
        "SNAPSHOT_NAME");

    createRegionalDisk(project, region, replicaZones, diskName, diskType, diskSizeGb,
        Optional.ofNullable(diskLink), Optional.ofNullable(snapshotLink));
  }

  // Creates a regional disk from an existing zonal disk in a given project.
  public static void createRegionalDisk(
      String project, String region, List<String> replicaZones, String diskName, String diskType,
      int diskSizeGb, Optional<String> diskLink, Optional<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 `regionDisksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (RegionDisksClient regionDisksClient = RegionDisksClient.create()) {

      Disk.Builder diskBuilder = Disk.newBuilder()
          .addAllReplicaZones(replicaZones)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setRegion(region);

      // Set source disk if diskLink is not empty.
      diskLink.ifPresent(diskBuilder::setSourceDisk);

      // Set source snapshot if the snapshot link is not empty.
      snapshotLink.ifPresent(diskBuilder::setSourceSnapshot);

      // Wait for the operation to complete.
      Operation operation = regionDisksClient.insertAsync(project, region, diskBuilder.build())
          .get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Regional disk created. Operation Status: " + operation.getStatus());
    }
  }
}

Python

在試用這個範例之前，請先按照「使用用戶端程式庫的 Compute Engine 快速入門導覽課程」中的 Python 設定說明操作。詳情請參閱「Compute Engine Python API 參考文件」。

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

from __future__ import annotations

from collections.abc import Iterable
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_regional_disk(
    project_id: str,
    region: str,
    replica_zones: Iterable[str],
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str | None = None,
    snapshot_link: str | None = None,
) -> compute_v1.Disk:
    """
    Creates a regional disk from an existing zonal disk in a given project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region in which you want to create the disk.
        replica_zones: an iterable collection of zone names in which you want to keep
            the new disks' replicas. One of the replica zones of the clone must match
            the zone of the source 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:
            "regions/{region}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "regions/us-west3/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        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 attachable regional disk.
    """
    disk_client = compute_v1.RegionDisksClient()
    disk = compute_v1.Disk()
    disk.replica_zones = replica_zones
    disk.size_gb = disk_size_gb
    if disk_link:
        disk.source_disk = disk_link
    if snapshot_link:
        disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.region = region
    disk.name = disk_name
    operation = disk_client.insert(
        project=project_id, region=region, disk_resource=disk
    )

    wait_for_extended_operation(operation, "disk creation")

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

REST

如要從可用區磁碟建立區域性磁碟副本，請向 compute.disks.insert 方法提出 POST 要求，並指定 sourceDisk 和 replicaZone 參數。

如果可用區磁碟是 Hyperdisk Balanced 或 Hyperdisk Extreme 磁碟區，請加入 type 欄位，建立 Hyperdisk Balanced High Availability 磁碟區。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/CLONED_REGION/disks

{
  "name": "TARGET_DISK_NAME",
  "sourceDisk": "projects/PROJECT_ID/zones/SOURCE_DISK_ZONE/disks/SOURCE_DISK_NAME",
  "replicaZone": "SOURCE_DISK_ZONE,REPLICA_ZONE_2",
  "type": "projects/PROJECT_ID/regions/CLONED_REGION/diskTypes/hyperdisk-balanced-high-availability",
  "provisionedIops": "IOPS_LIMIT",
  "provisionedThroughput": "THROUGHPUT_LIMIT"
}

更改下列內容：

PROJECT_ID：您要複製磁碟的專案 ID。
TARGET_DISK_NAME：新區域磁碟副本的名稱。
CLONED_REGION：來源和複製磁碟的區域。
SOURCE_DISK_NAME：要複製的可用區磁碟名稱。
SOURCE_DISK_ZONE：來源磁碟的可用區。這也會是區域性磁碟副本的第一個副本可用區。
REPLICA_ZONE_2：新區域磁碟複製項的第二個副本可用區。
IOPS_LIMIT：選用：如要建立區域 Hyperdisk Balanced High Availability 磁碟，可以指定磁碟可處理的 IOPS 數量，最多 100,000 IOPS。
THROUGHPUT_LIMIT：選用：如要建立區域 Hyperdisk Balanced High Availability 磁碟，可以指定磁碟可提供的最大處理量 (以 MiB/秒為單位)，最高可達 2,400 MiB/秒。

建立 CMEK 或 CSEK 加密來源磁碟的磁碟複製

如要建立以 CSEK 或 CMEK 加密的磁碟的區域或區域性副本，請按照前幾節所述程序操作。不過，您也必須提供用於加密來源磁碟的金鑰。

為採用 CSEK 加密的磁碟建立磁碟副本

如果您使用 CSEK 加密來源磁碟，也必須使用相同的金鑰加密副本。

控制台

前往 Google Cloud 控制台的「Disks」(磁碟) 頁面。

前往「Disks」(磁碟)
在區域永久磁碟清單中，找出要複製的磁碟。
在「動作」欄中，按一下選單按鈕，然後選取「複製磁碟」。

在隨即顯示的「複製磁碟」面板中，執行下列操作：
1. 在「Name」(名稱) 欄位中，指定複製磁碟的名稱。
2. 在「Decryption and encryption」(解密和加密) 欄位中，提供來源磁碟加密金鑰。
3. 在「Properties」(屬性) 下方，查看複製磁碟的其他詳細資料。
4. 按一下「建立」，即可完成複製磁碟的建立作業。

gcloud

如要為 CSEK 加密來源磁碟建立磁碟副本，請執行 gcloud compute disks create 指令，並使用 --csek-key-file 旗標提供來源磁碟加密金鑰。如果使用 RSA 包裝金鑰，請使用 gcloud beta compute disks create 指令。

gcloud compute disks create TARGET_DISK_NAME \
  --description="cloned disk" \
  --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME \
  --csek-key-file example-key-file.json

更改下列內容：

TARGET_DISK_NAME：新磁碟的名稱。
PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
SOURCE_DISK_NAME：來源磁碟的名稱

Go

如要向 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"
)

// Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.
// The encryption key must be the same for the source disk and the new disk.
// The disk type and size may differ.
func createDiskFromCustomerEncryptedDisk(
	w io.Writer,
	projectID, zone, diskName, diskType string,
	diskSizeGb int64,
	diskLink, encryptionKey string,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3/diskTypes/pd-ssd"
	// diskSizeGb := 120
	// diskLink := "projects/your_project_id/global/disks/disk_name"
	// encryptionKey := "SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=" // in base64

	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),
			SizeGb:     proto.Int64(diskSizeGb),
			SourceDisk: proto.String(diskLink),
			DiskEncryptionKey: &computepb.CustomerEncryptionKey{
				RawKey: &encryptionKey,
			},
		},
	}

	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

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。


import com.google.cloud.compute.v1.CustomerEncryptionKey;
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 com.google.protobuf.ByteString;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CloneEncryptedDisk {

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // Customer-supplied encryption key used for encrypting data in the source disk.
    // The data will be encrypted with the same key in the new disk.
    byte[] encryptionKey = null;

    createDiskFromCustomerEncryptedKey(project, zone, diskName, diskType, diskSizeGb, diskLink,
        encryptionKey);
  }

  // Creates a zonal non-boot persistent disk in a project with the copy of data
  // from an existing disk.
  // The encryption key must be the same for the source disk and the new disk.
  public static void createDiskFromCustomerEncryptedKey(String project, String zone,
      String diskName, String diskType, int diskSizeGb, String diskLink, byte[] encryptionKey)
      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()) {

      // Create a disk and set the encryption key.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setDiskEncryptionKey(CustomerEncryptionKey
              .newBuilder()
              .setRawKeyBytes(ByteString.copyFrom(encryptionKey))
              .build())
          .build();

      // Wait for the insert disk operation to complete.
      Operation operation = disksClient.insertAsync(
          InsertDiskRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setDiskResource(disk)
              .build()).get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk cloned with customer encryption key. Operation Status: " + operation.getStatus());
    }
  }
}

Python

如要向 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_customer_encrypted_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
    encryption_key: bytes,
) -> compute_v1.Disk:
    """
    Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.

    The encryption key must be the same for the source disk and the new disk.

    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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        encryption_key: customer-supplied encryption key used for encrypting
            data in the source disk. The data will be encrypted with the same key
            in the new disk.

    Returns:
        An attachable copy of an existing disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_link
    disk.type_ = disk_type
    disk.name = disk_name
    disk.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    disk.disk_encryption_key.raw_key = encryption_key
    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

如要為 CSEK 加密來源磁碟建立磁碟副本，請向 compute.disks.insert 方法發出 POST 要求，並使用 diskEncryptionKey 屬性提供來源磁碟加密金鑰。如果使用 RSA 包裝的金鑰，請使用方法的 beta 版本。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
  "diskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
}

更改下列內容：

PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
TARGET_DISK_NAME：新磁碟的名稱。
SOURCE_DISK_NAME：來源磁碟的名稱

為 CMEK 加密磁碟建立磁碟本機副本

如果您使用 CMEK 加密來源磁碟，也必須使用相同的金鑰加密複製磁碟。

控制台

Compute Engine 會自動使用來源磁碟加密金鑰來加密副本。

gcloud

如要為 CMEK 加密的來源磁碟建立磁碟複製，請執行 gcloud compute disks create 指令，並使用 --kms-key 旗標提供來源磁碟加密金鑰。如果您使用的是 RSA 包裝金鑰，請使用 gcloud beta compute disks create 指令。

gcloud compute disks create TARGET_DISK_NAME \
  --description="cloned disk" \
  --source-disk=projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME \
  --kms-key projects/KMS_PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY

更改下列內容：

TARGET_DISK_NAME：新磁碟的名稱。
PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
SOURCE_DISK_NAME：來源磁碟的名稱。
KMS_PROJECT_ID：加密金鑰的專案 ID。
REGION：加密金鑰的區域。
KEY_RING：加密金鑰的金鑰環。
KEY：加密金鑰的名稱。

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"
)

// Creates a zonal non-boot persistent disk in a project with the copy of data from an existing disk.
// The encryption key must be the same for the source disk and the new disk.
// The disk type and size may differ.
func createDiskFromKmsEncryptedDisk(
	w io.Writer,
	projectID, zone, diskName, diskType string,
	diskSizeGb int64,
	diskLink, kmsKeyLink string,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3/diskTypes/pd-ssd"
	// diskSizeGb := 120
	// diskLink := "projects/your_project_id/global/disks/disk_name"
	// kmsKeyLink := "projects/your_kms_project_id/locations/us-central1/keyRings/your_key_ring/cryptoKeys/your_key"

	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),
			SizeGb:     proto.Int64(diskSizeGb),
			SourceDisk: proto.String(diskLink),
			DiskEncryptionKey: &computepb.CustomerEncryptionKey{
				KmsKeyName: &kmsKeyLink,
			},
		},
	}

	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

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。


import com.google.cloud.compute.v1.CustomerEncryptionKey;
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 CloneEncryptedDiskManagedKey {

  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 project = "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.
    int diskSizeGb = 10;

    // A link to the disk you want to use as a source for the new disk.
    // This value uses the following format:
    // "projects/{project_name}/zones/{zone}/disks/{disk_name}"
    String diskLink = String.format("projects/%s/zones/%s/disks/%s", "PROJECT_NAME", "ZONE",
        "DISK_NAME");

    // URL of the key from KMS. The key might be from another project, as
    // long as you have access to it. The data will be encrypted with the same key
    // in the new disk. This value uses following format:
    // "projects/{kms_project_id}/locations/{region}/keyRings/{key_ring}/cryptoKeys/{key}"
    String kmsKeyName = "kms-key-name";

    createDiskFromKmsEncryptedDisk(project, zone, diskName, diskType, diskSizeGb, diskLink,
        kmsKeyName);
  }

  // Creates a zonal non-boot disk in a project with the copy of data from an existing disk.
  // The encryption key must be the same for the source disk and the new disk.
  public static void createDiskFromKmsEncryptedDisk(String project, String zone, String diskName,
      String diskType, int diskSizeGb, String diskLink, String kmsKeyName)
      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()) {

      // Create a disk and set the KMS encryption key name.
      Disk disk = Disk.newBuilder()
          .setZone(zone)
          .setName(diskName)
          .setType(diskType)
          .setSizeGb(diskSizeGb)
          .setSourceDisk(diskLink)
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setKmsKeyName(kmsKeyName)
              .build())
          .build();

      // Wait for the insert disk operation to complete.
      Operation operation = disksClient.insertAsync(
          InsertDiskRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setDiskResource(disk)
              .build()).get(3, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }
      System.out.println(
          "Disk cloned with KMS encryption key. Operation Status: " + operation.getStatus());
    }
  }
}

Python

如要向 Compute Engine 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

from __future__ import annotations

import sys
from typing import Any

from google.api_core.exceptions import BadRequest
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_kms_encrypted_disk(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    disk_link: str,
    kms_key_name: str,
) -> compute_v1.Disk:
    """
    Creates a zonal non-boot disk in a project with the copy of data from an existing disk.

    The encryption key must be the same for the source disk and the new disk.

    To run this method, the service-<project_id>@compute-system.iam.gserviceaccount.com
    service account needs to have the cloudkms.cryptoKeyEncrypterDecrypter role,
    as described in documentation:
    https://cloud.google.com/compute/docs/disks/customer-managed-encryption#before_you_begin

    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
        disk_link: a link to the disk you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/zones/{zone}/disks/{disk_name}"
        kms_key_name: URL of the key from KMS. The key might be from another project, as
            long as you have access to it. The data will be encrypted with the same key
            in the new disk. This value uses following format:
            "projects/{kms_project_id}/locations/{region}/keyRings/{key_ring}/cryptoKeys/{key}"

    Returns:
        An attachable copy of an existing disk.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_disk = disk_link
    disk.type_ = disk_type
    disk.name = disk_name
    disk.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    disk.disk_encryption_key.kms_key_name = kms_key_name
    try:
        operation = disk_client.insert(
            project=project_id, zone=zone, disk_resource=disk
        )
    except BadRequest as err:
        if "Permission 'cloudkms.cryptoKeyVersions.useToEncrypt' denied" in err.message:
            print(
                f"Please provide the cloudkms.cryptoKeyEncrypterDecrypter role to"
                f"service-{project_id}@compute-system.iam.gserviceaccount.com"
            )
        raise err

    wait_for_extended_operation(operation, "disk creation")

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

REST

如要為 CMEK 加密來源磁碟建立磁碟本機副本，請向 compute.disks.insert 方法提出 POST 要求，並使用 kmsKeyName 屬性提供來源磁碟加密金鑰。如果您使用的是 RSA 包裝金鑰，請使用beta 版本的這個方法。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks

{
  "name": "TARGET_DISK_NAME"
  "sourceDisk": "projects/PROJECT_ID/zones/ZONE/disks/SOURCE_DISK_NAME"
  "diskEncryptionKey": {
    "kmsKeyName": "projects/KMS_PROJECT_ID/locations/REGION/keyRings/KEY_RING/cryptoKeys/KEY"
  },
}

更改下列內容：

PROJECT_ID：您要複製磁碟的專案 ID。
ZONE：來源和新磁碟的可用區。
TARGET_DISK_NAME：新磁碟的名稱。
SOURCE_DISK_NAME：來源磁碟的名稱。
KMS_PROJECT_ID：加密金鑰的專案 ID。
REGION：加密金鑰的區域。
KEY_RING：加密金鑰的金鑰環。
KEY：加密金鑰的名稱。

後續步驟

瞭解如何使用標準快照定期備份磁碟，避免資料意外遺失。
瞭解如何使用即時快照就地備份磁碟。
瞭解如何使用區域性永久磁碟，在兩個可用區之間進行同步複製。
瞭解非同步複製。

使用副本複製磁碟 透過集合功能整理內容 你可以依據偏好儲存及分類內容。

事前準備

控制台

gcloud

Terraform

Go

Java

Python

REST

用途摘要

磁碟複製的運作方式

資料磁碟的複製延遲

從可用區 Hyperdisk 磁碟區複製的區域 Hyperdisk 磁碟區

從可用區磁碟複製的 Hyperdisk Balanced High Availability 磁碟區效能

範例

從可用區 Persistent Disk 磁碟區複製的區域性 Persistent Disk 磁碟區

支援的磁碟類型

限制

錯誤訊息

建立磁碟副本

這項工作需要的權限

在與來源相同的位置建立磁碟副本

Google Cloud 控制台

Google Cloud CLI

Terraform

Go

Go

Java

Java

Python

Python

REST

從可用區磁碟建立區域性磁碟副本

控制台

gcloud

Terraform

Go

Go

Java

Java

Python

Python

REST

建立 CMEK 或 CSEK 加密來源磁碟的磁碟複製

為採用 CSEK 加密的磁碟建立磁碟副本

控制台

gcloud

Go

Go

Java

Java

Python

Python

REST

為 CMEK 加密磁碟建立磁碟本機副本

控制台

gcloud

Go

Go

Java

Java

Python

Python

REST

後續步驟

使用副本複製磁碟