import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb""google.golang.org/protobuf/proto")// createConsistencyGroup creates a new consistency group for a project in a given region.funccreateConsistencyGroup(wio.Writer,projectID,region,groupNamestring)error{// projectID := "your_project_id"// region := "europe-west4"// groupName := "your_group_name"ctx:=context.Background()disksClient,err:=compute.NewResourcePoliciesRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewResourcePoliciesRESTClient: %w",err)}deferdisksClient.Close()req:=&computepb.InsertResourcePolicyRequest{Project:projectID,ResourcePolicyResource:&computepb.ResourcePolicy{Name:proto.String(groupName),DiskConsistencyGroupPolicy:&computepb.ResourcePolicyDiskConsistencyGroupPolicy{},},Region:region,}op,err:=disksClient.Insert(ctx,req)iferr!=nil{returnfmt.Errorf("unable to create group: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Group created\n")returnnil}

importcom.google.cloud.compute.v1.InsertResourcePolicyRequest;importcom.google.cloud.compute.v1.Operation;importcom.google.cloud.compute.v1.Operation.Status;importcom.google.cloud.compute.v1.ResourcePoliciesClient;importcom.google.cloud.compute.v1.ResourcePolicy;importjava.io.IOException;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassCreateConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Cloud project you want to use.Stringproject="YOUR_PROJECT_ID";// Name of the region in which you want to create the consistency group.Stringregion="us-central1";// Name of the consistency group you want to create.StringconsistencyGroupName="YOUR_CONSISTENCY_GROUP_NAME";createConsistencyGroup(project,region,consistencyGroupName);}// Creates a new consistency group resource policy in the specified project and region.publicstaticStatuscreateConsistencyGroup(Stringproject,Stringregion,StringconsistencyGroupName)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(ResourcePoliciesClientregionResourcePoliciesClient=ResourcePoliciesClient.create()){ResourcePolicyresourcePolicy=ResourcePolicy.newBuilder().setName(consistencyGroupName).setRegion(region).setDiskConsistencyGroupPolicy(ResourcePolicy.newBuilder().getDiskConsistencyGroupPolicy()).build();InsertResourcePolicyRequestrequest=InsertResourcePolicyRequest.newBuilder().setProject(project).setRegion(region).setResourcePolicyResource(resourcePolicy).build();Operationresponse=regionResourcePoliciesClient.insertAsync(request).get(1,TimeUnit.MINUTES);if(response.hasError()){thrownewError("Error creating consistency group! "+response.getError());}returnresponse.getStatus();}}}

// Import the Compute libraryconstcomputeLib=require('@google-cloud/compute');constcompute=computeLib.protos.google.cloud.compute.v1;// Instantiate a resourcePoliciesClientconstresourcePoliciesClient=newcomputeLib.ResourcePoliciesClient();// Instantiate a regionOperationsClientconstregionOperationsClient=newcomputeLib.RegionOperationsClient();/** * TODO(developer): Update/uncomment these variables before running the sample. */// The project that contains the consistency group.constprojectId=awaitresourcePoliciesClient.getProjectId();// The region for the consistency group.// If you want to add primary disks to consistency group, use the same region as the primary disks.// If you want to add secondary disks to the consistency group, use the same region as the secondary disks.// region = 'europe-central2';// The name for consistency group.// consistencyGroupName = 'consistency-group-name';asyncfunctioncallCreateConsistencyGroup(){// Create a resourcePolicyResourceconstresourcePolicyResource=newcompute.ResourcePolicy({diskConsistencyGroupPolicy:newcompute.ResourcePolicyDiskConsistencyGroupPolicy({}),name:consistencyGroupName,});const[response]=awaitresourcePoliciesClient.insert({project:projectId,region,resourcePolicyResource,});letoperation=response.latestResponse;// Wait for the create group operation to complete.while(operation.status!=='DONE'){[operation]=awaitregionOperationsClient.wait({operation:operation.name,project:projectId,region,});}console.log(`Consistency group:${consistencyGroupName} created.`);}awaitcallCreateConsistencyGroup();

from__future__importannotationsimportsysfromtypingimportAnyfromgoogle.api_core.extended_operationimportExtendedOperationfromgoogle.cloudimportcompute_v1defwait_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)ifoperation.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)raiseoperation.exception()orRuntimeError(operation.error_message)ifoperation.warnings:print(f"Warnings during{verbose_name}:\n",file=sys.stderr,flush=True)forwarninginoperation.warnings:print(f" -{warning.code}:{warning.message}",file=sys.stderr,flush=True)returnresultdefcreate_consistency_group(project_id:str,region:str,group_name:str,group_description:str)->compute_v1.ResourcePolicy:"""    Creates a consistency group in Google Cloud Compute Engine.    Args:        project_id (str): The ID of the Google Cloud project.        region (str): The region where the consistency group will be created.        group_name (str): The name of the consistency group.        group_description (str): The description of the consistency group.    Returns:        compute_v1.ResourcePolicy: The consistency group object    """# Initialize the ResourcePoliciesClientclient=compute_v1.ResourcePoliciesClient()# Create the ResourcePolicy object with the provided name, description, and policyresource_policy_resource=compute_v1.ResourcePolicy(name=group_name,description=group_description,disk_consistency_group_policy=compute_v1.ResourcePolicyDiskConsistencyGroupPolicy(),)operation=client.insert(project=project_id,region=region,resource_policy_resource=resource_policy_resource,)wait_for_extended_operation(operation,"Consistency group creation")returnclient.get(project=project_id,region=region,resource_policy=group_name)

resource "google_compute_resource_policy" "default" {  name   = "test-consistency-group"  region = "us-central1"  disk_consistency_group_policy {    enabled = true  }}

import("context""fmt""io""strings"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb""google.golang.org/api/iterator")// listRegionalConsistencyGroup get list of disks in consistency group for a project in a given region.funclistRegionalConsistencyGroup(wio.Writer,projectID,region,groupNamestring)error{// projectID := "your_project_id"// region := "europe-west4"// groupName := "your_group_name"ifgroupName==""{returnfmt.Errorf("group name cannot be empty")}ctx:=context.Background()// To check for zonal disks in consistency group use compute.NewDisksRESTClientdisksClient,err:=compute.NewRegionDisksRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewRegionDisksRESTClient: %w",err)}deferdisksClient.Close()// If using zonal disk client, use computepb.ListDisksRequestreq:=&computepb.ListRegionDisksRequest{Project:projectID,Region:region,}it:=disksClient.List(ctx,req)for{disk,err:=it.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}for_,diskPolicy:=rangedisk.GetResourcePolicies(){ifstrings.Contains(diskPolicy,groupName){fmt.Fprintf(w,"- %s\n",disk.GetName())}}}returnnil}

importcom.google.cloud.compute.v1.Disk;importcom.google.cloud.compute.v1.DisksClient;importcom.google.cloud.compute.v1.ListDisksRequest;importjava.io.IOException;importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.ExecutionException;publicclassListZonalDisksInConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,InterruptedException,ExecutionException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Cloud project you want to use.Stringproject="YOUR_PROJECT_ID";// Name of the consistency group.StringconsistencyGroupName="CONSISTENCY_GROUP_ID";// Zone of the disk.StringdisksLocation="us-central1-a";// Region of the consistency group.StringconsistencyGroupLocation="us-central1";listZonalDisksInConsistencyGroup(project,consistencyGroupName,consistencyGroupLocation,disksLocation);}// Lists disks in a consistency group.publicstaticList<Disk>listZonalDisksInConsistencyGroup(Stringproject,StringconsistencyGroupName,StringconsistencyGroupLocation,StringdisksLocation)throwsIOException{Stringfilter=String.format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",project,consistencyGroupLocation,consistencyGroupName);List<Disk>disksList=newArrayList<>();// 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()){ListDisksRequestrequest=ListDisksRequest.newBuilder().setProject(project).setZone(disksLocation).build();DisksClient.ListPagedResponseresponse=disksClient.list(request);for(Diskdisk:response.iterateAll()){if(disk.getResourcePoliciesList().contains(filter)){disksList.add(disk);}}}System.out.println(disksList.size());returndisksList;}}

importcom.google.cloud.compute.v1.Disk;importcom.google.cloud.compute.v1.ListRegionDisksRequest;importcom.google.cloud.compute.v1.RegionDisksClient;importjava.io.IOException;importjava.util.ArrayList;importjava.util.List;importjava.util.concurrent.ExecutionException;publicclassListRegionalDisksInConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,InterruptedException,ExecutionException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Cloud project you want to use.Stringproject="YOUR_PROJECT_ID";// Name of the consistency group.StringconsistencyGroupName="CONSISTENCY_GROUP_ID";// Region of the disk.StringdisksLocation="us-central1";// Region of the consistency group.StringconsistencyGroupLocation="us-central1";listRegionalDisksInConsistencyGroup(project,consistencyGroupName,consistencyGroupLocation,disksLocation);}// Lists disks in a consistency group.publicstaticList<Disk>listRegionalDisksInConsistencyGroup(Stringproject,StringconsistencyGroupName,StringconsistencyGroupLocation,StringdisksLocation)throwsIOException{Stringfilter=String.format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",project,consistencyGroupLocation,consistencyGroupName);List<Disk>disksList=newArrayList<>();// 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(RegionDisksClientdisksClient=RegionDisksClient.create()){ListRegionDisksRequestrequest=ListRegionDisksRequest.newBuilder().setProject(project).setRegion(disksLocation).build();RegionDisksClient.ListPagedResponseresponse=disksClient.list(request);for(Diskdisk:response.iterateAll()){if(disk.getResourcePoliciesList().contains(filter)){disksList.add(disk);}}}System.out.println(disksList.size());returndisksList;}}

// Import the Compute libraryconstcomputeLib=require('@google-cloud/compute');// If you want to get regional disks, you should use: RegionDisksClient.// Instantiate a disksClientconstdisksClient=newcomputeLib.DisksClient();/** * TODO(developer): Update/uncomment these variables before running the sample. */// The project that contains the disks.constprojectId=awaitdisksClient.getProjectId();// If you use RegionDisksClient- define region, if DisksClient- define zone.// The zone or region of the disks.// disksLocation = 'europe-central2-a';// The name of the consistency group.// consistencyGroupName = 'consistency-group-name';// The region of the consistency group.// consistencyGroupLocation = 'europe-central2';asyncfunctioncallConsistencyGroupDisksList(){constfilter=`https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`;const[response]=awaitdisksClient.list({project:projectId,// If you use RegionDisksClient, pass region as an argument instead of zone.zone:disksLocation,});// Filtering must be done manually for now, since list filtering inside disksClient.list is not supported yet.constfilteredDisks=response.filter(disk=>disk.resourcePolicies.includes(filter));console.log(JSON.stringify(filteredDisks));}awaitcallConsistencyGroupDisksList();

fromgoogle.cloudimportcompute_v1deflist_disks_consistency_group(project_id:str,disk_location:str,consistency_group_name:str,consistency_group_region:str,)->list:"""    Lists disks that are part of a specified consistency group.    Args:        project_id (str): The ID of the Google Cloud project.        disk_location (str): The region or zone of the disk        disk_region_flag (bool): Flag indicating if the disk is regional.        consistency_group_name (str): The name of the consistency group.        consistency_group_region (str): The region of the consistency group.    Returns:        list: A list of disks that are part of the specified consistency group.    """consistency_group_link=(f"https://www.googleapis.com/compute/v1/projects/{project_id}/regions/"f"{consistency_group_region}/resourcePolicies/{consistency_group_name}")# If the final character of the disk_location is a digit, it is a regional diskifdisk_location[-1].isdigit():region_client=compute_v1.RegionDisksClient()disks=region_client.list(project=project_id,region=disk_location)# For zonal disks we use DisksClientelse:client=compute_v1.DisksClient()disks=client.list(project=project_id,zone=disk_location)return[diskfordiskindisksifconsistency_group_linkindisk.resource_policies]

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb")// addDiskConsistencyGroup adds a disk to a consistency group for a project in a given region.funcaddDiskConsistencyGroup(wio.Writer,projectID,region,groupName,diskNamestring)error{// projectID := "your_project_id"// region := "europe-west4"// diskName := "your_disk_name"// 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.AddResourcePoliciesRegionDiskRequest{Project:projectID,Disk:diskName,RegionDisksAddResourcePoliciesRequestResource:&computepb.RegionDisksAddResourcePoliciesRequest{ResourcePolicies:[]string{consistencyGroupUrl},},Region:region,}op,err:=disksClient.AddResourcePolicies(ctx,req)iferr!=nil{returnfmt.Errorf("unable to add disk: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Disk added\n")returnnil}

importcom.google.cloud.compute.v1.AddResourcePoliciesDiskRequest;importcom.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest;importcom.google.cloud.compute.v1.DisksAddResourcePoliciesRequest;importcom.google.cloud.compute.v1.DisksClient;importcom.google.cloud.compute.v1.Operation;importcom.google.cloud.compute.v1.Operation.Status;importcom.google.cloud.compute.v1.RegionDisksAddResourcePoliciesRequest;importcom.google.cloud.compute.v1.RegionDisksClient;importjava.io.IOException;importjava.util.Arrays;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassAddDiskToConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,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 or region of the disk.Stringlocation="us-central1";// Name of the disk.StringdiskName="DISK_NAME";// Name of the consistency group.StringconsistencyGroupName="CONSISTENCY_GROUP";// Region of the consistency group.StringconsistencyGroupLocation="us-central1";addDiskToConsistencyGroup(project,location,diskName,consistencyGroupName,consistencyGroupLocation);}// Adds a disk to a consistency group.publicstaticStatusaddDiskToConsistencyGroup(Stringproject,Stringlocation,StringdiskName,StringconsistencyGroupName,StringconsistencyGroupLocation)throwsIOException,ExecutionException,InterruptedException,TimeoutException{StringconsistencyGroupUrl=String.format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",project,consistencyGroupLocation,consistencyGroupName);Operationresponse;if(Character.isDigit(location.charAt(location.length()-1))){// 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(RegionDisksClientdisksClient=RegionDisksClient.create()){AddResourcePoliciesRegionDiskRequestrequest=AddResourcePoliciesRegionDiskRequest.newBuilder().setDisk(diskName).setRegion(location).setProject(project).setRegionDisksAddResourcePoliciesRequestResource(RegionDisksAddResourcePoliciesRequest.newBuilder().addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)).build()).build();response=disksClient.addResourcePoliciesAsync(request).get(1,TimeUnit.MINUTES);}}else{try(DisksClientdisksClient=DisksClient.create()){AddResourcePoliciesDiskRequestrequest=AddResourcePoliciesDiskRequest.newBuilder().setDisk(diskName).setZone(location).setProject(project).setDisksAddResourcePoliciesRequestResource(DisksAddResourcePoliciesRequest.newBuilder().addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)).build()).build();response=disksClient.addResourcePoliciesAsync(request).get(1,TimeUnit.MINUTES);}}if(response.hasError()){thrownewError("Error adding disk to consistency group! "+response.getError());}returnresponse.getStatus();}}

// Import the Compute libraryconstcomputeLib=require('@google-cloud/compute');constcompute=computeLib.protos.google.cloud.compute.v1;// If you want to add regional disk,// you should use: RegionDisksClient and RegionOperationsClient.// Instantiate a disksClientconstdisksClient=newcomputeLib.DisksClient();// Instantiate a zoneconstzoneOperationsClient=newcomputeLib.ZoneOperationsClient();/** * TODO(developer): Update/uncomment these variables before running the sample. */// The project that contains the disk.constprojectId=awaitdisksClient.getProjectId();// The name of the disk.// diskName = 'disk-name';// If you use RegionDisksClient- define region, if DisksClient- define zone.// The zone or region of the disk.// diskLocation = 'europe-central2-a';// The name of the consistency group.// consistencyGroupName = 'consistency-group-name';// The region of the consistency group.// consistencyGroupLocation = 'europe-central2';asyncfunctioncallAddDiskToConsistencyGroup(){const[response]=awaitdisksClient.addResourcePolicies({disk:diskName,project:projectId,// If you use RegionDisksClient, pass region as an argument instead of zone.zone:diskLocation,disksAddResourcePoliciesRequestResource:newcompute.DisksAddResourcePoliciesRequest({resourcePolicies:[`https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,],}),});letoperation=response.latestResponse;// Wait for the add disk 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(),});}console.log(`Disk:${diskName} added to consistency group:${consistencyGroupName}.`);}awaitcallAddDiskToConsistencyGroup();

fromgoogle.cloudimportcompute_v1defadd_disk_consistency_group(project_id:str,disk_name:str,disk_location:str,consistency_group_name:str,consistency_group_region:str,)->None:"""Adds a disk to a specified consistency group.    Args:        project_id (str): The ID of the Google Cloud project.        disk_name (str): The name of the disk to be added.        disk_location (str): The region or zone of the disk        consistency_group_name (str): The name of the consistency group.        consistency_group_region (str): The region of the consistency group.    Returns:        None    """consistency_group_link=(f"regions/{consistency_group_region}/resourcePolicies/{consistency_group_name}")# Checking if the disk is zonal or regional# If the final character of the disk_location is a digit, it is a regional diskifdisk_location[-1].isdigit():policy=compute_v1.RegionDisksAddResourcePoliciesRequest(resource_policies=[consistency_group_link])disk_client=compute_v1.RegionDisksClient()disk_client.add_resource_policies(project=project_id,region=disk_location,disk=disk_name,region_disks_add_resource_policies_request_resource=policy,)# For zonal disks we use DisksClientelse:print("Using DisksClient")policy=compute_v1.DisksAddResourcePoliciesRequest(resource_policies=[consistency_group_link])disk_client=compute_v1.DisksClient()disk_client.add_resource_policies(project=project_id,zone=disk_location,disk=disk_name,disks_add_resource_policies_request_resource=policy,)print(f"Disk{disk_name} added to consistency group{consistency_group_name}")

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb")// removeDiskConsistencyGroup removes a disk from consistency group for a project in a given region.funcremoveDiskConsistencyGroup(wio.Writer,projectID,region,groupName,diskNamestring)error{// projectID := "your_project_id"// region := "europe-west4"// diskName := "your_disk_name"// 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.RemoveResourcePoliciesRegionDiskRequest{Project:projectID,Disk:diskName,RegionDisksRemoveResourcePoliciesRequestResource:&computepb.RegionDisksRemoveResourcePoliciesRequest{ResourcePolicies:[]string{consistencyGroupUrl},},Region:region,}op,err:=disksClient.RemoveResourcePolicies(ctx,req)iferr!=nil{returnfmt.Errorf("unable to remove disk: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Disk removed\n")returnnil}

importcom.google.cloud.compute.v1.DisksClient;importcom.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest;importcom.google.cloud.compute.v1.Operation;importcom.google.cloud.compute.v1.Operation.Status;importcom.google.cloud.compute.v1.RegionDisksClient;importcom.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest;importcom.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest;importcom.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest;importjava.io.IOException;importjava.util.Arrays;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassRemoveDiskFromConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,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 or region of the disk.Stringlocation="us-central1";// Name of the disk.StringdiskName="DISK_NAME";// Name of the consistency group.StringconsistencyGroupName="CONSISTENCY_GROUP";// Region of the consistency group.StringconsistencyGroupLocation="us-central1";removeDiskFromConsistencyGroup(project,location,diskName,consistencyGroupName,consistencyGroupLocation);}// Removes a disk from a consistency group.publicstaticStatusremoveDiskFromConsistencyGroup(Stringproject,Stringlocation,StringdiskName,StringconsistencyGroupName,StringconsistencyGroupLocation)throwsIOException,ExecutionException,InterruptedException,TimeoutException{StringconsistencyGroupUrl=String.format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",project,consistencyGroupLocation,consistencyGroupName);Operationresponse;if(Character.isDigit(location.charAt(location.length()-1))){// 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(RegionDisksClientdisksClient=RegionDisksClient.create()){RemoveResourcePoliciesRegionDiskRequestrequest=RemoveResourcePoliciesRegionDiskRequest.newBuilder().setDisk(diskName).setRegion(location).setProject(project).setRegionDisksRemoveResourcePoliciesRequestResource(RegionDisksRemoveResourcePoliciesRequest.newBuilder().addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)).build()).build();response=disksClient.removeResourcePoliciesAsync(request).get(1,TimeUnit.MINUTES);}}else{try(DisksClientdisksClient=DisksClient.create()){RemoveResourcePoliciesDiskRequestrequest=RemoveResourcePoliciesDiskRequest.newBuilder().setDisk(diskName).setZone(location).setProject(project).setDisksRemoveResourcePoliciesRequestResource(DisksRemoveResourcePoliciesRequest.newBuilder().addAllResourcePolicies(Arrays.asList(consistencyGroupUrl)).build()).build();response=disksClient.removeResourcePoliciesAsync(request).get(1,TimeUnit.MINUTES);}}if(response.hasError()){thrownewError("Error removing disk from consistency group! "+response.getError());}returnresponse.getStatus();}}

// Import the Compute libraryconstcomputeLib=require('@google-cloud/compute');constcompute=computeLib.protos.google.cloud.compute.v1;// If you want to remove regional disk,// you should use: RegionDisksClient and RegionOperationsClient.// Instantiate a disksClientconstdisksClient=newcomputeLib.DisksClient();// Instantiate a zoneconstzoneOperationsClient=newcomputeLib.ZoneOperationsClient();/** * TODO(developer): Update/uncomment these variables before running the sample. */// The project that contains the disk.constprojectId=awaitdisksClient.getProjectId();// The name of the disk.// diskName = 'disk-name';// If you use RegionDisksClient- define region, if DisksClient- define zone.// The zone or region of the disk.// diskLocation = 'europe-central2-a';// The name of the consistency group.// consistencyGroupName = 'consistency-group-name';// The region of the consistency group.// consistencyGroupLocation = 'europe-central2';asyncfunctioncallDeleteDiskFromConsistencyGroup(){const[response]=awaitdisksClient.removeResourcePolicies({disk:diskName,project:projectId,// If you use RegionDisksClient, pass region as an argument instead of zone.zone:diskLocation,disksRemoveResourcePoliciesRequestResource:newcompute.DisksRemoveResourcePoliciesRequest({resourcePolicies:[`https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,],}),});letoperation=response.latestResponse;// Wait for the delete disk 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(),});}console.log(`Disk:${diskName} deleted from consistency group:${consistencyGroupName}.`);}awaitcallDeleteDiskFromConsistencyGroup();

fromgoogle.cloudimportcompute_v1defremove_disk_consistency_group(project_id:str,disk_name:str,disk_location:str,consistency_group_name:str,consistency_group_region:str,)->None:"""Removes a disk from a specified consistency group.    Args:        project_id (str): The ID of the Google Cloud project.        disk_name (str): The name of the disk to be deleted.        disk_location (str): The region or zone of the disk        consistency_group_name (str): The name of the consistency group.        consistency_group_region (str): The region of the consistency group.    Returns:        None    """consistency_group_link=(f"regions/{consistency_group_region}/resourcePolicies/{consistency_group_name}")# Checking if the disk is zonal or regional# If the final character of the disk_location is a digit, it is a regional diskifdisk_location[-1].isdigit():policy=compute_v1.RegionDisksRemoveResourcePoliciesRequest(resource_policies=[consistency_group_link])disk_client=compute_v1.RegionDisksClient()disk_client.remove_resource_policies(project=project_id,region=disk_location,disk=disk_name,region_disks_remove_resource_policies_request_resource=policy,)# For zonal disks we use DisksClientelse:policy=compute_v1.DisksRemoveResourcePoliciesRequest(resource_policies=[consistency_group_link])disk_client=compute_v1.DisksClient()disk_client.remove_resource_policies(project=project_id,zone=disk_location,disk=disk_name,disks_remove_resource_policies_request_resource=policy,)print(f"Disk{disk_name} removed from consistency group{consistency_group_name}")

import("context""fmt""io"compute"cloud.google.com/go/compute/apiv1"computepb"cloud.google.com/go/compute/apiv1/computepb")// deleteConsistencyGroup deletes consistency group for a project in a given region.funcdeleteConsistencyGroup(wio.Writer,projectID,region,groupNamestring)error{// projectID := "your_project_id"// region := "europe-west4"// groupName := "your_group_name"ctx:=context.Background()disksClient,err:=compute.NewResourcePoliciesRESTClient(ctx)iferr!=nil{returnfmt.Errorf("NewResourcePoliciesRESTClient: %w",err)}deferdisksClient.Close()req:=&computepb.DeleteResourcePolicyRequest{Project:projectID,ResourcePolicy:groupName,Region:region,}op,err:=disksClient.Delete(ctx,req)iferr!=nil{returnfmt.Errorf("unable to delete group: %w",err)}iferr=op.Wait(ctx);err!=nil{returnfmt.Errorf("unable to wait for the operation: %w",err)}fmt.Fprintf(w,"Group deleted\n")returnnil}

importcom.google.cloud.compute.v1.Operation;importcom.google.cloud.compute.v1.Operation.Status;importcom.google.cloud.compute.v1.ResourcePoliciesClient;importjava.io.IOException;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassDeleteConsistencyGroup{publicstaticvoidmain(String[]args)throwsIOException,ExecutionException,InterruptedException,TimeoutException{// TODO(developer): Replace these variables before running the sample.// Project ID or project number of the Cloud project you want to use.Stringproject="YOUR_PROJECT_ID";// Region in which your consistency group is located.Stringregion="us-central1";// Name of the consistency group you want to delete.StringconsistencyGroupName="YOUR_CONSISTENCY_GROUP_NAME";deleteConsistencyGroup(project,region,consistencyGroupName);}// Deletes a consistency group resource policy in the specified project and region.publicstaticStatusdeleteConsistencyGroup(Stringproject,Stringregion,StringconsistencyGroupName)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(ResourcePoliciesClientresourcePoliciesClient=ResourcePoliciesClient.create()){Operationresponse=resourcePoliciesClient.deleteAsync(project,region,consistencyGroupName).get(1,TimeUnit.MINUTES);if(response.hasError()){thrownewError("Error deleting disk! "+response.getError());}returnresponse.getStatus();}}}

// Import the Compute libraryconstcomputeLib=require('@google-cloud/compute');// Instantiate a resourcePoliciesClientconstresourcePoliciesClient=newcomputeLib.ResourcePoliciesClient();// Instantiate a regionOperationsClientconstregionOperationsClient=newcomputeLib.RegionOperationsClient();/** * TODO(developer): Update/uncomment these variables before running the sample. */// The project that contains the consistency group.constprojectId=awaitresourcePoliciesClient.getProjectId();// The region of the consistency group.// region = 'europe-central2';// The name of the consistency group.// consistencyGroupName = 'consistency-group-name';asyncfunctioncallDeleteConsistencyGroup(){// Delete a resourcePolicyResourceconst[response]=awaitresourcePoliciesClient.delete({project:projectId,region,resourcePolicy:consistencyGroupName,});letoperation=response.latestResponse;// Wait for the delete group operation to complete.while(operation.status!=='DONE'){[operation]=awaitregionOperationsClient.wait({operation:operation.name,project:projectId,region,});}console.log(`Consistency group:${consistencyGroupName} deleted.`);}awaitcallDeleteConsistencyGroup();

from__future__importannotationsimportsysfromtypingimportAnyfromgoogle.api_core.extended_operationimportExtendedOperationfromgoogle.cloudimportcompute_v1defwait_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)ifoperation.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)raiseoperation.exception()orRuntimeError(operation.error_message)ifoperation.warnings:print(f"Warnings during{verbose_name}:\n",file=sys.stderr,flush=True)forwarninginoperation.warnings:print(f" -{warning.code}:{warning.message}",file=sys.stderr,flush=True)returnresultdefdelete_consistency_group(project_id:str,region:str,group_name:str)->None:"""    Deletes a consistency group in Google Cloud Compute Engine.    Args:        project_id (str): The ID of the Google Cloud project.        region (str): The region where the consistency group is located.        group_name (str): The name of the consistency group to delete.    Returns:        None    """# Initialize the ResourcePoliciesClientclient=compute_v1.ResourcePoliciesClient()# Delete the (consistency group) from the specified project and regionoperation=client.delete(project=project_id,region=region,resource_policy=group_name,)wait_for_extended_operation(operation,"Consistency group deletion")