Usar objetos con versión

Descripción general Configuración

En esta página, se describe cómo enumerar, acceder, restablecer y borrar objetos no actuales, que se suelen aplicar a los buckets con la función Control de versiones de objetos habilitada.

Roles obligatorios

Si deseas obtener los permisos que necesitas para administrar los objetos no actuales, pídele a tu administrador que te otorgue el rol de IAM de Usuario de objetos de almacenamiento (roles/storage.objectUser) en el proyecto. Este rol predefinido contiene los permisos necesarios para administrar objetos no actuales. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

storage.objects.create
storage.objects.delete
storage.objects.get
storage.objects.list

También puedes obtener estos permisos con roles personalizados.

Para obtener información sobre cómo otorgar roles en proyectos, consulta Administra el acceso a los proyectos.

Según tu caso de uso, es posible que necesites permisos adicionales o roles alternativos:

Si planeas usar la consola de Google Cloud para realizar las tareas de esta página, también necesitarás el permiso storage.buckets.list, que no se incluye en el rol Usuario de objetos de Storage (roles/storage.objectUser). Para obtener este permiso, pídele a tu administrador que te otorgue el rol Administrador de almacenamiento (roles/storage.admin) en el proyecto.
Si el acceso uniforme a nivel de bucket está inhabilitado para tu bucket, necesitas permisos adicionales en las siguientes situaciones:
- Si planeas mostrar objetos no actuales junto con sus LCA, también necesitas el permiso storage.objects.getIamPolicy, que no se incluye en el rol de Usuario de objetos de almacenamiento (roles/storage.objectUser). Para obtener este permiso, pídele a tu administrador que te otorgue el rol Administrador de objetos de almacenamiento (roles/storage.objectAdmin) en el proyecto.
- Si planeas cambiar el nombre de los objetos no actuales que tienen LCA o restablecerlos, también necesitas el permiso storage.objects.setIamPolicy, que no se incluye en el rol de Usuario de objetos de almacenamiento (roles/storage.objectUser). Para obtener este permiso, pídele a tu administrador que te otorgue el rol Administrador de objetos de almacenamiento (roles/storage.objectAdmin) en el proyecto.

Enumera las versiones no actuales de los objetos

Para enumerar las versiones publicadas y no actuales de objetos y ver sus números de generation, haz lo siguiente:

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene el objeto deseado.

Se abrirá la página Detalles del bucket y se seleccionará la pestaña Objetos.
Para ver los objetos no actuales, haz clic en el menú desplegable Mostrar y selecciona Objetos activos y no actuales.
En la lista de objetos, haz clic en el nombre del objeto cuyas versiones deseas ver.

Se abrirá la página Detalles del objeto y se seleccionará la pestaña Live Object.
Haz clic en la pestaña Historial de versiones para ver todas las versiones del objeto.

Línea de comandos

Usa el comando gcloud storage ls --all-versions:

gcloud storage ls --all-versions gs://BUCKET_NAME

En el ejemplo anterior, BUCKET_NAME es el nombre del bucket que contiene los objetos. Por ejemplo, my-bucket

La respuesta se ve como el siguiente ejemplo:

gs://BUCKET_NAME/OBJECT_NAME1#GENERATION_NUMBER1
gs://BUCKET_NAME/OBJECT_NAME2#GENERATION_NUMBER2
gs://BUCKET_NAME/OBJECT_NAME3#GENERATION_NUMBER3
...

Bibliotecas cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name) {
  for (auto&& object_metadata :
       client.ListObjects(bucket_name, gcs::Versions{true})) {
    if (!object_metadata) throw std::move(object_metadata).status();

    std::cout << "bucket_name=" << object_metadata->bucket()
              << ", object_name=" << object_metadata->name()
              << ", generation=" << object_metadata->generation() << "\n";
  }
}

C#

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


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

public class ListFileArchivedGenerationSample
{
	public IEnumerable<Google.Apis.Storage.v1.Data.Object> ListFileArchivedGeneration(string bucketName = "your-bucket-name")
	{
		var storage = StorageClient.Create();

		var storageObjects = storage.ListObjects(bucketName, options: new ListObjectsOptions
		{
			Versions = true
		});

		foreach (var storageObject in storageObjects)
		{
			Console.WriteLine($"Filename: {storageObject.Name}, Generation: {storageObject.Generation}");
		}

		return storageObjects;
	}
}

Go

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

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
	"google.golang.org/api/iterator"
)

// listFilesAllVersion lists both live and noncurrent versions of objects within specified bucket.
func listFilesAllVersion(w io.Writer, bucket string) error {
	// bucket := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	it := client.Bucket(bucket).Objects(ctx, &storage.Query{
		// Versions true to output all generations of objects
		Versions: true,
	})
	for {
		attrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Bucket(%q).Objects(): %w", bucket, err)
		}
		fmt.Fprintln(w, attrs.Name, attrs.Generation, attrs.Metageneration)
	}
	return nil
}

Java

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

import com.google.api.gax.paging.Page;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ListObjectsWithOldVersions {
  public static void listObjectsWithOldVersions(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";
    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    Page<Blob> blobs = bucket.list(Storage.BlobListOption.versions(true));

    for (Blob blob : blobs.iterateAll()) {
      System.out.println(blob.getName() + "," + blob.getGeneration());
    }
  }
}

Node.js

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

/**
 * 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 listFilesWithOldVersions() {
  const [files] = await storage.bucket(bucketName).getFiles({
    versions: true,
  });

  console.log('Files:');
  files.forEach(file => {
    console.log(file.name, file.generation);
  });
}

listFilesWithOldVersions().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * List objects in a specified bucket with all archived generations.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function list_file_archived_generations(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $objects = $bucket->objects([
        'versions' => true,
    ]);

    foreach ($objects as $object) {
        print($object->name() . ',' . $object->info()['generation'] . PHP_EOL);
    }
}

Python

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

from google.cloud import storage


def list_file_archived_generations(bucket_name):
    """Lists all the blobs in the bucket with generation."""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()

    blobs = storage_client.list_blobs(bucket_name, versions=True)

    for blob in blobs:
        print(f"{blob.name},{blob.generation}")

Ruby

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

def list_file_archived_generations 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.files.each do |file|
    puts "#{file.name},#{file.generation}"
  end
end

API de REST

API de JSON

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de JSON con una solicitud de Objects: list:
```
curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o?versions=true"
```
En el ejemplo anterior, BUCKET_NAME es el nombre del bucket que contiene los objetos. Por ejemplo, my-bucket

Las versiones no actuales de objetos tienen una propiedad timeDeleted.

API de XML

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de XML con una solicitud de bucket GET y el parámetro de string de consulta versions
```
curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME?versions&list-type=2"
```
En el ejemplo anterior, BUCKET_NAME es el nombre del bucket que contiene los objetos. Por ejemplo, my-bucket

Hay algunas diferencias en los resultados de la solicitud GET cuando se usa el parámetro de consulta versions. En particular, Cloud Storage muestra la siguiente información cuando incluyes un parámetro de consulta versions en la solicitud:

Un elemento Version que contiene información sobre cada objeto.
Un elemento DeletedTime que contiene la hora en la que la versión del objeto pasó a ser no actual (se borró o se reemplazó).
Un elemento IsLatest que indica si el objeto específico es la versión más reciente.
Se muestra un elemento NextGenerationMarker si la lista de objetos es parcial, lo que ocurre cuando tienes muchas versiones de objetos en un bucket. Usa el valor de este elemento en el parámetro de consulta generationmarker de las solicitudes posteriores para reanudar desde el último punto. El parámetro de consulta generationmarker se usa de la misma manera que el marker se usa para navegar por una lista de un depósito sin control de versiones.

Accede a las versiones no actuales de los objetos

Para usar la versión no actual de un objeto cuando realizas tareas como descargar el objeto, ver sus metadatos o actualizar sus metadatos, haz lo siguiente:

Console

El acceso general a una versión no actual no está disponible en la consola de Google Cloud. Con la consola de Google Cloud, solo puedes mover, copiar, restore o borrar una versión no actual. Estas acciones se realizan desde la lista del historial de versiones de un objeto.

Línea de comandos

Agrega el número de generación de la versión no actual al nombre del objeto:
```
OBJECT_NAME#GENERATION_NUMBER
```
Donde:
- OBJECT_NAME es el nombre de la versión no actual. Por ejemplo, pets/dog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual. Por ejemplo, 1560468815691234
Con la cadena del paso anterior, procede como lo harías con la versión publicada del objeto. Por ejemplo, para ver los metadatos de una versión de objeto no actual, usa el comando gcloud storage objects describe:
```
gcloud storage objects describe gs://my-bucket/pets/dog.png#1560468815691234
```

API de REST

API de JSON

Agrega el número de generación de la versión no actual al URI del objeto:
```
https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME?generation=GENERATION_NUMBER
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual. Por ejemplo, 1560468815691234
Con el URI del paso anterior, procede como lo harías con la versión publicada del objeto. Por ejemplo, para ver los metadatos de una versión no actual de objeto, usa cURL para llamar a la API de JSON con una solicitud Objects: get:
```
curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/my-bucket/o/pets/dog.png?generation=1560468815691234"
```

API de XML

Agrega el número de generación de la versión no actual al URI del objeto:
```
https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME?generation=GENERATION_NUMBER
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual. Por ejemplo, 1560468815691234
Con el URI del paso anterior, procede como lo harías con la versión publicada del objeto. Por ejemplo, para ver los metadatos de una versión de objeto no actual, usa cURL para llamar a la API de XML con una solicitud HEAD Object:
```
curl -I GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/my-bucket/pets/dog.png?generation=1560468815691234"
```

Restablece las versiones no actuales de los objetos

En Cloud Storage, restablecer una versión de objeto no actual significa hacer una copia de ella. Cuando lo haces, la copia se convierte en la versión publicada, lo que restablece la versión de forma eficaz. Si ya hay una versión publicada y el bucket tiene habilitado el control de versiones de objetos, restablecer la versión no actual hace que la versión publicada preexistente se vuelva no actual.

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene el objeto deseado.

Se abrirá la página Detalles del bucket y se seleccionará la pestaña Objetos.
Para ver los objetos no actuales, haz clic en el menú desplegable Mostrar y selecciona Objetos activos y no actuales.
En la lista de objetos, haz clic en el nombre de la versión del objeto que deseas restablecer.

Se abrirá la página Detalles del objeto y se seleccionará la pestaña Live Object.
Haz clic en la pestaña Historial de versiones.
Haz clic en el botón Restablecer de la versión que desees.

Se abrirá el panel para restablecer versiones de objetos.
Haz clic en Confirmar.

Línea de comandos

Usa el comando gcloud storage cp:

gcloud storage cp gs://BUCKET_NAME/OBJECT_NAME#GENERATION_NUMBER gs://BUCKET_NAME/OBJECT_NAME

Donde:

BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas restablecer. Por ejemplo, my-bucket
OBJECT_NAME es el nombre de la versión no actual que deseas restablecer. Por ejemplo, pets/dog.png.
GENERATION_NUMBER es el número de generación de la versión no actual que deseas restablecer. Por ejemplo, 1560468815691234.

Si se ejecuta de forma correcta, la respuesta se parece al siguiente ejemplo:

Operation completed over 1 objects/58.8 KiB.

Bibliotecas cliente

C++

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

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& source_bucket_name,
   std::string const& source_object_name,
   std::string const& destination_bucket_name,
   std::string const& destination_object_name,
   std::int64_t source_object_generation) {
  StatusOr<gcs::ObjectMetadata> copy =
      client.CopyObject(source_bucket_name, source_object_name,
                        destination_bucket_name, destination_object_name,
                        gcs::SourceGeneration{source_object_generation});
  if (!copy) throw std::move(copy).status();

  std::cout << "Successfully copied " << source_object_name << " generation "
            << source_object_generation << " in bucket " << source_bucket_name
            << " to bucket " << copy->bucket() << " with name "
            << copy->name()
            << ".\nThe full metadata after the copy is: " << *copy << "\n";
}

C#

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


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

public class CopyFileArchivedGenerationSample
{
    public Google.Apis.Storage.v1.Data.Object CopyFileArchivedGeneration(
        string sourceBucketName = "source-bucket-name",
        string sourceObjectName = "source-file",
        string destBucketName = "destination-bucket-name",
        string destObjectName = "destination-file-name",
        long? generation = 1579287380533984)
    {
        var storage = StorageClient.Create();
        var copyOptions = new CopyObjectOptions
        {
            SourceGeneration = generation
        };

        var copiedFile = storage.CopyObject(sourceBucketName, sourceObjectName,
            destBucketName, destObjectName, copyOptions);

        Console.WriteLine($"Generation {generation} of the object {sourceBucketName}/{sourceObjectName} " +
            $"was copied to to {destBucketName}/{destObjectName}.");

        return copiedFile;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"
	"time"

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

// copyOldVersionOfObject copies a noncurrent version of an object.
func copyOldVersionOfObject(w io.Writer, bucket, srcObject, dstObject string, gen int64) error {
	// bucket := "bucket-name"
	// srcObject := "source-object-name"
	// dstObject := "destination-object-name"

	// gen is the generation of srcObject to copy.
	// gen := 1587012235914578
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	src := client.Bucket(bucket).Object(srcObject)
	dst := client.Bucket(bucket).Object(dstObject)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to copy is aborted if the
	// object's generation number does not match your precondition.
	// For a dst object that does not yet exist, set the DoesNotExist precondition.
	dst = dst.If(storage.Conditions{DoesNotExist: true})
	// If the destination object already exists in your bucket, set instead a
	// generation-match precondition using its generation number.
	// attrs, err := dst.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %w", err)
	// }
	// dst = dst.If(storage.Conditions{GenerationMatch: attrs.Generation})

	if _, err := dst.CopierFrom(src.Generation(gen)).Run(ctx); err != nil {
		return fmt.Errorf("Object(%q).CopierFrom(%q).Generation(%v).Run: %w", dstObject, srcObject, gen, err)
	}
	fmt.Fprintf(w, "Generation %v of object %v in bucket %v was copied to %v\n", gen, srcObject, bucket, dstObject)
	return nil
}

Java

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

import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class CopyOldVersionOfObject {
  public static void copyOldVersionOfObject(
      String projectId,
      String bucketName,
      String objectToCopy,
      long generationToCopy,
      String newObjectName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of the GCS object to copy an old version of
    // String objectToCopy = "your-object-name";

    // The generation of objectToCopy to copy
    // long generationToCopy = 1579287380533984;

    // What to name the new object with the old data from objectToCopy
    // String newObjectName = "your-new-object";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // Optional: set a generation-match precondition to avoid potential race
    // conditions and data corruptions. The request returns a 412 error if the
    // preconditions are not met.
    Storage.BlobTargetOption precondition;
    if (storage.get(bucketName, newObjectName) == null) {
      // For a target object that does not yet exist, set the DoesNotExist precondition.
      // This will cause the request to fail if the object is created before the request runs.
      precondition = Storage.BlobTargetOption.doesNotExist();
    } else {
      // If the destination already exists in your bucket, instead set a generation-match
      // precondition. This will cause the request to fail if the existing object's generation
      // changes before the request runs.
      precondition =
          Storage.BlobTargetOption.generationMatch(
              storage.get(bucketName, newObjectName).getGeneration());
    }

    Storage.CopyRequest copyRequest =
        Storage.CopyRequest.newBuilder()
            .setSource(BlobId.of(bucketName, objectToCopy, generationToCopy))
            .setTarget(BlobId.of(bucketName, newObjectName), precondition)
            .build();
    storage.copy(copyRequest);

    System.out.println(
        "Generation "
            + generationToCopy
            + " of object "
            + objectToCopy
            + " in bucket "
            + bucketName
            + " was copied to "
            + newObjectName);
  }
}

Node.js

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

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

// The ID of the GCS file to copy an old version of
// const srcFilename = "your-file-name";

// The generation of fileToCopy to copy
// const generation = 1579287380533984;

// The ID of the bucket to copy the file to
// const destBucketName = 'target-file-bucket';

// What to name the new file with the old data from srcFilename
// const destFileName = "your-new-file";

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

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

async function copyOldVersionOfFile() {
  // Copies the file to the other bucket

  // Optional:
  // Set a generation-match precondition to avoid potential race conditions
  // and data corruptions. The request to copy is aborted if the object's
  // generation number does not match your precondition. For a destination
  // object that does not yet exist, set the ifGenerationMatch precondition to 0
  // If the destination object already exists in your bucket, set instead a
  // generation-match precondition using its generation number.
  const copyOptions = {
    preconditionOpts: {
      ifGenerationMatch: destinationGenerationMatchPrecondition,
    },
  };

  await storage
    .bucket(srcBucketName)
    .file(srcFilename, {
      generation,
    })
    .copy(storage.bucket(destBucketName).file(destFileName), copyOptions);

  console.log(
    `Generation ${generation} of file ${srcFilename} in bucket ${srcBucketName} was copied to ${destFileName} in bucket ${destBucketName}`
  );
}

copyOldVersionOfFile().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Copy archived generation of a given object to a new object.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectToCopy The name of the object to copy.
 *        (e.g. 'my-object')
 * @param string $generationToCopy The generation of the object to copy.
 *        (e.g. 1579287380533984)
 * @param string $newObjectName The name of the target object.
 *        (e.g. 'my-object-1579287380533984')
 */
function copy_file_archived_generation(string $bucketName, string $objectToCopy, string $generationToCopy, string $newObjectName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $object = $bucket->object($objectToCopy, [
        'generation' => $generationToCopy,
    ]);

    $object->copy($bucket, [
        'name' => $newObjectName,
    ]);

    printf(
        'Generation %s of object %s in bucket %s was copied to %s',
        $generationToCopy,
        $objectToCopy,
        $bucketName,
        $newObjectName
    );
}

Python

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

from google.cloud import storage


def copy_file_archived_generation(
        bucket_name, blob_name, destination_bucket_name, destination_blob_name, generation
):
    """Copies a blob from one bucket to another with a new name with the same generation."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # destination_bucket_name = "destination-bucket-name"
    # destination_blob_name = "destination-object-name"
    # generation = 1579287380533984

    storage_client = storage.Client()

    source_bucket = storage_client.bucket(bucket_name)
    source_blob = source_bucket.blob(blob_name)
    destination_bucket = storage_client.bucket(destination_bucket_name)

    # Optional: set a generation-match precondition to avoid potential race conditions
    # and data corruptions. The request to copy is aborted if the object's
    # generation number does not match your precondition. For a destination
    # object that does not yet exist, set the if_generation_match precondition to 0.
    # If the destination object already exists in your bucket, set instead a
    # generation-match precondition using its generation number.
    destination_generation_match_precondition = 0

    # source_generation selects a specific revision of the source object, as opposed to the latest version.
    blob_copy = source_bucket.copy_blob(
        source_blob, destination_bucket, destination_blob_name, source_generation=generation, if_generation_match=destination_generation_match_precondition
    )

    print(
        "Generation {} of the blob {} in bucket {} copied to blob {} in bucket {}.".format(
            generation,
            source_blob.name,
            source_bucket.name,
            blob_copy.name,
            destination_bucket.name,
        )
    )

Ruby

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

def copy_file_archived_generation source_bucket_name:,
                                  source_file_name:,
                                  generation:,
                                  destination_bucket_name:,
                                  destination_file_name:
  # The ID of the bucket the original object is in
  # source_bucket_name = "source-bucket-name"

  # The ID of the GCS object to copy
  # source_file_name = "source-file-name"

  # The generation of your GCS object to copy
  # generation = 1579287380533984

  # The ID of the bucket to copy the object to
  # destination_bucket_name = "destination-bucket-name"

  # The ID of the new GCS object
  # destination_file_name = "destination-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  source_bucket = storage.bucket source_bucket_name, skip_lookup: true
  source_file = source_bucket.file source_file_name
  destination_bucket = storage.bucket destination_bucket_name, skip_lookup: true

  destination_file = source_file.copy destination_bucket, destination_file_name, generation: generation

  puts "Generation #{generation} of the file #{source_file.name} in bucket #{source_bucket.name} copied to file " \
       "#{destination_file.name} in bucket #{destination_bucket.name}"
end

API de REST

API de JSON

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de JSON con una solicitud de objeto POST:
```
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Length: 0" \
  "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME/rewriteTo/b/BUCKET_NAME/o/OBJECT_NAME?sourceGeneration=GENERATION_NUMBER"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas restablecer. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual que deseas restablecer. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual que deseas restablecer. Por ejemplo, 1560468815691234.

API de XML

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de XML con una solicitud de objeto PUT:
```
curl -X PUT \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "x-goog-copy-source: BUCKET_NAME/OBJECT_NAME" \
  -H "x-goog-copy-source-generation:GENERATION_NUMBER" \
  "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas restablecer. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual que deseas restablecer. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual que deseas restablecer. Por ejemplo, 1560468815691234.

Después de restablecer la versión del objeto, la versión no actual original sigue existiendo en el bucket. Si ya no necesitas la versión no actual, puedes borrarla con posterioridad o configurar la Administración del ciclo de vida de los objetos para quitarla cuando cumpla con las condiciones que especifiques.

Borra las versiones no actuales de los objetos

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de buckets, haz clic en el nombre del bucket que contiene el objeto deseado.

Se abrirá la página Detalles del bucket y se seleccionará la pestaña Objetos.
Para ver los objetos no actuales, haz clic en el menú desplegable Mostrar y selecciona Objetos activos y no actuales.
Navega hasta el objeto, que puede estar en una carpeta.
En la lista de objetos, haz clic en el nombre del objeto cuya versión deseas borrar.

Se abrirá la página Detalles del objeto y se seleccionará la pestaña Live Object.
Haz clic en la pestaña Historial de versiones.
Selecciona la casilla de verificación de la versión que desees.
Haz clic en el botón Borrar.

Se abrirá el panel para borrar versiones.
Para confirmar que deseas borrar el objeto, escribe delete en el campo de texto.
Haz clic en Borrar.

Línea de comandos

Usa el comando gcloud storage rm:

gcloud storage rm gs://BUCKET_NAME/OBJECT_NAME#GENERATION_NUMBER

Donde:

BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas borrar. Por ejemplo, my-bucket.
OBJECT_NAME es el nombre de la versión no actual que deseas borrar. Por ejemplo, pets/dog.png.
GENERATION_NUMBER es el número de generación de la versión no actual que deseas borrar. Por ejemplo, 1560468815691234.

Si se ejecuta de forma correcta, la respuesta se parece al siguiente ejemplo:

Operation completed over 1 objects.

Bibliotecas cliente

C++

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

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, std::int64_t object_generation) {
  google::cloud::Status status = client.DeleteObject(
      bucket_name, object_name, gcs::Generation{object_generation});
  if (!status.ok()) throw std::runtime_error(status.message());

  std::cout << "Deleted " << object_name << " generation "
            << object_generation << " in bucket " << bucket_name << "\n";
}

C#

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


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

public class DeleteFileArchivedGenerationSample
{
    public void DeleteFileArchivedGeneration(
        string bucketName = "your-bucket-name",
        string objectName = "your-object-name",
        long? generation = 1579287380533984)
    {
        var storage = StorageClient.Create();

        storage.DeleteObject(bucketName, objectName, new DeleteObjectOptions
        {
            Generation = generation
        });

        Console.WriteLine($"Generation ${generation} of file {objectName} was deleted from bucket {bucketName}.");
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"
	"time"

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

// deleteOldVersionOfObject deletes a noncurrent version of an object.
func deleteOldVersionOfObject(w io.Writer, bucketName, objectName string, gen int64) error {
	// bucketName := "bucket-name"
	// objectName := "object-name"

	// gen is the generation of objectName to delete.
	// gen := 1587012235914578
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

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

	obj := client.Bucket(bucketName).Object(objectName)
	if err := obj.Generation(gen).Delete(ctx); err != nil {
		return fmt.Errorf("Bucket(%q).Object(%q).Generation(%v).Delete: %w", bucketName, objectName, gen, err)
	}
	fmt.Fprintf(w, "Generation %v of object %v was deleted from %v\n", gen, objectName, bucketName)
	return nil
}

Java

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

import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class DeleteOldVersionOfObject {
  public static void deleteOldVersionOfObject(
      String projectId, String bucketName, String objectName, long generationToDelete) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The generation of objectName to delete
    // long generationToDelete = 1579287380533984;

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    storage.delete(BlobId.of(bucketName, objectName, generationToDelete));

    System.out.println(
        "Generation "
            + generationToDelete
            + " of object "
            + objectName
            + " was deleted from "
            + bucketName);
  }
}

Node.js

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

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

// The generation of fileName to delete
// const generation = 1579287380533984;

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

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

async function deleteOldVersionOfFile() {
  // Deletes the file from the bucket with given version
  await storage
    .bucket(bucketName)
    .file(fileName, {
      generation,
    })
    .delete();

  console.log(
    `Generation ${generation} of file ${fileName} was deleted from ${bucketName}`
  );
}

deleteOldVersionOfFile().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an archived generation of the given object.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $generationToDelete the generation of the object to delete.
 *        (e.g. 1579287380533984)
 */
function delete_file_archived_generation(string $bucketName, string $objectName, string $generationToDelete): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $object = $bucket->object($objectName, [
        'generation' => $generationToDelete,
    ]);

    $object->delete();

    printf(
        'Generation %s of object %s was deleted from %s',
        $generationToDelete,
        $objectName,
        $bucketName
    );
}

Python

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

from google.cloud import storage


def delete_file_archived_generation(bucket_name, blob_name, generation):
    """Delete a blob in the bucket with the given generation."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # generation = 1579287380533984

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.delete_blob(blob_name, generation=generation)
    print(
        f"Generation {generation} of blob {blob_name} was deleted from {bucket_name}"
    )

Ruby

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

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

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

  # The generation of the file to delete
  # generation = 1579287380533984

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name, skip_lookup: true

  file = bucket.file file_name

  file.delete generation: generation

  puts "Generation #{generation} of file #{file_name} was deleted from #{bucket_name}"
end

API de REST

API de JSON

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de JSON con una solicitud de objeto DELETE:
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME?generation=GENERATION_NUMBER"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas borrar. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual que deseas borrar. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual que deseas borrar. Por ejemplo, 1560468815691234.

API de XML

Tener la gcloud CLI instalada e inicializada a fin de generar un token de acceso para el encabezado Authorization.

Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.
Usa cURL para llamar a la API de XML con una solicitud de objeto DELETE:
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME?generation=GENERATION_NUMBER"
```
Donde:
- BUCKET_NAME es el nombre del bucket que contiene la versión no actual que deseas borrar. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre codificado en URL de la versión no actual que deseas borrar. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.
- GENERATION_NUMBER es el número de generación de la versión no actual que deseas borrar. Por ejemplo, 1560468815691234.

¿Qué sigue?

Obtén más información sobre el control de versiones de objetos, incluido un ejemplo detallado.
Habilita o inhabilita el control de versiones de objetos en un bucket.
Aprende a usar la Administración del ciclo de vida de los objetos para administrar sus versiones de forma automática.