Asynchrone Replikation nichtflüchtiger Speicher konfigurieren

---

In diesem Dokument wird beschrieben, wie Sie die asynchrone Replikation konfigurieren. Die asynchrone Replikation ist nützlich für die Notfallwiederherstellung mit geringem RPO und mit geringem RTO.

Führen Sie die folgenden Schritte aus, um die asynchrone Laufwerksreplikation zu aktivieren:

1. Richten Sie ein Laufwerksreplikationspaar ein, um die asynchrone Replikation zu konfigurieren.
2. Replikation manuell starten, um mit der Replikation von Daten zwischen dem primären und dem sekundären Laufwerk zu beginnen.

Beschränkungen

• Sekundäre Laufwerke müssen beim Erstellen leer sein. Sie können nicht aus Images, Snapshots oder anderen Laufwerken erstellt werden.
• Die asynchrone Replikation wird für Hyperdisk ML oder Hyperdisk Throughput nicht unterstützt.
• Sie können die asynchrone Replikation für Hyperdisk nicht in der Google Cloud Konsole konfigurieren. Sie müssen die Google Cloud CLI, Terraform oder REST verwenden.

Hinweise

• Wählen Sie ein Regionspaar aus.
• Erstellen Sie optional eine Konsistenzgruppe.
• Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud -Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich so bei Compute Engine authentifizieren.
  <x0A>

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. After installing the Google Cloud CLI, initialize it by running the following command:

     gcloud init

     If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

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

  Terraform

  Wenn Sie die Terraform-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  3. To initialize the gcloud CLI, run the following command:

     gcloud init

  4. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

     If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Weitere Informationen unter Set up authentication for a local development environment.

  REST

  Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

  After installing the Google Cloud CLI, initialize it by running the following command:

  gcloud init

  If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  Weitere Informationen finden Sie in der Dokumentation zur Google Cloud -Authentifizierung unter Für die Verwendung von REST authentifizieren.

Festplattenreplikationspaar einrichten

Bevor Sie Daten zwischen Laufwerken replizieren können, müssen Sie die Replikation konfigurieren. Führen Sie dazu die folgenden Aufgaben aus:

1. Wählen Sie ein Regionspaar aus sowie Ihre primäre und sekundäre Region.
2. Optional: Wenn Sie die Replikation für eine Gruppe von Laufwerken koordinieren müssen, erstellen Sie eine Konsistenzgruppe in der primären Region. Sie müssen einer Konsistenzgruppe primäre Laufwerke hinzufügen, bevor Sie mit der Replikation beginnen.
3. Erstellen oder wählen Sie die primären Laufwerke aus. Optional können Sie diese Laufwerke der Konsistenzgruppe hinzufügen.
4. Erstellen Sie neue, leere sekundäre Laufwerke.

Laufwerksanforderungen

Laufwerke müssen die folgenden Anforderungen erfüllen, um als primäre oder sekundäre Laufwerke für die asynchrone Replikation verwendet zu werden:

• Laufwerkstyp: Sie müssen einen der folgenden Laufwerkstypen verwenden:
  • Abgestimmter nichtflüchtiger Speicher
  • Leistungsstarker nichtflüchtiger Speicher (SSD)
  • Hyperdisk Balanced
  • Hyperdisk mit ausgeglichener Hochverfügbarkeit
  • Hyperdisk Extrem
• Größe: kleiner oder gleich 64 TiB.
• Verschlüsselungstyp: Google-owned and Google-managed encryption keys oder vom Kunden verwaltete Verschlüsselungsschlüssel (CMEK).
• Modus für mehrere Autoren: Sie können die asynchrone Replikation für Hyperdisk Balanced- und Hyperdisk Balanced High Availability-Festplatten aktivieren, die sich im Modus für mehrere Autoren befinden. Bei allen anderen Laufwerkstypen muss das Laufwerk im Lese-/Schreibmodus sein.
• Standort: Befindet sich in einer unterstützten Region (oder in einer Zone innerhalb einer unterstützten Region).

Primären Datenträger erstellen oder auswählen

Das primäre Laufwerk ist das Boot- oder Datenlaufwerk, das an die VM angehängt ist, auf der die Arbeitslast ausgeführt wird. Sie können jedes vorhandene Laufwerk, das die Laufwerksanforderungen erfüllt, als primäres Laufwerk verwenden oder ein neues Laufwerk erstellen. Wenn Sie ein vorhandenes Laufwerk als primäres Laufwerk verwenden möchten, müssen Sie keine zusätzliche Konfiguration auf dem Laufwerk vornehmen. Fahren Sie mit dem Erstellen eines sekundären Laufwerks fort, um die Konfiguration der asynchronen Replikation abzuschließen.

Primäres Laufwerk erstellen

Erstellen Sie ein primäres Laufwerk mit den Methoden, die in einem der folgenden Dokumente beschrieben werden.

• Erstellen Sie ein primäres Bootlaufwerk beim Erstellen einer VM. Fügen Sie das Laufwerk optional zu einer Konsistenzgruppe hinzu. Erstellen Sie dazu die VM mithilfe der gcloud CLI oder REST und geben Sie eine der folgenden Optionen an:

  • Wenn Sie die VM mit der gcloud CLI erstellen, geben Sie das Flag --create-disk an:

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

  • Wenn Sie die VM mit REST erstellen, geben Sie das Attribut resourcePolicies an:

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

• Erstellen Sie ein primäres Datenlaufwerk beim Erstellen einer VM. Fügen Sie das Laufwerk optional zu einer Konsistenzgruppe hinzu. Erstellen Sie dazu die VM mithilfe der gcloud CLI oder REST und geben Sie eine der folgenden Optionen an:

  • Wenn Sie die VM mit der gcloud CLI erstellen, geben Sie das Flag --create-disk an:

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

  • Wenn Sie die VM mit REST erstellen, geben Sie das Attribut resourcePolicies an:

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

• Erstellen Sie ein primäres Datenlaufwerk, ohne eine VM zu erstellen. Fügen Sie das Laufwerk optional zu einer Konsistenzgruppe hinzu. Erstellen Sie dazu die VM mit derGoogle Cloud Console, der gcloud CLI oder REST und geben Sie eine der folgenden Optionen an:

  • Wenn Sie das Laufwerk mit der Google Cloud -Konsole erstellen, wählen Sie die Konsistenzgruppe aus dem Drop-down-Menü Konsistenzgruppe aus.

  • Wenn Sie das Laufwerk mit der gcloud CLI erstellen, geben Sie das Flag --resource-policies an:

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

  • Wenn Sie das Laufwerk mit REST erstellen, geben Sie das Attribut resourcePolicies an:

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

  Ersetzen Sie Folgendes:

  • PROJECT: das Projekt, das die Konsistenzgruppe enthält
  • REGION: die Region, in der sich die Konsistenzgruppe befindet
  • CONSISTENCY_GROUP_NAME: der Name der Konsistenzgruppe, der das Laufwerk hinzugefügt werden soll

Sekundäres Laufwerk erstellen

Das sekundäre Laufwerk ist ein Datenlaufwerk in einer anderen Region als das primäre Laufwerk, auf dem replizierte Daten vom primären Laufwerk empfangen und geschrieben werden. Beim Konfigurieren der asynchronen Replikation müssen Sie ein neues, leeres sekundäres Laufwerk erstellen, das auf das primäre Laufwerk verweist.

Wenn Sie ein sekundäres Laufwerk mit denselben Eigenschaften wie das primäre Laufwerk erstellen möchten, folgen Sie der Anleitung unter Sekundäres Laufwerk identisch mit dem primären Laufwerk erstellen.

Hinweis :Compute Engine kopiert die Eigenschaften des primären Laufwerks nur einmal auf das sekundäre Laufwerk, nämlich beim Erstellen des sekundären Laufwerks. Wenn Sie das Label, die Gastbetriebssystemfunktionen oder andere Eigenschaften des primären Laufwerks ändern, nachdem das sekundäre Laufwerk erstellt wurde, repliziert Compute Engine diese Änderungen nicht auf das sekundäre Laufwerk.

Informationen zum Erstellen eines sekundären Laufwerks, das sich vom primären Laufwerk unterscheidet, finden Sie unter Benutzerdefiniertes sekundäres Laufwerk erstellen.

Sekundäres Laufwerk identisch mit dem primären Laufwerk erstellen

In diesem Abschnitt wird beschrieben, wie Sie ein sekundäres Laufwerk erstellen, das mit dem primären Laufwerk identisch ist.

• Für die asynchrone Replikation von Persistent Disk können Sie ein sekundäres Laufwerk mit derGoogle Cloud Console, der gcloud CLI oder REST erstellen.

• Für die asynchrone Hyperdisk-Replikation können Sie die gcloud CLI, Terraform oder REST verwenden.

Console

Hinweis: Wenn Sie ein sekundäres Laufwerk mit der Google Cloud -Konsole erstellen, beginnt die Replikation sofort. Wenn Sie das entsprechende primäre Laufwerk des sekundären Laufwerks einer Konsistenzgruppe hinzufügen möchten, müssen Sie dies tun, bevor Sie das sekundäre Laufwerk erstellen.

So erstellen Sie ein sekundäres Laufwerk und starten die Replikation:

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

   Zur Seite „Laufwerke“

2. Klicken Sie auf den Namen der primären Festplatte. Die Seite Laufwerk verwalten wird geöffnet.

3. Klicken Sie auf Sekundäres Laufwerk erstellen.

4. Geben Sie im Feld Name einen Namen für das Laufwerk ein.

5. Führen Sie im Abschnitt Standort einen der folgenden Schritte aus:

   • So erstellen Sie ein regionales Laufwerk:

     1. Wählen Sie Regional aus.
     2. Wählen Sie im Feld Region eine Region aus, die der Region des primären Laufwerks entspricht.
     3. Wählen Sie im Feld Zone die primäre Zone aus.
     4. Wählen Sie im Feld Replikatzone die Replikatzone aus.

   • So erstellen Sie ein zonales Laufwerk:

     1. Wählen Sie Einzelne Zone aus.
     2. Wählen Sie im Feld Region eine Region aus, die der Region des primären Laufwerks entspricht.
     3. Wählen Sie im Feld Zone eine Zone aus.

6. Klicken Sie auf Erstellen. Compute Engine erstellt das Laufwerk und startet die Replikation.

gcloud

Erstellen Sie mit dem gcloud compute disks create-Befehl ein sekundäres Laufwerk:

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

Geben Sie zum Erstellen eines regionalen sekundären Laufwerks zusätzlich das Flag --replica-zones an:

--replica-zones=ZONE_1,ZONE_2

Dabei gilt:

• SECONDARY_DISK_NAME: der Name des sekundären Laufwerks.
• SECONDARY_LOCATION_FLAG: das Standort-Flag für das sekundäre Laufwerk. Verwenden Sie --region, um ein regionales sekundäres Laufwerk zu erstellen. Verwenden Sie --zone, um ein zonales sekundäres Laufwerk zu erstellen.
• SECONDARY_LOCATION: die Region oder Zone für das sekundäre Laufwerk.
  • Verwenden Sie zum Erstellen eines regionalen Laufwerks die Region, die der Region des primären Laufwerks entspricht.
  • Verwenden Sie zum Erstellen eines zonalen Laufwerks eine Zone in der Region, die der Region des primären Laufwerks entspricht.
• SIZE: durch die Größe des neuen Laufwerks in GB. Die Größe muss mit der Größe des primären Laufwerks übereinstimmen. Die Größe innerhalb des zulässigen Bereichs von 10 GB bis 2.000 GB kann in 1-GB-Schritten festgelegt werden.
• PRIMARY_DISK_NAME: der Name des primären Laufwerks, von dem das sekundäre Laufwerk Daten empfängt.
• PRIMARY_LOCATION_FLAG: das Standort-Flag für das primäre Laufwerk.
  • Verwenden Sie für ein regionales primäres Laufwerk --primary-disk-region.
  • Verwenden Sie für ein zonales primäres Laufwerk --primary-disk-zone.
• PRIMARY_LOCATION: die Region oder Zone des primären Laufwerks.
  • Verwenden Sie für ein regionales Laufwerk die Region.
  • Verwenden Sie für zonale Laufwerke die Zone.
• PRIMARY_PROJECT: das Projekt, das das primäre Laufwerk enthält.
• ZONE_1: Eine der Zonen, in die das regionale Laufwerk repliziert wird. Muss eine Zone in der angegebenen Region sein und sich von ZONE_2 unterscheiden.
• ZONE_2: Eine der Zonen, in die das regionale Laufwerk repliziert wird. Muss eine Zone in der angegebenen Region sein und sich von ZONE_1 unterscheiden.

Go

Erstellen Sie mit einem der folgenden Codebeispiele ein zonales oder regionales sekundäres Laufwerk:

Zonales sekundäres Laufwerk erstellen

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Regionales sekundäres Laufwerk erstellen

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Java

Erstellen Sie mit einem der folgenden Codebeispiele ein zonales oder regionales sekundäres Laufwerk:

Zonales sekundäres Laufwerk erstellen

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DiskAsyncReplication;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

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

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

  // Creates a secondary disk in a specified zone.
  public static Operation.Status createDiskSecondaryZonal(String primaryProjectId,
       String secondaryProjectId, String primaryDiskName, String secondaryDiskName,
       String primaryDiskZone, String secondaryDiskZone, long diskSizeGb, String diskType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (DisksClient disksClient = DisksClient.create()) {
      String primaryDiskSource = String.format("projects/%s/zones/%s/disks/%s",
          primaryProjectId, primaryDiskZone, primaryDiskName);

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

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

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

Regionales sekundäres Laufwerk erstellen

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

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

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

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

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

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

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

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

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

Node.js

Erstellen Sie mit einem der folgenden Codebeispiele ein zonales oder regionales sekundäres Laufwerk:

Zonales sekundäres Laufwerk erstellen

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

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

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

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

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeSecondaryDisk();

Regionales sekundäres Laufwerk erstellen

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

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

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

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

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeRegionalSecondaryDisk();

Python

Erstellen Sie mit einem der folgenden Codebeispiele ein zonales oder regionales sekundäres Laufwerk:

Zonales sekundäres Laufwerk erstellen

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

Regionales sekundäres Laufwerk erstellen

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

REST

Erstellen Sie ein zonales oder regionales sekundäres Laufwerk mit einer der folgenden Methoden:

• Verwenden Sie zum Erstellen eines zonalen sekundären Laufwerks die Methode disks.insert:

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

• Verwenden Sie zum Erstellen eines regionalen sekundären Laufwerks die Methode regionDisks.insert:

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

Dabei gilt:

• SECONDARY_DISK_PROJECT: das Projekt für das sekundäre Laufwerk.
• SECONDARY_DISK_LOCATION: die Region oder Zone für das sekundäre Laufwerk.
  • Verwenden Sie für ein regionales Laufwerk die Region.
  • Verwenden Sie für ein zonales Laufwerk die Zone.
• SECONDARY_DISK_NAME: der Name des sekundären Laufwerks.
• DISK_SIZE: Die Größe des sekundären Laufwerks. Muss der Größe des primären Laufwerks entsprechen.
• PRIMARY_DISK_PROJECT: das Projekt, das das primäre Laufwerk enthält.
• PRIMARY_DISK_LOCATION_PARAMETER: das Standort-Flag für das primäre Laufwerk.
  • Verwenden Sie für ein regionales primäres Laufwerk regions.
  • Verwenden Sie für ein zonales primäres Laufwerk zones.
• PRIMARY_DISK_LOCATION: die Region oder Zone des primären Laufwerks. Verwenden Sie für regionale Laufwerke die Region. Verwenden Sie für zonale Laufwerke die Zone.
• PRIMARY_DISK_NAME: der Name des primären Laufwerks, von dem das sekundäre Laufwerk Daten empfängt.

Hinweis :Sie können kein sekundäres Laufwerk aus einem Snapshot, Image oder Laufwerk erstellen. Fügen Sie Ihrer Anfrage nicht die Felder sourceSnapshot, sourceImage und sourceDisk hinzu.

Terraform

Verwenden Sie zum Erstellen eines sekundären Laufwerks, das mit dem primären Laufwerk identisch ist, die Ressource compute_disk.

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

  async_primary_disk {
    disk = google_compute_disk.primary_disk.id
  }

  physical_block_size_bytes = 4096
}

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

Benutzerdefiniertes sekundäres Laufwerk erstellen

In diesem Abschnitt wird beschrieben, wie Sie ein benutzerdefiniertes sekundäres Laufwerk erstellen, dessen Eigenschaften sich vom primären Laufwerk unterscheiden.

Wenn das primäre Laufwerk ein Bootlaufwerk ist, können Sie die Gastbetriebssystem-Features des primären Laufwerks nicht ändern oder entfernen. Sie können nur weitere Gastbetriebssystemfunktionen hinzufügen. Weitere Informationen finden Sie unter Sekundäre Laufwerksanpassung.

Sie können ein benutzerdefiniertes sekundäres Laufwerk mit der gcloud CLI, REST oder Terraform erstellen. Sie können das sekundäre Laufwerk nicht über die Google Cloud Console anpassen.

gcloud

Verwenden Sie zum Erstellen eines benutzerdefinierten sekundären Laufwerks auch den Befehl gcloud compute disks create, wie unter Sekundäres Laufwerk identisch mit dem primären Laufwerk erstellen beschrieben wird. Verwenden Sie zusätzliche Flags, um die Eigenschaften des sekundären Laufwerks anzupassen.

Im Folgenden finden Sie Beispiele für die Anpassung der sekundären Festplatte:

• Verwenden Sie den Parameter --guest-os-features, um zusätzliche Gastbetriebssystemfunktionen anzugeben.

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

• Verwenden Sie den Parameter --labels, um dem sekundären Laufwerk zusätzliche Labels zuzuweisen.

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

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

	op, err := disksClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create disk: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk created\n")

	return nil
}

Java

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

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

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

  // Creates a secondary disk with specified custom parameters.
  public static Status createSecondaryCustomDisk(String primaryProjectId, String secondaryProjectId,
      String primaryDiskName, String secondaryDiskName, String primaryDiskZone,
      String secondaryDiskZone, long diskSizeGb, String diskType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (DisksClient disksClient = DisksClient.create()) {
      String primaryDiskSource = String.format("projects/%s/zones/%s/disks/%s",
          primaryProjectId, primaryDiskZone, primaryDiskName);

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

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

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

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

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

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

Node.js

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

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

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

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

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateComputeSecondaryDisk();

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

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

REST

Verwenden Sie zum Erstellen eines benutzerdefinierten sekundären Laufwerks auch die Methode, die unter Sekundäres Laufwerk identisch mit dem primären Laufwerk erstellen beschrieben wird. Geben Sie zusätzliche Felder an, um die Attribute des sekundären Laufwerks anzupassen.

Im Folgenden finden Sie Beispiele für die Anpassung der sekundären Festplatte:

• Verwenden Sie das Feld guestOsFeatures, um zusätzliche Gastbetriebssystemfunktionen anzugeben. Sie können nur zusätzliche Gastbetriebssystem-Features angeben. Die Gastbetriebssystem-Features, die vom primären Laufwerk kopiert wurden, können nicht geändert oder entfernt werden.

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

• Verwenden Sie das Feld labels, um dem sekundären Laufwerk zusätzliche Labels zuzuweisen.

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

Terraform

Verwenden Sie zum Erstellen eines benutzerdefinierten sekundären Laufwerks auch die Methode, die unter Sekundäres Laufwerk identisch mit dem primären Laufwerk erstellen beschrieben wird. Sie können zusätzliche Felder angeben, um die Eigenschaften des sekundären Laufwerks anzupassen.

Im Folgenden finden Sie Beispiele für die Anpassung der sekundären Festplatte:

• Verwenden Sie das Feld guest_os_features, um zusätzliche Gastbetriebssystemfunktionen anzugeben. Sie können nur zusätzliche Gastbetriebssystem-Features angeben. Die Gastbetriebssystem-Features, die vom primären Laufwerk kopiert wurden, können nicht geändert oder entfernt werden.

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

• Verwenden Sie das Feld labels, um dem sekundären Laufwerk zusätzliche Labels zuzuweisen.

    labels = {
      environment = "dev"
    }
  

Replikation starten

Nachdem Sie ein primäres und ein sekundäres Laufwerk erstellt haben, müssen Sie die Replikation starten, um mit der Replikation von Daten vom primären auf das sekundäre Laufwerk zu beginnen.

Nächste Schritte

• Laufwerke verwalten, die die asynchrone Replikation verwenden
• Replikation verwalten
• Konsistenzgruppen verwalten
• Leistung der asynchronen Replikation überwachen