Laufwerk mit Klonen duplizieren

In diesem Dokument erfahren Sie, wie Festplattenklone funktionieren und wie Sie einen Festplattenklon erstellen. Mit dem Klonen von Laufwerken können Sie sofort verwendbare Kopien vorhandener Laufwerke am selben Standort (Zone oder Region) erstellen. Erstellen Sie einen Laufwerkklon in Szenarien, in denen Sie eine Kopie eines vorhandenen Laufwerks benötigen, die Sie sofort an eine VM anhängen können. Beispiele:

  • Staging-Umgebungen erstellen, indem Produktionsdaten dupliziert werden, um Fehler zu beheben, ohne die Produktion zu stören
  • Malwarescans eines Laufwerks ohne Beeinträchtigung der Leistung einer Produktionsarbeitslast durchführen
  • Kopien zur Überprüfung von Datenbanksicherungen erstellen
  • Daten von Laufwerken ohne Bootfunktion in ein neues Projekt verschieben
  • Laufwerke beim Skalieren Ihrer VMs duplizieren

Um die Notfallwiederherstellung für Ihre Daten zu aktivieren, sichern Sie Ihr Laufwerk mit Standard-Snapshots anstelle von Laufwerkklonen. Wenn Sie den Inhalt von Laufwerken in regelmäßigen Abständen erfassen möchten, ohne neue Laufwerke zu erstellen, verwenden Sie Instant Snapshots, da sie speichereffizienter als Klone sind. Weitere Optionen zum Schutz von Laufwerken finden Sie unter Datenschutzoptionen.

Hinweise

Zusammenfassung der Anwendungsfälle

Sie können ein Laufwerk nicht nur duplizieren, um schnell Tests und Fehlerbehebungen durchzuführen, sondern auch Hochverfügbarkeit für ein zonales Laufwerk aktivieren, indem Sie einen regionalen Klon des zonalen Laufwerks erstellen. Wenn Sie ein regionales Laufwerk aus einem zonalen Laufwerk erstellen, hat das regionale Laufwerk ein Replikat des Laufwerks in zwei Zonen derselben Region. Nachdem Sie das regionale Laufwerk erstellt haben, verwenden Sie es anstelle des zonalen Laufwerks. Im seltenen Fall eines Ausfalls in einer Zone können Sie weiterhin auf die Daten des Replikats in der anderen Zone zugreifen.

In dieser Tabelle sind die verschiedenen Arten von Klonen zusammengefasst, die von Compute Engine unterstützt werden.

Klonierungstyp Geeignet für Unterstützte Laufwerkstypen
Zonaler Klon aus einem zonalen Laufwerk Erstellen Sie eine identische Kopie eines Laufwerks in derselben Zone für eine der folgenden Aufgaben:
  • Arbeitslasten durch Duplizieren vorhandener Laufwerke für neue VMs skalieren.
  • Staging-, Debugging- oder Testumgebungen mit Produktionsdaten.
  • Scannen eines Produktionslaufwerks auf Malware
  • Ein Laufwerk in ein neues Projekt verschieben
  • Nichtflüchtiger Speicher: Standard, abgestimmter und nichtflüchtiger SSD-Speicher
  • Hyperdisk: Alle Hyperdisk-Typen, mit Ausnahme von Hyperdisk Balanced High Availability
Regionaler Klon eines zonalen Laufwerks
  • Eine zonale Arbeitslast hochverfügbar machen, indem ein Replikat der Daten in einer anderen Zone hinzugefügt wird.
  • Scannen eines Produktionslaufwerks auf Malware
  • Nichtflüchtiger Speicher: Standard, abgestimmter und nichtflüchtiger SSD-Speicher
  • Hyperdisk: Hyperdisk Extreme und Hyperdisk Balanced
Regionaler Klon eines regionalen Laufwerks Erstellen Sie eine identische Kopie eines regionalen Laufwerks in derselben Region für:
  • Testen oder Skalieren von regionalen, hochverfügbaren (HA) Arbeitslasten.
  • Datenredundanz über zwei Zonen hinweg aufrechterhalten, während administrative Aufgaben ausgeführt oder Tests durchgeführt werden.
  • Kopien von HA-Datenbankvolumes zur Überprüfung erstellen
  • Persistent Disk: Regional Balanced, SSD und nichtflüchtiger Standardspeicher
  • Hyperdisk: Hyperdisk Balanced High Availability

So funktioniert das Klonen von Festplatten

Wenn Sie ein Laufwerk klonen, erstellen Sie ein neues Laufwerk, das alle Daten vom Quelllaufwerk enthält. Sie können einen Laufwerksklon erstellen, auch wenn das vorhandene Laufwerk an eine VM-Instanz angehängt ist. Nachdem Sie ein Laufwerk geklont haben, können Sie das Quelllaufwerk löschen, ohne den Klon zu löschen.

Standardmäßig erben Klone eines Laufwerks seine Größe, Leistungslimits, seinen Typ und die genaue Zone oder Region. Einige dieser Eigenschaften können Sie so ändern:

  • Größe: Sie können einen Klon erstellen, der größer als das Quelllaufwerk ist, aber nicht kleiner.

  • Leistung: Für Hyperdisk-Volumes können Sie ein anderes Leistungslimit für den Klon angeben. Regionale Klone von zonalen Hyperdisk-Volumes sind Hyperdisk Balanced High Availability-Volumes und haben möglicherweise andere Leistungslimits.

  • Standort: Standardmäßig wird ein Laufwerkklon für zonale Laufwerke in derselben Zone und für regionale Laufwerke in derselben Region erstellt. Wenn Sie jedoch einen regionalen Klon eines zonalen Laufwerks erstellen möchten, können Sie eine zweite Zone angeben, die sich in derselben Region wie das zonale Laufwerk befindet. Der neue Klon wird auch als regionaler Klon bezeichnet und hat jeweils ein Replikat in der Zone des Quelllaufwerks und in der zweiten Zone, die Sie angegeben haben.

  • Typ: Regionale Klone von zonalen Hyperdisk Balanced- oder Hyperdisk Extreme-Volumes sind Hyperdisk Balanced High Availability-Volumes.

Regionale Hyperdisk-Volumes, die aus zonalen Hyperdisk-Volumes geklont wurden

Ein regionaler Klon eines vorhandenen zonalen Hyperdisk-Volumes ist immer ein neues Hyperdisk Balanced High Availability-Volume. Das liegt daran, dass Hyperdisk Balanced High Availability die einzige unterstützte regionale Hyperdisk ist. Wie Sie eine regionale Hyperdisk aus einer zonalen Hyperdisk erstellen, hängt vom Typ der zonalen Hyperdisk ab.

Leistung von Hyperdisk Balanced High Availability-Volumes, die von zonalen Laufwerken geklont wurden

Wenn Sie ein neues Hyperdisk Balanced High Availability-Volume aus einem Hyperdisk Balanced- oder Hyperdisk Extreme-Volume erstellen, übernimmt das neue Laufwerk die Größe des Quelllaufwerks. Sie können jedoch eine andere Größe angeben.

Die maximale bereitgestellte Leistung des neuen Laufwerks ist möglicherweise geringer als die des Quelllaufwerks, da Hyperdisk Extreme und Hyperdisk Balanced höhere Leistungslimits haben als Hyperdisk Balanced High Availability, wie in der folgenden Tabelle aufgeführt.

Hyperdisk-Typ Maximale E/A-Vorgänge pro Sekunde (IOPS) Maximaler Durchsatz ( MiB/s)
Hyperdisk mit ausgeglichener Hochverfügbarkeit 100.000 2.400
Hyperdisk Balanced 160.000 2.400
Hyperdisk Extrem 350.000 5.000

Sie können Limits für das neue regionale Laufwerk angeben, die jedoch die maximalen Leistungslimits von Hyperdisk Balanced High Availability nicht überschreiten dürfen – 100.000 IOPS und 2.400 MiB/s.

Wenn Sie kein Leistungslimit für das neue Laufwerk angeben, stellt Compute Engine das Laufwerk mit den Standard-IOPS und dem Standarddurchsatz bereit, die von der Größe des Hyperdisk Balanced High Availability-Volumes abhängen. Die Standardlimits finden Sie unter Standardlimits für Größe und Leistung von Hyperdisk Balanced High Availability.

Um 100.000 IOPS zu erreichen, muss ein Hyperdisk Balanced High Availability-Volume mindestens 200 GiB groß sein. Möglicherweise müssen Sie also auch die bereitgestellte Größe des regionalen Klons erhöhen.

Beispiel

Angenommen, Sie haben ein 150 GiB großes Hyperdisk Extreme-Volume (hdx-1) mit 180.000 IOPS bereitgestellt.

Wenn Sie einen regionalen Klon von hdx-1 erstellen und keine neue Größe oder kein neues Leistungslimit angeben, erstellt Compute Engine ein 150 GiB großes Hyperdisk Balanced High Availability-Volume mit dem Standard-IOPS-Limit für diese Größe: 3.900 IOPS.

Wenn Sie die Größe nicht erhöhen, können Sie für den regionalen Klon bis zu 75.000 IOPS angeben.

Regionale Persistent Disk-Volumes, die aus zonalen Persistent Disk-Volumes geklont wurden

Ein regionales Persistent Disk-Volume, das aus einem zonalen Persistent Disk-Volume geklont wurde, hat denselben Typ wie der Klon. Wenn Sie beispielsweise einen zonalen nichtflüchtigen Standardspeicher klonen, erstellen Sie ein regionales Volume für den nichtflüchtigen Standardspeicher.

Regionale Klone von nichtflüchtigen Speicher-Volumes haben jedoch möglicherweise andere Größen- und Leistungslimits als das zonale Quelllaufwerk.

  • Niedrigere Leistungslimits: Regionale Klone von Persistent Disk haben möglicherweise niedrigere IOPS- und Durchsatzleistungslimits als das Quelllaufwerk. Das liegt daran, dass zonale Persistent Disks höhere maximale Instanzleistungslimits bieten. Ein zonales Balanced Persistent Disk hat beispielsweise ein maximales Instanzlimit von 80.000 Schreib-IOPS, ein regionales Balanced Persistent Disk jedoch ein Limit von 60.000 Schreib-IOPS.

    Detaillierte Leistungslimits finden Sie unter Leistungslimits für zonale nichtflüchtige Speicher und Leistungslimits für regionale nichtflüchtige Speicher.

  • Für regionale nichtflüchtige Standardspeicher gilt eine Mindestgröße von 200 GiB: Regionale nichtflüchtige Standardspeicher haben eine Mindestgröße von 200 GiB. Wenn Sie also einen regionalen Klon eines zonalen nichtflüchtigen Standardspeichers mit einer Größe von 10 bis 199 GiB erstellen möchten, müssen Sie für das regionale Laufwerk eine Größe von mindestens 200 GiB angeben.

Unterstützte Laufwerkstypen

Sie können alle Persistent Disk- und Hyperdisk-Typen klonen, wenn sich der Klon am selben Standort (Zone oder Region) wie das Quelllaufwerk befindet.

Das Klonen eines zonalen Laufwerks in ein regionales Laufwerk wird nur für die folgenden Laufwerkstypen unterstützt:

  • Google Cloud Hyperdisk:

    • Hyperdisk Balanced
    • Hyperdisk Extrem

    Wenn Sie ein regionales Laufwerk aus einem Hyperdisk ML- oder Hyperdisk Throughput-Volume erstellen möchten, erstellen Sie einen Snapshot und dann ein Hyperdisk Balanced High Availability-Volume aus dem Snapshot.

  • Persistent Disk:

    • Abgestimmter nichtflüchtiger Speicher
    • Nichtflüchtiger SSD-Speicher
    • Nichtflüchtiger Standardspeicher

Beschränkungen

Für Festplattenklone gelten die folgenden Einschränkungen:

  • Sie können kein Hyperdisk Balanced High Availability-Volume erstellen, indem Sie ein zonales Hyperdisk ML- oder Hyperdisk Throughput-Volume klonen. Wenn Sie ein Hyperdisk Balanced High Availability-Volume für diese Hyperdisk-Typen erstellen möchten, führen Sie die Schritte unter Zonales Laufwerk in ein regionales Hyperdisk Balanced High Availability-Volume ändern aus.
  • Sie können kein Laufwerk klonen, das sich in einem Speicherpool befindet.
  • Sie können keinen zonalen Laufwerksklon eines vorhandenen zonalen Laufwerks in einer anderen Zone erstellen.
  • Die Größe des Klons muss mindestens die Größe des Quelllaufwerks haben. Wenn Sie einen Klon mit der Google Cloud Konsole erstellen, können Sie keine Laufwerkgröße angeben. Der Klon hat dieselbe Größe wie das Quelllaufwerk.
  • Wenn Sie ein Hyperdisk- oder Persistent Disk-Volume über die Google Cloud Konsole klonen, können Sie die bereitgestellte Leistung für die geklonte Festplatte nicht angeben.
  • Wenn Sie das Quelllaufwerk mit einem vom Kunden bereitgestellten Verschlüsselungsschlüssel (Customer-Supplied Encryption Key, CSEK) oder einem kundenverwalteten Verschlüsselungsschlüssel (Customer-Managed Encryption Key, CMEK) verschlüsseln, müssen Sie denselben Schlüssel auch zum Verschlüsseln des Klons verwenden. Weitere Informationen finden Sie unter Klon eines verschlüsselten Quelllaufwerks erstellen.
  • Sie können das Quelllaufwerk nicht löschen, während der Klon erstellt wird.
  • Die Compute-Instanz, an die das Quelllaufwerk angehängt ist, kann während der Erstellung des Klons nicht eingeschaltet werden.
  • Wenn das Quelllaufwerk zum Löschen zusammen mit der VM markiert wurde, an die es angehängt ist, können Sie die VM nicht löschen, während der Klon erstellt wird.
  • Pro 30 Sekunden können Sie maximal einen Klon eines bestimmten Quelllaufwerks oder seiner Klone erstellen.
  • Es kann maximal 1.000 gleichzeitige Laufwerkklone eines bestimmten Quelllaufwerks (oder von dessen Klonen) geben. Bei Überschreiten dieses Limits wird ein internalError zurückgegeben. Wenn Sie jedoch einen Laufwerkklon erstellen und später löschen, wird der gelöschte Laufwerkklon nicht für dieses Limit berücksichtigt.
  • Nachdem ein Laufwerk geklont wurde, werden alle nachfolgenden Klone dieses Laufwerks oder seiner Klone auf das Limit von 1.000 gleichzeitigen Laufwerkklonen für das ursprüngliche Quelllaufwerk und auf das Limit für die Erstellung von höchstens einem Klon alle 30 Sekunden angerechnet.
  • Wenn Sie einen regionalen nichtflüchtigen Speicher durch Klonen eines zonalen Laufwerks erstellen, können Sie alle 15 Minuten höchstens 1 TiB Kapazität klonen, mit einem Burst-Anfragelimit von 257 TiB.
  • Sie können keinen zonalen Laufwerksklon aus einem regionalen Laufwerk erstellen.
  • Zum Erstellen eines regionalen Laufwerkklons aus einem zonalen Quelllaufwerk muss eine der Replikatzonen des regionalen Laufwerkklons der Zone des Quelllaufwerks entsprechen.
  • Nach der Erstellung kann ein regionaler Laufwerkklon innerhalb von durchschnittlich 3 Minuten verwendet werden. Es kann jedoch einige Minuten dauern, bis das Laufwerk vollständig repliziert wurde und einen Status erreicht, in dem das Recovery Point Objective (RPO) fast null erreicht.
  • Wenn Sie ein zonales Laufwerk aus einem Image erstellt haben, können Sie dieses zonale Laufwerk nicht zum Erstellen eines regionalen Laufwerksklons verwenden.

Fehlermeldungen

Wenn Sie das Limit für das Klonen überschreiten, schlägt die Anfrage mit folgendem Fehler fehl:

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

Laufwerkklone erstellen

In diesem Abschnitt wird erläutert, wie Sie ein vorhandenes Laufwerk duplizieren und einen Laufwerksklon erstellen.

Eine detaillierte Anleitung finden Sie je nach Art des Laufwerkklons in einem der folgenden Abschnitte in diesem Dokument:

Laufwerkklon am selben Speicherort wie die Quelle erstellen

Sie können einen Klon einer vorhandenen zonalen oder regionalen Festplatte erstellen, die sich in derselben Zone bzw. Region wie die Quellfestplatte befindet. Dazu können Sie dieGoogle Cloud Console, die Google Cloud CLI, REST oder Cloud-Clientbibliotheken verwenden.

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console die Seite Laufwerke auf.

    Zur Seite „Laufwerke“

  2. Suchen Sie in der Liste der Laufwerke nach dem Laufwerk, das Sie klonen möchten.

  3. Klicken Sie in der Spalte Aktionen auf die Menüschaltfläche  und wählen Sie Laufwerk klonen aus.

    Klon erstellen

    Führen Sie im angezeigten Bereich Laufwerk klonen die folgenden Schritte aus:

    1. Geben Sie im Feld Name einen Namen für das geklonte Laufwerk an.
    2. Optional: Prüfen Sie bei zonalen Laufwerken unter Standort, ob Einzelne Zone ausgewählt ist.
    3. Prüfen Sie unter Attribute die anderen Details für das geklonte Laufwerk.
    4. Klicken Sie auf Erstellen, um die Erstellung des geklonten Laufwerks abzuschließen.

Google Cloud CLI

Führen Sie den Befehl disks create aus und geben Sie das Flag --source-disk an, um ein zonales Quelllaufwerk zu klonen und ein neues zonales Laufwerk zu erstellen:

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

Ersetzen Sie Folgendes:

  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • SOURCE_DISK_NAME: der Name des Quelllaufwerks.

Terraform

Verwenden Sie zum Erstellen eines Laufwerkklons die Ressource google_compute_disk.

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

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

Go

Go

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Java

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Python

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Senden Sie zum Klonen eines zonalen Quelllaufwerks und zum Erstellen eines neuen zonalen Laufwerks eine POST-Anfrage an die Methode compute.disks.insert. Geben Sie im Anfragetext die Parameter name und sourceDisk an. Alle nicht angegebenen Attribute werden im Klon vom Quelllaufwerk übernommen.

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • SOURCE_DISK_NAME: Name des Quelllaufwerks.

Regionalen Laufwerkklon aus einem zonalen Laufwerk erstellen

Sie können ein neues regionales Laufwerk erstellen, indem Sie ein vorhandenes zonales Laufwerk eines der folgenden Typen klonen:

  • Hyperdisk Balanced
  • Hyperdisk Extrem
  • Nichtflüchtiger Standardspeicher, abgestimmter nichtflüchtiger Speicher und nichtflüchtiger SSD-Speicher

Wenn das Quelllaufwerk ein Hyperdisk Balanced- oder Hyperdisk Extreme-Volume ist, ist das regionale Laufwerk immer ein Hyperdisk Balanced High Availability-Volume und übernimmt nicht die bereitgestellte Leistung des zonalen Laufwerks. Wenn Sie die bereitgestellte Leistung des regionalen Laufwerks festlegen möchten, müssen Sie das Laufwerk mit der Google Cloud CLI oder REST klonen. Wenn Sie das Laufwerk mit der Google Cloud Konsole klonen, können Sie kein Leistungslimit angeben. Das Laufwerk wird mit den Standardlimits für seine Größe bereitgestellt.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Laufwerke auf.

    Zur Seite „Laufwerke“

  2. Suchen Sie in der Liste der Laufwerke nach dem zonalen Persistent Disk-Volume, das Sie klonen möchten.

  3. Klicken Sie in der Spalte Aktionen auf die Menüschaltfläche  und wählen Sie Laufwerk klonen aus.

    Klon erstellen

    Führen Sie im angezeigten Bereich Laufwerk klonen die folgenden Schritte aus:

    1. Geben Sie im Feld Name einen Namen für das geklonte Laufwerk an.
    2. Wählen Sie als Standort die Option Regional und dann die sekundäre Replikatzone für das neue regionale geklonte Laufwerk aus.
    3. Prüfen Sie unter Attribute die anderen Details für das geklonte Laufwerk.
    4. Klicken Sie auf Erstellen, um die Erstellung des geklonten Laufwerks abzuschließen.

gcloud

Führen Sie den Befehl gcloud compute disks create aus und geben Sie die Parameter --region und --replica-zones an, um einen regionalen Laufwerkklon aus einem zonalen Laufwerk zu erstellen.

Wenn das zonale Laufwerk ein Hyperdisk Balanced- oder Hyperdisk Extreme-Volume ist, geben Sie das Flag --disk-type=hyperdisk-balanced-high-availability an, da das regionale Laufwerk ein Hyperdisk Balanced High Availability-Volume sein muss.

Wenn Sie ein Persistent Disk-Volume klonen möchten, lassen Sie das Flag --disk-type weg.

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 ]

Ersetzen Sie Folgendes:

  • TARGET_DISK_NAME: Name des neuen regionalen Laufwerks.
  • CLONED_REGION: die Region des Quelllaufwerks und des geklonten Laufwerks.
  • SOURCE_DISK_NAME: Name des zonalen Laufwerks, das geklont werden soll.
  • SOURCE_DISK_ZONE: die Zone für das Quelllaufwerk. Dies ist auch die erste Replikatzone für den regionalen Laufwerksklon.
  • REPLICA_ZONE_2: die zweite Replikatzone für den neuen regionalen Laufwerksklon.
  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • IOPS_LIMIT: Optional: Wenn Sie ein regionales Hyperdisk Balanced High Availability-Laufwerk erstellen möchten, können Sie eine Anzahl von IOPS angeben, die das Laufwerk verarbeiten kann,bis zu 100.000 IOPS.
  • THROUGHPUT_LIMIT: Optional: Wenn Sie ein regionales Hyperdisk Balanced High Availability-Laufwerk erstellen möchten, können Sie den maximalen Durchsatz in MiB/s angeben, den das Laufwerk bereitstellen kann, bis zu 2.400 MiB/s.

Terraform

Verwenden Sie die folgende Ressource, um einen regionalen Laufwerkklon aus einem zonalen Laufwerk zu erstellen. Wenn das Quelllaufwerk ein Hyperdisk Balanced- oder Hyperdisk Extreme-Volume ist, setzen Sie das type-Argument auf hyperdisk-balanced-high-availability.

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"]
}

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

Go

Go

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Java

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Python

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Senden Sie zum Erstellen eines regionalen Laufwerksklons aus einem zonalen Laufwerk eine POST-Anfrage an die Methode compute.disks.insert und geben Sie die Parameter sourceDisk und replicaZone an.

Wenn es sich bei dem zonalen Laufwerk um ein Hyperdisk Balanced- oder Hyperdisk Extreme-Volume handelt, fügen Sie das Feld type ein, um ein Hyperdisk Balanced High Availability-Volume zu erstellen.

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • TARGET_DISK_NAME: Name des neuen regionalen Laufwerks.
  • CLONED_REGION: die Region des Quelllaufwerks und des geklonten Laufwerks.
  • SOURCE_DISK_NAME: Name des zonalen Laufwerks, das geklont werden soll.
  • SOURCE_DISK_ZONE: die Zone für das Quelllaufwerk. Dies ist auch die erste Replikatzone für den regionalen Laufwerksklon.
  • REPLICA_ZONE_2: die zweite Replikatzone für den neuen regionalen Laufwerksklon.
  • IOPS_LIMIT: Optional: Wenn Sie ein regionales Hyperdisk Balanced High Availability-Laufwerk erstellen möchten, können Sie eine Anzahl von IOPS angeben, die das Laufwerk verarbeiten kann,bis zu 100.000 IOPS.
  • THROUGHPUT_LIMIT: Optional: Wenn Sie ein regionales Hyperdisk Balanced High Availability-Laufwerk erstellen möchten, können Sie den maximalen Durchsatz in MiB/s angeben, den das Laufwerk bereitstellen kann, bis zu 2.400 MiB/s.

Laufwerkklon eines CMEK- oder CSEK-verschlüsselten Quelllaufwerks erstellen

Wenn Sie einen zonalen oder regionalen Klon eines Laufwerks erstellen möchten, das mit CSEK oder CMEK verschlüsselt ist, folgen Sie der Anleitung in den vorherigen Abschnitten. Sie müssen jedoch auch den Schlüssel angeben, mit dem das Quelllaufwerk verschlüsselt wurde.

Laufwerkklone für CSEK-verschlüsselte Laufwerke erstellen

Wenn Sie das Quelllaufwerk mit einem CSEK verschlüsseln, müssen Sie den gleichen Schlüssel auch zum Verschlüsseln des Klons verwenden.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Laufwerke auf.

    Zur Seite „Laufwerke“

  2. Suchen Sie in der Liste der zonalen nichtflüchtigen Laufwerke nach dem Laufwerk, das Sie klonen möchten.

  3. Klicken Sie in der Spalte Aktionen auf die Menüschaltfläche  und wählen Sie Laufwerk klonen aus.

    Klon erstellen

    Führen Sie im angezeigten Bereich Laufwerk klonen die folgenden Schritte aus:

    1. Geben Sie im Feld Name einen Namen für das geklonte Laufwerk an.
    2. Geben Sie im Feld Entschlüsselung und Verschlüsselung den Verschlüsselungsschlüssel des Quelllaufwerks an.
    3. Prüfen Sie unter Attribute die anderen Details für das geklonte Laufwerk.
    4. Klicken Sie auf Erstellen, um die Erstellung des geklonten Laufwerks abzuschließen.

gcloud

Führen Sie den Befehl gcloud compute disks create aus und geben Sie den Verschlüsselungsschlüssel des Quelllaufwerks mit dem Flag --csek-key-file an, um einen Laufwerkklon für ein CSEK-verschlüsseltes Quelllaufwerk zu erstellen. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie den Befehl 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

Ersetzen Sie Folgendes:

  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • SOURCE_DISK_NAME: Name des Quelllaufwerks.

Go

Go

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Java

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Python

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Um einen Laufwerkklon für ein CSEK-verschlüsseltes Quelllaufwerk zu erstellen, senden Sie eine POST-Anfrage an die Methode compute.disks.insert und geben Sie den Verschlüsselungsschlüssel des Quelllaufwerks mit dem Attribut diskEncryptionKey an. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie die beta-Version der Methode.

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=="
  },
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • SOURCE_DISK_NAME: Name des Quelllaufwerks.

Laufwerkklone für CMEK-verschlüsselte Laufwerke erstellen

Wenn Sie das Quelllaufwerk mit einem CMEK verschlüsseln, müssen Sie denselben Schlüssel auch zum Verschlüsseln des Klons verwenden.

Console

Compute Engine verschlüsselt den Klon automatisch mit dem Verschlüsselungsschlüssel des Quelllaufwerks.

gcloud

Führen Sie den Befehl gcloud compute disks create aus und geben Sie den Verschlüsselungsschlüssel des Quelllaufwerks mit dem Flag --kms-key an, um einen Laufwerksklon für ein CMEK-verschlüsseltes Quelllaufwerk zu erstellen. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie den Befehl 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

Ersetzen Sie Folgendes:

  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • SOURCE_DISK_NAME: der Name des Quelllaufwerks.
  • KMS_PROJECT_ID: Projekt-ID für den Verschlüsselungsschlüssel.
  • REGION: Region des Verschlüsselungsschlüssels.
  • KEY_RING: Schlüsselbund des Verschlüsselungsschlüssels.
  • KEY: Name des Verschlüsselungsschlüssels.

Go

Go

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Java

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


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

Python

Bevor Sie dieses Beispiel verwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

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

Um einen Laufwerksklon für ein CMEK-verschlüsseltes Quelllaufwerk zu erstellen, senden Sie eine POST-Anfrage an die Methode compute.disks.insert und geben Sie den Verschlüsselungsschlüssel des Quelllaufwerks mit dem Attribut kmsKeyName an. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie die beta-Version der Methode.

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"
  },
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: Die Projekt-ID, in der Sie das Laufwerk klonen möchten.
  • ZONE: Zone des Quelllaufwerks und des neuen Laufwerks.
  • TARGET_DISK_NAME: Name des neuen Laufwerks.
  • SOURCE_DISK_NAME: der Name des Quelllaufwerks.
  • KMS_PROJECT_ID: Projekt-ID für den Verschlüsselungsschlüssel.
  • REGION: Region des Verschlüsselungsschlüssels.
  • KEY_RING: Schlüsselbund des Verschlüsselungsschlüssels.
  • KEY: Name des Verschlüsselungsschlüssels.

Nächste Schritte