上传对象

本页面介绍如何将对象上传到 Cloud Storage 存储分区。上传的对象包含要存储的数据以及所有关联元数据。如需查看概念性概览（包括如何根据文件大小选择最佳上传方法），请参阅上传和下载。

前提条件

前提条件因所使用的工具而异：

控制台

如需使用 Google Cloud Console 完成本指南，您必须拥有适当的 IAM 权限。如果您要上传的存储桶在不是由您创建的项目中，则可能需要项目所有者为您提供包含必要权限的角色。

如需查看特定操作所需权限的列表，请参阅 Google Cloud Console 的 IAM 权限。

如需查看相关角色的列表，请参阅 Cloud Storage 角色。或者，您也可以创建一个自定义角色，并为其提供具体受限的权限。

命令行

为使用命令行实用程序完成本指南，您必须拥有适当的 IAM 权限。如果您要上传的存储桶在不是由您创建的项目中，则可能需要项目所有者为您提供具有必要权限的角色。

如需查看特定操作所需权限的列表，请参阅 gsutil 命令的 IAM 权限。

如需查看相关角色的列表，请参阅 Cloud Storage 角色。或者，您也可以创建一个自定义角色，并为其提供具体受限的权限。

代码示例

如需使用 Cloud Storage 客户端库完成本指南，您必须拥有适当的 IAM 权限。如果您要上传的存储桶在不是由您创建的项目中，则可能需要项目所有者为您提供包含必要权限的角色。除非另有说明，否则客户端库请求通过 JSON API 发出。

如需查看特定操作所需的权限列表，请参阅 JSON 方法的 IAM 权限。

如需查看相关角色的列表，请参阅 Cloud Storage 角色。或者，您也可以创建一个自定义角色，并为其提供具体受限的权限。

REST API

JSON API

如需使用 JSON API 完成本指南，您必须拥有适当的 IAM 权限。如果您要上传的存储桶在不是由您创建的项目中，则可能需要项目所有者为您提供包含必要权限的角色。

如需查看特定操作所需的权限列表，请参阅 JSON 方法的 IAM 权限。

如需查看相关角色的列表，请参阅 Cloud Storage 角色。或者，您也可以创建一个自定义角色，并为其提供具体受限的权限。

将对象上传到存储桶

如需将对象上传到存储分区，请完成以下步骤：

控制台

1. 在 Google Cloud Console 中，转到 Cloud Storage 的浏览器页面。
   

   转到浏览器

2. 在存储分区列表中，点击要将对象上传到的存储分区的名称。

3. 在存储分区的对象标签中，执行以下任一操作：

   • 将所需文件从桌面或文件管理器拖放到 Cloud Console 的主窗格中。

   • 点击上传文件按钮，在出现的对话框中选择要上传的文件，然后点击打开。

   注意：如果您使用的是 Chrome 浏览器，还支持上传文件夹。

如需了解如何获取有关 Cloud Storage 浏览器中失败操作的详细错误信息，请参阅问题排查。

命令行

使用 gsutil cp 命令：

gsutil cp OBJECT_LOCATION gs://DESTINATION_BUCKET_NAME/

其中：

• OBJECT_LOCATION 是对象的本地路径。 例如 Desktop/dog.png。

• DESTINATION_BUCKET_NAME 是对象要上传到的存储分区的名称。例如 my-bucket。

如果成功，则响应类似如下示例：

Operation completed over 1 objects/58.8 KiB.

注意：使用 -r 标志以递归方式上传目录。

在请求标头中上传对象时，您可以使用 -h 全局选项设置固定键和自定义对象元数据。

代码示例

C++

如需了解详情，请参阅 Cloud Storage C++ API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  std::string const text = "Lorem ipsum dolor sit amet";
  std::vector<std::string> v(100, text);
  gcs::ObjectWriteStream stream =
      client.WriteObject(bucket_name, object_name);

  std::copy(v.begin(), v.end(), std::ostream_iterator<std::string>(stream));

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();
  if (!metadata) throw std::runtime_error(metadata.status().message());
  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

如需了解详情，请参阅 Cloud Storage C# API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

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

public class UploadObjectFromMemorySample
{
    public void UploadObjectFromMemory(
        string bucketName = "unique-bucket-name",
        string objectName = "file-name",
        string contents = "Hello world!")
    {
        var storage = StorageClient.Create();
        byte[] byteArray = Encoding.UTF8.GetBytes(contents);
        MemoryStream stream = new MemoryStream(byteArray);
        storage.UploadObject(bucketName, objectName, "application/octet-stream" , stream);

        Console.WriteLine($" {objectName} uploaded to bucket {bucketName} with contents: {contents}");
    }
}

Go

如需了解详情，请参阅 Cloud Storage Go API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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

	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: %v", 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: %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
}

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"time"

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

// streamFileUpload uploads an object via a stream.
func streamFileUpload(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()

	b := []byte("Hello world.")
	buf := bytes.NewBuffer(b)

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
	wc.ChunkSize = 0 // note retries are not supported for chunk size 0.

	if _, err = io.Copy(wc, buf); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	// Data can continue to be added to the file until the writer is closed.
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket)

	return nil
}

Java

如需了解详情，请参阅 Cloud Storage Java API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

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.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class UploadObjectFromMemory {
  public static void uploadObjectFromMemory(
      String projectId, String bucketName, String objectName, String contents) 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 string of contents you wish to upload
    // String contents = "Hello world!";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    byte[] content = contents.getBytes(StandardCharsets.UTF_8);
    storage.createFrom(blobInfo, new ByteArrayInputStream(content));

    System.out.println(
        "Object "
            + objectName
            + " uploaded to bucket "
            + bucketName
            + " with contents "
            + contents);
  }
}

Node.js

如需了解详情，请参阅 Cloud Storage Node.js API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

/**
 * 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() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

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

uploadFile().catch(console.error);

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

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

// The contents that you want to upload
// const contents = 'these are my contents';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

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

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

async function uploadFromMemory() {
  await storage.bucket(bucketName).file(destFileName).save(contents);

  console.log(
    `${destFileName} with contents ${contents} uploaded to ${bucketName}.`
  );
}

uploadFromMemory().catch(console.error);

PHP

如需了解详情，请参阅 Cloud Storage PHP API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 */
function upload_object($bucketName, $objectName, $source)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $source = '/path/to/your/file';

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

use Google\Cloud\Storage\StorageClient;

/**
 * Upload an object from memory buffer.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $contents The contents to upload to the file.
 */
function upload_object_from_memory(
    string $bucketName,
    string $objectName,
    string $contents
): void {
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $contents = 'these are my contents';

    $storage = new StorageClient();
    $stream = fopen('data://text/plain,' . $contents, 'r');
    $bucket = $storage->bucket($bucketName);
    $bucket->upload($stream, [
        'name' => $objectName,
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, $contents, $bucketName, $objectName);
}

Python

如需了解详情，请参阅 Cloud Storage Python API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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)

    blob.upload_from_filename(source_file_name)

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

from google.cloud import storage

def upload_blob_from_memory(bucket_name, contents, destination_blob_name):
    """Uploads a file to the bucket."""

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

    # The contents to upload to the file
    # contents = "these are my contents"

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

    blob.upload_from_string(contents)

    print(
        f"{destination_blob_name} with contents {contents} uploaded to {bucket_name}."
    )

Ruby

如需了解详情，请参阅 Cloud Storage Ruby API 参考文档。

以下示例会从文件上传对象：

在 GitHub 上查看 反馈

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

以下示例会从内存上传对象：

在 GitHub 上查看 反馈

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

# The ID of your GCS object
# file_name = "your-file-name"

# The contents to upload to your file
# file_content = "Hello, world!"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.bucket bucket_name, skip_lookup: true

file = bucket.create_file StringIO.new(file_content), file_name

puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

Terraform

您可以使用 Terraform 资源上传对象。为此，您必须指定 content 或 source（您也可以同时指定这两者）。

在 GitHub 上查看 反馈

# Upload files
# Discussion about using tf to upload a large number of objects
# https://stackoverflow.com/questions/68455132/terraform-copy-multiple-files-to-bucket-at-the-same-time-bucket-creation

# The text object in Cloud Storage
resource "google_storage_bucket_object" "default" {
  name         = "new-object"
# Uncomment and add valid path to an object.
#  source       = "/path/to/an/object"
  content      = "Data as string to be uploaded"
  content_type = "text/plain"
  bucket       = google_storage_bucket.static.id
}

REST API

JSON API

不含对象元数据的单一请求上传

1. 从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。 如需了解相关说明，请参阅 API 身份验证。

2. 使用 cURL，通过 POST 对象请求调用 JSON API：

   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"

   其中：

   • OBJECT_LOCATION 是对象的本地路径。例如 Desktop/dog.png。
   • OAUTH2_TOKEN 是您在第 1 步中生成的访问令牌。
   • OBJECT_CONTENT_TYPE 是该对象的内容类型，例如 image/png。
   • BUCKET_NAME 是对象要上传到的存储分区的名称。例如 my-bucket。
   • OBJECT_NAME 是您要为对象指定的网址编码名称。例如，pets/dog.png 的网址编码为 pets%2Fdog.png。

包含对象元数据的单一请求上传

注意：如需添加或更改 Cloud Storage 中现有对象的元数据，请参阅查看和修改对象元数据。

1. 从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。 如需了解相关说明，请参阅 API 身份验证。

2. 创建一个包含以下信息的 multipart/related 文件：

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

   其中：

   • BOUNDARY_STRING 是您定义的一个字符串，用于标识多部分文件的不同部分。例如 my-boundary。
   • OBJECT_METADATA 是您要包含的文件元数据（采用 JSON 格式）。此部分至少应包含对象的 name 特性，例如 {"name": "myObject"}。
   • OBJECT_CONTENT_TYPE 是该对象的内容类型，例如 image/png。
   • OBJECT_DATA 是对象的数据。

3. 使用 cURL，通过 POST Object 请求调用 JSON API：

   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"

   其中：

   • MULTIPART_FILE_LOCATION 是您在第 2 步中创建的多部分文件的本地路径。例如 Desktop/my-upload.multipart。
   • OAUTH2_TOKEN 是您在第 1 步中生成的访问令牌。
   • BOUNDARY_STRING 是您在第 2 步中定义的边界字符串。例如 my-boundary。
   • MULTIPART_FILE_SIZE 是您在第 2 步中创建的多部分文件的总大小（以字节为单位）。例如 2000000。
   • BUCKET_NAME 是对象要上传到的存储分区的名称。例如 my-bucket。

如果请求成功，服务器将返回 HTTP 200 OK 状态代码以及文件的元数据。

XML API

1. 从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。 如需了解相关说明，请参阅 API 身份验证。

2. 使用 cURL，通过 PUT Object 请求调用 XML API：

   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"

   其中：

   • OBJECT_LOCATION 是对象的本地路径。例如 Desktop/dog.png。
   • OAUTH2_TOKEN 是您在第 1 步中生成的访问令牌。
   • OBJECT_CONTENT_TYPE 是该对象的内容类型，例如 image/png。
   • BUCKET_NAME 是对象要上传到的存储分区的名称。例如 my-bucket。
   • OBJECT_NAME 是您要为对象指定的网址编码名称。例如，pets/dog.png 的网址编码为 pets%2Fdog.png。

在请求标头中上传对象时，您可以按照上述示例设置 Content-Type 相同的方式设置其他对象元数据。使用 XML API 时，您只能在写入对象时（例如上传、复制或替换对象时）设置元数据。如需了解详情，请参阅修改对象元数据。

后续步骤

• 了解对象的命名要求。
• 从 Compute Engine 实例转移对象。
• 从云服务商或其他在线来源转移数据，例如网址列表。
• 控制哪些人可以访问您的对象和存储桶。
• 查看对象的元数据，包括对象的网址。

自行试用

如果您是 Google Cloud 新手，请创建一个帐号来评估 Cloud Storage 在实际场景中的表现。新客户还可获享 $300 赠金，用于运行、测试和部署工作负载。

免费试用 Cloud Storage