Menggunakan penghapusan sementara

Ringkasan Penggunaan

Halaman ini menjelaskan cara mengaktifkan, menonaktifkan, memperbarui, dan memeriksa status kebijakan penghapusan sementara di bucket. Untuk mempelajari cara mencantumkan dan memulihkan objek yang dihapus sementara, lihat Menggunakan objek yang dihapus sementara. Untuk membuat daftar dan memulihkan bucket yang dihapus secara sementara, lihat Menggunakan bucket yang dihapus secara sementara. Untuk informasi selengkapnya tentang penghapusan sementara, lihat Ringkasan. Untuk menonaktifkan fitur ini, lihat Menonaktifkan penghapusan sementara.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan guna membuat dan mengelola kebijakan penghapusan sementara, minta administrator untuk memberi Anda peran IAM Storage Admin (roles/storage.admin) di bucket atau project yang berisi bucket.

Peran bawaan ini berisi izin yang diperlukan untuk membuat dan mengelola kebijakan penghapusan sementara. Untuk melihat izin yang benar-benar diperlukan, luaskan bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk membuat dan mengelola kebijakan penghapusan sementara:

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

Untuk informasi tentang cara memberikan peran, lihat Menggunakan IAM dengan bucket atau Mengelola akses ke project.

Mengedit kebijakan penghapusan sementara bucket

Durasi retensi penghapusan sementara yang baru hanya berlaku untuk objek atau bucket yang Anda hapus setelah kebijakan penghapusan sementara berlaku. Objek yang dihapus sementara yang ada tidak terpengaruh oleh pembaruan yang dilakukan pada kebijakan penghapusan sementara dan disimpan selama durasi yang berlaku saat dihapus.

Gunakan petunjuk berikut untuk mengedit kebijakan penghapusan sementara bucket:

Konsol

  1. Di Konsol Google Cloud, buka halaman Bucket Cloud Storage.

    Buka Bucket

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

  3. Klik tab Protection.

  4. Di bagian Kebijakan penghapusan sementara, lakukan salah satu tindakan berikut:

    • Jika bucket tidak memiliki kebijakan penghapusan sementara, klik Edit, pilih satuan waktu dan lama waktu untuk durasi retensi, lalu klik Save.

    • Jika bucket memiliki kebijakan penghapusan sementara, klik Edit untuk mengubah satuan waktu dan durasi waktu untuk durasi retensi Anda.

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

Command line

Untuk menambahkan atau mengubah kebijakan penghapusan sementara di bucket, gunakan perintah gcloud storage buckets update dengan flag --soft-delete-duration:

  gcloud storage buckets update gs://BUCKET_NAME --soft-delete-duration=SOFT_DELETE_DURATION

Dengan keterangan:

  • BUCKET_NAME adalah nama bucket. Contoh, my-bucket.
  • SOFT_DELETE_DURATION menentukan durasi untuk menyimpan objek yang dihapus sementara. Misalnya, 2w1d adalah dua minggu dan satu hari. Untuk informasi selengkapnya, lihat durasi retensi penghapusan sementara.

REST API

JSON API

  1. Menginstal dan melakukan inisialisasi gcloud CLI , yang memungkinkan Anda membuat token akses untuk header Authorization.

  2. Buat file JSON yang berisi informasi berikut:

    {
  "softDeletePolicy": {
    "retentionDurationSeconds": "TIME_IN_SECONDS"
  }
}

    Dengan TIME_IN_SECONDS adalah jumlah waktu dalam detik yang ingin Anda gunakan untuk mempertahankan objek yang dihapus secara sementara. Contohnya, 2678400. Untuk informasi selengkapnya, lihat durasi retensi penghapusan sementara.

  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 kebijakan penghapusan sementara bucket

Sebelum Anda memulai, pertimbangkan hal-hal berikut ini:

  • Jika Anda menonaktifkan kebijakan penghapusan sementara dari bucket yang berisi objek yang dihapus sementara selama periode penonaktifan, objek yang dihapus sementara yang ada akan disimpan hingga masa berlaku durasi retensi yang diterapkan sebelumnya berakhir.

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

Gunakan petunjuk berikut untuk menonaktifkan kebijakan penghapusan sementara bucket:

Konsol

  1. Di Konsol Google Cloud, buka halaman Bucket Cloud Storage.

    Buka Bucket

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

  3. Klik tab Protection.

  4. Di bagian Kebijakan penghapusan sementara, klik Nonaktifkan untuk menonaktifkan kebijakan penghapusan sementara.

  5. Klik Konfirmasi.

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

Command line

Untuk menghapus kebijakan penghapusan sementara dari bucket, gunakan perintah gcloud storage buckets update dengan flag --clear-soft-delete:

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

Dengan keterangan:

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

REST API

JSON API

  1. Menginstal dan melakukan inisialisasi gcloud CLI , yang memungkinkan Anda membuat token akses untuk header Authorization.

  2. Buat file JSON yang berisi informasi berikut:

    {
  "softDeletePolicy": {
    "retentionDurationSeconds": "TIME_IN_SECONDS"
  }
}

    Untuk menonaktifkan kebijakan penghapusan sementara untuk bucket, gunakan nilai 0 untuk TIME_IN_SECONDS.

  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.

Memeriksa apakah kebijakan penghapusan data sementara diaktifkan di bucket

Konsol

  1. Di Konsol Google Cloud, buka halaman Bucket Cloud Storage.

    Buka Bucket

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

  3. Klik tab Protection.

    Status ditampilkan di bagian Kebijakan penghapusan sementara (untuk pemulihan data).

Anda juga dapat menggunakan tab Perlindungan untuk memeriksa apakah ada kebijakan penghapusan sementara di bucket Anda.

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

Command line

Untuk memeriksa status kebijakan penghapusan sementara bucket, gunakan perintah gcloud storage buckets describe:

  gcloud storage buckets describe gs://BUCKET_NAME \
      --format="default(soft_delete_policy)"

Dengan keterangan:

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

REST API

JSON API

  1. Menginstal dan melakukan inisialisasi gcloud CLI , yang memungkinkan Anda membuat token akses untuk header Authorization.

  2. Gunakan cURL untuk memanggil JSON API dengan permintaan Bucket GET:

    curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=softDeletePolicy"

    Dengan BUCKET_NAME adalah nama bucket yang relevan. Contoh, my-bucket.

Menonaktifkan penghapusan sementara untuk beberapa bucket atau semua bucket dalam project

Petunjuk berikut menjelaskan cara menonaktifkan penghapusan sementara untuk beberapa atau semua bucket dalam project. Jika Anda ingin menonaktifkan penghapusan sementara di tingkat organisasi, lihat Menonaktifkan penghapusan sementara.

Konsol

Konsol Google Cloud memungkinkan Anda menonaktifkan penghapusan sementara untuk bucket yang diurutkan berdasarkan byte yang paling banyak dihapus sementara atau rasio tertinggi antara byte yang dihapus sementara dan byte aktif, sehingga Anda dapat menurunkan biaya yang timbul dari penggunaan penghapusan sementara.

  1. Di Konsol Google Cloud, buka halaman Bucket Cloud Storage.

    Buka Bucket

  2. Di halaman Cloud Storage, klik Settings.

  3. Klik tab Soft delete.

  4. Dari daftar Bucket teratas berdasarkan byte yang dihapus, pilih bucket yang ingin Anda nonaktifkan penghapusan lembutnya.

  5. Klik Nonaktifkan penghapusan sementara.

    Penghapusan sementara dinonaktifkan di bucket yang Anda pilih.

Command line

Untuk menonaktifkan penghapusan sementara untuk semua bucket dalam project, jalankan perintah gcloud storage buckets update dengan flag --clear-soft-delete dan karakter pengganti *:

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

Library klien

Untuk menonaktifkan penghapusan sementara untuk semua bucket dalam project, Anda harus mencantumkan bucket dalam project terlebih dahulu, lalu menonaktifkan penghapusan sementara untuk setiap hasil menggunakan petunjuk berikut:

Python

Untuk mengetahui informasi selengkapnya, lihatDokumentasi referensi Cloud Storage Python API.

Untuk melakukan autentikasi ke Cloud Storage, siapkan Kredensial Default Aplikasi. Untuk informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien. 

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 selanjutnya