Objekt-Holds verwenden

Zu den Konzepten

Auf dieser Seite wird die Verwendung von Objekt-Holds erläutert. Dazu gehört die standardmäßige Festlegung von Holds für neue Objekte und die Festlegung von Holds für einzelne Objekte.

Voraussetzungen

Gehen Sie vor der Verwendung dieser Funktion in Cloud Storage so vor:

  1. Achten Sie darauf, dass Sie ausreichende Berechtigungen zum Ansehen und Aktualisieren von Buckets und Objekten in Cloud Storage haben:

    • Wenn Sie der Inhaber des Projekts sind, zu dem der Bucket gehört, haben Sie wahrscheinlich die erforderlichen Berechtigungen.

    • Wenn Sie IAM verwenden, benötigen Sie die Berechtigungen storage.buckets.update, storage.buckets.get, storage.objects.update und storage.objects.get für den entsprechenden Bucket. Unter Cloud IAM-Berechtigungen verwenden wird gezeigt, wie eine Rolle wie z. B. Storage Admin zugewiesen wird, die diese Berechtigungen enthält.

    • Wenn Sie ACLs (Zugriffssteuerungslisten) verwenden, sollten Sie die Berechtigung INHABER für den betreffenden Bucket und die darin enthaltenen Objekte haben. Weitere Informationen dazu finden Sie unter Zugriffssteuerungslisten festlegen.

Standardmäßiges ereignisbasiertes Hold-Attribut anwenden

Mit den folgenden Aufgaben wird gezeigt, wie Sie das standardmäßige ereignisbasierte Hold-Attribut für einen Bucket aktivieren, anzeigen lassen und deaktivieren. Wenn dieses Attribut aktiviert ist, erhalten neue Objekte, die dem Bucket hinzugefügt werden, automatisch einen ereignisbasierten Hold.

Standardmäßiges ereignisbasiertes Hold-Attribut aktivieren

So wird für jedes neue Objekt, das einem Bucket hinzugefügt wird, automatisch ein ereignisbasierter Hold festgelegt:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, für den Sie das standardmäßige ereignisbasierte Hold-Attribut aktivieren möchten.

  3. Wählen Sie oben auf der Seite den Tab Aufbewahrung aus.

  4. Klicken Sie im Abschnitt Option für standardmäßige ereignisbasierte Holds auf Deaktiviert.

    Wenn der Vorgang erfolgreich durchgeführt wurde, ändert sich die Schaltfläche in Aktiviert.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie den Befehl gsutil retention event-default set aus:

gsutil retention event-default set gs://BUCKET_NAME

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

Codebeispiele

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  if (!original) throw std::runtime_error(original.status().message());
  StatusOr<gcs::BucketMetadata> patched_metadata = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetDefaultEventBasedHold(true),
      gcs::IfMetagenerationMatch(original->metageneration()));

  if (!patched_metadata) {
    throw std::runtime_error(patched_metadata.status().message());
  }

  std::cout << "The default event-based hold for objects in bucket "
            << bucket_name << " is "
            << (patched_metadata->default_event_based_hold() ? "enabled"
                                                             : "disabled")
            << "\n";
}

C#

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

private void EnableBucketDefaultEventBasedHold(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName);
    bucket.DefaultEventBasedHold = true;
    bucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration
    });
    Console.WriteLine($"Default event-based hold was enabled for {bucketName}");
}

Go

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

ctx := context.Background()

bucket := c.Bucket(bucketName)
bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
	DefaultEventBasedHold: true,
}
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
	return err
}

Java

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

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

Bucket bucket =
    storage.update(BucketInfo.newBuilder(bucketName).setDefaultEventBasedHold(true).build());

System.out.println("Default event-based hold was enabled for " + bucketName);

Node.js

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


/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Enables a default event-based hold for the bucket.

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function enableDefaultEventBasedHold() {
  // Enables a default event-based hold for the bucket.
  await storage.bucket(bucketName).setMetadata({
    defaultEventBasedHold: true,
  });

  console.log(`Default event-based hold was enabled for ${bucketName}.`);
}

enableDefaultEventBasedHold().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Enables a default event-based hold for a bucket.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function enable_default_event_based_hold($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $bucket->update(['defaultEventBasedHold' => true]);
    printf('Default event-based hold was enabled for %s' . PHP_EOL, $bucketName);
}

Python

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

from google.cloud import storage

def enable_default_event_based_hold(bucket_name):
    """Enables the default event based hold on a given bucket"""
    # bucket_name = "my-bucket"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.default_event_based_hold = True
    bucket.patch()

    print("Default event based hold was enabled for {}".format(bucket_name))

Ruby

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

# bucket_name = "Name of your Google Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

bucket.update do |b|
  b.default_event_based_hold = true
end

puts "Default event-based hold was enabled for #{bucket_name}."

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
  "defaultEventBasedHold": true
}

  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:

    curl -X PATCH --data-binary @JSON_FILE_NAME.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=defaultEventBasedHold"

    Dabei gilt:

    • JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

XML API

Die XML API kann nicht für Objekt-Holds angewendet werden. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool, z. B. "gsutil".

Status des Standard-Holds eines Buckets abrufen

So stellen Sie fest, ob in einem Bucket standardmäßig ereignisbasierte Holds für jedes neue Objekt festgelegt werden:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, für den Sie den Status standardmäßiger ereignisbasierter Holds prüfen möchten.

  3. Wählen Sie oben auf der Seite den Tab Aufbewahrung aus.

  4. Der Status wird im Abschnitt Option für standardmäßige ereignisbasierte Holds angezeigt.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Verwenden Sie den folgenden gsutil ls-Befehl:

gsutil ls -L -b gs://BUCKET_NAME

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

Die Antwort sieht in etwa so aus:

gs://my-bucket/ :
  Storage class:         STANDARD
  ...
  ...
  Default Event-Based Hold: True
  ...

Wenn für den Bucket standardmäßig keine ereignisbasierten Holds für neue Objekte festgelegt werden, lässt gsutil Default Event-Based Hold in der Ausgabe vollständig weg.

Codebeispiele

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.GetBucketMetadata(bucket_name);

  if (!bucket_metadata) {
    throw std::runtime_error(bucket_metadata.status().message());
  }

  std::cout << "The default event-based hold for objects in bucket "
            << bucket_metadata->name() << " is "
            << (bucket_metadata->default_event_based_hold() ? "enabled"
                                                            : "disabled")
            << "\n";
}

C#

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

private bool GetBucketDefaultEventBasedHold(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName);
    bool? defaultEventBasedHoldOrNull = bucket?.DefaultEventBasedHold;
    bool defaultEventBasedHold =
        defaultEventBasedHoldOrNull.HasValue ? defaultEventBasedHoldOrNull.Value : false;
    Console.WriteLine("Default event-based hold: {0}", defaultEventBasedHold);
    return defaultEventBasedHold;
}

Go

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

ctx := context.Background()

ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
attrs, err := c.Bucket(bucketName).Attrs(ctx)
if err != nil {
	return nil, err
}
log.Printf("Default event-based hold enabled? %t\n",
	attrs.DefaultEventBasedHold)

Java

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

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

Bucket bucket =
    storage.get(bucketName, BucketGetOption.fields(BucketField.DEFAULT_EVENT_BASED_HOLD));

if (bucket.getDefaultEventBasedHold() != null && bucket.getDefaultEventBasedHold()) {
  System.out.println("Default event-based hold is enabled for " + bucketName);
} else {
  System.out.println("Default event-based hold is not enabled for " + bucketName);
}

Node.js

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function getDefaultEventBasedHold() {
  // get bucketName metadata
  const [metadata] = await storage.bucket(bucketName).getMetadata();
  console.log(`Default event-based hold: ${metadata.defaultEventBasedHold}.`);
}

getDefaultEventBasedHold().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Enables a default event-based hold for a bucket.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function get_default_event_based_hold($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    if ($bucket->info()['defaultEventBasedHold']) {
        printf('Default event-based hold is enabled for ' . $bucketName . PHP_EOL);
    } else {
        printf('Default event-based hold is not enabled for ' . $bucketName . PHP_EOL);
    }
}

Python

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

from google.cloud import storage

def get_default_event_based_hold(bucket_name):
    """Gets the default event based hold on a given bucket"""
    # bucket_name = "my-bucket"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)

    if bucket.default_event_based_hold:
        print("Default event-based hold is enabled for {}".format(bucket_name))
    else:
        print(
            "Default event-based hold is not enabled for {}".format(
                bucket_name
            )
        )

Ruby

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

# bucket_name = "Name of your Google Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

if bucket.default_event_based_hold?
  puts "Default event-based hold is enabled for #{bucket_name}."
else
  puts "Default event-based hold is not enabled for #{bucket_name}."
end

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

  2. Verwenden Sie cURL, um die JSON API mit einer GET-Bucket-Anfrage aufzurufen, die die gewünschten fields enthält:

    curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=defaultEventBasedHold"

    Dabei gilt:

    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket

    Wenn für den Bucket ein standardmäßiger ereignisbasierter Hold aktiviert ist, sieht die Antwort in etwa so aus:

    {
  "retentionPolicy": true
}

XML API

Die XML API kann nicht für Objekt-Holds angewendet werden. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool, z. B. "gsutil".

Standardmäßigen ereignisbasierten Hold deaktivieren

So deaktivieren Sie einen standardmäßigen ereignisbasierten Hold für einen Bucket:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, für den Sie den standardmäßigen ereignisbasierten Hold deaktivieren möchten.

  3. Wählen Sie oben auf der Seite den Tab Aufbewahrung aus.

  4. Klicken Sie im Abschnitt Option für standardmäßige ereignisbasierte Holds auf Aktiviert.

    Wenn der Vorgang erfolgreich durchgeführt wurde, ändert sich die Schaltfläche in Deaktiviert.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie den Befehl gsutil retention event-default release aus:

gsutil retention event-default release gs://BUCKET_NAME

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

Codebeispiele

C++

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

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  if (!original) throw std::runtime_error(original.status().message());
  StatusOr<gcs::BucketMetadata> patched_metadata = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetDefaultEventBasedHold(false),
      gcs::IfMetagenerationMatch(original->metageneration()));

  if (!patched_metadata) {
    throw std::runtime_error(patched_metadata.status().message());
  }

  std::cout << "The default event-based hold for objects in bucket "
            << bucket_name << " is "
            << (patched_metadata->default_event_based_hold() ? "enabled"
                                                             : "disabled")
            << "\n";
}

C#

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

private void DisableBucketDefaultEventBasedHold(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName);
    bucket.DefaultEventBasedHold = false;
    bucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration
    });
    Console.WriteLine($"Default event-based hold was disabled for {bucketName}");
}

Go

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

ctx := context.Background()

bucket := c.Bucket(bucketName)
bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
	DefaultEventBasedHold: false,
}
ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
	return err
}

Java

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

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

Bucket bucket =
    storage.update(BucketInfo.newBuilder(bucketName).setDefaultEventBasedHold(false).build());

System.out.println("Default event-based hold was disabled for " + bucketName);

Node.js

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function disableDefaultEventBasedHold() {
  // Disables a default event-based hold for a bucket.
  await storage.bucket(bucketName).setMetadata({
    defaultEventBasedHold: false,
  });
  console.log(`Default event-based hold was disabled for ${bucketName}.`);
}

disableDefaultEventBasedHold().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Disables a default event-based hold for a bucket.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 */
function disable_default_event_based_hold($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $bucket->update(['defaultEventBasedHold' => false]);
    printf('Default event-based hold was disabled for %s' . PHP_EOL, $bucketName);
}

Python

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

from google.cloud import storage

def disable_default_event_based_hold(bucket_name):
    """Disables the default event based hold on a given bucket"""
    # bucket_name = "my-bucket"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.default_event_based_hold = False
    bucket.patch()

    print("Default event based hold was disabled for {}".format(bucket_name))

Ruby

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

# bucket_name = "Name of your Google Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name

bucket.update do |b|
  b.default_event_based_hold = false
end

puts "Default event-based hold was disabled for #{bucket_name}."

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
  "defaultEventBasedHold": false
}

  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:

    curl -X PATCH --data-binary @JSON_FILE_NAME.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=defaultEventBasedHold"

    Dabei gilt:

    • JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

XML API

Die XML API kann nicht für Objekt-Holds angewendet werden. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool, z. B. "gsutil".

Objekt-Holds anwenden

Mit den folgenden Aufgaben wird gezeigt, wie Sie Holds für Objekte festlegen, anzeigen lassen und freigeben.

Objekt-Hold festlegen

So legen Sie einen Hold für ein Objekt in Ihrem Bucket fest:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der die Objekte enthält, für die Sie Holds festlegen möchten.

  3. Wählen Sie das Kästchen neben den Namen der Objekte aus, für die Sie Holds festlegen möchten.

  4. Klicken Sie auf die Schaltfläche Holds verwalten.

    Das Fenster Holds verwalten wird angezeigt.

  5. Wählen Sie das Kästchen für die Hold-Typen aus, die Sie für die ausgewählten Objekte festlegen möchten.

  6. Klicken Sie auf Hold-Einstellungen speichern.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie den Befehl gsutil retention aus:

gsutil retention HOLD_TYPE set gs://BUCKET_NAME/OBJECT_NAME

Dabei gilt:

  • HOLD_TYPE ist der Typ des Holds, den Sie auf Ihr Objekt anwenden möchten. Beispiel: temp oder event. Weitere Informationen zu den verschiedenen Hold-Typen finden Sie unter Objekt-Holds.
  • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.
  • OBJECT_NAME ist der Name des entsprechenden Objekts. Beispiel: pets/dog.png.

Codebeispiele

C++

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

google/cloud/storage/examples/storage_object_hold_samples.cc
namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<gcs::ObjectMetadata> original =
      client.GetObjectMetadata(bucket_name, object_name);
  if (!original) throw std::runtime_error(original.status().message());

  StatusOr<gcs::ObjectMetadata> updated = client.PatchObject(
      bucket_name, object_name,
      gcs::ObjectMetadataPatchBuilder().SetEventBasedHold(true),
      gcs::IfMetagenerationMatch(original->metageneration()));
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "The event hold for object " << updated->name()
            << " in bucket " << updated->bucket() << " is "
            << (updated->event_based_hold() ? "enabled" : "disabled") << "\n";
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

google/cloud/storage/examples/storage_object_hold_samples.cc
namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<gcs::ObjectMetadata> original =
      client.GetObjectMetadata(bucket_name, object_name);
  if (!original) throw std::runtime_error(original.status().message());

  StatusOr<gcs::ObjectMetadata> updated = client.PatchObject(
      bucket_name, object_name,
      gcs::ObjectMetadataPatchBuilder().SetTemporaryHold(true),
      gcs::IfMetagenerationMatch(original->metageneration()));
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "The temporary hold for object " << updated->name()
            << " in bucket " << updated->bucket() << " is "
            << (updated->temporary_hold() ? "enabled" : "disabled") << "\n";
}

C#

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

storage/api/Storage/Storage.cs
private void SetObjectEventBasedHold(string bucketName,
    string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    storageObject.EventBasedHold = true;
    storageObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration
    });
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

storage/api/Storage/Storage.cs
private void SetObjectTemporaryHold(string bucketName,
    string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    storageObject.TemporaryHold = true;
    storageObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

Go

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

storage/objects/set_event_based_hold.go 
import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setEventBasedHold sets EventBasedHold flag of an object to true.
func setEventBasedHold(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	o := client.Bucket(bucket).Object(object)
	objectAttrsToUpdate := storage.ObjectAttrsToUpdate{
		EventBasedHold: true,
	}
	if _, err := o.Update(ctx, objectAttrsToUpdate); err != nil {
		return fmt.Errorf("Object(%q).Update: %v", object, err)
	}
	fmt.Fprintf(w, "Default event based hold was enabled for %v.\n", object)
	return nil
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

storage/objects/set_temporary_hold.go 
import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setTemporaryHold sets TemporaryHold flag of an object to true.
func setTemporaryHold(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	o := client.Bucket(bucket).Object(object)
	objectAttrsToUpdate := storage.ObjectAttrsToUpdate{
		TemporaryHold: true,
	}
	if _, err := o.Update(ctx, objectAttrsToUpdate); err != nil {
		return fmt.Errorf("Object(%q).Update: %v", object, err)
	}
	fmt.Fprintf(w, "Temporary hold was enabled for %v.\n", object)
	return nil
}

Java

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

google-cloud-examples/src/main/java/com/google/cloud/examples/storage/snippets/StorageSnippets.java
// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

// The name of a blob, e.g. "my-blob"
// String blobName = "my-blob";

BlobId blobId = BlobId.of(bucketName, blobName);
Blob blob = storage.update(BlobInfo.newBuilder(blobId).setEventBasedHold(true).build());

System.out.println("Event-based hold was set for " + blobName);

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

google-cloud-examples/src/main/java/com/google/cloud/examples/storage/snippets/StorageSnippets.java
// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

// The name of a blob, e.g. "my-blob"
// String blobName = "my-blob";

BlobId blobId = BlobId.of(bucketName, blobName);
Blob blob = storage.update(BlobInfo.newBuilder(blobId).setTemporaryHold(true).build());

System.out.println("Temporary hold was set for " + blobName);

Node.js

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

samples/setEventBasedHold.js
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function setEventBasedHold() {
  // Set event-based hold
  await storage.bucket(bucketName).file(fileName).setMetadata({
    eventBasedHold: true,
  });
  console.log(`Event-based hold was set for ${fileName}.`);
}

setEventBasedHold().catch(console.error);

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

samples/setTemporaryHold.js 
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function setTemporaryHold() {
  await storage.bucket(bucketName).file(fileName).setMetadata({
    temporaryHold: true,
  });
  console.log(`Temporary hold was set for ${fileName}.`);
}

setTemporaryHold().catch(console.error);

PHP

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

storage/src/set_event_based_hold.php 
use Google\Cloud\Storage\StorageClient;

/**
 * Sets an event-based hold for an object.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 */
function set_event_based_hold($bucketName, $objectName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->update(['eventBasedHold' => true]);
    printf('Event-based hold was set for %s' . PHP_EOL, $objectName);
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

storage/src/set_temporary_hold.php 
use Google\Cloud\Storage\StorageClient;

/**
 * Sets a temporary hold for an object.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 */
function set_temporary_hold($bucketName, $objectName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->update(['temporaryHold' => true]);
    printf('Temporary hold was set for %s' . PHP_EOL, $objectName);
}

Python

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

storage/cloud-client/storage_set_event_based_hold.py
from google.cloud import storage

def set_event_based_hold(bucket_name, blob_name):
    """Sets a event based hold on a given blob"""
    # bucket_name = "my-bucket"
    # blob_name = "my-blob"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    blob.event_based_hold = True
    blob.patch()

    print("Event based hold was set for {}".format(blob_name))

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

storage/cloud-client/storage_set_temporary_hold.py
from google.cloud import storage

def set_temporary_hold(bucket_name, blob_name):
    """Sets a temporary hold on a given blob"""
    # bucket_name = "my-bucket"
    # blob_name = "my-blob"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    blob.temporary_hold = True
    blob.patch()

    print("Temporary hold was set for #{blob_name}")

Ruby

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

google-cloud-storage/samples/files.rb 
# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of a file in the Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.set_event_based_hold!

puts "Event-based hold was set for #{file_name}."

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

google-cloud-storage/samples/files.rb 
# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of a file in the Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.set_temporary_hold!

puts "Temporary hold was set for #{file_name}."

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
  "HOLD_TYPE": true
}

    Dabei ist HOLD_TYPE der Typ des Holds, den Sie auf Ihr Objekt anwenden möchten. Beispiel: temporaryHold oder eventBasedHold. Weitere Informationen zu Hold-Typen finden Sie unter Objekt-Holds.

  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Objektanfrage aufzurufen:

    curl -X PATCH --data-binary @JSON_FILE_NAME.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"

    Dabei gilt:

    • JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket
    • OBJECT_NAME ist der Name des entsprechenden Objekts. Beispiel: pets/dog.png

XML API

Die XML API kann nicht für Objekt-Holds angewendet werden. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool, z. B. "gsutil".

Hold-Status für ein Objekt abrufen

Wenn Sie feststellen möchten, ob und welche Holds für ein Objekt vorhanden sind, folgen Sie der Anleitung unter Objektmetadaten ansehen.

Objekt-Hold freigeben

So geben Sie einen Hold von einem Objekt in Ihrem Bucket frei:

Console

  1. Öffnen Sie den Cloud Storage-Browser in der Google Cloud Console.
    Zum Cloud Storage-Browser

  2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets mit den Objekten, von denen Sie Holds freigeben möchten.

  3. Wählen Sie das Kästchen neben den Namen der Objekte aus, von denen Sie Holds freigeben möchten.

  4. Klicken Sie auf die Schaltfläche Holds verwalten.

    Das Fenster Holds verwalten wird angezeigt.

  5. Heben Sie die Auswahl der Kästchen für die Holds auf, die Sie freigeben möchten.

  6. Klicken Sie auf Hold-Einstellungen speichern.

Unter Fehlerbehebung erfahren Sie, wie Sie im Cloud Storage-Browser detaillierte Fehlerinformationen zu fehlgeschlagenen Vorgängen abrufen.

gsutil

Führen Sie den Befehl gsutil retention aus:

gsutil retention HOLD_TYPE release gs://BUCKET_NAME/OBJECT_NAME

Dabei gilt:

  • HOLD_TYPE ist der Typ des Holds, den Sie von Ihrem Objekt freigeben möchten. Beispiel: temp oder event. Weitere Informationen zu den verschiedenen Hold-Typen finden Sie unter Objekt-Holds.
  • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket.
  • OBJECT_NAME ist der Name des entsprechenden Objekts. Beispiel: pets/dog.png.

Codebeispiele

C++

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt festgelegt:

google/cloud/storage/examples/storage_object_hold_samples.cc
namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<gcs::ObjectMetadata> original =
      client.GetObjectMetadata(bucket_name, object_name);
  if (!original) throw std::runtime_error(original.status().message());

  StatusOr<gcs::ObjectMetadata> updated = client.PatchObject(
      bucket_name, object_name,
      gcs::ObjectMetadataPatchBuilder().SetEventBasedHold(false),
      gcs::IfMetagenerationMatch(original->metageneration()));
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "The event hold for object " << updated->name()
            << " in bucket " << updated->bucket() << " is "
            << (updated->event_based_hold() ? "enabled" : "disabled") << "\n";
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt festgelegt:

google/cloud/storage/examples/storage_object_hold_samples.cc
namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<gcs::ObjectMetadata> original =
      client.GetObjectMetadata(bucket_name, object_name);

  if (!original) throw std::runtime_error(original.status().message());
  StatusOr<gcs::ObjectMetadata> updated = client.PatchObject(
      bucket_name, object_name,
      gcs::ObjectMetadataPatchBuilder().SetTemporaryHold(false),
      gcs::IfMetagenerationMatch(original->metageneration()));

  if (!updated) throw std::runtime_error(updated.status().message());
  std::cout << "The temporary hold for object " << updated->name()
            << " in bucket " << updated->bucket() << " is "
            << (updated->temporary_hold() ? "enabled" : "disabled") << "\n";
}

C#

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

storage/api/Storage/Storage.cs
private void ReleaseObjectEventBasedHold(string bucketName,
    string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    storageObject.EventBasedHold = false;
    storageObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

storage/api/Storage/Storage.cs
private void ReleaseObjectTemporaryHold(string bucketName,
    string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    storageObject.TemporaryHold = false;
    storageObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Use IfMetagenerationMatch to avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

Go

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

storage/objects/release_event_based_hold.go 
import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// releaseEventBasedHold releases an object with event-based hold.
func releaseEventBasedHold(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	o := client.Bucket(bucket).Object(object)
	objectAttrsToUpdate := storage.ObjectAttrsToUpdate{
		EventBasedHold: false,
	}
	if _, err := o.Update(ctx, objectAttrsToUpdate); err != nil {
		return fmt.Errorf("Object(%q).Update: %v", object, err)
	}
	fmt.Fprintf(w, "Event based hold was released for %v.\n", object)
	return nil
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

storage/objects/release_temporary_hold.go 
import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// releaseTemporaryHold releases an object with temporary hold.
func releaseTemporaryHold(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	o := client.Bucket(bucket).Object(object)
	objectAttrsToUpdate := storage.ObjectAttrsToUpdate{
		TemporaryHold: false,
	}
	if _, err := o.Update(ctx, objectAttrsToUpdate); err != nil {
		return fmt.Errorf("Object(%q).Update: %v", object, err)
	}
	fmt.Fprintf(w, "Temporary hold was released for %v.\n", object)
	return nil
}

Java

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

google-cloud-examples/src/main/java/com/google/cloud/examples/storage/snippets/StorageSnippets.java
// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

// The name of a blob, e.g. "my-blob"
// String blobName = "my-blob";

BlobId blobId = BlobId.of(bucketName, blobName);
Blob blob = storage.update(BlobInfo.newBuilder(blobId).setEventBasedHold(false).build());

System.out.println("Event-based hold was released for " + blobName);

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

google-cloud-examples/src/main/java/com/google/cloud/examples/storage/snippets/StorageSnippets.java
// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of a bucket, e.g. "my-bucket"
// String bucketName = "my-bucket";

// The name of a blob, e.g. "my-blob"
// String blobName = "my-blob";

BlobId blobId = BlobId.of(bucketName, blobName);
Blob blob = storage.update(BlobInfo.newBuilder(blobId).setTemporaryHold(false).build());

System.out.println("Temporary hold was released for " + blobName);

Node.js

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

samples/releaseEventBasedHold.js
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function releaseEventBasedHold() {
  await storage.bucket(bucketName).file(fileName).setMetadata({
    eventBasedHold: false,
  });
  console.log(`Event-based hold was released for ${fileName}.`);
}

releaseEventBasedHold().catch(console.error);

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

samples/releaseTemporaryHold.js
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to access, e.g. file.txt';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function releaseTemporaryHold() {
  await storage.bucket(bucketName).file(fileName).setMetadata({
    temporaryHold: false,
  });
  console.log(`Temporary hold was released for ${fileName}.`);
}

releaseTemporaryHold().catch(console.error);

PHP

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

storage/src/release_event_based_hold.php 
use Google\Cloud\Storage\StorageClient;

/**
 * Releases an event-based hold for an object.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 */
function release_event_based_hold($bucketName, $objectName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->update(['eventBasedHold' => false]);
    printf('Event-based hold was released for %s' . PHP_EOL, $objectName);
}

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

storage/src/release_temporary_hold.php 
use Google\Cloud\Storage\StorageClient;

/**
 * Releases a temporary hold for an object.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 */
function release_temporary_hold($bucketName, $objectName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->update(['temporaryHold' => false]);
    printf('Temporary hold was released for %s' . PHP_EOL, $objectName);
}

Python

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

storage/cloud-client/storage_release_event_based_hold.py
from google.cloud import storage

def release_event_based_hold(bucket_name, blob_name):
    """Releases the event based hold on a given blob"""

    # bucket_name = "my-bucket"
    # blob_name = "my-blob"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    blob.event_based_hold = False
    blob.patch()

    print("Event based hold was released for {}".format(blob_name))

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

storage/cloud-client/storage_release_temporary_hold.py
from google.cloud import storage

def release_temporary_hold(bucket_name, blob_name):
    """Releases the temporary hold on a given blob"""

    # bucket_name = "my-bucket"
    # blob_name = "my-blob"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    blob.temporary_hold = False
    blob.patch()

    print("Temporary hold was release for #{blob_name}")

Ruby

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

Im folgenden Beispiel wird ein ereignisbasierter Hold für ein Objekt freigegeben:

google-cloud-storage/samples/files.rb 
# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of a file in the Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.release_event_based_hold!

puts "Event-based hold was released for #{file_name}."

Im folgenden Beispiel wird ein temporärer Hold für ein Objekt freigegeben:

google-cloud-storage/samples/files.rb 
# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of a file in the Cloud Storage bucket"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name
file    = bucket.file file_name

file.release_temporary_hold!

puts "Temporary hold was released for #{file_name}."

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.

  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
  "HOLD_TYPE": false
}

    Dabei ist HOLD_TYPE der Typ des Holds, den Sie von Ihrem Objekt freigeben möchten. Beispiel: temporaryHold oder eventBasedHold. Weitere Informationen zu Hold-Typen finden Sie unter Objekt-Holds.

  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Objektanfrage aufzurufen:

    curl -X PATCH --data-binary @JSON_FILE_NAME.json \
-H "Authorization: Bearer OAUTH2_TOKEN" \
-H "Content-Type: application/json" \
"https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME"

    Dabei gilt:

    • JSON_FILE_NAME ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • OAUTH2_TOKEN ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • BUCKET_NAME ist der Name des entsprechenden Buckets. Beispiel: my-bucket
    • OBJECT_NAME ist der Name des entsprechenden Objekts. Beispiel: pets/dog.png

XML API

Die XML API kann nicht für Objekt-Holds angewendet werden. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool, z. B. "gsutil".

Weitere Informationen