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.

Attention : Les objets sources ne sont pas affectés par le processus de composition. Si ces objets sont censés être temporaires, vous devez les supprimer lorsque vous avez terminé la composition. Comme les autres classes de stockage sont soumises à des frais de suppression anticipée, vous devez toujours utiliser le stockage standard pour les objets temporaires.

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.

Remarque : Vous pouvez également utiliser un caractère générique pour composer des objets partageant un préfixe commun sans avoir à les répertorier séparément dans la commande compose.

Exemples de code

C++

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

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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.

Afficher sur GitHub Commentaires

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é.

Remarque : L'API XML vous autorise à inclure un numéro de génération pour chaque composant (<Component>), en utilisant soit un élément <Generation> ou un élément <IfGenerationMatch>.

Étape suivante

• Apprenez-en plus sur la composition d'objets.