Compón objetos

Ir a los conceptos

En esta página, se muestra cómo componer objetos de origen para crear un objeto compuesto. Puedes componer entre 1 y 32 objetos de origen en una sola solicitud.

Precaución: El proceso de composición no afecta a los objetos de origen. Si están destinados a ser temporales, debes borrarlos una vez que hayas completado la composición con éxito. Debido a que otras clases de almacenamiento están sujetas a tarifas de eliminación temprana, siempre debes usar Standard Storage para los objetos temporales.

Para crear un objeto compuesto, haz lo siguiente:

Console

No se admite la composición de objetos en Cloud Console. En su lugar, usa gsutil.

gsutil

Usa el comando gsutil compose:

gsutil compose gs://BUCKET_NAME/SOURCE_OBJECT_1 gs://BUCKET_NAME/SOURCE_OBJECT_2 gs://BUCKET_NAME/COMPOSITE_OBJECT_NAME

En el ejemplo anterior, se ilustra lo siguiente:

• BUCKET_NAME es el nombre del bucket que contiene los objetos de origen.
• SOURCE_OBJECT_1 y SOURCE_OBJECT_2 son los nombres de los objetos de origen que se usarán en la composición del objeto.
• COMPOSITE_OBJECT_NAME es el nombre que le asignas al resultado de la composición del objeto.

Nota: También puedes usar un comodín para componer objetos con un prefijo común sin tener que enumerar cada objeto por separado en el comando compose.

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& destination_object_name,
   std::vector<gcs::ComposeSourceObject> const& compose_objects) {
  StatusOr<gcs::ObjectMetadata> composed_object = client.ComposeObject(
      bucket_name, compose_objects, destination_object_name);

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

  std::cout << "Composed new object " << composed_object->name()
            << " in bucket " << composed_object->bucket()
            << "\nFull metadata: " << *composed_object << "\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"
)

// composeFile composes source objects to create a composite object.
func composeFile(w io.Writer, bucket, object1, object2, toObject string) error {
	// bucket := "bucket-name"
	// object1 := "object-name-1"
	// object2 := "object-name-2"
	// toObject := "object-name-3"

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

	src1 := client.Bucket(bucket).Object(object1)
	src2 := client.Bucket(bucket).Object(object2)
	dst := client.Bucket(bucket).Object(toObject)

	// ComposerFrom takes varargs, so you can put as many objects here
	// as you want.
	_, err = dst.ComposerFrom(src1, src2).Run(ctx)
	if err != nil {
		return fmt.Errorf("ComposerFrom: %v", err)
	}
	fmt.Fprintf(w, "New composite object %v was created by combining %v and %v\n", toObject, object1, object2)
	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.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class ComposeObject {
  public static void composeObject(
      String bucketName,
      String firstObjectName,
      String secondObjectName,
      String targetObjectName,
      String projectId) {
    // 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 first GCS object to compose
    // String firstObjectName = "your-first-object-name";

    // The ID of the second GCS object to compose
    // String secondObjectName = "your-second-object-name";

    // The ID to give the new composite object
    // String targetObjectName = "new-composite-object-name";

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

    Storage.ComposeRequest composeRequest =
        Storage.ComposeRequest.newBuilder()
            // addSource takes varargs, so you can put as many objects here as you want, up to the
            // max of 32
            .addSource(firstObjectName, secondObjectName)
            .setTarget(BlobInfo.newBuilder(bucketName, targetObjectName).build())
            .build();

    Blob compositeObject = storage.compose(composeRequest);

    System.out.println(
        "New composite object "
            + compositeObject.getName()
            + " was created by combining "
            + firstObjectName
            + " and "
            + secondObjectName);
  }
}

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 GitHubComentarios

/**
 * 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 the first GCS file to compose
// const firstFileName = 'your-first-file-name';

// The ID of the second GCS file to compose
// const secondFileName = 'your-second-file-name';

// The ID to give the new composite file
// const destinationFileName = 'new-composite-file-name';

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

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

async function composeFile() {
  const bucket = storage.bucket(bucketName);
  const sources = [firstFileName, secondFileName];

  await bucket.combine(sources, destinationFileName);

  console.log(
    `New composite file ${destinationFileName} was created by combining ${firstFileName} and ${secondFileName}`
  );
}

composeFile().catch(console.error);

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 compose_file(bucket_name, first_blob_name, second_blob_name, destination_blob_name):
    """Concatenate source blobs into destination blob."""
    # bucket_name = "your-bucket-name"
    # first_blob_name = "first-object-name"
    # second_blob_name = "second-blob-name"
    # destination_blob_name = "destination-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    destination = bucket.blob(destination_blob_name)
    destination.content_type = "text/plain"

    # sources is a list of Blob instances, up to the max of 32 instances per request
    sources = [bucket.get_blob(first_blob_name), bucket.get_blob(second_blob_name)]
    destination.compose(sources)

    print(
        "New composite object {} in the bucket {} was created by combining {} and {}".format(
            destination_blob_name, bucket_name, first_blob_name, second_blob_name
        )
    )
    return destination

Ruby

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

Ver en GitHubComentarios

def compose_file bucket_name:, first_file_name:, second_file_name:, destination_file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of the first GCS object to compose
  # first_file_name = "your-first-file-name"

  # The ID of the second GCS object to compose
  # second_file_name = "your-second-file-name"

  # The ID to give the new composite object
  # destination_file_name = "new-composite-file-name"

  require "google/cloud/storage"

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

  destination = bucket.compose [first_file_name, second_file_name], destination_file_name do |f|
    f.content_type = "text/plain"
  end

  puts "Composed new file #{destination.name} in the bucket #{bucket_name} " \
       "by combining #{first_file_name} and #{second_file_name}"
end

C#

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

Por el momento, no puedes redactar objetos mediante la biblioteca cliente C#.

PHP

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

Para redactar un objeto mediante PHP, consulta la documentación de referencia Google\Cloud\Storage\Bucket.

API de REST

API de JSON

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

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

   {
     "sourceObjects": [
       {
         "name": "SOURCE_OBJECT_1"
       },
       {
         "name": "SOURCE_OBJECT_2"
       }
     ],
     "destination": {
       "contentType": "COMPOSITE_OBJECT_CONTENT_TYPE"
     }
   }

   En el ejemplo anterior, se ilustra lo siguiente:

   • SOURCE_OBJECT_1 y SOURCE_OBJECT_2 son los nombres de los objetos de origen que se usarán en la composición del objeto.
   • COMPOSITE_OBJECT_CONTENT_TYPE es el tipo de contenido del objeto compuesto resultante.

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/COMPOSITE_OBJECT_NAME/compose"

   En el ejemplo anterior, se ilustra lo siguiente:

   • JSON_FILE_NAME es el nombre del archivo que creaste en el paso anterior.
   • OAUTH2_TOKEN es el token de acceso que generaste en pasos anteriores de la guía.
   • BUCKET_NAME es el nombre del bucket que contiene los objetos de origen.
   • COMPOSITE_OBJECT_NAME es el nombre que le asignas al resultado de la composición del objeto.

Si se ejecuta de forma correcta, la respuesta es un recurso de objeto para el objeto compuesto resultante.

API de XML

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

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

     <ComposeRequest>
       <Component>
         <Name>SOURCE_OBJECT_1</Name>
       </Component>
       <Component>
         <Name>SOURCE_OBJECT_2</Name>
       </Component>
     </ComposeRequest>

   En el ejemplo anterior, se ilustra lo siguiente:

   • SOURCE_OBJECT_1 y SOURCE_OBJECT_2 son los nombres de los objetos de origen que se usarán en la composición del objeto.

3. Usa cURL para llamar a la API de XML con una solicitud de objeto PUT y el parámetro de string de consulta compose:

   curl -X PUT --data-binary @XML_FILE_NAME.xml \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: COMPOSITE_OBJECT_CONTENT_TYPE" \
     "https://storage.googleapis.com/BUCKET_NAME/COMPOSITE_OBJECT_NAME?compose"

   En el ejemplo anterior, se ilustra lo siguiente:

   • XML_FILE_NAME es el nombre del archivo que creaste en el paso anterior.
   • OAUTH2_TOKEN es el token de acceso que generaste en pasos anteriores de la guía.
   • COMPOSITE_OBJECT_CONTENT_TYPE es el tipo de contenido del objeto compuesto resultante.
   • BUCKET_NAME es el nombre del bucket que contiene los objetos de origen.
   • COMPOSITE_OBJECT_NAME es el nombre que le asignas al resultado de la composición del objeto.

Si se ejecuta de forma correcta, se muestra una respuesta vacía.

Nota: La API de XML admite incluir un número de generación para cada <Component>, con un elemento <Generation> o <IfGenerationMatch>.

Próximos pasos

• Obtén más información sobre la composición de objetos.