Caricare oggetti da un file system

Questa pagina mostra come caricare oggetti nel bucket Cloud Storage dal file system locale. Un oggetto caricato è costituito dai dati che vuoi archiviare insieme a eventuali metadati associati. Per una panoramica concettuale, inclusa la modalità di scelta del metodo di caricamento ottimale in base alle dimensioni del file, consulta Caricamenti e download.

Per istruzioni sul caricamento dalla memoria, consulta Caricare oggetti dalla memoria.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per caricare oggetti in un bucket, chiedi all'amministratore di concederti il ruolo IAM Utente oggetto archiviazione (roles/storage.objectUser) nel bucket. Questo ruolo predefinito contiene le autorizzazioni necessarie per caricare un oggetto in un bucket. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

• storage.objects.create
• storage.objects.delete
  • Questa autorizzazione è obbligatoria solo per i caricamenti che sovrascrivono un oggetto esistente.
• storage.objects.get
  • Questa autorizzazione è necessaria solo se prevedi di utilizzare Google Cloud CLI per eseguire le attività in questa pagina.
• storage.objects.list
  • Questa autorizzazione è necessaria solo se prevedi di utilizzare Google Cloud CLI per eseguire le attività in questa pagina. Questa autorizzazione è necessaria anche se vuoi utilizzare la console Google Cloud per verificare gli oggetti che hai caricato.

Se prevedi di utilizzare la console Google Cloud per eseguire le attività in questa pagina, ti servirà anche l'autorizzazione storage.buckets.list, che non è inclusa nel ruolo Utente oggetto archiviazione (roles/storage.objectUser). Per ottenere questa autorizzazione, chiedi all'amministratore di concederti il ruolo Amministratore archiviazione (roles/storage.admin) nel progetto.

Puoi anche ottenere queste autorizzazioni con altri ruoli predefiniti o ruoli personalizzati.

Per informazioni sulla concessione dei ruoli ai bucket, consulta Utilizzare IAM con i bucket.

Caricare un oggetto in un bucket

Per caricare un oggetto in un bucket:

Console

1. Nella console Google Cloud, vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket in cui vuoi caricare un oggetto.

3. Nella scheda Oggetti del bucket:

   • Trascina i file dal desktop o dal gestore file al riquadro principale della console Google Cloud.

   • Fai clic sul pulsante Carica file, seleziona i file che vuoi caricare nella finestra di dialogo visualizzata e fai clic su Apri.

   Nota: se utilizzi il browser Chrome, sono supportati anche i caricamenti di cartelle.

Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni di Cloud Storage non riuscite nella console Google Cloud, consulta la sezione Risoluzione dei problemi.

Riga di comando

Utilizza il comando gcloud storage cp:

gcloud storage cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME

Dove:

• OBJECT_LOCATION è il percorso locale dell'oggetto. Ad esempio, Desktop/dog.png.

• DESTINATION_BUCKET_NAME è il nome del bucket in cui stai caricando l'oggetto. Ad esempio, my-bucket.

Se l'operazione ha esito positivo, la risposta è simile al seguente esempio:

Completed files 1/1 | 164.3kiB/164.3kiB

Nota: utilizza il flag --recursive per caricare in modo ricorsivo le directory.

Puoi impostare metadati degli oggetti con chiave fissa e personalizzati durante il caricamento degli oggetti utilizzando i flag di comando.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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::move(metadata).status();

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

C#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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: %w", err)
	}
	defer client.Close()

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

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

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to upload is aborted if the
	// object's generation number does not match your precondition.
	// For an object that does not yet exist, set the DoesNotExist precondition.
	o = o.If(storage.Conditions{DoesNotExist: true})
	// If the live object already exists in your bucket, set instead a
	// generation-match precondition using the live object's generation number.
	// attrs, err := o.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %w", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %w", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

Java

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Il seguente esempio carica un singolo oggetto:

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

    // 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.BlobWriteOption precondition;
    if (storage.get(bucketName, objectName) == 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.BlobWriteOption.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.BlobWriteOption.generationMatch(
              storage.get(bucketName, objectName).getGeneration());
    }
    storage.createFrom(blobInfo, Paths.get(filePath), precondition);

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

L'esempio seguente carica più oggetti contemporaneamente:

import com.google.cloud.storage.transfermanager.ParallelUploadConfig;
import com.google.cloud.storage.transfermanager.TransferManager;
import com.google.cloud.storage.transfermanager.TransferManagerConfig;
import com.google.cloud.storage.transfermanager.UploadResult;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;

class UploadMany {

  public static void uploadManyFiles(String bucketName, List<Path> files) throws IOException {
    TransferManager transferManager = TransferManagerConfig.newBuilder().build().getService();
    ParallelUploadConfig parallelUploadConfig =
        ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();
    List<UploadResult> results =
        transferManager.uploadFiles(files, parallelUploadConfig).getUploadResults();
    for (UploadResult result : results) {
      System.out.println(
          "Upload for "
              + result.getInput().getName()
              + " completed with status "
              + result.getStatus());
    }
  }
}

Il seguente esempio carica contemporaneamente tutti gli oggetti con un prefisso comune:

import com.google.cloud.storage.transfermanager.ParallelUploadConfig;
import com.google.cloud.storage.transfermanager.TransferManager;
import com.google.cloud.storage.transfermanager.TransferManagerConfig;
import com.google.cloud.storage.transfermanager.UploadResult;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

class UploadDirectory {

  public static void uploadDirectoryContents(String bucketName, Path sourceDirectory)
      throws IOException {
    TransferManager transferManager = TransferManagerConfig.newBuilder().build().getService();
    ParallelUploadConfig parallelUploadConfig =
        ParallelUploadConfig.newBuilder().setBucketName(bucketName).build();

    // Create a list to store the file paths
    List<Path> filePaths = new ArrayList<>();
    // Get all files in the directory
    // try-with-resource to ensure pathStream is closed
    try (Stream<Path> pathStream = Files.walk(sourceDirectory)) {
      pathStream.filter(Files::isRegularFile).forEach(filePaths::add);
    }
    List<UploadResult> results =
        transferManager.uploadFiles(filePaths, parallelUploadConfig).getUploadResults();
    for (UploadResult result : results) {
      System.out.println(
          "Upload for "
              + result.getInput().getName()
              + " completed with status "
              + result.getStatus());
    }
  }
}

Node.js

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Il seguente esempio carica un singolo oggetto:

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

// The path to your file to upload
// const filePath = 'path/to/your/file';

// 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 uploadFile() {
  const options = {
    destination: destFileName,
    // Optional:
    // Set a generation-match precondition to avoid potential race conditions
    // and data corruptions. The request to upload 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.
    preconditionOpts: {ifGenerationMatch: generationMatchPrecondition},
  };

  await storage.bucket(bucketName).upload(filePath, options);
  console.log(`${filePath} uploaded to ${bucketName}`);
}

uploadFile().catch(console.error);

L'esempio seguente carica più oggetti contemporaneamente:

/**
 * 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 upload
// const firstFilePath = 'your-first-file-name';

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

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

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

// Creates a transfer manager client
const transferManager = new TransferManager(storage.bucket(bucketName));

async function uploadManyFilesWithTransferManager() {
  // Uploads the files
  await transferManager.uploadManyFiles([firstFilePath, secondFilePath]);

  for (const filePath of [firstFilePath, secondFilePath]) {
    console.log(`${filePath} uploaded to ${bucketName}.`);
  }
}

uploadManyFilesWithTransferManager().catch(console.error);

Il seguente esempio carica contemporaneamente tutti gli oggetti con un prefisso comune:

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

// The local directory to upload
// const directoryName = 'your-directory';

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

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

// Creates a transfer manager client
const transferManager = new TransferManager(storage.bucket(bucketName));

async function uploadDirectoryWithTransferManager() {
  // Uploads the directory
  await transferManager.uploadManyFiles(directoryName);

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

uploadDirectoryWithTransferManager().catch(console.error);

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @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 $source The path to the file to upload.
 *        (e.g. '/path/to/your/file')
 */
function upload_object(string $bucketName, string $objectName, string $source): void
{
    $storage = new StorageClient();
    if (!$file = fopen($source, 'r')) {
        throw new \InvalidArgumentException('Unable to open file for reading');
    }
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

Il seguente esempio carica un singolo oggetto:

from google.cloud import storage


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

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

    # Optional: set a generation-match precondition to avoid potential race conditions
    # and data corruptions. The request to upload 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.
    generation_match_precondition = 0

    blob.upload_from_filename(source_file_name, if_generation_match=generation_match_precondition)

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

L'esempio seguente carica più oggetti contemporaneamente:

def upload_many_blobs_with_transfer_manager(
    bucket_name, filenames, source_directory="", workers=8
):
    """Upload every file in a list to a bucket, concurrently in a process pool.

    Each blob name is derived from the filename, not including the
    `source_directory` parameter. For complete control of the blob name for each
    file (and other aspects of individual blob metadata), use
    transfer_manager.upload_many() instead.
    """

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # A list (or other iterable) of filenames to upload.
    # filenames = ["file_1.txt", "file_2.txt"]

    # The directory on your computer that is the root of all of the files in the
    # list of filenames. This string is prepended (with os.path.join()) to each
    # filename to get the full path to the file. Relative paths and absolute
    # paths are both accepted. This string is not included in the name of the
    # uploaded blob; it is only used to find the source files. An empty string
    # means "the current working directory". Note that this parameter allows
    # directory traversal (e.g. "/", "../") and is not intended for unsanitized
    # end user input.
    # source_directory=""

    # The maximum number of processes to use for the operation. The performance
    # impact of this value depends on the use case, but smaller files usually
    # benefit from a higher number of processes. Each additional process occupies
    # some CPU and memory resources until finished. Threads can be used instead
    # of processes by passing `worker_type=transfer_manager.THREAD`.
    # workers=8

    from google.cloud.storage import Client, transfer_manager

    storage_client = Client()
    bucket = storage_client.bucket(bucket_name)

    results = transfer_manager.upload_many_from_filenames(
        bucket, filenames, source_directory=source_directory, max_workers=workers
    )

    for name, result in zip(filenames, results):
        # The results list is either `None` or an exception for each filename in
        # the input list, in order.

        if isinstance(result, Exception):
            print("Failed to upload {} due to exception: {}".format(name, result))
        else:
            print("Uploaded {} to {}.".format(name, bucket.name))

Il seguente esempio carica contemporaneamente tutti gli oggetti con un prefisso comune:

def upload_directory_with_transfer_manager(bucket_name, source_directory, workers=8):
    """Upload every file in a directory, including all files in subdirectories.

    Each blob name is derived from the filename, not including the `directory`
    parameter itself. For complete control of the blob name for each file (and
    other aspects of individual blob metadata), use
    transfer_manager.upload_many() instead.
    """

    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The directory on your computer to upload. Files in the directory and its
    # subdirectories will be uploaded. An empty string means "the current
    # working directory".
    # source_directory=""

    # The maximum number of processes to use for the operation. The performance
    # impact of this value depends on the use case, but smaller files usually
    # benefit from a higher number of processes. Each additional process occupies
    # some CPU and memory resources until finished. Threads can be used instead
    # of processes by passing `worker_type=transfer_manager.THREAD`.
    # workers=8

    from pathlib import Path

    from google.cloud.storage import Client, transfer_manager

    storage_client = Client()
    bucket = storage_client.bucket(bucket_name)

    # Generate a list of paths (in string form) relative to the `directory`.
    # This can be done in a single list comprehension, but is expanded into
    # multiple lines here for clarity.

    # First, recursively get all files in `directory` as Path objects.
    directory_as_path_obj = Path(source_directory)
    paths = directory_as_path_obj.rglob("*")

    # Filter so the list only includes files, not directories themselves.
    file_paths = [path for path in paths if path.is_file()]

    # These paths are relative to the current working directory. Next, make them
    # relative to `directory`
    relative_paths = [path.relative_to(source_directory) for path in file_paths]

    # Finally, convert them all to strings.
    string_paths = [str(path) for path in relative_paths]

    print("Found {} files.".format(len(string_paths)))

    # Start the upload.
    results = transfer_manager.upload_many_from_filenames(
        bucket, string_paths, source_directory=source_directory, max_workers=workers
    )

    for name, result in zip(string_paths, results):
        # The results list is either `None` or an exception for each filename in
        # the input list, in order.

        if isinstance(result, Exception):
            print("Failed to upload {} due to exception: {}".format(name, result))
        else:
            print("Uploaded {} to {}.".format(name, bucket.name))

Ruby

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per le librerie client.

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, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

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

Terraform

Puoi utilizzare una risorsa Terraform per caricare un oggetto. È necessario specificare content o source.

# Create a text object in Cloud Storage
resource "google_storage_bucket_object" "default" {
  name = "new-object"
  # Use `source` or `content`
  # source       = "/path/to/an/object"
  content      = "Data as string to be uploaded"
  content_type = "text/plain"
  bucket       = google_storage_bucket.static.id
}

API REST

API JSON

L'API JSON distingue tra caricamenti di contenuti multimediali, in cui nella richiesta sono inclusi solo i dati dell'oggetto, e caricamenti suddivisi in più parti dell'API JSON, in cui nella richiesta sono inclusi sia i dati dell'oggetto sia i metadati dell'oggetto.

Caricamento di contenuti multimediali (un caricamento con una singola richiesta senza metadati dell'oggetto)

1. Avere installato e inizializzatogcloud CLI, che consente di generare un token di accesso per l'intestazione Authorization.

2. Utilizza cURL per chiamare l'API JSON con una richiesta di POST oggetto:

   curl -X POST --data-binary @OBJECT_LOCATION \
       -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       -H "Content-Type: OBJECT_CONTENT_TYPE" \
       "https://storage.googleapis.com/upload/storage/v1/b/BUCKET_NAME/o?uploadType=media&name=OBJECT_NAME"

   Dove:

   • OBJECT_LOCATION è il percorso locale dell'oggetto. Ad esempio, Desktop/dog.png.
   • OBJECT_CONTENT_TYPE è il tipo di contenuto dell'oggetto. Ad esempio: image/png.
   • BUCKET_NAME è il nome del bucket in cui stai caricando l'oggetto. Ad esempio, my-bucket.
   • OBJECT_NAME è il nome con codifica URL che vuoi assegnare all'oggetto. Ad esempio, pets/dog.png, codificato come URL come pets%2Fdog.png.

Caricamento multiparte dell'API JSON (un caricamento con una singola richiesta che include i metadati dell'oggetto)

Nota: per aggiungere o modificare i metadati di un oggetto esistente in Cloud Storage, consulta Visualizzazione e modifica dei metadati degli oggetti.

1. Avere installato e inizializzatogcloud CLI, che consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file multipart/related contenente le seguenti informazioni:

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

   Dove:

   • BOUNDARY_STRING è una stringa che definisci per identificare le diverse parti del file suddiviso in più parti. Ad esempio, separator_string.
   • OBJECT_METADATA sono i metadati da includere per il file in formato JSON. Come minimo, questa sezione deve includere un attributo name per l'oggetto, ad esempio {"name": "myObject"}.
   • OBJECT_CONTENT_TYPE è il tipo di contenuto dell'oggetto. Ad esempio: text/plain.
   • OBJECT_DATA sono i dati dell'oggetto.

   Ad esempio:

   --separator_string
   Content-Type: application/json; charset=UTF-8
   
   {"name":"my-document.txt"}
   
   --separator_string
   Content-Type: text/plain
   
   This is a text file.
   --separator_string--

3. Utilizza cURL per chiamare l'API JSON con una richiesta di oggetto POST:

   curl -X POST --data-binary @MULTIPART_FILE_LOCATION \
       -H "Authorization: Bearer $(gcloud auth print-access-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"

   Dove:

   • MULTIPART_FILE_LOCATION è il percorso locale del file suddiviso in più parti che hai creato nel passaggio 2. Ad esempio, Desktop/my-upload.multipart.
   • BOUNDARY_STRING è la stringa di confine che hai definito nel passaggio 2. Ad esempio, my-boundary.
   • MULTIPART_FILE_SIZE è la dimensione totale, in byte, del file suddiviso in più parti che hai creato nel passaggio 2. Ad esempio, 2000000.
   • BUCKET_NAME è il nome del bucket in cui stai caricando l'oggetto. Ad esempio, my-bucket.

Se la richiesta riesce, il server restituisce il codice di stato HTTP 200 OK insieme ai metadati del file.

API XML

1. Avere installato e inizializzatogcloud CLI, che consente di generare un token di accesso per l'intestazione Authorization.

2. Utilizza cURL per chiamare l'API XML con una richiesta di PUT Object:

   curl -X PUT --data-binary @OBJECT_LOCATION \
       -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       -H "Content-Type: OBJECT_CONTENT_TYPE" \
       "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME"

   Dove:

   • OBJECT_LOCATION è il percorso locale dell'oggetto. Ad esempio, Desktop/dog.png.
   • OBJECT_CONTENT_TYPE è il tipo di contenuto dell'oggetto. Ad esempio: image/png.
   • BUCKET_NAME è il nome del bucket in cui stai caricando l'oggetto. Ad esempio, my-bucket.
   • OBJECT_NAME è il nome con codifica URL che vuoi assegnare all'oggetto. Ad esempio, pets/dog.png, codificato come URL come pets%2Fdog.png.

Puoi impostare metadati aggiuntivi degli oggetti durante il caricamento degli oggetti nelle intestazioni della richiesta nello stesso modo in cui l'esempio precedente imposta Content-Type. Quando utilizzi l'API XML, i metadati possono essere impostati solo al momento della scrittura dell'oggetto, ad esempio durante il caricamento, la copia o la sostituzione dell'oggetto. Per ulteriori informazioni, consulta la sezione Modificare i metadati degli oggetti.

Passaggi successivi

• Scopri di più sui requisiti di denominazione degli oggetti.
• Scopri come utilizzare le cartelle per organizzare gli oggetti.
• Trasferisci gli oggetti dall'istanza Compute Engine.
• Trasferisci dati da provider cloud o altre origini online, come gli elenchi di URL.
• Controlla chi ha accesso ai tuoi oggetti e bucket.
• Visualizza i metadati dell'oggetto, incluso l'URL dell'oggetto.

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di Cloud Storage in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Cloud Storage gratuitamente