Usa conservaciones de objetos

En esta página, se describe cómo usar conservaciones de objetos, incluida la colocación predeterminada de conservaciones en objetos nuevos y en objetos individuales. Si quieres obtener más detalles sobre esta función, incluidos los tipos de conservaciones que se pueden colocar en los objetos, consulta la sección Conservaciones de objetos.

Requisitos previos

Antes de usar esta función en Cloud Storage, ten en cuenta lo siguiente:

  1. Debes tener permiso suficiente para ver y actualizar los depósitos y objetos en Cloud Storage:

    • Si eres propietario del proyecto que contiene el depósito, es probable que tengas los permisos necesarios.

    • Si usas IAM, deberías tener permisos storage.buckets.update, storage.buckets.get, storage.objects.update y storage.objects.get en el depósito correspondiente. Consulta Usa permisos de Cloud IAM si deseas obtener instrucciones para obtener una función, como roles/storage.admin, que tenga estos permisos.

    • Si usas las LCA, debes tener permisos de PROPIETARIO en el depósito relevante y en los objetos que contiene. Consulta Configura las LCA a fin de obtener instrucciones para hacerlo.

Trabaja con la propiedad de conservación predeterminada basada en eventos

En las siguientes tareas, se muestra cómo habilitar, inhabilitar y ver la propiedad de conservación predeterminada basada en eventos en un depósito. Cuando se habilita esta propiedad, los objetos nuevos agregados al depósito obtienen de manera automática una conservación basada en eventos.

Habilita la propiedad de conservación predeterminada basada en eventos

Sigue los pasos a continuación para colocar automáticamente una retención basada en eventos en cada objeto nuevo agregado a un grupo:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito en el que quieres habilitar la propiedad de conservación predeterminada basada en eventos.

  3. En la parte superior de la página, selecciona la pestaña Bloqueo del depósito.

  4. En la entrada Conservaciones predeterminadas basadas en eventos, haz clic en el botón Inhabilitar.

gsutil

Usa el comando gsutil retention event-default set:

gsutil retention event-default set gs://[BUCKET_NAME]

aquí, [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para 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";

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

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

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.


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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id  = "Your Google Cloud project ID"
    # bucket_name = "Name of your Google Cloud Storage bucket"

    require "google/cloud/storage"

    storage = Google::Cloud::Storage.new project_id: project_id
    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}."

API de REST

API de JSON

  1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
          "defaultEventBasedHold": true
        }
  3. Usa cURL para llamar a la API de JSON con una solicitud de depósito PATCH:

    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"

    Donde:

    • [JSON_FILE_NAME] es el nombre del archivo que creaste en el paso 2.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

API de XML

La API de XML no se puede usar para trabajar con conservaciones de objetos. En su lugar, usa una de las otras herramientas de Cloud Storage, como gsutil.

Obtén el estado de conservación predeterminado de un depósito

Sigue los pasos a continuación para ver si un depósito coloca retenciones basadas en eventos en objetos nuevos de forma predeterminada:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito del que quieras verificar el estado predeterminado basado en eventos.

  3. En la parte superior de la página, selecciona la pestaña Bloqueo del depósito.

  4. El estado aparece en la entrada Retenciones basadas en eventos de forma predeterminada.

gsutil

Usa el siguiente comando gsutil ls:

gsutil ls -L -b gs://[BUCKET_NAME]/

donde [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

La respuesta se ve como el siguiente ejemplo:

gs://[BUCKET_NAME]/ :
      Storage class:         STANDARD
      ...
      ...
      Default Event-Based Hold: On
      ...

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para 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";

    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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id  = "Your Google Cloud project ID"
    # bucket_name = "Name of your Google Cloud Storage bucket"

    require "google/cloud/storage"

    storage = Google::Cloud::Storage.new project_id: project_id
    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

API de REST

API de JSON

  1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de depósito GET que incluya los fields deseados:

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

    Donde

    • [OAUTH2_TOKEN] es el token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

    Si el depósito tiene habilitada una conservación predeterminada basada en eventos, la respuesta se ve como en el siguiente ejemplo:

    {
          "retentionPolicy": true
        }

API de XML

La API de XML no se puede usar para trabajar con conservaciones de objetos. En su lugar, usa una de las otras herramientas de Cloud Storage, como gsutil.

Inhabilita una conservación predeterminada basada en eventos

Sigue los pasos a continuación para inhabilitar una retención basada en eventos predetermina en un depósito:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito en el que quieras inhabilitar la propiedad de conservación predeterminada basada en eventos.

  3. En la parte superior de la página, selecciona la pestaña Bloqueo del depósito.

  4. En la entrada Conservaciones predeterminadas basadas en eventos, haz clic en el botón Habilitar.

gsutil

Usa el comando gsutil retention event-default release:

gsutil retention event-default release gs://[BUCKET_NAME]

aquí, [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para 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";

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

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

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id  = "Your Google Cloud project ID"
    # bucket_name = "Name of your Google Cloud Storage bucket"

    require "google/cloud/storage"

    storage = Google::Cloud::Storage.new project_id: project_id
    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}."

API de REST

API de JSON

  1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
          "defaultEventBasedHold": false
        }
  3. Usa cURL para llamar a la API de JSON con una solicitud de depósito PATCH:

    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"

    Donde:

    • [JSON_FILE_NAME] es el nombre del archivo que creaste en el paso 2.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.

API de XML

La API de XML no se puede usar para trabajar con conservaciones de objetos. En su lugar, usa una de las otras herramientas de Cloud Storage, como gsutil.

Trabaja con conservaciones de objetos

En las siguientes tareas, se muestra cómo colocar, ver y liberar conservaciones en los objetos.

Coloca una conservación de objetos

Sigue los pasos a continuación para colocar una retención en un objeto en tu depósito:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito que contiene los objetos a los que quieras colocar en conservación.

  3. Selecciona la casilla de verificación junto a los nombres de los objetos que quieras colocar en conservación.

  4. Haz clic en el botón Administrar conservaciones.

    Aparecerá la ventana Administrar conservaciones.

  5. Selecciona la casilla de verificación para los tipos de conservaciones que quieras colocar en los objetos seleccionados.

  6. Haz clic en Guardar configuración de conservación.

gsutil

Usa el comando gsutil retention:

gsutil retention [HOLD_TYPE] set gs://[BUCKET_NAME]/[OBJECT_NAME]

Donde:

  • [HOLD_TYPE] es el tipo de conservación que quieres aplicar a tu objeto. Por ejemplo, temp o event. Consulta Conservaciones de objetos para obtener más información sobre los tipos de conservación.
  • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
  • [OBJECT_NAME] es el nombre del objeto pertinente. Por ejemplo, pets/dog.png.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string bucket_name, std::string 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";
    }

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string bucket_name, std::string 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

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
        });
    }

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

ctx := context.Background()

    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 err
    }

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

ctx := context.Background()

    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 err
    }

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

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

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

/**
     * 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);

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

/**
     * 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 setTemporarydHold() {
      await storage
        .bucket(bucketName)
        .file(fileName)
        .setMetadata({
          temporaryHold: true,
        });
      console.log(`Temporary hold was set for ${fileName}.`);
    }

    setTemporarydHold().catch(console.error);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

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);
    }

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

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

    

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

# project_id  = "Your Google Cloud project ID"
    # 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 project_id: project_id
    bucket  = storage.bucket bucket_name
    file    = bucket.file file_name

    file.set_event_based_hold!

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

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

# project_id  = "Your Google Cloud project ID"
    # 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 project_id: project_id
    bucket  = storage.bucket bucket_name
    file    = bucket.file file_name

    file.set_temporary_hold!

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

API de REST

API de JSON

  1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
          "[HOLD_TYPE]": true
        }

    donde [HOLD_TYPE] es el tipo de conservación que quieres aplicar a tu objeto. Por ejemplo, temporaryHold o eventBasedHold. Consulta Conservaciones de objetos para obtener más información sobre los tipos de conservación.

  3. Usa cURL para llamar a la API de JSON con una solicitud de objeto PATCH:

    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]"

    Donde:

    • [JSON_FILE_NAME] es el nombre del archivo que creaste en el paso 2.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto pertinente. Por ejemplo, pets/dog.png.

API de XML

La API de XML no se puede usar para trabajar con conservaciones de objetos. En su lugar, usa una de las otras herramientas de Cloud Storage, como gsutil.

Obtén el estado de conservación de un objeto

A fin de ver si alguna conservación existe en un objeto, sigue las instrucciones generales detalladas en Visualiza metadatos de objeto.

Libera una conservación de objeto

Sigue los pasos a continuación para liberar una retención de un objeto en tu depósito:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito que contiene los objetos en los que deseas liberar las conservaciones.

  3. Selecciona la casilla de verificación junto a los nombres de los objetos a los que quieras quitarles las conservaciones.

  4. Haz clic en el botón Administrar conservaciones.

    Aparecerá la ventana Administrar conservaciones.

  5. Desmarca la casilla de verificación de las retenciones que quieras quitar.

  6. Haz clic en Guardar configuración de conservación.

gsutil

Usa el comando gsutil retention:

gsutil retention [HOLD_TYPE] release gs://[BUCKET_NAME]/[OBJECT_NAME]

Donde:

  • [HOLD_TYPE] es el tipo de conservación que quieres liberar del objeto. Por ejemplo, temp o event. Consulta Conservaciones de objetos para obtener más información sobre los tipos de conservación.
  • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
  • [OBJECT_NAME] es el nombre del objeto pertinente. Por ejemplo, pets/dog.png.

Muestras de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

En el siguiente ejemplo, se configura una conservación basada en eventos en un objeto:

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string bucket_name, std::string 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";
    }

En el siguiente ejemplo, se configura una conservación temporal en un objeto:

namespace gcs = google::cloud::storage;
    using ::google::cloud::StatusOr;
    [](gcs::Client client, std::string bucket_name, std::string 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

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,
        });
    }

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

ctx := context.Background()

    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 err
    }

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

ctx := context.Background()

    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 err
    }

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

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

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

/**
     * 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);

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

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);
    }

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

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

    

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

En el siguiente ejemplo, se libera una conservación basada en eventos en un objeto:

# project_id  = "Your Google Cloud project ID"
    # 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 project_id: project_id
    bucket  = storage.bucket bucket_name
    file    = bucket.file file_name

    file.release_event_based_hold!

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

En el siguiente ejemplo, se libera una conservación temporal en un objeto:

# project_id  = "Your Google Cloud project ID"
    # 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 project_id: project_id
    bucket  = storage.bucket bucket_name
    file    = bucket.file file_name

    file.release_temporary_hold!

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

API de REST

API de JSON

  1. Obtén un token de acceso de autorización de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
          "[HOLD_TYPE]": false
        }

    Donde [HOLD_TYPE] es el tipo de conservación que quieres liberar del objeto. Por ejemplo, temporaryHold o eventBasedHold. Consulta Conservaciones de objetos para obtener más información sobre los tipos de conservación.

  3. Usa cURL para llamar a la API de JSON con una solicitud de objeto PATCH:

    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]"

    Donde:

    • [JSON_FILE_NAME] es el nombre del archivo que creaste en el paso 2.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el paso 1.
    • [BUCKET_NAME] es el nombre del depósito correspondiente. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto pertinente. Por ejemplo, pets/dog.png.

API de XML

La API de XML no se puede usar para trabajar con conservaciones de objetos. En su lugar, usa una de las otras herramientas de Cloud Storage, como gsutil.

Próximos pasos