上传对象

本页面介绍如何将对象上传到 Cloud Storage 存储分区。上传的对象包含要存储的数据以及所有关联元数据。如需查看概念性概览，请参阅上传和下载。

前提条件

如需将对象上传到项目中的存储分区，您必须拥有该项目的 storage.objects.create IAM 权限。如果您要在并非由您创建的项目中执行操作，则可能需要项目所有者为您提供一个拥有此权限的角色，例如 Storage Object Creator。

如需查看角色的完整列表，请参阅 Cloud Storage 角色。如果您需要一个拥有更多有限权限的角色，请参阅创建和管理自定义角色。

将对象上传到存储分区

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

控制台

在 Google Cloud Console 中，转到 Cloud Storage 浏览器页面。
转到浏览器
在存储分区列表中，点击要将对象上传到的存储分区的名称。
在存储分区的对象标签页中，执行以下任一操作：
- 将所需文件从桌面或文件管理器拖放到 Cloud Console 的主窗格中。
- 点击上传文件按钮，在出现的对话框中选择要上传的文件，然后点击打开。
注意：如果您使用的是 Chrome 浏览器，还支持上传文件夹。

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

gsutil

使用 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.

在请求标头中上传对象时，您可以使用 -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";
}

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

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

	// 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

如需了解详情，请参阅 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);
  }
}

Node.js

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

如需详细了解如何上传数据流、字符串或缓冲区，请参阅 File.save()。

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

PHP

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

在 GitHub 上查看反馈

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

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

使用 Blob.upload_from_file()、Blob.upload_from_filename() 或 Blob.upload_from_string() 方法上传对象。

在 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(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_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

  file = bucket.create_file local_file_path, file_name

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

REST API

JSON API

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

从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。
使用 cURL，通过 POST Object 请求调用 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。

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

从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。
创建一个包含以下信息的 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 是对象的数据。
使用 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

从 OAuth 2.0 Playground 获取授权访问令牌。将 Playground 配置为使用您自己的 OAuth 凭据。
使用 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。

在请求标头中上传对象时，您可以采用与上述示例设置 Content-Type 相同的方式设置其他对象元数据。使用 XML API 时，您只能在写入对象时（例如上传、移动或替换对象时）设置元数据。如需详细了解固定键和自定义元数据，请参阅对象元数据和修改对象元数据。

后续步骤

亲自尝试

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

免费试用 Cloud Storage