Diese Seite wurde von der Cloud Translation API übersetzt.

Vorläufig löschen verwenden

Auf dieser Seite wird beschrieben, wie Sie die Richtlinie zum weichen Löschen für einen Bucket aktivieren, deaktivieren, aktualisieren und den Status prüfen. Informationen zum Auflisten und Wiederherstellen vorläufig gelöschter Objekte finden Sie unter Vorläufig gelöschte Objekte verwenden. Informationen zum Auflisten und Wiederherstellen vorläufig gelöschter Buckets finden Sie unter Vorläufig gelöschte Buckets verwenden. Weitere Informationen zum Soft-Löschen finden Sie in der Übersicht. Informationen zum Deaktivieren der Funktion finden Sie unter Soft-Löschen deaktivieren.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Storage-Administrator (roles/storage.admin) für den Bucket oder das Projekt mit dem Bucket zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Richtlinien für das vorläufige Löschen benötigen.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Erstellen und Verwalten von Richtlinien für das vorläufige Löschen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Richtlinien für das weichgelöschte Speichern zu erstellen und zu verwalten:

storage.buckets.get
storage.buckets.update
storage.buckets.list (Diese Berechtigung ist nur erforderlich, wenn Sie die Google Cloud Console verwenden möchten, um die Anleitung auf dieser Seite auszuführen.)

Informationen zum Zuweisen von Rollen finden Sie unter IAM mit Buckets verwenden oder Zugriff auf Projekte verwalten.

Richtlinie für das vorläufige Löschen eines Buckets bearbeiten

Die neue Aufbewahrungsdauer für das vorläufige Löschen gilt nur für Objekte oder Buckets, die Sie nach Inkrafttreten der Richtlinie für das vorläufige Löschen löschen. Vorhandene vorläufig gelöschte Objekte sind von Aktualisierungen der Richtlinie für das vorläufige Löschen nicht betroffen und werden für die Dauer beibehalten, die beim Löschen gegolten hat.

So bearbeiten Sie die Richtlinie für das vorläufige Löschen eines Buckets:

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, dessen Richtlinie für das weiche Löschen Sie verwalten möchten.
Klicken Sie auf den Tab Schutz.
Führen Sie im Abschnitt Richtlinie für das Soft-Löschen einen der folgenden Schritte aus:
- Wenn für den Bucket keine Richtlinie für das vorläufige Löschen festgelegt ist, klicken Sie auf Bearbeiten, wählen Sie eine Zeiteinheit und eine Zeitdauer für die Aufbewahrungsdauer aus und klicken Sie auf Speichern.
- Wenn für den Bucket eine Richtlinie für das vorläufige Löschen gilt, klicken Sie auf Bearbeiten, um die Zeiteinheit und die Dauer der Aufbewahrungsdauer zu ändern.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Verwenden Sie den Befehl gcloud storage buckets update mit dem Flag --soft-delete-duration, um die Richtlinie für die schrittweise Löschung für einen Bucket hinzuzufügen oder zu ändern:

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

Wobei:

BUCKET_NAME ist der Name des Buckets. Beispiel: my-bucket
SOFT_DELETE_DURATION gibt die Dauer an, für die vorläufig gelöschte Objekte aufbewahrt werden sollen. 2w1d entspricht beispielsweise zwei Wochen und einem Tag. Weitere Informationen finden Sie unter Aufbewahrungsdauer für Soft-Deletes.

REST APIs

JSON API

Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

Erstellen Sie eine JSON-Datei, die folgende Informationen enthält:
```
{
  "softDeletePolicy": {
    "retentionDurationSeconds": "TIME_IN_SECONDS"
  }
}
```
Dabei ist TIME_IN_SECONDS der Zeitraum in Sekunden, in dem vorläufig gelöschte Objekte aufbewahrt werden sollen. Beispiel: 2678400. Weitere Informationen finden Sie unter Aufbewahrungsdauer für Soft-Deletes.
Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:
```
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"
```
Dabei gilt:
- JSON_FILE_NAME ist der Pfad für die JSON-Datei, die Sie in Schritt 2 erstellt haben.
- BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

Richtlinie für vorläufiges Löschen eines Buckets deaktivieren

Beachten Sie Folgendes, bevor Sie beginnen:

Wenn Sie eine Richtlinie für vorläufiges Löschen für Ihren Bucket deaktivieren, der zum Zeitpunkt der Deaktivierung vorläufig gelöschte Objekte enthält, werden die vorhandenen vorläufig gelöschten Objekte so lange aufbewahrt, bis die zuvor angewendete Aufbewahrungsdauer abgelaufen ist.
Nachdem Sie eine Richtlinie für das vorläufige Löschen für Ihren Bucket deaktiviert haben, speichert Cloud Storage neu gelöschte Daten nicht.

So deaktivieren Sie die Richtlinie für das vorläufige Löschen eines Buckets:

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, dessen Richtlinie für das vorläufige Löschen Sie deaktivieren möchten.
Klicken Sie auf den Tab Schutz.
Klicken Sie im Abschnitt Richtlinie für vorläufiges Löschen auf Deaktivieren, um die Richtlinie für vorläufiges Löschen zu deaktivieren.
Klicken Sie auf Bestätigen.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Verwenden Sie den Befehl gcloud storage buckets update mit dem Flag --clear-soft-delete, um die Richtlinie für die schrittweise Löschung aus einem Bucket zu entfernen:

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

Wobei:

BUCKET_NAME ist der Name des Buckets. Beispiel: my-bucket

REST APIs

JSON API

Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

Erstellen Sie eine JSON-Datei, die folgende Informationen enthält:

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

Wenn Sie die Richtlinie für das Soft-Löschen für einen Bucket deaktivieren möchten, verwenden Sie den Wert 0 anstelle von TIME_IN_SECONDS.

Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:
```
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"
```
Dabei gilt:
- JSON_FILE_NAME ist der Pfad für die JSON-Datei, die Sie in Schritt 2 erstellt haben.
- BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

Prüfen, ob die Richtlinie für vorläufiges Löschen für einen Bucket aktiviert ist

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie in der Liste der Buckets auf den Namen des Buckets, dessen Richtlinie für das vorläufige Löschen Sie prüfen möchten.
Klicken Sie auf den Tab Schutz.

Der Status wird im Abschnitt Richtlinie für vorläufiges Löschen (zur Datenwiederherstellung) angezeigt.

Auf dem Tab Schutz können Sie auch prüfen, ob für Ihren Bucket eine Richtlinie für das weiche Löschen gilt.

Unter Fehlerbehebung erfahren Sie, wie Sie detaillierte Fehlerinformationen zu fehlgeschlagenen Cloud Storage-Vorgängen in der Google Cloud Console abrufen.

Befehlszeile

Verwenden Sie den Befehl gcloud storage buckets describe, um den Status der Richtlinie für die schrittweise Löschung eines Buckets zu prüfen:

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

Wobei:

BUCKET_NAME ist der Name des Buckets. Beispiel: my-bucket

REST APIs

JSON API

Die gcloud CLI installieren und initialisieren, um ein Zugriffstoken für den Header Authorization zu generieren.

Verwenden Sie cURL, um die JSON API mit einer GET-Bucket-Anfrage aufzurufen:

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"

Dabei ist BUCKET_NAME der Name des entsprechenden Buckets. Beispiel: my-bucket.

Vorläufiges Löschen für mehrere oder alle Buckets in einem Projekt deaktivieren

In der folgenden Anleitung wird beschrieben, wie Sie das weichgelöschte Löschen für mehrere oder alle Bucket in einem Projekt deaktivieren. Informationen zum Deaktivieren des weichen Löschens auf Ebene der Organisation finden Sie unter Weiches Löschen deaktivieren.

Console

In der Google Cloud Console können Sie das vorläufige Löschen für Buckets deaktivieren, die nach der größten Anzahl von vorläufig gelöschten Bytes oder dem höchsten Verhältnis von vorläufig gelöschten Bytes zu aktiven Bytes sortiert sind. So können Sie die Kosten für das vorläufige Löschen senken.

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

Buckets aufrufen
Klicken Sie auf der Seite „Cloud Storage“ auf Einstellungen.
Klicken Sie auf den Tab Weniger striktes Löschen.
Wählen Sie in der Liste Top-Buckets nach gelöschten Bytes die Bucket aus, für die Sie das Soft-Delete deaktivieren möchten.
Klicken Sie auf Vorläufiges Löschen deaktivieren.

Das vorläufige Löschen ist für die von Ihnen ausgewählten Buckets deaktiviert.

Befehlszeile

Wenn Sie die Vorläufige Löschung für alle Bucket in einem Projekt deaktivieren möchten, führen Sie den Befehl gcloud storage buckets update mit dem Flag --clear-soft-delete und dem Wildcard-Zeichen * aus:

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

Clientbibliotheken

Wenn Sie das schadlose Löschen für alle Buckets in Ihrem Projekt deaktivieren möchten, müssen Sie zuerst die Buckets in Ihrem Projekt auflisten und dann das schadlose Löschen für jedes Ergebnis mithilfe der folgenden Anleitung deaktivieren:

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

Vorläufig löschen verwenden

Erforderliche Rollen

Erforderliche Berechtigungen

Richtlinie für das vorläufige Löschen eines Buckets bearbeiten

Console

Befehlszeile

REST APIs

JSON API

Richtlinie für vorläufiges Löschen eines Buckets deaktivieren

Console

Befehlszeile

REST APIs

JSON API

Prüfen, ob die Richtlinie für vorläufiges Löschen für einen Bucket aktiviert ist

Console

Befehlszeile

REST APIs

JSON API

Vorläufiges Löschen für mehrere oder alle Buckets in einem Projekt deaktivieren

Console

Befehlszeile

Clientbibliotheken

Python

Nächste Schritte