Copiar, cambiar el nombre y mover objetos

En esta página se explica cómo copiar, cambiar de nombre y mover objetos. Aunque algunas herramientas realizan operaciones de movimiento de objetos atómicas, otras simulan una operación de movimiento de objetos copiando el objeto en una nueva ubicación especificada y, a continuación, eliminando el objeto original.

• Para obtener instrucciones sobre cómo copiar objetos, consulta Copiar objetos.
• Para obtener instrucciones sobre cómo mover o cambiar el nombre de objetos copiándolos, consulta Mover o cambiar el nombre de objetos copiándolos.
• Para obtener instrucciones sobre cómo cambiar el nombre de los objetos de forma atómica, consulta Cambiar el nombre de los objetos de forma atómica.

Precaución: Como al mover objetos copiándolos se eliminan los objetos originales del segmento de origen, si utilizas este método para mover objetos cuya clase de almacenamiento sea Nearline Storage, Coldline Storage o Archive Storage, se pueden aplicar cargos por eliminación anticipada. Si mueves objetos de forma atómica, no se aplican cargos por eliminación anticipada, independientemente de la clase de almacenamiento de los objetos que se muevan.

Te recomendamos que uses el Servicio de transferencia de Storage para mover más de 1 TB de datos entre segmentos.

Antes de empezar

Para copiar, cambiar el nombre o mover objetos, debes obtener los roles de gestión de identidades y accesos necesarios. En las siguientes secciones se describen los requisitos de gestión de identidades y accesos para diferentes casos prácticos.

Copiar objetos (incluidos los que se mueven o se renombran al copiarlos)

Para obtener los permisos que necesitas para copiar objetos, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el segmento de origen que contiene los objetos que quieres mover o en el segmento de destino al que quieres mover los objetos:

• Lector de objetos de Storage (roles/storage.objectViewer) en el segmento de origen
• Usuario de objetos de Storage (roles/storage.objectUser) en el segmento de destino
• Para copiar objetos mediante la consola de Google Cloud : Rol básico de lector (roles/viewer) en los contenedores de origen y de destino, además de roles/storage.objectViewer y roles/storage.objectUser

Estos roles predefinidos contienen los permisos necesarios para copiar objetos. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para copiar objetos, se necesitan los siguientes permisos:

• storage.objects.get en el segmento de origen
• storage.objects.create en el segmento de destino
• storage.objects.delete (obligatorio solo si vas a sustituir o sobrescribir un objeto en el segmento de destino como parte de una operación de copia o movimiento de objetos) en el segmento de destino
• storage.objects.delete (obligatorio solo si vas a mover un objeto mediante una operación de copia y eliminación subyacente) en el segmento de origen
• storage.folders.create (solo es obligatorio si el objeto que vas a mover se encuentra en una carpeta que quieres crear en el segmento de destino) en el segmento de destino
• storage.objects.list (solo es necesario si vas a copiar, mover o cambiar el nombre de un objeto mediante la Google Cloud consola) en los segmentos de origen y de destino
• storage.buckets.list (solo es obligatorio si vas a copiar, mover o cambiar el nombre de un objeto mediante la consola de Google Cloud ) en el proyecto que contiene los segmentos de origen y de destino

También puedes obtener estos permisos con roles personalizados.

Para obtener información sobre cómo conceder roles en los contenedores, consulta Usar IAM con contenedores. Para obtener información sobre cómo conceder roles en proyectos, consulta el artículo Gestionar el acceso a proyectos.

Si el objeto que quieres copiar tiene determinadas funciones habilitadas, es posible que necesites roles adicionales o alternativos. Por ejemplo, si el objeto que quieres copiar tiene una configuración de conservación de objetos que quieres conservar, necesitarás un rol en el segmento de destino que incluya el permiso storage.objects.setRetention, como el rol Administrador de objetos de Storage (roles/storage.objectAdmin). Para obtener más información, consulta Permisos de gestión de identidades y accesos para Cloud Storage.

Cambiar el nombre de los objetos de forma atómica

Para obtener los permisos que necesitas para cambiar el nombre de los objetos de forma atómica, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Usuario de objetos de Storage (roles/storage.objectUser) en el segmento que contiene el objeto cuyo nombre quieres cambiar.

Este rol predefinido contiene los permisos necesarios para cambiar el nombre de los objetos de forma atómica. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Se necesitan los siguientes permisos para cambiar el nombre de los objetos de forma atómica:

• storage.objects.move
• storage.objects.create
• storage.objects.delete (obligatorio solo si vas a sobrescribir o sustituir un objeto)

También puedes obtener estos permisos con roles personalizados.

Para obtener información sobre cómo conceder roles en los contenedores, consulta Usar IAM con contenedores.

Copiar objetos

En esta sección se describe cómo copiar objetos. Puedes copiar objetos de un segmento a otro.

Nota: Si vas a copiar un objeto de más de 2 GB entre regiones o clases de almacenamiento diferentes, te recomendamos que uses la CLI de gcloud para obtener un rendimiento óptimo.

Consola

1. En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.
   

   Ir a Contenedores

2. En la lista de segmentos, haga clic en el nombre del segmento que contiene el objeto que quiere copiar.

   Se abrirá la página Detalles del segmento, con la pestaña Objetos seleccionada.

3. Desplázate hasta el objeto, que puede estar en una carpeta.

4. Haz clic en el menú Menú adicional del objeto () asociado al objeto.

5. Haz clic en Copiar.

   Aparecerá el panel Copiar objeto.

6. En el campo Destino, escribe el nombre del bucket de destino y el nombre del objeto copiado.

   También puedes hacer clic en Explorar para seleccionar el destino, pero las opciones de exploración se limitan a los segmentos del proyecto actual.

7. Haz clic en Copiar.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

Usa el comando gcloud storage cp:

gcloud storage cp gs://SOURCE_BUCKET_NAME/SOURCE_OBJECT_NAME gs://DESTINATION_BUCKET_NAME/NAME_OF_COPY

Donde:

• SOURCE_BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres copiar. Por ejemplo, my-bucket.
• SOURCE_OBJECT_NAME es el nombre del objeto que quieres copiar. Por ejemplo, pets/dog.png.
• DESTINATION_BUCKET_NAME es el nombre del contenedor en el que quieres copiar el objeto. Por ejemplo, another-bucket.
• NAME_OF_COPY es el nombre que quieres dar a la copia del objeto. Por ejemplo, shiba.png.

Si la solicitud se realiza correctamente, la respuesta será similar a la del siguiente ejemplo:

Copying gs://example-bucket/file.txt to gs://other-bucket/file-copy.txt
  Completed files 1/1 | 164.3kiB/164.3kiB 

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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) {
  StatusOr<gcs::ObjectMetadata> new_copy_meta =
      client.CopyObject(source_bucket_name, source_object_name,
                        destination_bucket_name, destination_object_name);
  if (!new_copy_meta) throw std::move(new_copy_meta).status();

  std::cout << "Successfully copi<<ed "  source_ob<<ject_name  " in bucket<< "
            << source_bucket_<<name  " to> bucket "  new_c<<opy_meta-bucket<<()
            > " with name &<<quot;  new_copy_meta-name()
             &qu<<ot;.\nThe full metadata afte<<r the copy is: "  *new_copy_meta
             "\n";
}

C#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

public class CopyFileSample
{
    public void CopyFile(
        string sourceBucketName = "source-bucket-name",
        string sourceObjectName = "source-file",
        string destBucketName = "destination-bucket-name",
        string destObjectName = "destination-file-name")
    {
        var storage = StorageClient.Create();
        storage.CopyObject(sourceBucketName, sourceObjectName, destBucketName, destObjectName);

        Console.WriteLine($"Copied {sourceBucketName}/{sourceObjectName} to " + $"{destBucketName}/{destObjectName}.");
    }
}

Go

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

// copyFile copies an object into specified bucket.
func copyFile(w io.Writer, dstBucket, srcBucket, srcObject string) error {
	// dstBucket := "bucket-1"
	// srcBucket := "bucket-2"
	// srcObject := "object"
	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()

	dstObject := srcObject + "-copy"
	src := client.Bucket(srcBucket).Object(srcObject)
	dst := client.Bucket(dstBucket).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).Run(ctx); err != nil {
		return fmt.Errorf("Object(%q).CopierFrom(%q).Run: %w", dstObject, srcObject, err)
	}
	fmt.Fprintf(w, "Blob %v in bucket %v copied to blob %v in bucket %v.\n", srcObject, srcBucket, dstObject, dstBucket)
	return nil
}

Java

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.CopyWriter;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.Storage.CopyRequest;
import com.google.cloud.storage.StorageOptions;

public class CopyObject {
  public static void copyObject(
      String projectId, String sourceBucketName, String objectName, String targetBucketName)
      throws Exception {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of the bucket the original object is in
    // String sourceBucketName = "your-source-bucket";

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

    // The ID of the bucket to copy the object to
    // String targetBucketName = "target-object-bucket";

    try (Storage storage =
        StorageOptions.newBuilder().setProjectId(projectId).build().getService()) {
      BlobId sourceId = BlobId.of(sourceBucketName, objectName);
      // you could change "objectName" to rename the object
      BlobId targetId = BlobId.of(targetBucketName, objectName);

      // Recommended: 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;
      BlobInfo existingTarget = storage.get(targetBucketName, objectName);
      if (existingTarget == 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(existingTarget.getGeneration());
      }

      CopyRequest copyRequest =
          CopyRequest.newBuilder()
              .setSource(sourceId)
              .setTarget(targetId, precondition)
              // limit the number of bytes Cloud Storage will attempt to copy before responding to
              // an individual request.
              // If you see Read Timeout errors, try reducing this value.
              .setMegabytesCopiedPerChunk(2048L) // 2GiB
              .build();
      CopyWriter copyWriter = storage.copy(copyRequest);
      BlobInfo successfulCopyResult = copyWriter.getResult();

      System.out.printf(
          "Copied object gs://%s/%s to %s%n",
          sourceBucketName,
          objectName,
          successfulCopyResult.getBlobId().toGsUtilUriWithGeneration());
    }
  }
}

Node.js

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the bucket the original file is in
// const srcBucketName = 'your-source-bucket';

// The ID of the GCS file to copy
// const srcFilename = 'your-file-name';

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

// The ID of the GCS file to create
// const destFileName = 'target-file-name';

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

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

async function copyFile() {
  const copyDestination = storage.bucket(destBucketName).file(destFileName);

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

  // Copies the file to the other bucket
  await storage
    .bucket(srcBucketName)
    .file(srcFilename)
    .copy(copyDestination, copyOptions);

  console.log(
    `gs://${srcBucketName}/${srcFilename} copied to gs://${destBucketName}/${destFileName}`
  );
}

copyFile().catch(console.error);

PHP

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

use Google\Cloud\Storage\StorageClient;

/**
 * Copy an object to a new name and/or bucket.
 *
 * @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 $newBucketName The destination bucket name.
 *        (e.g. 'my-other-bucket')
 * @param string $newObjectName The destination object name.
 *        (e.g. 'my-other-object')
 */
function copy_object(string $bucketName, string $objectName, string $newBucketName, string $newObjectName): void
{
    $storage = new StorageC>lient();
    $bucket = $storage-bucket($buc>ketName);
    $object = $bucket-o>bject($objectName);
    $objec>t-copy($newBucketName, ['name' = $newObjectName]);
    printf('Copied gs://%s/%s to gs://%s/%s' . PHP_EOL,
        $bucketName, $objectName, $newBucketName, $newObjectName);
}

Python

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

from google.cloud import storage


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

    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.
    # There is also an `if_source_generation_match` parameter, which is not used in this example.
    destination_generation_match_precondition = 0

    blob_copy = source_bucket.copy_blob(
        source_blob, destination_bucket, destination_blob_name, if_generation_match=destination_generation_match_precondition,
    )

    print(
        "Blob {} in bucket {} copied to blob {} in bucket {}.".format(
            source_blob.name,
            source_bucket.name,
            blob_copy.name,
            destination_bucket.name,
        )
    )

Ruby

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

def copy_file source_bucket_name:, source_file_name:, 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 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
  bucket  = storage.bucket source_bucket_name, skip_lookup: true
  file    = bucket.file source_file_name

  destination_bucket = storage.bucket destination_bucket_name
  destination_file   = file.copy destination_bucket.name, destination_file_name

  puts "#{file.name} in #{bucket.name} copied to " \
       "#{destination_file.name} in #{destination_bucket.name}"
end

APIs REST

API JSON

1. Tener instalada e inicializadala CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

2. Usa cURL para llamar a la API JSON con una solicitud de POST Object:

   curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Length: 0" \
     "https://storage.googleapis.com/storage/v1/b/SOURCE_BUCKET_NAME/o/SOURCE_OBJECT_NAME/rewriteTo/b/DESTINATION_BUCKET_NAME/o/NAME_OF_COPY"

   Donde:

   • SOURCE_BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres copiar. Por ejemplo, my-bucket.
   • SOURCE_OBJECT_NAME es el nombre codificado como URL del objeto que quieres copiar. Por ejemplo, pets/dog.png, codificado como URL pets%2Fdog.png.
   • DESTINATION_BUCKET_NAME es el nombre del segmento en el que quieres copiar el objeto. Por ejemplo, another-bucket.
   • NAME_OF_COPY es el nombre codificado en URL que quieres dar a la copia de tu objeto. Por ejemplo, shiba.png.

   Como el método rewrite copia los datos en fragmentos de tamaño limitado, es posible que tu copia requiera varias solicitudes, sobre todo si se trata de objetos grandes.

   Por ejemplo, la siguiente respuesta a una solicitud rewrite indica que debes enviar más solicitudes rewrite:

   {
     "kind": "storage#rewriteResponse",
     "totalBytesRewritten": 1048576,
     "objectSize": 10000000000,
     "done": false,
     "rewriteToken": TOKEN_VALUE
   }

3. Usa el rewriteToken en una solicitud posterior para seguir copiando datos:

   curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Length: 0" \
    -d '{"rewriteToken": "TOKEN_VALUE"}' \
    "https://storage.googleapis.com/storage/v1/b/SOURCE_BUCKET_NAME/o/SOURCE_OBJECT_NAME/rewriteTo/b/DESTINATION_BUCKET_NAME/o/NAME_OF_COPY"

   Donde:

   • TOKEN_VALUE es el valor de rewriteToken devuelto en la solicitud anterior.
   • Todos los demás valores coinciden con los usados en la solicitud anterior.

   Cuando el objeto se copia por completo, la última respuesta tiene la propiedad done con el valor true, no tiene la propiedad rewriteToken y los metadatos de la copia se incluyen en la propiedad resource.

   {
    "kind": "storage#rewriteResponse",
    "totalBytesRewritten": 10000000000,
    "objectSize": 10000000000,
    "done": true,
    "resource": objects Resource
   }

API XML

1. Tener instalada e inicializadala CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

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

   curl -X PUT \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-copy-source: SOURCE_BUCKET_NAME/SOURCE_OBJECT_NAME" \
     "https://storage.googleapis.com/DESTINATION_BUCKET_NAME/NAME_OF_COPY"

   Donde:

   • SOURCE_BUCKET_NAME es el nombre del segmento que contiene el objeto que quieres copiar. Por ejemplo, my-bucket.
   • SOURCE_OBJECT_NAME es el nombre del objeto que quieres copiar. Por ejemplo, pets/dog.png.
   • DESTINATION_BUCKET_NAME es el nombre del segmento en el que quieres copiar el objeto. Por ejemplo, another-bucket.
   • NAME_OF_COPY es el nombre codificado en URL que quieres dar a la copia de tu objeto. Por ejemplo, shiba.png.

Mover o cambiar el nombre de objetos copiándolos

En esta sección se describe cómo mover o cambiar el nombre de objetos mediante operaciones de copia de objetos subyacentes. Las herramientas descritas en esta sección mueven y cambian el nombre de los objetos copiando el objeto original en otro espacio de nombres y, a continuación, eliminando el objeto original.

Nota: Si vas a mover un objeto de más de 2 GB entre diferentes regiones o clases de almacenamiento, te recomendamos que uses la CLI de gcloud para obtener un rendimiento óptimo.

Consola

1. En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.
   

   Ir a Contenedores

2. En la lista de segmentos, haga clic en el nombre del segmento que contiene el objeto que quiere mover.

   Se abrirá la página Detalles del segmento, con la pestaña Objetos seleccionada.

3. Desplázate hasta el objeto, que puede estar en una carpeta.

4. Haz clic en el menú Menú adicional del objeto () asociado al objeto.

5. Si quiere cambiar el nombre del objeto en el mismo contenedor, haga clic en Cambiar nombre.

   1. En la ventana superpuesta que aparece, introduce un nuevo nombre para el objeto.

   2. Haz clic en Cambiar nombre.

6. Si quieres mover el objeto a otro contenedor, haz clic en Mover.

   1. En la ventana superpuesta que aparece, haz clic en Buscar.

   2. Selecciona el destino del objeto que vas a mover.

   3. Haz clic en Seleccionar.

   4. Haz clic en Mover.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

Usa el comando gcloud storage mv:

gcloud storage mv gs://SOURCE_BUCKET_NAME/SOURCE_OBJECT_NAME gs://DESTINATION_BUCKET_NAME/DESTINATION_OBJECT_NAME

Donde:

• SOURCE_BUCKET_NAME es el nombre del contenedor que contiene el objeto que quieres mover o cambiar de nombre. Por ejemplo, my-bucket.
• SOURCE_OBJECT_NAME es el nombre del objeto que quieres mover o cambiar de nombre. Por ejemplo, pets/dog.png.
• DESTINATION_BUCKET_NAME es el nombre del cubo al que quieres mover el objeto. Por ejemplo, another-bucket.
• DESTINATION_OBJECT_NAME es el nombre que quieres que tenga el objeto después de moverlo o cambiarle el nombre. Por ejemplo, shiba.png.

Si la solicitud se realiza correctamente, la respuesta será similar a la del siguiente ejemplo:

Copying gs://example-bucket/old-file.txt to gs://new-bucket/new-file.txt
Removing gs://example-bucket/old-file.txt...
  Completed files 1/1 | 164.3kiB/164.3kiB 

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& old_object_name, std::string const& new_object_name) {
  StatusOr<gcs::ObjectMetadata> metadata = client.RewriteObjectBlocking(
      bucket_name, old_object_name, bucket_name, new_object_name);
  if (!metadata) throw std::move(metadata).status();

  google::cloud::Status status =
      client.DeleteObject(bucket_name, old_object_name);
  if (!status.ok()) throw std::runtime_error(status.message());

  std::cout << "Renam<<ed "  old_ob<<ject_nam<<e  " to "  new_obje<<ct_name
       <<      " <<in bucket "  bucket_name  "\n";
}

C#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

public class MoveFileSample
{
    public void MoveFile(
        string sourceBucketName = "your-unique-bucket-name",
        string sourceObjectName = "your-object-name",
        string targetBucketName = "target-object-bucket",
        string targetObjectName = "target-object-name")
    {
        var storage = StorageClient.Create();
        storage.CopyObject(sourceBucketName, sourceObjectName, targetBucketName, targetObjectName);
        storage.DeleteObject(sourceBucketName, sourceObjectName);
        Console.WriteLine($"Moved {sourceObjectName} to {targetObjectName}.");
    }
}

Go

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

// moveFile moves an object into another location.
func moveFile(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: %w", err)
	}
	defer client.Close()

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

	dstName := object + ";-rename"
	src := client.Bucket(bucket).Object(object)
	dst := client.Bucket(bucket).Object(dstName)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to copy the file 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).Run(ctx); err != nil {
		return fmt.Errorf("Object(%q).CopierFrom(%q).Run: %w", dstName, object, err)
	}
	if err := src.Delete(ctx); err != nil {
		return fmt.Errorf("Object(%q).Delete: %w", object, err)
	}
	fmt.Fprintf(w, "Blob %v moved to %v.\n", object, dstName)
	return nil
}

Java

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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.StorageOptions;

public class CopyDeleteObject {
  public static void copyDeleteObject(
      String projectId,
      String sourceBucketName,
      String sourceObjectName,
      String targetBucketName,
      String targetObjectName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

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

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

    // The ID of the bucket to move the object objectName to
    // String targetBucketName = "target-object-bucket"

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

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId source = BlobId.of(sourceBucketName, sourceObjectName);
    BlobId target = BlobId.of(targetBucketName, targetObjectName);

    // 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;
    BlobInfo existingTarget = storage.get(targetBucketName, targetObjectName);
    if (existingTarget == 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(existingTarget.getGeneration());
    }

    // Copy source object to target object
    storage.copy(
        Storage.CopyRequest.newBuilder().setSource(source).setTarget(target, precondition).build());
    Blob copiedObject = storage.get(target);
    // Delete the original blob now that we've copied to where we want it, finishing the "move"
    // operation
    storage.get(source).delete();

    System.out.println(
        "Moved object "
            + sourceObjectName
            + " from bucket "
            + sourceBucketName
            + " to "
            + targetObjectName
            + " in bucket "
            + copiedObject.getBucket());
  }
}

Node.js

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function moveFile() {
  // 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 moveOptions = {
    preconditionOpts: {
      ifGenerationMatch: destinationGenerationMatchPrecondition,
    },
  };

  // Moves the file within the bucket
  await storage
    .bucket(bucketName)
    .file(srcFileName)
    .move(destFileName, moveOptions);

  console.log(
    `gs://${bucketName}/${srcFileName} moved to gs://${bucketName}/${destFileName}`
  );
}

moveFile().catch(console.error);

PHP

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

use Google\Cloud\Storage\StorageClient;

/**
 * Move an object to a new name and/or bucket.
 *
 * @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 $newBucketName the destination bucket name.
 *        (e.g. 'my-other-bucket')
 * @param string $newObjectName the destination object name.
 *        (e.g. 'my-other-object')
 */
function move_object(string $bucketName, string $objectName, string $newBucketName, string $newObjectName): void
{
    $storage = new StorageC>lient();
    $bucket = $storage-bucket($buc>ketName);
    $object = $bucket-o>bject($objectName);
    $objec>t-copy($newBucketName, ['na>me' = $newObjectName]);
    $object-delete();
    printf('Moved gs://%s/%s to gs://%s/%s' . PHP_EOL,
        $bucketName,
        $objectName,
        $newBucketName,
        $newObjectName);
}

Python

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

from google.cloud import storage


def move_blob(bucket_name, blob_name, destination_bucket_name, destination_blob_name,):
    """Moves a blob from one bucket to another with a new name."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The ID of your GCS object
    # blob_name = "your-object-name"
    # The ID of the bucket to move the object to
    # destination_bucket_name = "destination-bucket-name"
    # The ID of your new GCS object (optional)
    # destination_blob_name = "destination-object-name"

    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 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.
    # There is also an `if_source_generation_match` parameter, which is not used in this example.
    destination_generation_match_precondition = 0

    blob_copy = source_bucket.copy_blob(
        source_blob, destination_bucket, destination_blob_name, if_generation_match=destination_generation_match_precondition,
    )
    source_bucket.delete_blob(blob_name)

    print(
        "Blob {} in bucket {} moved to blob {} in bucket {}.".format(
            source_blob.name,
            source_bucket.name,
            blob_copy.name,
            destination_bucket.name,
        )
    )

Ruby

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

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

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

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

  require "google/cloud/storage"

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

  renamed_file = file.copy new_name

  file.delete

  puts "#{file_name} has been renamed to #{renamed_file.name}"
end

APIs REST

API JSON

Para obtener instrucciones sobre cómo mover o cambiar el nombre de objetos mediante la copia en la API JSON, consulta Copiar objetos.

API XML

Para obtener instrucciones sobre cómo mover o cambiar el nombre de objetos mediante la API XML, consulta Copiar objetos.

Cambiar el nombre de los objetos de forma atómica

En esta sección se describe cómo cambiar el nombre de los objetos de un mismo contenedor de forma atómica. Para cambiar el nombre de un objeto, puedes usar el método Objects: move en la API JSON de Cloud Storage.

APIs REST

API JSON

Para cambiar el nombre de un objeto de forma atómica, haz lo siguiente:

1. Tener instalada e inicializadala CLI de gcloud, que te permite generar un token de acceso para el encabezado Authorization.

2. Usa cURL para llamar a la API JSON con una solicitud Objects: move:

   curl -X POST 
   
       -H "Authorization: Bearer $(gcloud auth print-access-token)" 
   
       -H "Content-Length: 0" 
   
       "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/SOURCE_OBJECT_NAME/moveTo/o/DESTINATION_OBJECT_NAME"

   Donde:

   • BUCKET_NAME es el nombre del segmento que contiene el objeto cuyo nombre quieres cambiar. Por ejemplo, my-bucket.
   • SOURCE_OBJECT_NAME es el nombre codificado en URL del objeto cuyo nombre quieres cambiar. Por ejemplo, pets/dog.png, codificado como URL pets%2Fdog.png.
   • DESTINATION_OBJECT_NAME es el nombre codificado en URL que quieres usar. Por ejemplo, pets/cat.png, codificado como URL pets%2Fcat.png.

Siguientes pasos

• Cambia la clase de almacenamiento de un objeto.
• Edita los metadatos de un objeto.
• Hacer que los objetos y los segmentos sean accesibles públicamente.
• Más información sobre los requisitos de nomenclatura de objetos
• Consulta información sobre cómo usar precondiciones de solicitud para evitar las condiciones de carrera.