Mengelola grup konsistensi

---

Dokumen ini menjelaskan cara mengelola grup konsistensi. Grup konsistensi adalah kebijakan resource yang menyelaraskan replikasi di beberapa disk di region atau zona yang sama.

Untuk mempelajari grup konsistensi lebih lanjut, lihat Tentang Replikasi Asinkron.

Batasan

• Grup konsistensi tidak didukung untuk disk di sole-tenant node.
• Grup konsistensi dapat memiliki maksimum 128 disk.
• Semua disk dalam grup konsistensi harus berada dalam project yang sama dengan kebijakan resource grup konsistensi.
• Semua disk dalam grup konsistensi harus berada di zona yang sama, untuk disk zona, atau dalam pasangan zona yang sama, untuk disk regional.
• Grup konsistensi dapat berisi disk utama atau disk sekunder, tetapi tidak keduanya.
• Anda tidak dapat menambahkan atau menghapus disk utama ke atau dari grup konsistensi saat disk sedang direplikasi. Jika ingin menambahkan atau menghapus disk utama ke atau dari grup konsistensi, Anda harus menghentikan replikasi terlebih dahulu. Anda dapat menambahkan atau menghapus disk sekunder ke atau dari grup konsistensi kapan saja.
• Anda dapat memasang maksimum 16 disk yang berada di grup konsistensi berbeda, atau disk yang tidak berada dalam grup konsistensi ke VM. Disk yang berada dalam grup konsistensi yang sama dihitung sebagai satu disk dalam batas 16 disk.

Sebelum memulai

• Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses yang digunakan untuk memverifikasi identitas Anda untuk mengakses Google Cloud layanan dan API. Untuk menjalankan kode atau sampel dari lingkungan pengembangan lokal, Anda dapat melakukan autentikasi ke Compute Engine dengan memilih salah satu opsi berikut:
  

  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. Menginstal Google Cloud CLI. Setelah penginstalan, lakukan inisialisasi Google Cloud CLI dengan menjalankan perintah berikut:

     gcloud init

     Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

     Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi terbaru dengan menjalankan gcloud components update.
  2. Set a default region and zone.

  Terraform

  Untuk menggunakan contoh Terraform di halaman ini dalam lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

  Menginstal Google Cloud CLI.

  Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

  Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi terbaru dengan menjalankan gcloud components update.

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

  gcloud auth application-default login

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

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

  Untuk informasi selengkapnya, lihat Set up authentication for a local development environment.

  REST

  Untuk menggunakan contoh REST API di halaman ini dalam lingkungan pengembangan lokal, Anda menggunakan kredensial yang Anda berikan ke gcloud CLI.

  Menginstal Google Cloud CLI.

  Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

  Untuk mengetahui informasi selengkapnya, lihat Melakukan autentikasi untuk menggunakan REST dalam dokumentasi autentikasi Google Cloud .

Membuat grup konsistensi

Jika Anda perlu menyelaraskan replikasi di beberapa disk, buat grup konsistensi di region yang sama dengan disk utama. Jika Anda perlu menyelaraskan clone disk, buat grup konsistensi di region yang sama dengan disk sekunder.

Buat grup konsistensi menggunakan konsol, Google Cloud CLI, REST, atau Terraform. Google Cloud

Konsol

Buat grup konsistensi dengan melakukan hal berikut:

1. Di Google Cloud console, buka halaman Replikasi asinkron.

   Buka Replikasi asinkron

2. Klik tab Grup konsistensi.

3. Klik Buat grup konsistensi.

4. Di kolom Nama, masukkan nama untuk grup konsistensi.

5. Di kolom Region, pilih region tempat disk Anda berada. Jika Anda ingin menambahkan disk utama ke grup konsistensi, pilih region utama. Jika Anda ingin menambahkan disk sekunder ke grup konsistensi, pilih region sekunder.

6. Klik Buat.

gcloud

Buat grup konsistensi menggunakan perintah gcloud compute resource-policies create disk-consistency-group:

gcloud compute resource-policies create disk-consistency-group CONSISTENCY_GROUP_NAME \
    --region=REGION

Ganti kode berikut:

• CONSISTENCY_GROUP_NAME: nama untuk grup konsistensi.
• REGION: region untuk grup konsistensi. Jika Anda ingin menambahkan disk utama ke grup konsistensi, gunakan region utama. Jika Anda ingin menambahkan disk sekunder ke grup konsistensi, gunakan region sekunder.

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

// createConsistencyGroup creates a new consistency group for a project in a given region.
func createConsistencyGroup(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.NewResourcePoliciesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewResourcePoliciesRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.InsertResourcePolicyRequest{
		Project: projectID,
		ResourcePolicyResource: &computepb.ResourcePolicy{
			Name:                       proto.String(groupName),
			DiskConsistencyGroupPolicy: &computepb.ResourcePolicyDiskConsistencyGroupPolicy{},
		},
		Region: region,
	}

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.InsertResourcePolicyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResourcePoliciesClient;
import com.google.cloud.compute.v1.ResourcePolicy;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateConsistencyGroup {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String project = "YOUR_PROJECT_ID";
    // Name of the region in which you want to create the consistency group.
    String region = "us-central1";
    // Name of the consistency group you want to create.
    String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME";

    createConsistencyGroup(project, region, consistencyGroupName);
  }

  // Creates a new consistency group resource policy in the specified project and region.
  public static Status createConsistencyGroup(
      String project, String region, String consistencyGroupName)
          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 (ResourcePoliciesClient  regionResourcePoliciesClient = ResourcePoliciesClient.create()) {
      ResourcePolicy resourcePolicy =
          ResourcePolicy.newBuilder()
              .setName(consistencyGroupName)
              .setRegion(region)
              .setDiskConsistencyGroupPolicy(
                  ResourcePolicy.newBuilder().getDiskConsistencyGroupPolicy())
              .build();

      InsertResourcePolicyRequest request = InsertResourcePolicyRequest.newBuilder()
              .setProject(project)
              .setRegion(region)
              .setResourcePolicyResource(resourcePolicy)
              .build();

      Operation response =
          regionResourcePoliciesClient.insertAsync(request).get(1, TimeUnit.MINUTES);

      if (response.hasError()) {
        throw new Error("Error creating consistency group! " + 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 resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the consistency group.
const projectId = await resourcePoliciesClient.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';

async function callCreateConsistencyGroup() {
  // Create a resourcePolicyResource
  const resourcePolicyResource = new compute.ResourcePolicy({
    diskConsistencyGroupPolicy:
      new compute.ResourcePolicyDiskConsistencyGroupPolicy({}),
    name: consistencyGroupName,
  });

  const [response] = await resourcePoliciesClient.insert({
    project: projectId,
    region,
    resourcePolicyResource,
  });

  let operation = response.latestResponse;

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

  console.log(`Consistency group: ${consistencyGroupName} created.`);
}

await callCreateConsistencyGroup();

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_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 ResourcePoliciesClient
    client = compute_v1.ResourcePoliciesClient()

    # Create the ResourcePolicy object with the provided name, description, and policy
    resource_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")

    return client.get(project=project_id, region=region, resource_policy=group_name)

REST

Buat grup konsistensi menggunakan metode resourcePolicies.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/resourcePolicies
{
 "name": "CONSISTENCY_GROUP_NAME",
 "diskConsistencyGroupPolicy": {
  }
}

Ganti kode berikut:

• PROJECT: project yang berisi grup konsistensi.
• REGION: region untuk grup konsistensi. Jika Anda ingin menambahkan disk utama ke grup konsistensi, gunakan region yang sama dengan disk utama. Jika Anda ingin menambahkan disk sekunder ke grup konsistensi, gunakan region yang sama dengan disk sekunder.
• CONSISTENCY_GROUP_NAME: nama untuk grup konsistensi.

Terraform

Untuk membuat grup konsistensi, gunakan resource compute_resource_policy.

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

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

Melihat disk dalam grup konsistensi

Lihat disk dalam grup konsistensi menggunakan konsol Google Cloud , Google Cloud CLI, atau REST.

Konsol

Lihat disk yang disertakan dalam grup konsistensi dengan melakukan hal berikut:

1. Di Google Cloud console, buka halaman Replikasi asinkron.

   Buka Replikasi asinkron

2. Klik tab Grup konsistensi.

3. Klik nama grup konsistensi yang ingin Anda lihat disknya. Halaman Kelola grup konsistensi akan terbuka.

4. Lihat bagian Consistency group members untuk melihat semua disk yang disertakan dalam grup konsistensi.

gcloud

Lihat disk yang disertakan dalam grup konsistensi menggunakan perintah gcloud compute disks list:

gcloud compute disks list \
    --LOCATION_FLAG=LOCATION \
    --filter=resourcePolicies=CONSISTENCY_GROUP_NAME

Ganti kode berikut:

• LOCATION_FLAG: flag lokasi untuk disk dalam grup konsistensi. Jika disk dalam grup konsistensi bersifat regional, gunakan --region. Jika disk dalam grup konsistensi bersifat zona, gunakan --zone.
• LOCATION: region atau zona disk dalam grup konsistensi. Untuk disk regional, gunakan region. Untuk disk zona, gunakan zona.
• CONSISTENCY_GROUP_NAME: nama grup konsistensi.

Go

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.
func listRegionalConsistencyGroup(w io.Writer, projectID, region, groupName string) error {
	// projectID := "your_project_id"
	// region := "europe-west4"
	// groupName := "your_group_name"

	if groupName == "" {
		return fmt.Errorf("group name cannot be empty")
	}

	ctx := context.Background()
	// To check for zonal disks in consistency group use compute.NewDisksRESTClient
	disksClient, err := compute.NewRegionDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewRegionDisksRESTClient: %w", err)
	}
	defer disksClient.Close()

	// If using zonal disk client, use computepb.ListDisksRequest
	req := &computepb.ListRegionDisksRequest{
		Project: projectID,
		Region:  region,
	}

	it := disksClient.List(ctx, req)
	for {
		disk, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}

		for _, diskPolicy := range disk.GetResourcePolicies() {
			if strings.Contains(diskPolicy, groupName) {
				fmt.Fprintf(w, "- %s\n", disk.GetName())
			}
		}
	}

	return nil
}

Java

Mencantumkan disk zona dalam grup konsistensi

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.ListDisksRequest;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;

public class ListZonalDisksInConsistencyGroup {
  public static void main(String[] args)
          throws IOException, InterruptedException, ExecutionException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String project = "YOUR_PROJECT_ID";
    // Name of the consistency group.
    String consistencyGroupName = "CONSISTENCY_GROUP_ID";
    // Zone of the disk.
    String disksLocation = "us-central1-a";
    // Region of the consistency group.
    String consistencyGroupLocation = "us-central1";

    listZonalDisksInConsistencyGroup(
            project, consistencyGroupName, consistencyGroupLocation, disksLocation);
  }

  // Lists disks in a consistency group.
  public static List<Disk> listZonalDisksInConsistencyGroup(String project,
      String consistencyGroupName, String consistencyGroupLocation, String disksLocation)
          throws IOException {
    String filter = String
            .format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",
                    project, consistencyGroupLocation, consistencyGroupName);
    List<Disk> disksList = new ArrayList<>();
    // 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()) {
      ListDisksRequest request =
              ListDisksRequest.newBuilder()
                      .setProject(project)
                      .setZone(disksLocation)
                      .build();
      DisksClient.ListPagedResponse response = disksClient.list(request);

      for (Disk disk : response.iterateAll()) {
        if (disk.getResourcePoliciesList().contains(filter)) {
          disksList.add(disk);
        }
      }
    }
    System.out.println(disksList.size());
    return disksList;
  }
}

Mencantumkan disk regional dalam grup konsistensi

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.ListRegionDisksRequest;
import com.google.cloud.compute.v1.RegionDisksClient;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;

public class ListRegionalDisksInConsistencyGroup {
  public static void main(String[] args)
          throws IOException, InterruptedException, ExecutionException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String project = "YOUR_PROJECT_ID";
    // Name of the consistency group.
    String consistencyGroupName = "CONSISTENCY_GROUP_ID";
    // Region of the disk.
    String disksLocation = "us-central1";
    // Region of the consistency group.
    String consistencyGroupLocation = "us-central1";

    listRegionalDisksInConsistencyGroup(
            project, consistencyGroupName, consistencyGroupLocation, disksLocation);
  }

  // Lists disks in a consistency group.
  public static List<Disk> listRegionalDisksInConsistencyGroup(String project,
      String consistencyGroupName, String consistencyGroupLocation, String disksLocation)
          throws IOException {
    String filter = String
            .format("https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",
                    project, consistencyGroupLocation, consistencyGroupName);
    List<Disk> disksList = new ArrayList<>();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (RegionDisksClient disksClient = RegionDisksClient.create()) {
      ListRegionDisksRequest request =
              ListRegionDisksRequest.newBuilder()
                      .setProject(project)
                      .setRegion(disksLocation)
                      .build();

      RegionDisksClient.ListPagedResponse response = disksClient.list(request);
      for (Disk disk : response.iterateAll()) {
        if (disk.getResourcePoliciesList().contains(filter)) {
          disksList.add(disk);
        }
      }
    }
    System.out.println(disksList.size());
    return disksList;
  }
}

Node.js

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

// If you want to get regional disks, you should use: RegionDisksClient.
// Instantiate a disksClient
const disksClient = new computeLib.DisksClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the disks.
const projectId = await disksClient.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';

async function callConsistencyGroupDisksList() {
  const filter = `https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`;

  const [response] = await disksClient.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.
  const filteredDisks = response.filter(disk =>
    disk.resourcePolicies.includes(filter)
  );

  console.log(JSON.stringify(filteredDisks));
}

await callConsistencyGroupDisksList();

Python

from google.cloud import compute_v1


def list_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 disk
    if disk_location[-1].isdigit():
        region_client = compute_v1.RegionDisksClient()
        disks = region_client.list(project=project_id, region=disk_location)
    # For zonal disks we use DisksClient
    else:
        client = compute_v1.DisksClient()
        disks = client.list(project=project_id, zone=disk_location)
    return [disk for disk in disks if consistency_group_link in disk.resource_policies]

REST

Lihat disk dalam grup konsistensi menggunakan filter kueri dengan salah satu metode berikut:

• Lihat disk zona dalam grup konsistensi menggunakan metode disks.get:

  GET https://compute.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/disks?filter=resourcePolicies%3DCONSISTENCY_GROUP_NAME
  

• Lihat disk regional dalam grup konsistensi menggunakan metode regionDisks.get:

  GET https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/disks?filter=resourcePolicies%3DCONSISTENCY_GROUP_NAME
  

Ganti kode berikut:

• PROJECT: project yang berisi grup konsistensi
• ZONE: zona disk dalam grup konsistensi
• REGION: region disk dalam grup konsistensi
• CONSISTENCY_GROUP_NAME: nama grup konsistensi

Menambahkan disk ke grup konsistensi

Jika ingin menambahkan disk utama ke grup konsistensi, Anda harus menambahkan disk ke grup konsistensi sebelum memulai replikasi. Anda dapat menambahkan disk sekunder ke grup konsistensi kapan saja. Semua disk dalam grup konsistensi harus berada di zona yang sama, untuk disk zona, atau dalam pasangan zona yang sama untuk disk regional.

Tambahkan disk ke grup konsistensi menggunakan Google Cloud konsol, Google Cloud CLI, REST, atau Terraform.

Konsol

Tambahkan disk ke grup konsistensi dengan melakukan hal berikut:

1. Di Google Cloud console, buka halaman Replikasi asinkron.

   Buka Replikasi asinkron

2. Klik tab Grup konsistensi.

3. Klik nama grup konsistensi tempat Anda ingin menambahkan disk. Halaman Kelola grup konsistensi akan terbuka.

4. Klik Tetapkan disk. Halaman Tetapkan disk akan terbuka.

5. Pilih disk yang ingin Anda tambahkan ke grup konsistensi.

6. Klik Tetapkan disk. Saat diminta, klik Tambahkan.

gcloud

Tambahkan disk ke grup konsistensi menggunakan perintah gcloud compute disks add-resource-policies:

gcloud compute disks add-resource-policies DISK_NAME \
    --LOCATION_FLAG=LOCATION \
    --resource-policies=CONSISTENCY_GROUP

Ganti kode berikut:

• DISK_NAME: nama disk yang akan ditambahkan ke grup konsistensi.
• LOCATION_FLAG: flag lokasi untuk disk. Untuk disk regional, gunakan --region. Untuk disk zona, gunakan --zone.
• LOCATION: region atau zona disk. Untuk disk regional, gunakan region. Untuk disk zona, gunakan zona.
• CONSISTENCY_GROUP: URL grup konsistensi. Contoh, projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME.

Go

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.
func addDiskConsistencyGroup(w io.Writer, projectID, region, groupName, diskName string) error {
	// projectID := "your_project_id"
	// region := "europe-west4"
	// diskName := "your_disk_name"
	// 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.AddResourcePoliciesRegionDiskRequest{
		Project: projectID,
		Disk:    diskName,
		RegionDisksAddResourcePoliciesRequestResource: &computepb.RegionDisksAddResourcePoliciesRequest{
			ResourcePolicies: []string{consistencyGroupUrl},
		},
		Region: region,
	}

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.AddResourcePoliciesDiskRequest;
import com.google.cloud.compute.v1.AddResourcePoliciesRegionDiskRequest;
import com.google.cloud.compute.v1.DisksAddResourcePoliciesRequest;
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.RegionDisksAddResourcePoliciesRequest;
import com.google.cloud.compute.v1.RegionDisksClient;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

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

    addDiskToConsistencyGroup(
        project, location, diskName, consistencyGroupName, consistencyGroupLocation);
  }

  // Adds a disk to a consistency group.
  public static Status addDiskToConsistencyGroup(
      String project, String location, String diskName,
      String consistencyGroupName, String consistencyGroupLocation)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    String consistencyGroupUrl = String.format(
        "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",
        project, consistencyGroupLocation, consistencyGroupName);
    Operation response;
    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 (RegionDisksClient disksClient = RegionDisksClient.create()) {
        AddResourcePoliciesRegionDiskRequest request =
                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 (DisksClient disksClient = DisksClient.create()) {
        AddResourcePoliciesDiskRequest request =
                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()) {
      throw new Error("Error adding disk to consistency group! " + response.getError());
    }
    return response.getStatus();
  }
}

Node.js

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

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

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the disk.
const projectId = await disksClient.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';

async function callAddDiskToConsistencyGroup() {
  const [response] = await disksClient.addResourcePolicies({
    disk: diskName,
    project: projectId,
    // If you use RegionDisksClient, pass region as an argument instead of zone.
    zone: diskLocation,
    disksAddResourcePoliciesRequestResource:
      new compute.DisksAddResourcePoliciesRequest({
        resourcePolicies: [
          `https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,
        ],
      }),
  });

  let operation = response.latestResponse;

  // Wait for the add disk 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(),
    });
  }

  console.log(
    `Disk: ${diskName} added to consistency group: ${consistencyGroupName}.`
  );
}

await callAddDiskToConsistencyGroup();

Python

from google.cloud import compute_v1


def add_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 disk
    if disk_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 DisksClient
    else:
        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}")

REST

Tambahkan disk ke grup konsistensi menggunakan salah satu metode berikut:

• Tambahkan disk zona ke grup konsistensi menggunakan metode disks.addResourcePolicies:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT/zones/LOCATION/disks/DISK_NAME/addResourcePolicies
  
  {
  "resourcePolicies": "CONSISTENCY_GROUP"
  }
  

• Tambahkan disk regional ke grup konsistensi menggunakan metode regionDisks.addResourcePolicies:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/LOCATION/disks/DISK_NAME/addResourcePolicies
  
  {
  "resourcePolicies": "CONSISTENCY_GROUP"
  }
  

Ganti kode berikut:

• PROJECT: project yang berisi disk.
• LOCATION: zona atau region disk. Untuk disk zona, gunakan zona. Untuk disk regional, gunakan region.
• DISK_NAME: nama disk yang akan ditambahkan ke grup konsistensi.
• CONSISTENCY_GROUP: URL grup konsistensi. Contoh, projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME.

Terraform

Untuk menambahkan disk ke grup konsistensi, gunakan resource compute_disk_resource_policy_attachment.

• Jika menggunakan disk Regional, tentukan region, bukan zona.

  resource "google_compute_disk_resource_policy_attachment" "default" {
    name = google_compute_resource_policy.default.name
    disk = google_compute_disk.default.name
    zone = "us-central1-a"
  }

  Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

Mengeluarkan disk dari grup konsistensi

Sebelum dapat menghapus disk dari grup konsistensi, Anda harus menghentikan replikasi untuk disk tersebut.

Hapus disk dari grup konsistensi menggunakan Google Cloud konsol, Google Cloud CLI, atau REST.

Konsol

Hapus disk utama dari grup konsistensi dengan melakukan hal berikut:

1. Di Google Cloud console, buka halaman Replikasi asinkron.

   Buka Replikasi asinkron

2. Klik tab Grup konsistensi.

3. Klik nama grup konsistensi tempat Anda ingin menambahkan disk. Halaman Kelola grup konsistensi akan terbuka.

4. Pilih disk yang ingin Anda hapus dari grup konsistensi.

5. Klik Hapus disk. Saat diminta, klik Hapus.

gcloud

Hapus disk dari grup konsistensi menggunakan perintah gcloud compute disks remove-resource-policies:

gcloud compute disks remove-resource-policies DISK_NAME \
    --LOCATION_FLAG=LOCATION \
    --resource-policies=CONSISTENCY_GROUP

Ganti kode berikut:

• DISK_NAME: nama disk yang akan dihapus dari grup konsistensi.
• LOCATION_FLAG: flag lokasi untuk disk. Untuk disk regional, gunakan --region. Untuk disk zona, gunakan --zone.
• LOCATION: region atau zona disk. Untuk disk regional, gunakan region. Untuk disk zona, gunakan zona.
• CONSISTENCY_GROUP: URL grup konsistensi. Contoh, projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME.

Go

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.
func removeDiskConsistencyGroup(w io.Writer, projectID, region, groupName, diskName string) error {
	// projectID := "your_project_id"
	// region := "europe-west4"
	// diskName := "your_disk_name"
	// 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.RemoveResourcePoliciesRegionDiskRequest{
		Project: projectID,
		Disk:    diskName,
		RegionDisksRemoveResourcePoliciesRequestResource: &computepb.RegionDisksRemoveResourcePoliciesRequest{
			ResourcePolicies: []string{consistencyGroupUrl},
		},
		Region: region,
	}

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

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

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

	return nil
}

Java

import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.DisksRemoveResourcePoliciesRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.RegionDisksClient;
import com.google.cloud.compute.v1.RegionDisksRemoveResourcePoliciesRequest;
import com.google.cloud.compute.v1.RemoveResourcePoliciesDiskRequest;
import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RemoveDiskFromConsistencyGroup {

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

    removeDiskFromConsistencyGroup(
        project, location, diskName, consistencyGroupName, consistencyGroupLocation);
  }

  // Removes a disk from a consistency group.
  public static Status removeDiskFromConsistencyGroup(
      String project, String location, String diskName,
      String consistencyGroupName, String consistencyGroupLocation)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    String consistencyGroupUrl = String.format(
        "https://www.googleapis.com/compute/v1/projects/%s/regions/%s/resourcePolicies/%s",
        project, consistencyGroupLocation, consistencyGroupName);
    Operation response;
    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 (RegionDisksClient disksClient = RegionDisksClient.create()) {
        RemoveResourcePoliciesRegionDiskRequest request =
            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 (DisksClient disksClient = DisksClient.create()) {
        RemoveResourcePoliciesDiskRequest request =
            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()) {
      throw new Error("Error removing disk from consistency group! " + response.getError());
    }
    return response.getStatus();
  }
}

Node.js

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

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

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The project that contains the disk.
const projectId = await disksClient.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';

async function callDeleteDiskFromConsistencyGroup() {
  const [response] = await disksClient.removeResourcePolicies({
    disk: diskName,
    project: projectId,
    // If you use RegionDisksClient, pass region as an argument instead of zone.
    zone: diskLocation,
    disksRemoveResourcePoliciesRequestResource:
      new compute.DisksRemoveResourcePoliciesRequest({
        resourcePolicies: [
          `https://www.googleapis.com/compute/v1/projects/${projectId}/regions/${consistencyGroupLocation}/resourcePolicies/${consistencyGroupName}`,
        ],
      }),
  });

  let operation = response.latestResponse;

  // Wait for the delete disk 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(),
    });
  }

  console.log(
    `Disk: ${diskName} deleted from consistency group: ${consistencyGroupName}.`
  );
}

await callDeleteDiskFromConsistencyGroup();

Python

from google.cloud import compute_v1


def remove_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 disk
    if disk_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 DisksClient
    else:
        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}")

REST

Hapus disk dari grup konsistensi menggunakan metode disks.removeResourcePolicies untuk disk zona, atau metode regionDisks.removeResourcePolicies untuk disk regional tambahan.

• Hapus disk zona dari grup konsistensi:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT/zones/LOCATION/disks/DISK_NAME/removeResourcePolicies
  
  {
  "resourcePolicies": "CONSISTENCY_GROUP"
  }
  

• Hapus disk regional dari grup konsistensi:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/LOCATION/disks/DISK_NAME/removeResourcePolicies
  
  {
  "resourcePolicies": "CONSISTENCY_GROUP"
  }
  

Ganti kode berikut:

• PROJECT: project yang berisi disk.
• LOCATION: zona atau region disk. Untuk disk zona, gunakan zona. Untuk disk regional, gunakan region.
• DISK_NAME: nama disk yang akan dihapus dari grup konsistensi.
• CONSISTENCY_GROUP: URL grup konsistensi. Contoh, projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME.

Menghapus grup konsistensi

Hapus grup konsistensi menggunakan Google Cloud konsol, Google Cloud CLI, atau REST.

Konsol

Hapus konsistensi dengan melakukan hal berikut:

1. Di Google Cloud console, buka halaman Replikasi asinkron.

   Buka Replikasi asinkron

2. Klik tab Grup konsistensi.

3. Pilih grup konsistensi yang ingin Anda hapus.

4. Klik Hapus. Jendela Hapus grup konsistensi akan terbuka.

5. Klik Hapus.

gcloud

Hapus kebijakan resource menggunakan perintah gcloud compute resource-policies delete:

gcloud compute resource-policies delete CONSISTENCY_GROUP \
    --region=REGION

Ganti kode berikut:

• CONSISTENCY_GROUP: nama grup konsistensi
• REGION: region dari grup konsistensi

Go

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.
func deleteConsistencyGroup(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.NewResourcePoliciesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewResourcePoliciesRESTClient: %w", err)
	}
	defer disksClient.Close()

	req := &computepb.DeleteResourcePolicyRequest{
		Project:        projectID,
		ResourcePolicy: groupName,
		Region:         region,
	}

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

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

	fmt.Fprintf(w, "Group deleted\n")

	return nil
}

Java

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

public class DeleteConsistencyGroup {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String project = "YOUR_PROJECT_ID";
    // Region in which your consistency group is located.
    String region = "us-central1";
    // Name of the consistency group you want to delete.
    String consistencyGroupName = "YOUR_CONSISTENCY_GROUP_NAME";

    deleteConsistencyGroup(project, region, consistencyGroupName);
  }

  // Deletes a consistency group resource policy in the specified project and region.
  public static Status deleteConsistencyGroup(
      String project, String region, String consistencyGroupName)
          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 (ResourcePoliciesClient resourcePoliciesClient = ResourcePoliciesClient.create()) {
      Operation response = resourcePoliciesClient
          .deleteAsync(project, region, consistencyGroupName).get(1, TimeUnit.MINUTES);

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

Node.js

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

// Instantiate a resourcePoliciesClient
const resourcePoliciesClient = new computeLib.ResourcePoliciesClient();
// Instantiate a regionOperationsClient
const regionOperationsClient = new computeLib.RegionOperationsClient();

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

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

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

async function callDeleteConsistencyGroup() {
  // Delete a resourcePolicyResource
  const [response] = await resourcePoliciesClient.delete({
    project: projectId,
    region,
    resourcePolicy: consistencyGroupName,
  });

  let operation = response.latestResponse;

  // Wait for the delete group operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await regionOperationsClient.wait({
      operation: operation.name,
      project: projectId,
      region,
    });
  }

  console.log(`Consistency group: ${consistencyGroupName} deleted.`);
}

await callDeleteConsistencyGroup();

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 delete_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 ResourcePoliciesClient
    client = compute_v1.ResourcePoliciesClient()

    # Delete the (consistency group) from the specified project and region
    operation = client.delete(
        project=project_id,
        region=region,
        resource_policy=group_name,
    )
    wait_for_extended_operation(operation, "Consistency group deletion")

REST

Hapus konsistensi menggunakan metode resourcePolicies.delete:

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/resourcePolicies/CONSISTENCY_GROUP_NAME

Ganti kode berikut:

• PROJECT: project yang berisi grup konsistensi
• REGION: region dari grup konsistensi
• CONSISTENCY_GROUP: nama grup konsistensi

Langkah berikutnya

• Pelajari cara mengelola disk yang menggunakan Replikasi Asinkron.
• Pelajari cara failover dan failback.
• Pelajari cara memantau performa Replikasi Asinkron.