Asynchrone Replikation nichtflüchtiger Speicher verwalten

In diesem Dokument wird beschrieben, wie Sie die asynchrone Replikation eines nichtflüchtigen Speichers starten und anhalten.

Die asynchrone PD-Replikation ist nützlich für die Notfallwiederherstellung mit geringem RPO und mit geringem RTO. Weitere Informationen zur asynchronen Replikation finden Sie unter Asynchrone Replikation eines nichtflüchtigen Speichers.

Beschränkungen

  • Ein primäres Laufwerk kann immer nur auf ein sekundäres Laufwerk repliziert werden.
  • Nachdem die Replikation beendet wurde, können Sie die Replikation auf demselben Laufwerk nicht fortsetzen. Sie müssen ein neues sekundäres Laufwerk erstellen und die Replikation neu starten.
  • Sekundäre Laufwerke können nicht angehängt, gelöscht oder Snapshots davon erstellt werden, während sie repliziert werden.
  • Wenn Sie ein regionales Laufwerk als sekundäres Laufwerk verwenden und in einer der Zonen des sekundären Laufwerks ein Zonenausfall auftritt, schlägt die Replikation vom primären Laufwerk auf das sekundäre Laufwerk fehl.

Hinweise

  • Wenn Sie die Replikation über mehrere Laufwerke hinweg abstimmen müssen, erstellen Sie eine Konsistenzgruppe.
  • Erstellen Sie ein primäres Laufwerk.
  • Ein sekundäres Laufwerk erstellen
  • 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 bei Compute Engine authentifizieren. Wählen Sie dazu eine der folgenden Optionen aus:

    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. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

      3. 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. To initialize the gcloud CLI, run the following command: 

        gcloud init

      3. 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.

      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.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

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

Replikation starten

Starten Sie die Replikation mit der Google Cloud Console, der Google Cloud CLI, REST oder Terraform.

Console

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

    Zu „Asynchrone Replikation“

  2. Klicken Sie auf den Namen des sekundären Laufwerks, auf das Sie die Replikation starten möchten.

  3. Klicken Sie auf Replikation starten. Das Fenster Replikation starten wird geöffnet.

  4. Klicken Sie auf Replikation starten.

gcloud

Starten Sie die Replikation mit dem Befehl gcloud compute disks start-async-replication:

gcloud compute disks start-async-replication PRIMARY_DISK_NAME \
    --PRIMARY_LOCATION_FLAG=PRIMARY_LOCATION \
    --secondary-disk=SECONDARY_DISK_NAME \
    --SECONDARY_LOCATION_FLAG=SECONDARY_LOCATION \
    --secondary-disk-project=SECONDARY_PROJECT

Dabei gilt:

  • PRIMARY_DISK_NAME: der Name des primären Laufwerks.
  • PRIMARY_LOCATION_FLAG: das Standort-Flag für das primäre Laufwerk. Verwenden Sie für regionale Laufwerke --region. Verwenden Sie für zonale Laufwerke --zone.
  • PRIMARY_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.
  • SECONDARY_DISK_NAME: der Name des sekundären Laufwerks.
  • SECONDARY_LOCATION_FLAG: das Standort-Flag für das sekundäre Laufwerk. Verwenden Sie für regionale Laufwerke --secondary-disk-region. Verwenden Sie für zonale Laufwerke --secondary-disk-zone.
  • SECONDARY_LOCATION: die Region oder Zone des sekundären Laufwerks. Verwenden Sie für regionale Laufwerke die Region. Verwenden Sie für zonale Laufwerke die Zone.
  • SECONDARY_PROJECT: das Projekt, das das sekundäre Laufwerk enthält.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// startReplication starts disk replication in a project for a given zone.
func startReplication(
	w io.Writer,
	projectID, zone, diskName, primaryDiskName, primaryZone string,
) error {
	// projectID := "your_project_id"
	// zone := "europe-west4-b"
	// diskName := "your_disk_name"
	// primaryDiskName := "your_disk_name2"
	// primaryZone := "europe-west2-b"

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

	secondaryFullDiskName := fmt.Sprintf("projects/%s/zones/%s/disks/%s", projectID, zone, diskName)

	req := &computepb.StartAsyncReplicationDiskRequest{
		Project: projectID,
		Zone:    primaryZone,
		Disk:    primaryDiskName,
		DisksStartAsyncReplicationRequestResource: &computepb.DisksStartAsyncReplicationRequest{
			AsyncSecondaryDisk: &secondaryFullDiskName,
		},
	}

	op, err := disksClient.StartAsyncReplication(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, "Replication started\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.DisksStartAsyncReplicationRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartAsyncReplicationDiskRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartZonalDiskReplication {

  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 projectId = "YOUR_PROJECT_ID";
    // Name of the primary disk.
    String primaryDiskName = "PRIMARY_DISK_NAME";
    // Name of the secondary disk.
    String secondaryDiskName = "SECONDARY_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 primaryDiskLocation = "us-central1-a";
    // Name of the zone in which your secondary disk is located.
    String secondaryDiskLocation = "us-east1-b";

    startZonalDiskAsyncReplication(projectId, primaryDiskName, primaryDiskLocation,
            secondaryDiskName, secondaryDiskLocation);
  }

  // Starts asynchronous replication for the specified zonal disk.
  public static Status startZonalDiskAsyncReplication(String projectId, String primaryDiskName,
      String primaryDiskLocation, String secondaryDiskName, String secondaryDiskLocation)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    String secondaryDiskPath = String.format("projects/%s/zones/%s/disks/%s",
            projectId, secondaryDiskLocation, secondaryDiskName);
    // 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()) {
      DisksStartAsyncReplicationRequest diskRequest =
              DisksStartAsyncReplicationRequest.newBuilder()
                      .setAsyncSecondaryDisk(secondaryDiskPath)
                      .build();

      StartAsyncReplicationDiskRequest request =
              StartAsyncReplicationDiskRequest.newBuilder()
                      .setDisk(primaryDiskName)
                      .setDisksStartAsyncReplicationRequestResource(diskRequest)
                      .setProject(projectId)
                      .setZone(primaryDiskLocation)
                      .build();
      Operation response = disksClient.startAsyncReplicationAsync(request).get(1, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error starting replication! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js 

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

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

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

// The zone of the secondary disk.
// secondaryLocation = 'us-central1-a';

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

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

// The zone of the primary disk.
// primaryLocation = 'us-central1-a';

// The name of the primary disk.
// primaryDiskName = 'primary-disk-name';

// Start replication
async function callStartReplication() {
  const [response] = await disksClient.startAsyncReplication({
    project: secondaryProjectId,
    zone: primaryLocation,
    disk: primaryDiskName,
    disksStartAsyncReplicationRequestResource:
      new compute.DisksStartAsyncReplicationRequest({
        asyncSecondaryDisk: `projects/${primaryProjectId}/zones/${secondaryLocation}/disks/${secondaryDiskName}`,
      }),
  });

  let operation = response.latestResponse;

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

  console.log(
    `Data replication from primary disk: ${primaryDiskName} to secondary disk: ${secondaryDiskName} started.`
  );
}

await callStartReplication();

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 start_disk_replication(
    project_id: str,
    primary_disk_location: str,
    primary_disk_name: str,
    secondary_disk_location: str,
    secondary_disk_name: str,
) -> bool:
    """Starts the asynchronous replication of a primary disk to a secondary disk.
    Args:
        project_id (str): The ID of the Google Cloud project.
        primary_disk_location (str): The location of the primary disk, either a zone or a region.
        primary_disk_name (str): The name of the primary disk.
        secondary_disk_location (str): The location of the secondary disk, either a zone or a region.
        secondary_disk_name (str): The name of the secondary disk.
    Returns:
        bool: True if the replication was successfully started.
    """
    # Check if the primary disk location is a region or a zone.
    if primary_disk_location[-1].isdigit():
        region_client = compute_v1.RegionDisksClient()
        request_resource = compute_v1.RegionDisksStartAsyncReplicationRequest(
            async_secondary_disk=f"projects/{project_id}/regions/{secondary_disk_location}/disks/{secondary_disk_name}"
        )
        operation = region_client.start_async_replication(
            project=project_id,
            region=primary_disk_location,
            disk=primary_disk_name,
            region_disks_start_async_replication_request_resource=request_resource,
        )
    else:
        client = compute_v1.DisksClient()
        request_resource = compute_v1.DisksStartAsyncReplicationRequest(
            async_secondary_disk=f"zones/{secondary_disk_location}/disks/{secondary_disk_name}"
        )
        operation = client.start_async_replication(
            project=project_id,
            zone=primary_disk_location,
            disk=primary_disk_name,
            disks_start_async_replication_request_resource=request_resource,
        )
    wait_for_extended_operation(operation, verbose_name="replication operation")
    print(f"Replication for disk {primary_disk_name} started.")
    return True

REST

Starten Sie die Replikation mit einer der folgenden Methoden:

  • Starten Sie die Replikation für zonale Laufwerke mit der Methode disks.startAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PRIMARY_DISK_PROJECT/zones/PRIMARY_LOCATION/disks/PRIMARY_DISK_NAME/startAsyncReplication

{
"asyncSecondaryDisk": "projects/SECONDARY_DISK_PROJECT/SECONDARY_LOCATION_PARAMETER/SECONDARY_LOCATION/disks/SECONDARY_DISK_NAME"
}

  • Starten Sie die Replikation für regionale Laufwerke mit der Methode regionDisks.startAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PRIMARY_DISK_PROJECT/regions/PRIMARY_LOCATION/regionDisks/PRIMARY_DISK_NAME/startAsyncReplication

{
"asyncSecondaryDisk": "projects/SECONDARY_DISK_PROJECT/SECONDARY_LOCATION_PARAMETER/SECONDARY_LOCATION/disks/SECONDARY_DISK_NAME"
}

Dabei gilt:

  • PRIMARY_DISK_PROJECT: das Projekt, das das primäre Laufwerk enthält.
  • PRIMARY_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.
  • SECONDARY_DISK_PROJECT: das Projekt, das das sekundäre Laufwerk enthält.
  • SECONDARY_LOCATION_PARAMETER: der Standortparameter für das sekundäre Laufwerk. Verwenden Sie für regionale Laufwerke regions. Verwenden Sie für zonale Laufwerke zones.
  • SECONDARY_LOCATION: die Region oder Zone des sekundären Laufwerks. Verwenden Sie für regionale Laufwerke die Region. Verwenden Sie für zonale Laufwerke die Zone.
  • SECONDARY_DISK_NAME: der Name des sekundären Laufwerks.

Terraform

Verwenden Sie die Ressource compute_disk_async_replication, um die Replikation zwischen primären und sekundären Laufwerken zu starten.

resource "google_compute_disk_async_replication" "default" {
  primary_disk = google_compute_disk.primary_disk.id
  secondary_disk {
    disk = google_compute_disk.secondary_disk.id
  }
}

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

Replikation beenden

Sie können die Replikation für ein einzelnes primäres oder sekundäres Laufwerk oder für alle Laufwerke in einer Konsistenzgruppe beenden. Wenn Sie die Replikation für ein einzelnes Laufwerk in einer Konsistenzgruppe beenden, ist die Replikationszeit für dieses Laufwerk nicht mehr mit der der anderen Laufwerke in der Konsistenzgruppe synchronisiert.

Die Replikation wird in Failover- und Failback-Szenarien angehalten. Wenn Sie die Replikation beenden, können Sie sie nicht auf demselben sekundären Laufwerk neu starten. Wenn Sie die Replikation neu starten möchten, müssen Sie ein neues sekundäres Laufwerk erstellen und von vorn beginnen.

Wenn Sie die Replikation auf einem Laufwerk beenden, ändert sich der Replikationsstatus des Laufwerks in STOPPED. Der Replikationsstatus des anderen Laufwerks im Replikationspaar des Laufwerks (das entsprechende primäre oder sekundäre Laufwerk) wird später auf STOPPED aktualisiert. Wenn Sie die Zeitspanne vermeiden und den Replikationsstatus des anderen Laufwerks sofort auf STOPPED aktualisieren möchten, müssen Sie die Replikation auch auf dem anderen Laufwerk manuell beenden. Wenn Sie die Replikation auf beiden Laufwerken beenden, hat das keinen Einfluss darauf, wann die Replikation beendet wird. Es wirkt sich nur auf die Replikationsstatus der Laufwerke aus.

Replikation für ein einzelnes Laufwerk beenden

Beenden Sie die Replikation für ein einzelnes Laufwerk mit der Google Cloud Console, der Google Cloud CLI oder REST.

Console

So beenden Sie die Replikation:

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

    Zu „Asynchrone Replikation“

  2. Klicken Sie auf den Namen des primären oder sekundären Laufwerks, für das Sie die Replikation beenden möchten. Die Seite Laufwerk verwalten wird geöffnet.

  3. Klicken Sie auf Replikation beenden. Das Fenster Replikation beenden wird geöffnet.

  4. Klicken Sie auf Replikation beenden.

gcloud

Beenden Sie die Replikation mit dem Befehl gcloud compute disks stop-async-replication:

gcloud compute disks stop-async-replication DISK_NAME \
    --LOCATION_FLAG=LOCATION

Dabei gilt:

  • DISK_NAME: der Name des Laufwerks
  • LOCATION_FLAG: das Standort-Flag für das Laufwerk. Verwenden Sie für ein regionales Laufwerk --region. Verwenden Sie für ein zonales Laufwerk --zone.
  • LOCATION: die Region oder Zone des Laufwerks. Verwenden Sie für regionale Laufwerke die Region. Verwenden Sie für zonale Laufwerke die Zone.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// stopReplication stops primary disk replication in a project for a given zone.
func stopReplication(
	w io.Writer,
	projectID, primaryDiskName, primaryZone string,
) error {
	// projectID := "your_project_id"
	// primaryDiskName := "your_disk_name2"
	// primaryZone := "europe-west2-b"

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

	req := &computepb.StopAsyncReplicationDiskRequest{
		Project: projectID,
		Zone:    primaryZone,
		Disk:    primaryDiskName,
	}

	op, err := disksClient.StopAsyncReplication(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, "Replication stopped\n")

	return nil
}

Java 

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

public class StopZonalDiskReplication {

  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 projectId = "YOUR_PROJECT_ID";
    // Name of the region or zone in which your secondary disk is located.
    String secondaryDiskLocation = "us-east1-b";
    // Name of the secondary disk.
    String secondaryDiskName = "SECONDARY_DISK_NAME";

    stopZonalDiskAsyncReplication(projectId, secondaryDiskLocation, secondaryDiskName);
  }

  // Stops asynchronous replication for the specified disk.
  public static Status stopZonalDiskAsyncReplication(
          String project, String secondaryDiskLocation, String secondaryDiskName)
          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()) {
      StopAsyncReplicationDiskRequest stopReplicationDiskRequest =
              StopAsyncReplicationDiskRequest.newBuilder()
                      .setProject(project)
                      .setDisk(secondaryDiskName)
                      .setZone(secondaryDiskLocation)
                      .build();
      Operation response = disksClient.stopAsyncReplicationAsync(stopReplicationDiskRequest)
              .get(1, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error stopping replication! " + response.getError());
      }
      return response.getStatus();
    }
  }
}

Node.js 

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

// 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 that contains the primary disk.
const primaryProjectId = await disksClient.getProjectId();

// The zone of the primary disk.
// primaryLocation = 'us-central1-a';

// The name of the primary disk.
// primaryDiskName = 'primary-disk-name';

// Stop replication
async function callStopReplication() {
  const [response] = await disksClient.stopAsyncReplication({
    project: primaryProjectId,
    zone: primaryLocation,
    disk: primaryDiskName,
  });

  let operation = response.latestResponse;

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

  console.log(`Replication for primary disk: ${primaryDiskName} stopped.`);
}

await callStopReplication();

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 stop_disk_replication(
    project_id: str, primary_disk_location: str, primary_disk_name: str
) -> bool:
    """
    Stops the asynchronous replication of a disk.
    Args:
        project_id (str): The ID of the Google Cloud project.
        primary_disk_location (str): The location of the primary disk, either a zone or a region.
        primary_disk_name (str): The name of the primary disk.
    Returns:
        bool: True if the replication was successfully stopped.
    """
    # Check if the primary disk is in a region or a zone
    if primary_disk_location[-1].isdigit():
        region_client = compute_v1.RegionDisksClient()
        operation = region_client.stop_async_replication(
            project=project_id, region=primary_disk_location, disk=primary_disk_name
        )
    else:
        zone_client = compute_v1.DisksClient()
        operation = zone_client.stop_async_replication(
            project=project_id, zone=primary_disk_location, disk=primary_disk_name
        )

    wait_for_extended_operation(operation, verbose_name="replication operation")
    print(f"Replication for disk {primary_disk_name} stopped.")
    return True

REST

Sie haben folgende Möglichkeiten, die Replikation zu beenden:

  • Beenden Sie die Replikation für zonale Laufwerke mit der Methode disks.stopAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT/zones/LOCATION/disks/DISK_NAME/stopAsyncReplication
{
}

  • Beenden Sie die Replikation für regionale Laufwerke mit der Methode regionDisks.stopAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/LOCATION/regionDisks/DISK_NAME/stopAsyncReplication
{
}

Dabei gilt:

  • PROJECT: das Projekt, das das Laufwerk enthält.
  • DISK_NAME: der Name des Laufwerks
  • LOCATION: die Zone oder Region des Laufwerks. Verwenden Sie für zonale Laufwerke die Zone. Verwenden Sie für regionale Laufwerke die Region.

Terraform

Wenn Sie die Replikation auf dem primären und dem sekundären Laufwerk beenden möchten, entfernen Sie die compute_disk_async_replication-Ressource.

Replikation für eine Konsistenzgruppe beenden

Beenden Sie die Replikation für alle Laufwerke in einer Konsistenzgruppe über die Google Cloud Console, die Google Cloud CLI oder REST.

Console

So beenden Sie die Replikation für alle Laufwerke in einer Konsistenzgruppe:

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

    Zu „Asynchrone Replikation“

  2. Klicken Sie auf den Tab Konsistenzgruppen.

  3. Klicken Sie auf den Namen der Konsistenzgruppe, für die Sie die Replikation beenden möchten. Die Seite Konsistenzgruppe verwalten wird geöffnet.

  4. Klicken Sie auf Replikation beenden. Das Fenster Replikation beenden wird geöffnet.

  5. Klicken Sie auf Replikation beenden.

gcloud

Beenden Sie die Replikation für alle Laufwerke in einer Konsistenzgruppe mit dem Befehl gcloud compute disks stop-group-async-replication:

gcloud compute disks stop-group-async-replication CONSISTENCY_GROUP \
--LOCATION_FLAG=LOCATION

Dabei gilt:

  • CONSISTENCY_GROUP: die URL der Konsistenzgruppe. Beispiel: projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME
  • LOCATION_FLAG: das Standort-Flag für die Laufwerke in der Konsistenzgruppe. Verwenden Sie für regionale Laufwerke --region. Verwenden Sie für zonale Laufwerke --zone.
  • LOCATION: die Region oder Zone des Laufwerks. Verwenden Sie für regionale Laufwerke die Region. Verwenden Sie für zonale Laufwerke die Zone.

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

// stopReplicationConsistencyGroup stop replication for a consistency group for a project in a given region.
func stopReplicationConsistencyGroup(w io.Writer, projectID, region, groupName string) error {
	// projectID := "your_project_id"
	// region := "europe-west4"
	// groupName := "your_group_name"

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

	consistencyGroupUrl := fmt.Sprintf("projects/%s/regions/%s/resourcePolicies/%s", projectID, region, groupName)

	req := &computepb.StopGroupAsyncReplicationRegionDiskRequest{
		Project: projectID,
		DisksStopGroupAsyncReplicationResourceResource: &computepb.DisksStopGroupAsyncReplicationResource{
			ResourcePolicy: proto.String(consistencyGroupUrl),
		},
		Region: region,
	}

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

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

	fmt.Fprintf(w, "Group stopped replicating\n")

	return nil
}

Java 

import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StopZonalDiskReplicationConsistencyGroup {
  public static void main(String[] args)
          throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project that contains the disk.
    String project = "YOUR_PROJECT_ID";
    // Zone of the disk.
    String zone = "us-central1-a";
    // Name of the consistency group.
    String consistencyGroupName = "CONSISTENCY_GROUP";

    stopZonalDiskReplicationConsistencyGroup(project, zone, consistencyGroupName);
  }

  // Stops replication of a consistency group for a project in a given zone.
  public static Status stopZonalDiskReplicationConsistencyGroup(
          String project, String zone, String consistencyGroupName)
          throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String region = zone.substring(0, zone.lastIndexOf('-'));

    String resourcePolicy = String.format("projects/%s/regions/%s/resourcePolicies/%s",
            project, region, consistencyGroupName);
    // 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()) {
      StopGroupAsyncReplicationDiskRequest request =
              StopGroupAsyncReplicationDiskRequest.newBuilder()
                      .setProject(project)
                      .setZone(zone)
                      .setDisksStopGroupAsyncReplicationResourceResource(
                              DisksStopGroupAsyncReplicationResource.newBuilder()
                                      .setResourcePolicy(resourcePolicy).build())
                      .build();
      Operation response = disksClient.stopGroupAsyncReplicationAsync(request)
              .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error stopping disk replication! " + 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 disks are regional- use RegionDisksClient and RegionOperationsClient.
// TODO(developer): Uncomment disksClient and zoneOperationsClient before running the sample.
// Instantiate a disksClient
// disksClient = new computeLib.DisksClient();
// Instantiate a zoneOperationsClient
// zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the consistency group.
const projectId = await disksClient.getProjectId();

// If you use RegionDisksClient- define region, if DisksClient- define zone.
// The zone or region of the disks.
const disksLocation = 'europe-central2-a';

// The name of the consistency group.
const consistencyGroupName = 'consistency-group-1';

// The region of the consistency group.
const consistencyGroupLocation = 'europe-central2';

async function callStopReplication() {
  const [response] = await disksClient.stopGroupAsyncReplication({
    project: projectId,
    // If you use RegionDisksClient, pass region as an argument instead of zone.
    zone: disksLocation,
    disksStopGroupAsyncReplicationResourceResource:
      new compute.DisksStopGroupAsyncReplicationResource({
        resourcePolicy: [
          `https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,
        ],
      }),
  });

  let operation = response.latestResponse;

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

  const message = `Replication stopped for consistency group: ${consistencyGroupName}.`;
  console.log(message);
  return message;
}

return await callStopReplication();

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 stop_replication_consistency_group(project_id, location, consistency_group_name):
    """
    Stops the asynchronous replication for a consistency group.
    Args:
        project_id (str): The ID of the Google Cloud project.
        location (str): The region where the consistency group is located.
        consistency_group_id (str): The ID of the consistency group.
    Returns:
        bool: True if the replication was successfully stopped.
    """
    consistency_group = compute_v1.DisksStopGroupAsyncReplicationResource(
        resource_policy=f"regions/{location}/resourcePolicies/{consistency_group_name}"
    )
    region_client = compute_v1.RegionDisksClient()
    operation = region_client.stop_group_async_replication(
        project=project_id,
        region=location,
        disks_stop_group_async_replication_resource_resource=consistency_group,
    )
    wait_for_extended_operation(operation, "Stopping replication for consistency group")

    return True

REST

Beenden Sie die Replikation für alle Laufwerke in einer Konsistenzgruppe mit einer der folgenden Methoden:

  • Beenden Sie die Replikation für zonale Laufwerke mit der Methode disks.stopGroupAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT/zones/LOCATION/disks/stopGroupAsyncReplication
{
"resourcePolicy": "CONSISTENCY_GROUP"
}

  • Beenden Sie die Replikation für regionale Laufwerke mit der Methode regionDisks.stopGroupAsyncReplication:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/LOCATION/regionDisks/DISK_NAME/stopAsyncReplication
{
"resourcePolicy": "CONSISTENCY_GROUP"
}

Dabei gilt:

  • DISK_NAME: Name des Laufwerks
  • LOCATION: die Zone oder Region des Laufwerks. Verwenden Sie für zonale Laufwerke die Zone. Verwenden Sie für regionale Laufwerke die Region.
  • CONSISTENCY_GROUP: die URL der Konsistenzgruppe. Beispiel: projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME

Nächste Schritte