Manage Persistent Disk Asynchronous Replication

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.
funcstartReplication(
wio.Writer,
projectID,zone,diskName,primaryDiskName,primaryZonestring,
)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)
iferr!=nil{
returnfmt.Errorf("NewDisksRESTClient: %w",err)
}
deferdisksClient.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)
iferr!=nil{
returnfmt.Errorf("unable to create disk: %w",err)
}
iferr=op.Wait(ctx);err!=nil{
returnfmt.Errorf("unable to wait for the operation: %w",err)
}
fmt.Fprintf(w,"Replication started\n")
returnnil
}

importcom.google.cloud.compute.v1.DisksClient;
importcom.google.cloud.compute.v1.DisksStartAsyncReplicationRequest;
importcom.google.cloud.compute.v1.Operation;
importcom.google.cloud.compute.v1.Operation.Status;
importcom.google.cloud.compute.v1.StartAsyncReplicationDiskRequest;
importjava.io.IOException;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
publicclass StartZonalDiskReplication{
publicstaticvoidmain(String[]args)
throwsIOException,ExecutionException,InterruptedException,TimeoutException{
// TODO(developer): Replace these variables before running the sample.
// The project that contains the primary disk.
StringprojectId="YOUR_PROJECT_ID";
// Name of the primary disk.
StringprimaryDiskName="PRIMARY_DISK_NAME";
// Name of the secondary disk.
StringsecondaryDiskName="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
StringprimaryDiskLocation="us-central1-a";
// Name of the zone in which your secondary disk is located.
StringsecondaryDiskLocation="us-east1-b";
startZonalDiskAsyncReplication(projectId,primaryDiskName,primaryDiskLocation,
secondaryDiskName,secondaryDiskLocation);
}
// Starts asynchronous replication for the specified zonal disk.
publicstaticStatusstartZonalDiskAsyncReplication(StringprojectId,StringprimaryDiskName,
StringprimaryDiskLocation,StringsecondaryDiskName,StringsecondaryDiskLocation)
throwsIOException,ExecutionException,InterruptedException,TimeoutException{
StringsecondaryDiskPath=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(DisksClientdisksClient=DisksClient.create()){
DisksStartAsyncReplicationRequestdiskRequest=
DisksStartAsyncReplicationRequest.newBuilder()
.setAsyncSecondaryDisk(secondaryDiskPath)
.build();
StartAsyncReplicationDiskRequestrequest=
StartAsyncReplicationDiskRequest.newBuilder()
.setDisk(primaryDiskName)
.setDisksStartAsyncReplicationRequestResource(diskRequest)
.setProject(projectId)
.setZone(primaryDiskLocation)
.build();
Operationresponse=disksClient.startAsyncReplicationAsync(request).get(1,TimeUnit.MINUTES);
if(response.hasError()){
thrownewError("Error starting replication! "+response.getError());
}
returnresponse.getStatus();
}
}
}

// Import the Compute library
constcomputeLib=require('@google-cloud/compute');
constcompute=computeLib.protos.google.cloud.compute.v1;
// Instantiate a diskClient
constdisksClient=newcomputeLib.DisksClient();
// Instantiate a zoneOperationsClient
constzoneOperationsClient=newcomputeLib.ZoneOperationsClient();
/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project of the secondary disk.
constsecondaryProjectId=awaitdisksClient.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.
constprimaryProjectId=awaitdisksClient.getProjectId();
// The zone of the primary disk.
// primaryLocation = 'us-central1-a';
// The name of the primary disk.
// primaryDiskName = 'primary-disk-name';
// Start replication
asyncfunctioncallStartReplication(){
const[response]=awaitdisksClient.startAsyncReplication({
project:secondaryProjectId,
zone:primaryLocation,
disk:primaryDiskName,
disksStartAsyncReplicationRequestResource:
newcompute.DisksStartAsyncReplicationRequest({
asyncSecondaryDisk:`projects/${primaryProjectId}/zones/${secondaryLocation}/disks/${secondaryDiskName}`,
}),
});
letoperation=response.latestResponse;
// Wait for the operation to complete.
while(operation.status!=='DONE'){
[operation]=awaitzoneOperationsClient.wait({
operation:operation.name,
project:secondaryProjectId,
zone:operation.zone.split('/').pop(),
});
}
console.log(
`Data replication from primary disk: ${primaryDiskName} to secondary disk: ${secondaryDiskName} started.`
);
}
awaitcallStartReplication();

from__future__import annotations
importsys
fromtypingimport Any
fromgoogle.api_core.extended_operationimport ExtendedOperation
fromgoogle.cloudimport compute_v1
defwait_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
defstart_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

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

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.
funcstopReplication(
wio.Writer,
projectID,primaryDiskName,primaryZonestring,
)error{
// projectID := "your_project_id"
// primaryDiskName := "your_disk_name2"
// primaryZone := "europe-west2-b"
ctx:=context.Background()
disksClient,err:=compute.NewDisksRESTClient(ctx)
iferr!=nil{
returnfmt.Errorf("NewDisksRESTClient: %w",err)
}
deferdisksClient.Close()
req:=&computepb.StopAsyncReplicationDiskRequest{
Project:projectID,
Zone:primaryZone,
Disk:primaryDiskName,
}
op,err:=disksClient.StopAsyncReplication(ctx,req)
iferr!=nil{
returnfmt.Errorf("unable to create disk: %w",err)
}
iferr=op.Wait(ctx);err!=nil{
returnfmt.Errorf("unable to wait for the operation: %w",err)
}
fmt.Fprintf(w,"Replication stopped\n")
returnnil
}

importcom.google.cloud.compute.v1.DisksClient;
importcom.google.cloud.compute.v1.Operation;
importcom.google.cloud.compute.v1.Operation.Status;
importcom.google.cloud.compute.v1.StopAsyncReplicationDiskRequest;
importjava.io.IOException;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
publicclass StopZonalDiskReplication{
publicstaticvoidmain(String[]args)
throwsIOException,ExecutionException,InterruptedException,TimeoutException{
// TODO(developer): Replace these variables before running the sample.
// The project that contains the primary disk.
StringprojectId="YOUR_PROJECT_ID";
// Name of the region or zone in which your secondary disk is located.
StringsecondaryDiskLocation="us-east1-b";
// Name of the secondary disk.
StringsecondaryDiskName="SECONDARY_DISK_NAME";
stopZonalDiskAsyncReplication(projectId,secondaryDiskLocation,secondaryDiskName);
}
// Stops asynchronous replication for the specified disk.
publicstaticStatusstopZonalDiskAsyncReplication(
Stringproject,StringsecondaryDiskLocation,StringsecondaryDiskName)
throwsIOException,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(DisksClientdisksClient=DisksClient.create()){
StopAsyncReplicationDiskRequeststopReplicationDiskRequest=
StopAsyncReplicationDiskRequest.newBuilder()
.setProject(project)
.setDisk(secondaryDiskName)
.setZone(secondaryDiskLocation)
.build();
Operationresponse=disksClient.stopAsyncReplicationAsync(stopReplicationDiskRequest)
.get(1,TimeUnit.MINUTES);
if(response.hasError()){
thrownewError("Error stopping replication! "+response.getError());
}
returnresponse.getStatus();
}
}
}

// Import the Compute library
constcomputeLib=require('@google-cloud/compute');
// Instantiate a diskClient
constdisksClient=newcomputeLib.DisksClient();
// Instantiate a zoneOperationsClient
constzoneOperationsClient=newcomputeLib.ZoneOperationsClient();
/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the primary disk.
constprimaryProjectId=awaitdisksClient.getProjectId();
// The zone of the primary disk.
// primaryLocation = 'us-central1-a';
// The name of the primary disk.
// primaryDiskName = 'primary-disk-name';
// Stop replication
asyncfunctioncallStopReplication(){
const[response]=awaitdisksClient.stopAsyncReplication({
project:primaryProjectId,
zone:primaryLocation,
disk:primaryDiskName,
});
letoperation=response.latestResponse;
// Wait for the operation to complete.
while(operation.status!=='DONE'){
[operation]=awaitzoneOperationsClient.wait({
operation:operation.name,
project:primaryProjectId,
zone:operation.zone.split('/').pop(),
});
}
console.log(`Replication for primary disk: ${primaryDiskName} stopped.`);
}
awaitcallStopReplication();

from__future__import annotations
importsys
fromtypingimport Any
fromgoogle.api_core.extended_operationimport ExtendedOperation
fromgoogle.cloudimport compute_v1
defwait_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
defstop_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

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.
funcstopReplicationConsistencyGroup(wio.Writer,projectID,region,groupNamestring)error{
// projectID := "your_project_id"
// region := "europe-west4"
// groupName := "your_group_name"
ctx:=context.Background()
disksClient,err:=compute.NewRegionDisksRESTClient(ctx)
iferr!=nil{
returnfmt.Errorf("NewResourcePoliciesRESTClient: %w",err)
}
deferdisksClient.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)
iferr!=nil{
returnfmt.Errorf("unable to stop replication: %w",err)
}
iferr=op.Wait(ctx);err!=nil{
returnfmt.Errorf("unable to wait for the operation: %w",err)
}
fmt.Fprintf(w,"Group stopped replicating\n")
returnnil
}

importcom.google.cloud.compute.v1.DisksClient;
importcom.google.cloud.compute.v1.DisksStopGroupAsyncReplicationResource;
importcom.google.cloud.compute.v1.Operation;
importcom.google.cloud.compute.v1.Operation.Status;
importcom.google.cloud.compute.v1.StopGroupAsyncReplicationDiskRequest;
importjava.io.IOException;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
publicclass StopZonalDiskReplicationConsistencyGroup{
publicstaticvoidmain(String[]args)
throwsIOException,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.
Stringproject="YOUR_PROJECT_ID";
// Zone of the disk.
Stringzone="us-central1-a";
// Name of the consistency group.
StringconsistencyGroupName="CONSISTENCY_GROUP";
stopZonalDiskReplicationConsistencyGroup(project,zone,consistencyGroupName);
}
// Stops replication of a consistency group for a project in a given zone.
publicstaticStatusstopZonalDiskReplicationConsistencyGroup(
Stringproject,Stringzone,StringconsistencyGroupName)
throwsIOException,InterruptedException,ExecutionException,TimeoutException{
Stringregion=zone.substring(0,zone.lastIndexOf('-'));
StringresourcePolicy=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(DisksClientdisksClient=DisksClient.create()){
StopGroupAsyncReplicationDiskRequestrequest=
StopGroupAsyncReplicationDiskRequest.newBuilder()
.setProject(project)
.setZone(zone)
.setDisksStopGroupAsyncReplicationResourceResource(
DisksStopGroupAsyncReplicationResource.newBuilder()
.setResourcePolicy(resourcePolicy).build())
.build();
Operationresponse=disksClient.stopGroupAsyncReplicationAsync(request)
.get(3,TimeUnit.MINUTES);
if(response.hasError()){
thrownewError("Error stopping disk replication! "+response.getError());
}
returnresponse.getStatus();
}
}
}

// Import the Compute library
constcomputeLib=require('@google-cloud/compute');
constcompute=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.
constprojectId=awaitdisksClient.getProjectId();
// If you use RegionDisksClient- define region, if DisksClient- define zone.
// The zone or region of the disks.
constdisksLocation='europe-central2-a';
// The name of the consistency group.
constconsistencyGroupName='consistency-group-1';
// The region of the consistency group.
constconsistencyGroupLocation='europe-central2';
asyncfunctioncallStopReplication(){
const[response]=awaitdisksClient.stopGroupAsyncReplication({
project:projectId,
// If you use RegionDisksClient, pass region as an argument instead of zone.
zone:disksLocation,
disksStopGroupAsyncReplicationResourceResource:
newcompute.DisksStopGroupAsyncReplicationResource({
resourcePolicy:[
`https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,
],
}),
});
letoperation=response.latestResponse;
// Wait for the operation to complete.
while(operation.status!=='DONE'){
[operation]=awaitzoneOperationsClient.wait({
operation:operation.name,
project:projectId,
// If you use RegionDisksClient, pass region as an argument instead of zone.
zone:operation.zone.split('/').pop(),
});
}
constmessage=`Replication stopped for consistency group: ${consistencyGroupName}.`;
console.log(message);
returnmessage;
}
returnawaitcallStopReplication();

from__future__import annotations
importsys
fromtypingimport Any
fromgoogle.api_core.extended_operationimport ExtendedOperation
fromgoogle.cloudimport compute_v1
defwait_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
defstop_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