Cambia clases de almacenamiento de objetos

En esta página, se describe cómo cambiar la clase de almacenamiento de los objetos dentro de un bucket mediante la reescritura del objeto. Para aprender a cambiar las clases de almacenamiento de objetos sin reescribir un objeto, consulta la función Administración del ciclo de vida de los objetos.

Console

Las clases de almacenamiento de objetos individuales no se pueden configurar a través de Console. En su lugar, usa gsutil.

gsutil

Usa la marca -s en un comando rewrite. Por ejemplo:

gsutil rewrite -s STORAGE_CLASS gs://PATH_TO_OBJECT

Aquí:

• STORAGE_CLASS es la clase de almacenamiento nueva del objeto. Por ejemplo, nearline.
• PATH_TO_OBJECT es el nombre del objeto al que le quieres cambiar la clase. 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++.

Ver en GitHub Comentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name, std::string const& storage_class) {
  StatusOr<gcs::ObjectMetadata> object_metadata =
      client.RewriteObjectBlocking(
          bucket_name, object_name, bucket_name, object_name,
          gcs::WithObjectMetadata(
              gcs::ObjectMetadata().set_storage_class(storage_class)));

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

  std::cout << "Changed storage class of object " << object_metadata->name()
            << " in bucket " << object_metadata->bucket() << " to "
            << object_metadata->storage_class() << "\n";
}

Go

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

Ver en GitHub Comentarios

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

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

// changeObjectStorageClass changes the storage class of a single object.
func changeObjectStorageClass(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

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

	bkt := client.Bucket(bucket)
	obj := bkt.Object(object)
	// See the StorageClass documentation for other valid storage classes:
	// https://cloud.google.com/storage/docs/storage-classes
	newStorageClass := "COLDLINE"
	// You can't change an object's storage class directly, the only way is
	// to rewrite the object with the desired storage class.
	copier := obj.CopierFrom(obj)
	copier.StorageClass = newStorageClass
	if _, err := copier.Run(ctx); err != nil {
		return fmt.Errorf("copier.Run: %v", err)
	}
	fmt.Fprintf(w, "Object %v in bucket %v had its storage class set to %v\n", object, bucket, newStorageClass)
	return nil
}

Java

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

Ver en GitHub Comentarios

import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class ChangeObjectStorageClass {
  public static void changeObjectStorageClass(
      String projectId, String bucketName, String objectName) {
    // 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";

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

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // You can't change an object's storage class directly, the only way is to rewrite the object
    // with the
    // desired storage class
    Storage.CopyRequest request =
        Storage.CopyRequest.newBuilder()
            .setSource(blobId)
            .setTarget(BlobInfo.newBuilder(blobId).setStorageClass(storageClass).build())
            .build();
    Blob updatedBlob = storage.copy(request).getResult();

    System.out.println(
        "Object "
            + objectName
            + " in bucket "
            + bucketName
            + " had its storage class set to "
            + updatedBlob.getStorageClass().name());
  }
}

Node.js

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

Ver en GitHub Comentarios

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

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

/**
 * 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 name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

async function fileChangeStorageClass() {
  await storage
    .bucket(bucketName)
    .file(fileName)
    .setStorageClass(storageClass);

  console.log(`${fileName} has been set to ${storageClass}`);
}

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

Ver en GitHub Comentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Change the storage class of the given file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $storageClass The storage class of the new object.
 */
function change_file_storage_class($bucketName, $objectName, $storageClass)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $storageClass = 'COLDLINE';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);

    // Storage class cannot be changed directly. But we can rewrite the object
    // using the new storage class.

    $newObject = $object->rewrite($bucket, [
        'storageClass' => $storageClass,
    ]);

    printf(
        'Object %s in bucket %s had its storage class set to %s',
        $objectName,
        $bucketName,
        $newObject->info()['storageClass']
    );
}

Python

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

Ver en GitHub Comentarios

from google.cloud import storage

def change_file_storage_class(bucket_name, blob_name):
    """Change the default storage class of the blob"""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    blob = bucket.get_blob(blob_name)
    blob.update_storage_class("NEARLINE")

    print(
        "Blob {} in bucket {} had its storage class set to {}".format(
            blob_name,
            bucket_name,
            blob.storage_class
        )
    )
    return blob

Ruby

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

Ver en GitHub Comentarios

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

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

  require "google/cloud/storage"

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

  file = bucket.file file_name

  file.storage_class = "NEARLINE"

  puts "File #{file_name} in bucket #{bucket_name} had its storage class set to #{file.storage_class}"
end

API de REST

API de JSON

Precaución: Las LCA del objeto original que deseas conservar deben incluirse en el recurso de objeto que proporcionas en el cuerpo de la solicitud.

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Crea un archivo .json que contenga la siguiente información:

   {
     "storageClass": "STORAGE_CLASS"
   }

   Aquí:

   • STORAGE_CLASS es la clase de almacenamiento nueva del objeto. Por ejemplo, nearline.

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

   curl -X POST --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/rewriteTo/b/BUCKET_NAME/o/OBJECT_NAME"

   En el ejemplo anterior, se ilustra lo siguiente:

   • JSON_FILE_NAME es el nombre del archivo JSON 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 bucket que contiene el objeto original. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto. Un ejemplo es pets/dog.png.

API de XML

Precaución: Los metadatos del objeto original que deseas conservar, como los metadatos personalizados, deben incluirse en los encabezados que proporciones en la solicitud. Además, todas las LCA del objeto que difieran de las LCA del objeto predeterminado del depósito que las contiene deben volver a aplicarse después de que se suba el objeto.

1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.

2. Usa cURL para llamar a la API de XML con una solicitud de objeto PUT:

   curl -X PUT --data-binary @OBJECT \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: OBJECT_CONTENT_TYPE" \
     -H "x-goog-storage-class: STORAGE_CLASS" \
     "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

   En el ejemplo anterior, se ilustra lo siguiente:

   • OBJECT es la ruta de acceso local al objeto del que quieres cambiar la clase de almacenamiento (debes volver a subir el objeto cuando cambies la clase de almacenamiento con la API de XML). Por ejemplo, Desktop/dog.png.
   • OAUTH2_TOKEN es el token de acceso que generaste en el paso 1.
   • OBJECT_CONTENT_TYPE es el tipo de contenido del objeto. Por ejemplo, image/png.
   • STORAGE_CLASS es la clase de almacenamiento nueva del objeto. Por ejemplo, nearline.
   • BUCKET_NAME es el nombre del bucket que contiene el objeto que reescribes. Por ejemplo, my-bucket.
   • OBJECT_NAME es el nombre del objeto que reescribes. Por ejemplo, pets/dog.png.

Nota:: En esta guía, se explica cómo volver a escribir datos, que es una operación de clase A y que se pueden generar cargos de recuperación y eliminación temprana si los datos se almacenaron originalmente como Nearline Storage, Coldline Storage o Archive Storage. Además, ten en cuenta que si habilitaste el Control de versiones de objetos en tu bucket, el objeto original permanecerá en él hasta que se borre de forma explícita.

¿Qué sigue?

• Obtén información sobre las clases de almacenamiento disponibles.
• Cambia las clases de almacenamiento de los objetos con la administración del ciclo de vida de los objetos.
• Obtén información sobre los metadatos de los objetos.