此页面由 Cloud Translation API 翻译。

将数据从 Amazon S3 传输到 Cloud Storage

本页面介绍了如何从以下位置创建和启动转移作业 Amazon S3 到 Cloud Storage。

配置权限

创建转移作业之前，您必须在 Amazon S3 上配置权限存储桶。如需了解详情，请参阅配置对来源的访问权限：Amazon S3。

您还必须为以下内容配置权限： Google Cloud 实体：

	用于创建转移作业的用户账号。这是或登录 Google Cloud 控制台的账号在向“gcloud”CLI 进行身份验证时指定。用户账号可以是常规用户账号或用户代管式服务账号。
	Google 管理的服务账号（也称为服务）由 Storage Transfer Service 使用。该账号通常由电子邮件地址，格式为 `project-PROJECT_NUMBER@storage-transfer-service.iam.gserviceaccount.com`.

请参阅无代理转移权限： instructions.

出站流量选项

Storage Transfer Service 提供了多种 S3 数据转移方案 Cloud Storage

出站选项	说明
默认无代理	此选项使用代管式无代理转移从 S3 开始。Amazon 向您收取出站流量费用。请按照此页面上的说明选项。
CloudFront 分布	将 Amazon CloudFront 分布用作出站流量路径。通过 CloudFront 进行的数据传输可能会 AWS 出站流量费用比直接从 S3 进行转移。请参阅 CloudFront 价格和 S3 出站流量费用了解详情。请按照通过 CloudFront 从 S3 转移以进行设置并创建转移作业。
代管式专用网络	通过由 Google 管理的。您无需付费 S3 出站流量费用；而是按每 GiB 的费率付费 Google Cloud请参阅价格页面了解详情。您可能仍需支付相关费用来自 AWS 的运维费用（例如，`LIST` 或 `GET` 调用）；如需了解详情，请参阅其定价。所有项目的通过代管式专用网络共享带宽相同在高使用量期间，您的转移作业可能会运行缓慢。包含大型文件的传输受到的影响大于处理小文件。请按照此页面上的说明使用此选项。指定使用 Google Cloud 控制台中的代管式专用网络选项，或 REST API 中的 `managedPrivateNetwork` 字段。gcloud CLI 和客户端库不支持代管式专用网络传输。请参阅支持的区域。
由代理驱动	适用于所有与 S3 兼容的存储，包括 Amazon S3。修改者在具有访问权限的机器上安装代理软件复制到 S3 存储分区中，您就可以控制路径和带宽。此选项需要代理和代理池请按照以下网址中的说明操作：从 S3 兼容的来源转移以供使用此选项。

支持的区域

Storage Transfer Service 支持以下 Amazon S3 区域：

af-south-1
ap-east-1
ap-northeast-1
ap-northeast-2
ap-northeast-3
ap-south-1
ap-south-2
ap-southeast-1
ap-southeast-2
ap-southeast-3 ap-southeast-4
ca-central-1
ca-west-1
eu-central-1
eu-central-2
eu-north-1
eu-south-1
eu-south-2
eu-west-1
eu-west-2 eu-west-3
il-central-1
me-central-1
me-south-1
sa-east-1
us-east-1
us-east-2
us-west-1
us-west-2

使用代管式专用网络进行传输时，支持以下 AWS 区域：

us-east-1
us-east-2
us-west-1
us-west-2
ca-west-1
ca-central-1

转移选项

以下 Storage Transfer Service 功能适用于从从 S3 迁移到 Cloud Storage

使用清单传输特定文件

您可以传递一系列文件，以供 Storage Transfer Service 进行处理。请参阅转移特定文件或对象。

指定存储类别

您可以指定 Cloud Storage 存储类别，用于目标位置的数据存储桶。请参阅 <ph type="x-smartling-placeholder"></ph> StorageClass 选项，或使用 --custom-storage-class 标志。

请注意，如果目标位置存储桶已启用 Autoclass。如果 Autoclass 已启用，转移到存储桶的对象最初会设置为 Standard Storage。

元数据保留

从 S3 传输文件时，Storage Transfer Service 可以可以选择将某些属性保留为自定义元数据。

请参阅 Amazon S3 到 Cloud Storage 部分， <ph type="x-smartling-placeholder"></ph> 元数据保留：详细了解可以将哪些元数据以及如何配置转移作业。

事件驱动型转移

Storage Transfer Service 可以监听发送到 Amazon SQS，用于自动转移已添加或更新的数据来源位置中请参阅事件驱动型传输。

日志记录和监控

可以在 Cloud Logging 中查看来自 S3 的转移作业， Cloud Monitoring。请参阅适用于 Storage Transfer Service 和监控传输 “作业”了解详情。你还可以 Pub/Sub 通知。

创建转移作业

Storage Transfer Service 提供了多种接口，通过这些接口。

请勿在转移作业名称中包含敏感信息，例如个人身份信息 (PII) 或安全数据。资源名称可能会传播到其他 Google Cloud 资源的名称，并且可能会向您项目之外的 Google 内部系统公开。

Google Cloud 控制台

转到 Google Cloud 控制台中的 Storage Transfer Service 页面。

转到 Storage Transfer Service
点击创建转移作业。系统随即会显示创建转移作业页面。
在来源类型下，选择 Amazon S3。
选择 Google Cloud Storage 作为目标类型。
选择时间安排模式。批量转移是一次性或按计划执行的。事件驱动型转移会持续监控来源，并在添加或修改数据时转移数据。

如需配置事件驱动型转移，请按照事件驱动型转移中的说明操作。
点击下一步。
在存储桶或文件夹名称字段中，输入数据源存储桶名称。

存储分区名称是其在 AWS 管理控制台中显示的名称。
如果您使用 CloudFront 发行版从 S3 传输数据，在 CloudFront 网域中输入分发域名字段。例如 https://dy1h2n3l4ob56.cloudfront.net。请参阅通过 CloudFront 从 S3 转移来配置 CloudFront 分发。
如需将代管式专用网络用于此转移作业，请选择复选框。如需了解详情，请参阅出站流量选项。
选择 Amazon Web Services (AWS) 身份验证方法。请参阅如需了解详情，请配置对来源：Amazon S3 的访问权限。
- 访问密钥：在访问密钥 ID 字段中输入访问密钥，在私有访问密钥字段中输入与访问密钥关联的 Secret。
- 身份联合的 AWS IAM 角色：在 AWS IAM 角色 ARN 字段，使用如下语法：
```
arn:aws:iam::ACCOUNT:role/ROLE-NAME-WITH-PATH
```
  其中：
  - ACCOUNT：无连字符的 AWS 账号 ID。
  - ROLE-NAME-WITH-PATH：AWS 角色名称，包括路径。
  如需详细了解 ARN，请参阅 IAM ARN。
- Secret 资源：选择此选项可使用 Amazon 凭据保存在 Secret Manager 中。从列表中选择一个 Secret，或请手动输入一个 projects/PROJECT_NUMBER/secrets/SECRET_NAME.
如果是事件驱动型转移，请输入 Amazon SQS 队列 ARN，格式如下：
```
arn:aws:sqs:us-east-1:1234567890:event-queue
```
（可选）选择按前缀过滤对象或按上次修改日期排序。如果您将文件夹指定为来源位置，请使用前缀过滤条件所有文件例如，如果您的来源是 my-test-bucket/path/， “file”的“包含”过滤条件可包含以下列内容开头的所有文件： my-test-bucket/path/file.
点击下一步。
在存储桶或文件夹字段中，输入目标存储桶以及（可选）文件夹名称，或点击浏览从当前项目的现有存储桶列表中选择一个存储桶。如需创建新存储桶，请点击 创建新存储桶。
点击下一步。
为转移作业选择设置。
1. 在说明字段中，输入转移作业的说明。最佳做法是输入有意义且唯一的说明，以便区分作业。
2. 在元数据选项下，您可以选择使用默认选项，也可以点击查看和选择选项为所有受支持的元数据指定值。如需了解详情，请参阅元数据保留。
3. 在何时覆盖下，选择以下选项之一：
  - 如果不同：如果同名的源文件具有不同的 ETag 或校验和值，则覆盖目标文件。
  - 始终：当源文件同名时，即使源文件相同，也始终覆盖目标文件。
4. 在何时删除下，选择以下选项之一：
  - 永不：永不从源或目标中删除文件。
  - 在转移文件后从数据源删除文件：将文件转移到目标位置后，从数据源中删除文件。
    
    重要提示：如果您没有本地备份，则此选项是不可逆转的操作。
  - 如果文件不在数据源中则从目标位置删除文件：如果目标 Cloud Storage 存储桶中的文件也不在数据源中，则从 Cloud Storage 存储桶中删除文件。
    
    此选项可确保目标 Cloud Storage 存储桶与您的数据源完全匹配。
5. 在通知选项下，选择 Pub/Sub 主题以及要通知的事件。如需了解详情，请参阅 Pub/Sub 通知。
点击下一步。
选择时间安排选项：

注意：Storage Transfer Service 以本地时区时间显示转移作业时间表，但会以世界协调时间 (UTC) 存储作业时间。如果您所在的区域使用夏令时 (DST)，则夏令时开始或结束时您的转移作业时间表可能会发生变化。
1. 从运行一次下拉列表中，选择以下选项之一：
  - 运行一次：从您选择的时间开始运行一次转移作业。
  - 每天运行：每天从您选择的时间开始，每天运行转移作业。
    
    您可以输入可选的结束日期，或者将结束日期留空以持续运行转移作业。
  - 每周运行：从您选择的时间开始，每周运行一次转移作业。
  - 按自定义频率运行：按您选择的频率运行转移作业。您可以选择按照小时、天或周的固定间隔来重复运行转移作业。
    
    您可以输入可选的结束日期，或者将结束日期留空以持续运行转移作业。
2. 从立即开始下拉列表中，选择以下选项之一：
  - 立即开始：点击创建后开始转移作业。
  - 开始日期：在您选择的日期和时间开始转移作业。点击日历，以显示一个日历来选择开始日期。
3. 要创建转移作业，请点击创建。

gcloud CLI

如需创建新的转移作业，请使用 gcloud transfer jobs create 命令。除非指定了时间表或 --do-not-run，否则创建新作业时会启动指定的转移作业。

gcloud CLI 不支持 CloudFront 或代管式专用网络。

gcloud transfer jobs create \
  s3://S3_BUCKET_NAME gs://STORAGE_BUCKET_NAME \
  --source-creds-file="relative_path/to/creds.json"

其中：

S3_BUCKET_NAME 是此转移作业的数据源。您可以（可选）添加路径： s3://S3_BUCKET_NAME/S3_FOLDER_PATH
STORAGE_BUCKET_NAME 是要转移的 Cloud Storage 存储桶。如需转移到特定目录，请指定 gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/，包括尾部斜杠。
--source-creds-file 指定本地文件的相对路径，该机器包含转移来源的 AWS 凭据。内容必须采用以下 JSON 格式：
```
{
  "accessKeyId": string,
  "secretAccessKey": string
}
```

其他选项包括：

--do-not-run 可阻止 Storage Transfer Service 在提交命令后运行作业。如需运行作业，请更新作业以添加时间表，或使用 jobs run 来手动启动作业。
--manifest-file 指定 Cloud Storage 中 CSV 文件的路径，该文件包含要从来源转移的文件的列表。如需了解清单文件的格式，请参阅使用清单转移特定文件或对象。
作业信息：您可以指定 --name 和 --description。
时间表：您可以指定 --schedule-starts、--schedule-repeats-every 和 --schedule-repeats-until 或 --do-not-run。
对象条件：您可以使用条件确定要转移的对象。这些条件包括 --include-prefixes 和 --exclude-prefixes 以及 --include-modified-[before | after]-[absolute | relative] 中基于时间的条件。如果您则前缀过滤条件是相对于该文件夹的文件夹中。有关详情，请参阅按前缀过滤源对象信息。
转移选项：指定是否覆盖目标文件（--overwrite-when=different 或 always），以及是否要在转移过程中或之后删除某些文件（--delete-from=destination-if-unique 或 source-after-transfer）；指定要保留的元数据值 (--preserve-metadata)；（可选）为转移的对象设置存储类别 (--custom-storage-class)。
通知：使用 --notification-pubsub-topic、--notification-event-types 和 --notification-payload-format 为转移作业配置 Pub/Sub 通知。
Cloud Logging：使用 --log-actions 和 --log-action-states。如需了解详情，请参阅适用于 Storage Transfer Service 的 Cloud Logging。

如需查看所有选项，请运行 gcloud transfer jobs create --help 或参阅 gcloud 参考文档。

REST

以下示例展示了如何通过 REST API 使用 Storage Transfer Service。

使用 Storage Transfer Service API 配置或编辑转移作业时，必须采用世界协调时间 (UTC)。如需详细了解如何指定转移作业的时间表，请参阅时间表。

创建转移作业时，请勿在 Amazon S3 存储桶来源名称中为 bucketName 添加 s3:// 前缀。

无代理转移

以下示例使用标准无代理标准配置。请参阅 transferJobs.create 参考资料。

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

请参阅配置对来源的访问权限：Amazon S3 了解其他身份验证选项。

CloudFront 分布

如果您要通过 CloudFront 发行版从 S3 进行转移，请指定作为 transferSpec.awsS3DataSource.cloudfrontDomain 字段：

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "cloudfrontDomain": "https://dy1h2n3l4ob56.cloudfront.net",
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

代管式专用网络

如需使用 Google 管理的专用网络从 S3 进行转移，请指定 transferSpec.awsS3DataSource.managedPrivateNetwork 字段：

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  "description": "DESCRIPTION",
  "status": "ENABLED",
  "projectId": "PROJECT_ID",
  "transferSpec": {
      "awsS3DataSource": {
          "bucketName": "AWS_SOURCE_NAME",
          "managedPrivateNetwork": TRUE,
          "awsAccessKey": {
            "accessKeyId": "AWS_ACCESS_KEY_ID",
            "secretAccessKey": "AWS_SECRET_ACCESS_KEY"
          }
      },
      "gcsDataSink": {
          "bucketName": "GCS_SINK_NAME"
      }
  }
}

客户端库

以下示例展示了如何通过 Go、Java、Node.js 和 Python 以编程方式使用 Storage Transfer Service。

以编程方式配置或修改转移作业时，必须采用世界协调时间 (UTC)。如需详细了解如何指定转移作业的时间表，请参阅时间表。

如需详细了解 Storage Transfer Service 客户端库，请参阅 Storage Transfer Service 客户端库使用入门。

将数据从 Amazon S3 传输到 Cloud Storage

在此示例中，您将学习如何将文件从 Amazon S3 迁移至 Cloud Storage 存储桶。

创建转移作业时，请勿在 Amazon S3 存储桶来源名称中为 bucketName 添加 s3:// 前缀。

Storage Transfer Service 客户端库不支持 CloudFront 或代管式专用网络。

Go

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

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
	"google.golang.org/genproto/googleapis/type/date"
	"google.golang.org/genproto/googleapis/type/timeofday"
)

func transferFromAws(w io.Writer, projectID string, awsSourceBucket string, gcsSinkBucket string) (*storagetransferpb.TransferJob, error) {
	// Your Google Cloud Project ID
	// projectID := "my-project-id"

	// The name of the Aws bucket to transfer objects from
	// awsSourceBucket := "my-source-bucket"

	// The name of the GCS bucket to transfer objects to
	// gcsSinkBucket := "my-sink-bucket"

	ctx := context.Background()
	client, err := storagetransfer.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("storagetransfer.NewClient: %w", err)
	}
	defer client.Close()

	// A description of this job
	jobDescription := "Transfers objects from an AWS bucket to a GCS bucket"

	// The time to start the transfer
	startTime := time.Now().UTC()

	// The AWS access key credential, should be accessed via environment variable for security
	awsAccessKeyID := os.Getenv("AWS_ACCESS_KEY_ID")

	// The AWS secret key credential, should be accessed via environment variable for security
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId:   projectID,
			Description: jobDescription,
			TransferSpec: &storagetransferpb.TransferSpec{
				DataSource: &storagetransferpb.TransferSpec_AwsS3DataSource{
					AwsS3DataSource: &storagetransferpb.AwsS3Data{
						BucketName: awsSourceBucket,
						AwsAccessKey: &storagetransferpb.AwsAccessKey{
							AccessKeyId:     awsAccessKeyID,
							SecretAccessKey: awsSecretKey,
						}},
				},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{BucketName: gcsSinkBucket}},
			},
			Schedule: &storagetransferpb.Schedule{
				ScheduleStartDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				ScheduleEndDate: &date.Date{
					Year:  int32(startTime.Year()),
					Month: int32(startTime.Month()),
					Day:   int32(startTime.Day()),
				},
				StartTimeOfDay: &timeofday.TimeOfDay{
					Hours:   int32(startTime.Hour()),
					Minutes: int32(startTime.Minute()),
					Seconds: int32(startTime.Second()),
				},
			},
			Status: storagetransferpb.TransferJob_ENABLED,
		},
	}
	resp, err := client.CreateTransferJob(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("failed to create transfer job: %w", err)
	}
	if _, err = client.RunTransferJob(ctx, &storagetransferpb.RunTransferJobRequest{
		ProjectId: projectID,
		JobName:   resp.Name,
	}); err != nil {
		return nil, fmt.Errorf("failed to run transfer job: %w", err)
	}
	fmt.Fprintf(w, "Created and ran transfer job from %v to %v with name %v", awsSourceBucket, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

想要寻找较早的示例？请参阅 Storage Transfer Service 迁移指南。


import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto.CreateTransferJobRequest;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsAccessKey;
import com.google.storagetransfer.v1.proto.TransferTypes.AwsS3Data;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.Schedule;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob.Status;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import com.google.type.Date;
import com.google.type.TimeOfDay;
import java.io.IOException;
import java.util.Calendar;

public class TransferFromAws {

  // Creates a one-off transfer job from Amazon S3 to Google Cloud Storage.
  public static void transferFromAws(
      String projectId,
      String jobDescription,
      String awsSourceBucket,
      String gcsSinkBucket,
      long startDateTime)
      throws IOException {

    // Your Google Cloud Project ID
    // String projectId = "your-project-id";

    // A short description of this job
    // String jobDescription = "Sample transfer job from S3 to GCS.";

    // The name of the source AWS bucket to transfer data from
    // String awsSourceBucket = "yourAwsSourceBucket";

    // The name of the GCS bucket to transfer data to
    // String gcsSinkBucket = "your-gcs-bucket";

    // What day and time in UTC to start the transfer, expressed as an epoch date timestamp.
    // If this is in the past relative to when the job is created, it will run the next day.
    // long startDateTime =
    //     new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2000-01-01 00:00:00").getTime();

    // The ID used to access your AWS account. Should be accessed via environment variable.
    String awsAccessKeyId = System.getenv("AWS_ACCESS_KEY_ID");

    // The Secret Key used to access your AWS account. Should be accessed via environment variable.
    String awsSecretAccessKey = System.getenv("AWS_SECRET_ACCESS_KEY");

    // Set up source and sink
    TransferSpec transferSpec =
        TransferSpec.newBuilder()
            .setAwsS3DataSource(
                AwsS3Data.newBuilder()
                    .setBucketName(awsSourceBucket)
                    .setAwsAccessKey(
                        AwsAccessKey.newBuilder()
                            .setAccessKeyId(awsAccessKeyId)
                            .setSecretAccessKey(awsSecretAccessKey)))
            .setGcsDataSink(GcsData.newBuilder().setBucketName(gcsSinkBucket))
            .build();

    // Parse epoch timestamp into the model classes
    Calendar startCalendar = Calendar.getInstance();
    startCalendar.setTimeInMillis(startDateTime);
    // Note that this is a Date from the model class package, not a java.util.Date
    Date startDate =
        Date.newBuilder()
            .setYear(startCalendar.get(Calendar.YEAR))
            .setMonth(startCalendar.get(Calendar.MONTH) + 1)
            .setDay(startCalendar.get(Calendar.DAY_OF_MONTH))
            .build();
    TimeOfDay startTime =
        TimeOfDay.newBuilder()
            .setHours(startCalendar.get(Calendar.HOUR_OF_DAY))
            .setMinutes(startCalendar.get(Calendar.MINUTE))
            .setSeconds(startCalendar.get(Calendar.SECOND))
            .build();
    Schedule schedule =
        Schedule.newBuilder()
            .setScheduleStartDate(startDate)
            .setScheduleEndDate(startDate)
            .setStartTimeOfDay(startTime)
            .build();

    // Set up the transfer job
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setDescription(jobDescription)
            .setProjectId(projectId)
            .setTransferSpec(transferSpec)
            .setSchedule(schedule)
            .setStatus(Status.ENABLED)
            .build();

    // Create a Transfer Service client
    StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create();

    // Create the transfer job
    TransferJob response =
        storageTransfer.createTransferJob(
            CreateTransferJobRequest.newBuilder().setTransferJob(transferJob).build());

    System.out.println("Created transfer job from AWS to GCS:");
    System.out.println(response.toString());
  }
}

Node.js


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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of the Google Cloud Platform Project that owns the job
// projectId = 'my-project-id'

// A useful description for your transfer job
// description = 'My transfer job'

// AWS S3 source bucket name
// awsSourceBucket = 'my-s3-source-bucket'

// AWS Access Key ID
// awsAccessKeyId = 'AKIA...'

// AWS Secret Access Key
// awsSecretAccessKey = 'HEAoMK2.../...ku8'

// Google Cloud Storage destination bucket name
// gcsSinkBucket = 'my-gcs-destination-bucket'

// Creates a client
const client = new StorageTransferServiceClient();

/**
 * Creates a one-time transfer job from Amazon S3 to Google Cloud Storage.
 */
async function transferFromS3() {
  // Setting the start date and the end date as the same time creates a
  // one-time transfer
  const now = new Date();
  const oneTimeSchedule = {
    day: now.getDate(),
    month: now.getMonth() + 1,
    year: now.getFullYear(),
  };

  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      description,
      status: 'ENABLED',
      schedule: {
        scheduleStartDate: oneTimeSchedule,
        scheduleEndDate: oneTimeSchedule,
      },
      transferSpec: {
        awsS3DataSource: {
          bucketName: awsSourceBucket,
          awsAccessKey: {
            accessKeyId: awsAccessKeyId,
            secretAccessKey: awsSecretAccessKey,
          },
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
        },
      },
    },
  });

  console.log(
    `Created and ran a transfer job from '${awsSourceBucket}' to '${gcsSinkBucket}' with name ${transferJob.name}`
  );
}

transferFromS3();

Python

想要寻找较早的示例？请参阅 Storage Transfer Service 迁移指南。

from datetime import datetime

from google.cloud import storage_transfer


def create_one_time_aws_transfer(
    project_id: str,
    description: str,
    source_bucket: str,
    aws_access_key_id: str,
    aws_secret_access_key: str,
    sink_bucket: str,
):
    """Creates a one-time transfer job from Amazon S3 to Google Cloud
    Storage."""

    client = storage_transfer.StorageTransferServiceClient()

    # The ID of the Google Cloud Platform Project that owns the job
    # project_id = 'my-project-id'

    # A useful description for your transfer job
    # description = 'My transfer job'

    # AWS S3 source bucket name
    # source_bucket = 'my-s3-source-bucket'

    # AWS Access Key ID
    # aws_access_key_id = 'AKIA...'

    # AWS Secret Access Key
    # aws_secret_access_key = 'HEAoMK2.../...ku8'

    # Google Cloud Storage destination bucket name
    # sink_bucket = 'my-gcs-destination-bucket'

    now = datetime.utcnow()
    # Setting the start date and the end date as
    # the same time creates a one-time transfer
    one_time_schedule = {"day": now.day, "month": now.month, "year": now.year}

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "schedule": {
                    "schedule_start_date": one_time_schedule,
                    "schedule_end_date": one_time_schedule,
                },
                "transfer_spec": {
                    "aws_s3_data_source": {
                        "bucket_name": source_bucket,
                        "aws_access_key": {
                            "access_key_id": aws_access_key_id,
                            "secret_access_key": aws_secret_access_key,
                        },
                    },
                    "gcs_data_sink": {
                        "bucket_name": sink_bucket,
                    },
                },
            }
        }
    )

    result = client.create_transfer_job(transfer_job_request)
    print(f"Created transferJob: {result.name}")