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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class EnableBucketDefaultEventBasedHoldSample
{
    public Bucket EnableBucketDefaultEventBasedHold(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.DefaultEventBasedHold = true;
        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Default event-based hold was enabled for {bucketName}");
        return bucket;
    }
}

Go

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

// 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.

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

def enable_default_event_based_hold bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  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}."
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. 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;
using System;

public class GetDefaultEventBasedHoldSample
{
    public bool GetDefaultEventBasedHold(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bool defaultEventBasedHold = bucket.DefaultEventBasedHold ?? false;
        Console.WriteLine($"Default event-based hold: {defaultEventBasedHold}");
        return defaultEventBasedHold;
    }
}

Go

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

// 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.

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

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

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

async function getDefaultEventBasedHold() {
  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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

def get_default_event_based_hold bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  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
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 den 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class DisableDefaultEventBasedHoldSample
{
    public Bucket DisableDefaultEventBasedHold(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);
        bucket.DefaultEventBasedHold = false;
        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Default event-based hold was disabled for {bucketName}");
        return bucket;
    }
}

Go

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

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

// 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.

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// 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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

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.

Auf GitHub ansehen Feedback

def disable_default_event_based_hold bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  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}."
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. 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 können.

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

Wobei:

• 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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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.Samples/SetEventBasedHold.cs

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;
using System;

public class SetEventBasedHoldSample
{
    public void SetEventBasedHold(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.EventBasedHold = true;
        storage.UpdateObject(storageObject);
        Console.WriteLine($"Event-based hold was set for {objectName}.");
    }
}

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

storage/api/Storage.Samples/SetTemporaryHold.cs

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;

public class SetTemporaryHoldSample
{
    public void SetTemporaryHold(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.TemporaryHold = true;
        storage.UpdateObject(storageObject);
        System.Console.WriteLine($"Temporary hold was set for {objectName}.");
    }
}

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

// 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

Auf GitHub ansehen Feedback

// 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

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// 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

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// 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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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/storage_set_event_based_hold.rb

Auf GitHub ansehen Feedback

def set_event_based_hold bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  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}."
end

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

google-cloud-storage/samples/storage_set_temporary_hold.rb

Auf GitHub ansehen Feedback

def set_temporary_hold bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  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}."
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. 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

Hinweis: Sie können Objekt-Holds nicht mit der XML API aufrufen. Verwenden Sie stattdessen ein anderes Cloud Storage-Tool wie gsutil.

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

Wobei:

• 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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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.Samples/ReleaseEventBasedHold.cs

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;
using System;

public class ReleaseEventBasedHoldSample
{
    public void ReleaseEventBasedHold(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.EventBasedHold = false;
        storage.UpdateObject(storageObject);
        Console.WriteLine($"Event-based hold was released for {objectName}.");
    }
}

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

storage/api/Storage.Samples/ReleaseTemporaryHold.cs

Auf GitHub ansehen Feedback

using Google.Cloud.Storage.V1;
using System;

public class ReleaseTemporaryHoldSample
{
    public void ReleaseTemporaryHold(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.TemporaryHold = false;
        storage.UpdateObject(storageObject);
        Console.WriteLine($"Temporary hold was released for {objectName}.");
    }
}

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

// 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

Auf GitHub ansehen Feedback

// 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

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// 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

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The ID of your GCS file
// const fileName = 'your-file-name';

// 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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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

Auf GitHub ansehen Feedback

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/storage_release_event_based_hold.rb

Auf GitHub ansehen Feedback

def release_event_based_hold bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  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}."
end

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

google-cloud-storage/samples/storage_release_temporary_hold.rb

Auf GitHub ansehen Feedback

def release_temporary_hold bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object
  # file_name = "your-file-name"

  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}."
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. 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

• Mehr über Objekt-Holds erfahren, einschließlich der verschiedenen Typen von Holds, die ein Objekt haben kann
• Aufbewahrungsrichtlinien