Composer des objets

Accéder aux concepts

Cette page vous explique comment composer des objets sources dans le but de créer un objet composite. Vous pouvez composer entre 1 et 32 objets sources dans une même requête.

Pour créer un objet composite, procédez comme suit :

Console

La composition d'objets n'est pas compatible avec Cloud Console. Utilisez plutôt gsutil.

gsutil

Exécutez la commande gsutil compose :

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

Où :

  • BUCKET_NAME est le nom du bucket qui contient les objets sources ;
  • SOURCE_OBJECT_1 et SOURCE_OBJECT_2 sont les noms des objets sources à utiliser dans la composition de l'objet ;
  • COMPOSITE_OBJECT_NAME est le nom que vous donnez au résultat de la composition d'objet.

Exemples de code

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Go.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Python

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Python.

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

C#

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C#.

Actuellement, vous ne pouvez pas rédiger des objets à avec la bibliothèque cliente C#.

Node.js

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Node.js.

Pour composer un objet en langage Node.js, consultez la documentation de référence sur l'objet Bucket.

PHP

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage PHP.

Pour composer un objet en langage PHP, consultez la documentation de référence sur Google\Cloud\Storage\Bucket.

Ruby

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Ruby.

Pour composer un objet en langage Ruby, consultez la documentation de référence sur Google::Cloud::Storage.

API REST

API JSON

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground pour utiliser vos propres identifiants OAuth.
  2. Créez un fichier .json contenant les informations suivantes :

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

    Où :

    • SOURCE_OBJECT_1 et SOURCE_OBJECT_2 sont les noms des objets sources à utiliser dans la composition de l'objet.
    • COMPOSITE_OBJECT_CONTENT_TYPE est le Content-Type de l'objet composite obtenu.
  3. Exécutez la commande cURL pour appeler l'API JSON avec une requête POST Object :

    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"

    Où :

    • JSON_FILE_NAME est le nom du fichier que vous avez créé à l'étape précédente.
    • OAUTH2_TOKEN est le jeton d'accès généré plus tôt dans le guide.
    • BUCKET_NAME est le nom du bucket qui contient les objets sources.
    • COMPOSITE_OBJECT_NAME est le nom que vous donnez au résultat de la composition d'objet.

Si la requête aboutit, la réponse est une ressource d'objet pour l'objet composite obtenu.

API XML

  1. Obtenez un jeton d'autorisation d'accès sur la page OAuth 2.0 Playground. Configurez Playground de façon à utiliser vos propres identifiants OAuth.
  2. Créez un fichier .xml contenant les informations suivantes :

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

    Où :

    • SOURCE_OBJECT_1 et SOURCE_OBJECT_2 sont les noms des objets sources à utiliser dans la composition de l'objet.
  3. Utilisez cURL pour appeler l'API XML avec une requête d'objet PUT et un paramètre de chaîne de requête 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"

    Où :

    • XML_FILE_NAME est le nom du fichier que vous avez créé à l'étape précédente.
    • OAUTH2_TOKEN est le jeton d'accès généré plus tôt dans le guide.
    • COMPOSITE_OBJECT_CONTENT_TYPE est le Content-Type de l'objet composite obtenu.
    • BUCKET_NAME est le nom du bucket qui contient les objets sources.
    • COMPOSITE_OBJECT_NAME est le nom que vous donnez au résultat de la composition d'objet.

Si la requête aboutit, un corps de réponse vide est renvoyé.

Étape suivante