Importer des objets

Cette page explique comment importer des objets dans votre bucket Cloud Storage. Un objet importé se compose des données que vous souhaitez stocker ainsi que des métadonnées associées. Pour obtenir une présentation conceptuelle, consultez la page Importations et téléchargements.

Console

  1. Ouvrez le navigateur Cloud Storage dans Google Cloud Console.
    Ouvrir le navigateur Cloud Storage
  2. Dans la liste des buckets, cliquez sur le nom du bucket dans lequel vous souhaitez importer un objet.

  3. Dans l'onglet Objets du bucket, exécutez l'une des actions suivantes :

    • Effectuez un glisser-déposer des fichiers souhaités depuis votre bureau ou votre gestionnaire de fichiers vers le volet principal de Cloud Console.

    • Cliquez sur le bouton Importer des fichiers, sélectionnez les fichiers que vous souhaitez importer dans la boîte de dialogue qui s'affiche, puis cliquez sur Ouvrir.

Consultez la page Dépannage pour obtenir des informations détaillées sur les erreurs liées aux opérations ayant échoué dans le navigateur Cloud Storage.

gsutil

Exécutez la commande gsutil cp :

gsutil cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

Où :

  • OBJECT_LOCATION correspond au chemin d'accès local à votre objet. Exemple : Desktop/dog.png.

  • DESTINATION_BUCKET_NAME correspond au nom du bucket dans lequel vous importez votre objet. Exemple : my-bucket.

Si l'opération réussit, la réponse se présente comme suit :

Operation completed over 1 objects/58.8 KiB.

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& file_name,
   std::string const& bucket_name, std::string const& object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

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

private void UploadFile(string bucketName, string localPath,
    string objectName = null)
{
    var storage = StorageClient.Create();
    using (var f = File.OpenRead(localPath))
    {
        objectName = objectName ?? Path.GetFileName(localPath);
        storage.UploadObject(bucketName, objectName, null, f);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

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

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

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

// uploadFile uploads an object.
func uploadFile(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()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %v", err)
	}
	defer f.Close()

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	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.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UploadObject {
  public static void uploadObject(
      String projectId, String bucketName, String objectName, String filePath) throws IOException {
    // 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";

    // The path to your file to upload
    // String filePath = "path/to/your/file"

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)));

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

Node.js

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';

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

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

async function uploadFile() {
  // Uploads a local file to the bucket
  await storage.bucket(bucketName).upload(filename, {
    // Support for HTTP requests made with `Accept-Encoding: gzip`
    gzip: true,
    // By setting the option `destination`, you can change the name of the
    // object you are uploading to a bucket.
    metadata: {
      // Enable long-lived HTTP caching headers
      // Use only if the contents of the file will never change
      // (If the contents will change, use cacheControl: 'no-cache')
      cacheControl: 'public, max-age=31536000',
    },
  });

  console.log(`${filename} uploaded to ${bucketName}.`);
}

uploadFile().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_object($bucketName, $objectName, $source)
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

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

Pour importer un objet, exécutez la méthode Blob.upload_from_file(), Blob.upload_from_filename() ou Blob.upload_from_string().
from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # bucket_name = "your-bucket-name"
    # source_file_name = "local/path/to/file"
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    blob.upload_from_filename(source_file_name)

    print(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

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

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

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # 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.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

API REST

API JSON

Importation des objets seuls via une requête unique (sans métadonnées d'objet)

  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. Utilisez cURL pour appeler l'API JSON avec une requête d'objet POST :

    curl -X POST --data-binary @OBJECT_LOCATION \
        -H "Authorization: Bearer OAUTH2_TOKEN" \
        -H "Content-Type: OBJECT_CONTENT_TYPE" \
        "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=media&name=OBJECT_NAME"

    Où :

    • OBJECT_LOCATION correspond au chemin d'accès local à votre objet. Exemple : Desktop/dog.png.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • OBJECT_CONTENT_TYPE correspond au type de contenu de l'objet. Exemple : image/png.
    • BUCKET_NAME correspond au nom du bucket dans lequel vous importez votre objet. Exemple : my-bucket.
    • OBJECT_NAME correspond au nom que vous souhaitez attribuer à l'objet. Exemple : pets/dog.png.

Importation via une requête unique incluant les métadonnées d'objet

  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 multipart/related contenant les informations suivantes :

    --BOUNDARY_STRING
        Content-Type: application/json; charset=UTF-8
    
        OBJECT_METADATA
    
        --BOUNDARY_STRING
        Content-Type: OBJECT_CONTENT_TYPE
    
        OBJECT_DATA
        --BOUNDARY_STRING--

    Où :

    • BOUNDARY_STRING est une chaîne que vous définissez et qui identifie les différentes parties du fichier multipart. Exemple : my-boundary.
    • OBJECT_METADATA correspond aux métadonnées que vous souhaitez inclure pour le fichier, au format JSON. Au minimum, cette section doit inclure un attribut name pour l'objet, par exemple {"name": "myObject"}.
    • OBJECT_CONTENT_TYPE correspond au type de contenu de l'objet. Exemple : image/png.
    • OBJECT_DATA correspond aux données de l'objet.
  3. Utilisez cURL pour appeler l'API JSON avec une requête d'objet POST :

    curl -X POST --data-binary @MULTIPART_FILE_LOCATION \
        -H "Authorization: Bearer OAUTH2_TOKEN" \
        -H "Content-Type: multipart/related; boundary=BOUNDARY_STRING" \
        -H "Content-Length: MULTIPART_FILE_SIZE" \
        "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=multipart"

    Où :

    • MULTIPART_FILE_LOCATION correspond au chemin d'accès local au fichier multipart que vous avez créé à l'étape 2. Exemple : Desktop/my-upload.multipart.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • BOUNDARY_STRING correspond à la chaîne de limite que vous avez définie à l'étape 2. Exemple : my-boundary.
    • MULTIPART_FILE_SIZE correspond à la taille totale, en octets, du fichier multipart que vous avez créé à l'étape 2. Exemple : 2000000.
    • BUCKET_NAME correspond au nom du bucket dans lequel vous importez votre objet. Exemple : my-bucket.

Si la requête aboutit, le serveur affiche le code d'état HTTP 200 OK avec les métadonnées du fichier.

API XML

  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. Utilisez cURL pour appeler l'API XML avec une requête d'objet PUT :

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

    Où :

    • OBJECT_LOCATION correspond au chemin d'accès local à votre objet. Exemple : Desktop/dog.png.
    • OAUTH2_TOKEN correspond au jeton d'accès que vous avez généré à l'étape 1.
    • OBJECT_CONTENT_TYPE correspond au type de contenu de l'objet. Exemple : image/png.
    • BUCKET_NAME correspond au nom du bucket dans lequel vous importez votre objet. Exemple : my-bucket.
    • OBJECT_NAME correspond au nom que vous souhaitez attribuer à l'objet. Exemple : pets/dog.png.

Étapes suivantes