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

使用副本複製磁碟

磁碟複製功能可讓您在與來源磁碟相同的位置 (可用區或區域) 建立現有磁碟的副本，並立即使用。在下列情況下，您可以建立磁碟複製，快速將現有磁碟的副本附加至執行個體：

複製正式環境資料來建立測試環境，以便在不干擾正式環境的情況下進行偵錯
對磁碟執行不中斷的惡意軟體掃描，不影響正式環境工作負載的效能
建立資料庫備份驗證副本
將非開機磁碟資料移至新專案
在水平擴展 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，藉此水平擴展工作負載。使用正式環境資料的暫存、偵錯或測試環境。掃描正式環境中的磁碟，檢查是否有惡意軟體。將磁碟移至新專案。	Persistent Disk：標準、平衡和 SSD 永久磁碟 Google Cloud 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 Balanced 或 Hyperdisk Extreme 磁碟區，您可以複製來源磁碟來建立區域磁碟。
如果來源磁碟是 Hyperdisk ML 或 Hyperdisk Throughput 磁碟區，您就無法複製來源磁碟來建立區域磁碟。您必須依據可用區磁碟的快照，建立新的 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，因此您可能也需要增加區域性本機副本的佈建大小。

範例

假設您佈建了 180,000 IOPS，並使用 150 GiB 的 Hyperdisk Extreme 磁碟區 hdx-1。

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

根據「Hyperdisk Balanced High Availability 磁碟區可設定 IOPS 的限制」一節所述的公式，150 GiB Hyperdisk Balanced High Availability 磁碟區可指定的 IOPS 上限為 75,000 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 的大小。

支援的磁碟類型

如果複製作業與來源磁碟位於相同位置 (可用區或區域)，您可以複製所有永久磁碟和 Hyperdisk 類型。

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

Hyperdisk：
- Hyperdisk Balanced
- Hyperdisk Extreme 如要從 Hyperdisk ML 或 Hyperdisk Throughput 磁碟區建立區域性磁碟，請按照「將區域性磁碟變更為 Hyperdisk Balanced High Availability 磁碟區」一文中的步驟操作。
Persistent Disk：
- 平衡型永久磁碟
- SSD 永久磁碟
- 標準永久磁碟
極端永久磁碟區僅限可用區，不支援區域磁碟。

限制

磁碟複製作業有下列限制。

一般限制

所有磁碟複製作業都適用下列限制。

無法複製 Hyperdisk 集區中的磁碟。
複製磁碟的大小至少須與來源磁碟相同。如果您使用 Google Cloud 控制台建立副本，則無法指定磁碟大小，副本會與來源磁碟大小相同。
您無法在不同可用區中，建立現有可用區磁碟的可用區磁碟副本。
無法在建立來源磁碟的複製項目時刪除來源磁碟。
建立複製作業時，無法開啟來源磁碟所連結的運算執行個體。
如果來源磁碟已標示為要連同所連執行個體一併刪除，則在建立副本時，您無法刪除執行個體。
如果從 Google Cloud 控制台複製 Hyperdisk 或 Persistent Disk 磁碟區，則無法為複製的磁碟指定佈建效能。
如果您使用客戶提供的加密金鑰 (CSEK) (已淘汰) 或客戶自行管理的加密金鑰 (CMEK) 加密來源磁碟，則必須使用相同的金鑰加密複製磁碟。

詳情請參閱「建立加密來源磁碟的複製本」。
無法透過複製區域磁碟來建立可用區磁碟。
如要從可用區來源磁碟建立區域磁碟副本，區域磁碟副本的其中一個副本可用區必須與來源磁碟的可用區相符。
建立完成後，區域磁碟副本平均會在三分鐘內可用。不過，磁碟可能需要數十分鐘才能完全複製，並達到復原點目標 (RPO) 接近零的狀態。
相較於複製依據快照建立的可用區資料磁碟或可用區開機磁碟，依據映像檔建立的可用區開機磁碟建立區域磁碟的速度較慢。這個程序所需的時間，與建立來源磁碟的快照，然後從該快照建立區域性磁碟的時間差不多。
如果區域性磁碟是從映像檔建立，或是透過複製從映像檔建立的磁碟而來，且您同時建立其他磁碟的標準快照，則建立這類磁碟的區域性副本可能需要較長時間。
如果來源磁碟是 Hyperdisk ML 或 Hyperdisk Throughput 磁碟區，則無法透過複製來源磁碟來建立區域磁碟。您必須依據可用區磁碟的快照，建立新的 Hyperdisk Balanced High Availability 磁碟區。

複製磁碟的頻率限制

複製磁碟的頻率有以下限制。

如果可用區開機磁碟是依據映像檔建立，或複製依據映像檔建立的磁碟，則該磁碟的區域副本有下列限制：
- 在 60 分鐘內，您最多可以建立六個來源磁碟的區域複製，之後每十分鐘只能建立一個來源磁碟的區域複製。
- 60 分鐘內最多可建立六個區域性複製項目，這個限制與來源磁碟的快照共用。也就是說，您在 60 分鐘內，最多可以為同一個可用區磁碟建立六個區域性複製項目和快照。如果您在 60 分鐘內為來源磁碟建立五個標準快照，則可在同一 60 分鐘內建立一個區域性本機副本，或再建立一個相同磁碟的快照。
複製其他區域或可用區磁碟時，須遵守下列限制：
- 每 30 秒可為指定來源磁碟或其副本建立一個副本。
- 最多可以同時複製 1,000 個磁碟，包括來源磁碟和複製的磁碟。超過這個限制會傳回 internalError。不過，如果您建立磁碟副本並在之後刪除，則刪除的磁碟副本不會計入這項限制。
- 磁碟複製完成後，該磁碟或其副本的後續副本都會計入原始來源磁碟的 1,000 個同步磁碟副本上限，以及每 30 秒最多建立一個副本的上限。
如果透過複製可用區磁碟來建立區域磁碟，每 15 分鐘最多可複製 1 TiB 的容量，爆發要求限制為 257 TiB。

錯誤訊息

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

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」(複製磁碟)。

在顯示的「Clone disk」(複製磁碟) 面板中，執行下列操作：
1. 在「Name」(名稱) 欄位中，指定複製磁碟的名稱。
2. 選用：如果是可用區磁碟，請在「位置」下方，確認已選取「單一可用區」。
3. 在「Properties」(屬性) 下方，查看複製磁碟的其他詳細資料。
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 High Availability 磁碟的區域磁碟佈建效能，您必須使用 Google Cloud CLI 或 REST 複製磁碟，無法使用 Google Cloud 控制台。

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

控制台

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

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

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

gcloud

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

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

如要複製 Persistent 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 \
  --type=hyperdisk-balanced-high-availability  \
  --size=DISK_SIZE \
  --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。
DISK_SIZE：選用：新區域磁碟的大小，以 GB 為單位。大小至少須與來源磁碟相同。如果指定 IOPS 或處理量限制，則必須使用這個旗標指定磁碟大小，即使與來源磁碟相同也一樣。
IOPS_LIMIT：選用：如要建立區域性 Hyperdisk Balanced High Availability 磁碟，可以指定磁碟可達到的 IOPS 數量，最多 100,000 IOPS。如果加入這個旗標，則必須一併使用 --size 旗標指定磁碟大小。
THROUGHPUT_LIMIT：選用：如要建立區域 Hyperdisk Balanced High Availability 磁碟，可以指定磁碟可達到的最大處理量 (以 MiB/s 為單位)，最高可達 2,400 MiB/s。如果加入這個旗標，則必須一併使用 --size 旗標指定磁碟大小。

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 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。


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",
  "sizeGb": "DISK_SIZE",
  "provisionedIops": "IOPS_LIMIT",
  "provisionedThroughput": "THROUGHPUT_LIMIT"
}

更改下列內容：

PROJECT_ID：您要複製磁碟的專案 ID。
TARGET_DISK_NAME：新區域磁碟複製作業的名稱。
CLONED_REGION：來源和複製磁碟的區域。
SOURCE_DISK_NAME：要複製的可用區磁碟名稱。
SOURCE_DISK_ZONE：來源磁碟的可用區。這也會是區域性磁碟副本的第一個副本可用區。
REPLICA_ZONE_2：新區域磁碟複製項的第二個副本可用區。
DISK_SIZE：選用：新區域磁碟的大小 (以 GB 為單位)。大小必須至少與來源磁碟相同。如果您指定 IOPS 或處理量限制，則必須加入這個欄位來指定磁碟大小，即使與來源磁碟相同也一樣。
IOPS_LIMIT：選用：如要建立區域 Hyperdisk Balanced High Availability 磁碟，您可以指定磁碟可處理的 IOPS 數量，最多為 100,000 IOPS。如果加入這個欄位，則必須一併使用 size 欄位指定磁碟大小。
THROUGHPUT_LIMIT：選用：如要建立區域性 Hyperdisk Balanced High Availability 磁碟，您可以指定磁碟可提供的最大處理量，最高可達 2,400 MiB/s。如果加入這個欄位，則必須一併使用 size 欄位指定磁碟大小。

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

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

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

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

控制台

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

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

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

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 快速入門導覽課程」中的 Java 設定說明操作。詳情請參閱 Compute Engine Java API 參考文件。

如要向 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 快速入門導覽課程」中的 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_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 進行驗證，請設定應用程式預設憑證。詳情請參閱「設定用戶端程式庫的驗證機制」。

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 快速入門導覽課程」中的 Java 設定說明操作。詳情請參閱「Compute Engine Java API 參考文件」。

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

後續步驟

使用副本複製磁碟