このページは Cloud Translation API によって翻訳されました。

削除（復元可能）を無効にする

このページでは、組織全体で新規および既存のバケットに対して削除（復元可能）機能を無効にする方法を説明します。

データ損失を防ぐために、デフォルトでは新しいバケットに対して削除（復元可能）が有効になっています。必要に応じて、削除（復元可能）を無効にできます。既存のバケットに対して削除（復元可能）を無効にするには、削除（復元可能）ポリシーを変更します。新しいバケットに対してデフォルトで削除（復元可能）を無効にするには、組織全体のデフォルトタグを設定します。削除（復元可能）を無効にすると、誤って削除されたデータや悪意を持って削除されたデータを含め、データを復元できなくなります。

必要なロール

削除（復元可能）を無効にするために必要な権限を取得するには、組織レベルで次の IAM ロールを付与するよう管理者に依頼してください。

ストレージ管理者（roles/storage.admin）
タグ管理者（roles/resourcemanager.tagAdmin）
組織閲覧者（roles/resourcemanager.organizationViewer）

これらの事前定義ロールには、削除（復元可能）を無効にするために必要な権限が含まれています。必要とされる正確な権限については、「必要な権限」セクションを開いてご確認ください。

必要な権限

削除（復元可能）を無効にするには、次の権限が必要です。

storage.buckets.get
storage.buckets.update
storage.buckets.list（この権限は、このページで説明する操作を Google Cloud コンソールを使用して行う場合にのみ必要です）
タグ管理者（roles/resourcemanager.tagAdmin）ロールの一部として含まれる必要な権限については、タグの管理に必要な権限をご覧ください。

ロールの付与については、バケットでの IAM ポリシーの設定と管理またはプロジェクトに対するアクセス権の管理をご覧ください。

特定のバケットの削除（復元可能）を無効にする

始める前に、次の点を考慮してください。

無効化中に削除済み（復元可能）オブジェクトを含むバケットの削除（復元可能）ポリシーを無効にすると、以前に適用された保持期間が経過するまで既存の削除済み（復元可能）オブジェクトが保持されます。
バケットで削除（復元可能）ポリシーを無効にすると、Cloud Storage は新しく削除されたオブジェクトを保持しません。
バケットで削除（復元可能）ポリシーを無効にすると、メタデータのキャッシュ保存により、Cloud Storage 全体で変更がすぐに反映されません。そのため、削除（復元可能削除ポリシーを無効にした後の一括削除など）のオペレーションを開始する前に、少なくとも 30 秒待つことをおすすめします。これにより、データは削除（復元可能な削除）ではなく完全に削除されます。Cloud Storage オペレーションの一貫性について詳しくは、Cloud Storage の一貫性をご覧ください。

特定のバケットの削除（復元可能）を無効にするには、次の操作を行います。

コンソール

Google Cloud コンソールで Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
バケットのリストで、削除（復元可能）ポリシーを無効にするバケットの名前をクリックします。
[保護] タブをクリックします。
[削除（復元可能）ポリシー] セクションで [無効にする] をクリックして、削除（復元可能）ポリシーを無効にします。
[確認] をクリックします。

失敗した Cloud Storage オペレーションの詳細なエラー情報を Google Cloud コンソールで確認する方法については、トラブルシューティングをご覧ください。

コマンドライン

--clear-soft-delete フラグを指定して gcloud storage buckets update コマンドを実行します。

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

ここで

BUCKET_NAME はバケットの名前です。例: my-bucket。

REST API

JSON API

gcloud CLI をインストールして初期化します。これにより、Authorization ヘッダーのアクセストークンを生成できます。

次の情報が含まれる JSON ファイルを作成します。

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

cURL を使用して、PATCH Bucket リクエストで JSON API を呼び出します。
```
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"
```
ここで
- JSON_FILE_NAME は、手順 2 で作成した JSON ファイルのパスです。
- BUCKET_NAME は、関連するバケットの名前です。例: my-bucket

プロジェクト内の最大 100 個のバケットに対して削除（復元可能）を無効にする

Google Cloud コンソールを使用すると、削除（復元可能）されたバイト数が多い順、またはライブバイト数に対して削除（復元可能）バイト数の比率が高い順にバケットが並べ替えられ、一度に最大 100 個のバケットに対して削除（復元可能）を無効にできます。これにより、削除（復元可能）の費用に最も大きな影響を与えるバケットを管理できます。

Google Cloud コンソールで Cloud Storage の [バケット] ページに移動します。
[バケット] に移動
[Cloud Storage] のページで [設定] をクリックします。
[削除（復元可能）] タブをクリックします。
[過去 30 日間に削除（復元可能）された平均バイト数が多いバケット] のリストから、削除（復元可能）を無効にするバケットを選択します。
[削除（復元可能）をオフにする] をクリックします。

選択したバケットで削除（復元可能）が無効になります。

プロジェクト内の複数またはすべてのバケットで削除（復元可能）を無効にする

Google Cloud CLI を使用して、--project フラグとワイルドカード（*）を指定して gcloud storage buckets update コマンドを実行し、プロジェクト内の複数またはすべてのバケットで削除（復元可能）を一括で無効にします。

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

ここで

PROJECT_ID はプロジェクト ID です。例: my-project

フォルダ内のすべてのバケットで削除（復元可能）を無効にする

Google Cloud CLI を使用して gcloud projects list コマンドと gcloud storage buckets update コマンドを実行し、指定したフォルダ内のすべてのプロジェクトのバケットで削除（復元可能）を無効にします。

gcloud projects list コマンドと gcloud storage buckets update コマンドを実行して、指定したフォルダのすべてのバケットを一覧表示し、フォルダ内のすべてのバケットで削除（復元可能）を無効にします。

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

ここで

FOLDER_ID はフォルダの名前です。例: 123456

組織レベルで削除（復元可能）を無効にする

Google Cloud CLI を使用して、--clear-soft-delete フラグとワイルドカード（*）を指定して gcloud storage buckets update コマンドを実行し、組織レベルで削除（復元可能）を無効にします。

--clear-soft-delete フラグとワイルドカード（*）を指定して gcloud storage buckets update コマンドを実行し、組織内のすべてのバケットで削除（復元可能）を無効にします。

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

Cloud Storage で、既存のバケットに対して削除（復元可能）が無効になります。すでに削除（復元可能）されたオブジェクトは、削除（復元可能）の保持期間が完了するまでバケットに残ります。保持期間が完了すると、完全に削除されます。

新しいバケットの削除（復元可能）を無効にする

新しいバケットに対しては削除（復元可能）がデフォルトで有効になっていますが、タグを使用して、デフォルトによる削除（復元可能）の有効化を防ぐことができます。タグでは storage.defaultSoftDeletePolicy キーを使用して、組織レベルで 0d（0 日）の削除（復元可能）ポリシーを適用します。これにより、削除（復元可能）機能が無効になり、削除されたデータが今後保持されなくなります。

新しいバケットの作成時にデフォルトで削除（復元可能）を無効にするには、以下の手順を使用します。以下の手順は、特定の削除（復元可能）ポリシーを義務付ける組織のポリシーを設定することと同等ではありません。つまり、必要に応じてポリシーを指定することで、特定のバケットに対して削除（復元可能）を有効にできます。

Google Cloud CLI を使用して、storage.defaultSoftDeletePolicy タグを作成します。このタグは、新しいバケットに対するデフォルトの削除（復元可能）保持期間を変更するために使用されます。storage.defaultSoftDeletePolicy タグ名のみがデフォルトの削除（復元可能）保持期間を更新します。

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."
```
ここで
- ORGANIZATION_ID は、デフォルトの削除（復元可能）保持期間を設定する対象の組織の数値 ID です。例: 12345678901。組織 ID を確認する方法については、組織リソース ID の取得をご覧ください。
gcloud resource-manager tags values create コマンドを使用して、新しいバケットに対してデフォルトで削除（復元可能）保持期間を無効にする 0d（0 日）のタグ値を作成します。
```
gcloud resource-manager tags values create 0d \
  --parent=ORGANIZATION_ID/storage.defaultSoftDeletePolicy \
  --description="Disables soft delete for new Storage buckets."
```
ここで
- ORGANIZATION_ID は、デフォルトの削除（復元可能）保持期間を設定する対象の組織の数値 ID です。例: 12345678901
注: storage.defaultSoftDeletePolicy タグを作成済みの場合、このコマンドは失敗します。0d のタグ値を作成して削除（復元可能）を無効にするには、既存の storage.defaultSoftDeletePolicy タグを更新して 0d タグ値を使用する必要があります。タグを更新する方法の詳細については、既存のタグを更新するをご覧ください。
gcloud resource-manager tags bindings create コマンドを使用して、タグをリソースに適用します。
```
gcloud resource-manager tags bindings create \
 --tag-value=ORGANIZATION_ID/storage.defaultSoftDeletePolicy/0d \
 --parent=RESOURCE_ID
```
ここで
- ORGANIZATION_ID はタグが作成された組織の数値 ID です。例: 12345678901
- RESOURCE_ID は、タグバインディングを作成する対象の組織の完全な名前です。たとえば、organizations/7890123456 にタグを適用するには、「//cloudresourcemanager.googleapis.com/organizations/7890123456」と入力します。

指定したコストしきい値を超えるバケットの削除（復元可能）を無効にする

Python 用の Cloud クライアントライブラリを使用すると、Python クライアントライブラリのサンプルで、指定された相対コストしきい値を超えるバケットの削除（復元可能）を無効にできます。サンプルでは以下を行います。

各ストレージクラスのストレージの相対コストを計算します。
バケットで蓄積された削除（復元可能）のコストを評価します。
削除（復元可能）の使用に対するコストしきい値を設定して、設定したしきい値を超えるバケットを一覧表示し、しきい値を超えるバケットの削除（復元可能）を無効にできます。

Python 用のクライアントライブラリの設定とサンプルの使用の詳細については、Cloud Storage Soft Delete Cost Analyzer の README.md ページをご覧ください。

次のサンプルでは、指定したコストしきい値を超えるバケットの削除（復元可能）を無効にします。

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

次のステップ

削除（復元可能）を再度有効にする前に、考慮事項を確認する。
削除（復元可能）と他の Cloud Storage 機能との相互作用を確認する。