Menonaktifkan hapus sementara

Ringkasan Penggunaan

Halaman ini menjelaskan cara menonaktifkan fitur penghapusan sementara pada bucket baru dan yang sudah ada di seluruh organisasi Anda.

Penghapusan sementara diaktifkan secara default pada bucket baru untuk mencegah kehilangan data. Jika diperlukan, Anda dapat menonaktifkan penghapusan sementara untuk bucket yang sudah ada dengan mengubah kebijakan penghapusan sementara, dan Anda dapat menonaktifkan penghapusan sementara secara default untuk bucket baru dengan menetapkan tag default di seluruh organisasi. Perhatikan bahwa setelah Anda menonaktifkan penghapusan sementara, data yang dihapus tidak dapat dipulihkan, termasuk penghapusan yang tidak disengaja atau berbahaya.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk menonaktifkan penghapusan sementara, minta administrator untuk memberi Anda peran IAM berikut di tingkat organisasi:

Peran bawaan ini berisi izin yang diperlukan untuk menonaktifkan penghapusan sementara. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk menonaktifkan penghapusan sementara:

  • storage.buckets.get
  • storage.buckets.update
  • storage.buckets.list (izin ini hanya diperlukan jika Anda berencana menggunakan Google Cloud konsol untuk menjalankan petunjuk di halaman ini)

    Untuk izin yang diperlukan yang disertakan sebagai bagian dari peran Tag Admin(roles/resourcemanager.tagAdmin), lihatIzin yang diperlukan untuk mengelola tag.

Untuk mengetahui informasi tentang cara memberikan peran, lihat Menetapkan dan mengelola kebijakan IAM di bucket atau Mengelola akses ke project.

Menonaktifkan penghapusan sementara untuk bucket tertentu

Sebelum Anda memulai, pertimbangkan hal-hal berikut ini:

  • Jika Anda menonaktifkan kebijakan penghapusan sementara dari bucket yang memiliki objek yang dihapus sementara di dalamnya selama waktu penonaktifan, objek yang dihapus sementara yang ada akan dipertahankan hingga durasi retensi yang sebelumnya diterapkan berakhir.

  • Setelah menonaktifkan kebijakan penghapusan sementara di bucket Anda, Cloud Storage tidak akan mempertahankan objek yang baru dihapus.

  • Saat Anda menonaktifkan kebijakan penghapusan sementara di bucket, perubahan tidak akan langsung terjadi di seluruh Cloud Storage karena caching metadata. Oleh karena itu, sebaiknya tunggu setidaknya tiga puluh detik sebelum memulai operasi penghapusan lainnya, seperti penghapusan massal, setelah Anda menonaktifkan kebijakan penghapusan sementara. Hal ini memastikan bahwa data Anda dihapus secara permanen, bukan dihapus sementara. Untuk mengetahui informasi selengkapnya tentang konsistensi dalam operasi Cloud Storage, lihat Konsistensi Cloud Storage.

Gunakan petunjuk berikut untuk menonaktifkan penghapusan sementara untuk bucket tertentu:

Konsol

  1. Di Google Cloud konsol, buka halaman Buckets Cloud Storage.

    Buka Buckets

  2. Dalam daftar bucket, klik nama bucket yang kebijakan penghapusan sementaranya ingin Anda nonaktifkan.

  3. Klik tab Protection.

  4. Di bagian Soft delete policy, klik Disable untuk menonaktifkan kebijakan penghapusan sementara.

  5. Klik Confirm.

Untuk mempelajari cara mendapatkan informasi error mendetail tentang operasi Cloud Storage yang gagal di Google Cloud konsol, lihat Pemecahan masalah.

Command line

Jalankan perintah gcloud storage buckets update dengan flag --clear-soft-delete:

gcloud storage buckets update --clear-soft-delete gs://BUCKET_NAME

Dengan keterangan:

  • BUCKET_NAME adalah nama bucket. Contoh, my-bucket.

REST API

JSON API

  1. Pastikan gcloud CLI telah diinstal dan diinisialisasi, yang memungkinkan Anda membuat token akses untuk header Authorization.

  2. Buat file JSON yang berisi informasi berikut:

    {
  "softDeletePolicy": {
    "retentionDurationSeconds": "0"
  }
}

  3. Gunakan cURL untuk memanggil JSON API dengan permintaan Bucket PATCH:

    curl -X PATCH --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME"

    Dengan keterangan:

    • JSON_FILE_NAME adalah jalur untuk file JSON yang Anda buat di Langkah 2.
    • BUCKET_NAME adalah nama bucket yang relevan. Contoh, my-bucket.

Menonaktifkan penghapusan sementara untuk 100 bucket terbesar dalam project

Dengan Google Cloud konsol, Anda dapat menonaktifkan penghapusan sementara hingga 100 bucket sekaligus, dengan bucket diurutkan berdasarkan byte yang paling banyak dihapus sementara atau rasio byte yang dihapus sementara tertinggi terhadap byte aktif, sehingga Anda dapat mengelola bucket dengan dampak terbesar pada biaya penghapusan sementara.

  1. Di Google Cloud konsol, buka halaman Buckets Cloud Storage.

    Buka Buckets

  2. Di halaman Cloud Storage, klik Settings.

  3. Klik tab Soft delete.

  4. Dari daftar Top buckets by deleted bytes, pilih bucket yang penghapusan sementaranya ingin Anda nonaktifkan.

  5. Klik Turn off soft delete.

    Penghapusan sementara dinonaktifkan pada bucket yang Anda pilih.

Menonaktifkan penghapusan sementara untuk beberapa atau semua bucket dalam project

Dengan Google Cloud CLI, jalankan gcloud storage buckets update perintah dengan flag --project dan karakter pengganti * untuk menonaktifkan penghapusan sementara secara massal untuk beberapa atau semua bucket dalam project:

gcloud storage buckets update --project=PROJECT_ID --clear-soft-delete gs://*

Dengan keterangan:

  • PROJECT_ID adalah ID project. Contoh, my-project.

Menonaktifkan penghapusan sementara di semua bucket dalam folder

Dengan Google Cloud CLI, jalankan perintah gcloud projects list dan gcloud storage buckets update untuk menonaktifkan penghapusan sementara di bucket di semua project dalam folder tertentu.

Jalankan perintah gcloud projects list dan gcloud storage buckets update untuk mencantumkan semua bucket dalam folder tertentu, lalu nonaktifkan penghapusan sementara untuk semua bucket dalam folder:

gcloud projects list --filter="parent.id: FOLDER_ID" --format="value(projectId)" | while read project
do
  gcloud storage buckets update --project=$project --clear-soft-delete gs://*
done

Dengan keterangan:

  • FOLDER_ID adalah nama folder. Contoh, 123456.

Menonaktifkan penghapusan sementara di tingkat organisasi

Dengan Google Cloud CLI, jalankan gcloud storage buckets update perintah dengan flag --clear-soft-delete dan karakter pengganti * untuk menonaktifkan penghapusan sementara di tingkat organisasi:

Jalankan perintah gcloud storage buckets update dengan flag --clear-soft-delete dan karakter pengganti * untuk menonaktifkan penghapusan sementara untuk semua bucket dalam organisasi Anda:

gcloud projects list --format="value(projectId)" | while read project
do
  gcloud storage buckets update --project=$project --clear-soft-delete gs://*
done

Cloud Storage menonaktifkan penghapusan sementara di bucket yang sudah ada. Objek yang telah dihapus sementara akan tetap berada di bucket hingga durasi retensi data penghapusan sementaranya selesai, setelah itu, objek akan dihapus secara permanen.

Menonaktifkan penghapusan sementara untuk bucket baru

Meskipun penghapusan sementara diaktifkan secara default pada bucket baru, Anda dapat mencegah penghapusan sementara dari pengaktifan default menggunakan tag. Tag menggunakan kunci storage.defaultSoftDeletePolicy untuk menerapkan kebijakan penghapusan sementara 0d (nol hari) di tingkat organisasi, yang menonaktifkan fitur dan mencegah retensi data yang dihapus di masa mendatang.

Gunakan petunjuk berikut untuk menonaktifkan penghapusan sementara secara default saat Anda membuat bucket baru. Perhatikan bahwa petunjuk berikut tidak setara dengan menetapkan kebijakan organisasi yang mewajibkan kebijakan penghapusan sementara tertentu, yang berarti Anda masih dapat mengaktifkan penghapusan sementara di bucket tertentu dengan menentukan kebijakan jika diperlukan.

  1. Dengan Google Cloud CLI, buat tag storage.defaultSoftDeletePolicy yang digunakan untuk mengubah durasi retensi data penghapusan sementara default di bucket baru. Perhatikan bahwa hanya nama tag storage.defaultSoftDeletePolicy yang memperbarui durasi retensi data penghapusan sementara default.

    Buat kunci tag menggunakan perintah gcloud resource-manager tags keys create:

    gcloud resource-manager tags keys create storage.defaultSoftDeletePolicy \
 --parent=organizations/ORGANIZATION_ID \
 --description="Configures the default softDeletePolicy for new Storage buckets."

    Dengan keterangan:

    • ORGANIZATION_ID adalah ID numerik organisasi yang ingin Anda tetapkan durasi retensi data penghapusan sementara default. Contoh, 12345678901. Untuk mempelajari cara menemukan ID organisasi, lihat Mendapatkan ID resource organisasi.

  2. Buat nilai tag untuk 0d (nol hari) guna menonaktifkan periode retensi data penghapusan sementara secara default di bucket baru menggunakan perintah gcloud resource-manager tags values create:

    gcloud resource-manager tags values create 0d \
  --parent=ORGANIZATION_ID/storage.defaultSoftDeletePolicy \
  --description="Disables soft delete for new Storage buckets."

    Dengan keterangan:

    • ORGANIZATION_ID adalah ID numerik organisasi yang ingin Anda tetapkan durasi retensi data penghapusan sementara default. Contoh, 12345678901.

  3. Lampirkan tag ke resource Anda menggunakan perintah gcloud resource-manager tags bindings create:

    gcloud resource-manager tags bindings create \
 --tag-value=ORGANIZATION_ID/storage.defaultSoftDeletePolicy/0d \
 --parent=RESOURCE_ID

    Dengan keterangan:

    • ORGANIZATION_ID adalah ID numerik organisasi tempat tag dibuat. Contoh, 12345678901.

    • RESOURCE_ID adalah nama lengkap organisasi yang ingin Anda buat binding tag-nya. Misalnya, untuk melampirkan tag ke organizations/7890123456, masukkan //cloudresourcemanager.googleapis.com/organizations/7890123456.

Menonaktifkan penghapusan sementara untuk bucket yang melebihi batas biaya yang ditentukan

Dengan Library Klien Cloud untuk Python, Anda dapat menonaktifkan penghapusan sementara untuk bucket yang melebihi batas biaya relatif yang ditentukan dengan contoh library klien Python. Contohnya melakukan hal berikut:

  1. Menghitung biaya relatif penyimpanan untuk setiap kelas penyimpanan.

  2. Menilai biaya penghapusan sementara yang diakumulasikan oleh bucket Anda.

  3. Menetapkan batas biaya untuk penggunaan penghapusan sementara dan mencantumkan bucket yang melebihi batas yang Anda tetapkan serta memungkinkan Anda menonaktifkan penghapusan sementara untuk bucket yang melebihi batas.

Untuk mempelajari lebih lanjut cara menyiapkan library klien Python dan menggunakan contoh, lihat halaman README.md Cloud Storage soft delete cost analyzer.

Contoh berikut menonaktifkan penghapusan sementara untuk bucket yang melebihi batas biaya yang ditentukan:

from __future__ import annotations

import argparse
import json
import google.cloud.monitoring_v3 as monitoring_client


def get_relative_cost(storage_class: str) -> float:
    """Retrieves the relative cost for a given storage class and location.

    Args:
        storage_class: The storage class (e.g., 'standard', 'nearline').

    Returns:
        The price per GB from the https://cloud.google.com/storage/pricing,
        divided by the standard storage class.
    """
    relative_cost = {
        "STANDARD": 0.023 / 0.023,
        "NEARLINE": 0.013 / 0.023,
        "COLDLINE": 0.007 / 0.023,
        "ARCHIVE": 0.0025 / 0.023,
    }

    return relative_cost.get(storage_class, 1.0)


def get_soft_delete_cost(
    project_name: str,
    soft_delete_window: float,
    agg_days: int,
    lookback_days: int,
) -> dict[str, list[dict[str, float]]]:
    """Calculates soft delete costs for buckets in a Google Cloud project.

    Args:
        project_name: The name of the Google Cloud project.
        soft_delete_window: The time window in seconds for considering
          soft-deleted objects (default is 7 days).
        agg_days: Aggregate results over a time period, defaults to 30-day period
        lookback_days: Look back up to upto days, defaults to 360 days

    Returns:
        A dictionary with bucket names as keys and cost data for each bucket,
        broken down by storage class.
    """

    query_client = monitoring_client.QueryServiceClient()

    # Step 1: Get storage class ratios for each bucket.
    storage_ratios_by_bucket = get_storage_class_ratio(
        project_name, query_client, agg_days, lookback_days
    )

    # Step 2: Fetch soft-deleted bytes and calculate costs using Monitoring API.
    soft_deleted_costs = calculate_soft_delete_costs(
        project_name,
        query_client,
        soft_delete_window,
        storage_ratios_by_bucket,
        agg_days,
        lookback_days,
    )

    return soft_deleted_costs


def calculate_soft_delete_costs(
    project_name: str,
    query_client: monitoring_client.QueryServiceClient,
    soft_delete_window: float,
    storage_ratios_by_bucket: dict[str, float],
    agg_days: int,
    lookback_days: int,
) -> dict[str, list[dict[str, float]]]:
    """Calculates the relative cost of enabling soft delete for each bucket in a
       project for certain time frame in secs.

    Args:
        project_name: The name of the Google Cloud project.
        query_client: A Monitoring API query client.
        soft_delete_window: The time window in seconds for considering
          soft-deleted objects (default is 7 days).
        storage_ratios_by_bucket: A dictionary of storage class ratios per bucket.
        agg_days: Aggregate results over a time period, defaults to 30-day period
        lookback_days: Look back up to upto days, defaults to 360 days

    Returns:
        A dictionary with bucket names as keys and a list of cost data
        dictionaries
        for each bucket, broken down by storage class.
    """
    soft_deleted_bytes_time = query_client.query_time_series(
        monitoring_client.QueryTimeSeriesRequest(
            name=f"projects/{project_name}",
            query=f"""
                    {{  # Fetch 1: Soft-deleted (bytes seconds)
                        fetch gcs_bucket :: storage.googleapis.com/storage/v2/deleted_bytes
                        | value val(0) * {soft_delete_window}\'s\'  # Multiply by soft delete window
                        | group_by [resource.bucket_name, metric.storage_class], window(), .sum;

                        # Fetch 2: Total byte-seconds (active objects)
                        fetch gcs_bucket :: storage.googleapis.com/storage/v2/total_byte_seconds
                        | filter metric.type != 'soft-deleted-object'
                        | group_by [resource.bucket_name, metric.storage_class], window(1d), .mean  # Daily average
                        | group_by [resource.bucket_name, metric.storage_class], window(), .sum  # Total over window

                    }}  # End query definition
                    | every {agg_days}d  # Aggregate over larger time intervals
                    | within {lookback_days}d  # Limit data range for analysis
                    | ratio  # Calculate ratio (soft-deleted (bytes seconds)/ total (bytes seconds))
                    """,
        )
    )

    buckets: dict[str, list[dict[str, float]]] = {}
    missing_distribution_storage_class = []
    for data_point in soft_deleted_bytes_time.time_series_data:
        bucket_name = data_point.label_values[0].string_value
        storage_class = data_point.label_values[1].string_value
        # To include location-based cost analysis:
        # 1. Uncomment the line below:
        # location = data_point.label_values[2].string_value
        # 2. Update how you calculate 'relative_storage_class_cost' to factor in location
        soft_delete_ratio = data_point.point_data[0].values[0].double_value
        distribution_storage_class = bucket_name + " - " + storage_class
        storage_class_ratio = storage_ratios_by_bucket.get(
            distribution_storage_class
        )
        if storage_class_ratio is None:
            missing_distribution_storage_class.append(
                distribution_storage_class)
        buckets.setdefault(bucket_name, []).append({
            # Include storage class and location data for additional plotting dimensions.
            # "storage_class": storage_class,
            # 'location': location,
            "soft_delete_ratio": soft_delete_ratio,
            "storage_class_ratio": storage_class_ratio,
            "relative_storage_class_cost": get_relative_cost(storage_class),
        })

    if missing_distribution_storage_class:
        print(
            "Missing storage class for following buckets:",
            missing_distribution_storage_class,
        )
        raise ValueError("Cannot proceed with missing storage class ratios.")

    return buckets


def get_storage_class_ratio(
    project_name: str,
    query_client: monitoring_client.QueryServiceClient,
    agg_days: int,
    lookback_days: int,
) -> dict[str, float]:
    """Calculates storage class ratios for each bucket in a project.

    This information helps determine the relative cost contribution of each
    storage class to the overall soft-delete cost.

    Args:
        project_name: The Google Cloud project name.
        query_client: Google Cloud's Monitoring Client's QueryServiceClient.
        agg_days: Aggregate results over a time period, defaults to 30-day period
        lookback_days: Look back up to upto days, defaults to 360 days

    Returns:
        Ratio of Storage classes within a bucket.
    """
    request = monitoring_client.QueryTimeSeriesRequest(
        name=f"projects/{project_name}",
        query=f"""
            {{
            # Fetch total byte-seconds for each bucket and storage class
            fetch gcs_bucket :: storage.googleapis.com/storage/v2/total_byte_seconds
            | group_by [resource.bucket_name, metric.storage_class], window(), .sum;
            # Fetch total byte-seconds for each bucket (regardless of class)
            fetch gcs_bucket :: storage.googleapis.com/storage/v2/total_byte_seconds
            | group_by [resource.bucket_name], window(), .sum
            }}
            | ratio  # Calculate ratios of storage class size to total size
            | every {agg_days}d
            | within {lookback_days}d
            """,
    )

    storage_class_ratio = query_client.query_time_series(request)

    storage_ratios_by_bucket = {}
    for time_series in storage_class_ratio.time_series_data:
        bucket_name = time_series.label_values[0].string_value
        storage_class = time_series.label_values[1].string_value
        ratio = time_series.point_data[0].values[0].double_value

        # Create a descriptive key for the dictionary
        key = f"{bucket_name} - {storage_class}"
        storage_ratios_by_bucket[key] = ratio

    return storage_ratios_by_bucket


def soft_delete_relative_cost_analyzer(
    project_name: str,
    cost_threshold: float = 0.0,
    soft_delete_window: float = 604800,
    agg_days: int = 30,
    lookback_days: int = 360,
    list_buckets: bool = False,
    ) -> str | dict[str, float]: # Note potential string output
    """Identifies buckets exceeding the relative cost threshold for enabling soft delete.

    Args:
        project_name: The Google Cloud project name.
        cost_threshold: Threshold above which to consider removing soft delete.
        soft_delete_window: Time window for calculating soft-delete costs (in
          seconds).
        agg_days: Aggregate results over this time period (in days).
        lookback_days: Look back up to this many days.
        list_buckets: Return a list of bucket names (True) or JSON (False,
          default).

    Returns:
        JSON formatted results of buckets exceeding the threshold and costs
        *or* a space-separated string of bucket names.
    """

    buckets: dict[str, float] = {}
    for bucket_name, storage_sources in get_soft_delete_cost(
        project_name, soft_delete_window, agg_days, lookback_days
    ).items():
        bucket_cost = 0.0
        for storage_source in storage_sources:
            bucket_cost += (
                storage_source["soft_delete_ratio"]
                * storage_source["storage_class_ratio"]
                * storage_source["relative_storage_class_cost"]
            )
        if bucket_cost > cost_threshold:
            buckets[bucket_name] = round(bucket_cost, 4)

    if list_buckets:
        return " ".join(buckets.keys())  # Space-separated bucket names
    else:
        return json.dumps(buckets, indent=2)  # JSON output


def soft_delete_relative_cost_analyzer_main() -> None:
    # Sample run: python storage_soft_delete_relative_cost_analyzer.py <Project Name>
    parser = argparse.ArgumentParser(
        description="Analyze and manage Google Cloud Storage soft-delete costs."
    )
    parser.add_argument(
        "project_name", help="The name of the Google Cloud project to analyze."
    )
    parser.add_argument(
        "--cost_threshold",
        type=float,
        default=0.0,
        help="Relative Cost threshold.",
    )
    parser.add_argument(
        "--soft_delete_window",
        type=float,
        default=604800.0,
        help="Time window (in seconds) for considering soft-deleted objects.",
    )
    parser.add_argument(
        "--agg_days",
        type=int,
        default=30,
        help=(
            "Time window (in days) for aggregating results over a time period,"
            " defaults to 30-day period"
        ),
    )
    parser.add_argument(
        "--lookback_days",
        type=int,
        default=360,
        help=(
            "Time window (in days) for considering the how old the bucket to be."
        ),
    )
    parser.add_argument(
        "--list",
        type=bool,
        default=False,
        help="Return the list of bucketnames seperated by space.",
    )

    args = parser.parse_args()

    response = soft_delete_relative_cost_analyzer(
        args.project_name,
        args.cost_threshold,
        args.soft_delete_window,
        args.agg_days,
        args.lookback_days,
        args.list,
    )
    if not args.list:
        print(
            "To remove soft-delete policy from the listed buckets run:\n"
            # Capture output
            "python storage_soft_delete_relative_cost_analyzer.py"
            " [your-project-name] --[OTHER_OPTIONS] --list > list_of_buckets.txt \n"
            "cat list_of_buckets.txt | gcloud storage buckets update -I "
            "--clear-soft-delete",
            response,
        )
        return
    print(response)


if __name__ == "__main__":
    soft_delete_relative_cost_analyzer_main()

Langkah berikutnya