将数据从 Amazon S3 传输到 Cloud Storage

本页面介绍如何创建和启动从 Amazon S3 到 Cloud Storage 的转移作业。

配置权限

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

您还必须为以下 Google Cloud 实体配置权限:

用于创建转移作业的用户账号 。这是登录 Google Cloud 控制台的 账号,或向 `gcloud` CLI 进行身份验证时指定的 账号。用户账号可以 是常规用户账号,也可以是用户代管式服务账号。
Storage Transfer Service 使用的服务代理。此账号通常通过其电子邮件地址进行标识,该地址采用 project-PROJECT_NUMBER@storage-transfer-service. 格式。

如需查看相关说明,请参阅 无代理转移权限

出站流量选项

Storage Transfer Service 提供了多种将 S3 数据转移到 Cloud Storage 的方式。

出站流量选项 说明
默认无代理 此选项使用从 S3 进行的托管式无代理转移。Amazon 会向您收取出站流量费用。

按照此页面上的说明使用此选项。
CloudFront 分配 使用 Amazon CloudFront 分配作为出站流量路径。与直接从 S3 转移相比,通过 CloudFront 进行数据转移可能有助于降低 AWS 出站流量费用。如需了解详情,请参阅 CloudFront 价格S3 出站流量费用

按照 通过 CloudFront 从 S3 转移中的说明设置 分配并创建转移作业。
Google 管理的专用网络 通过 Google 管理的网络转移数据。您无需支付 S3 出站流量费用,而是按每 GiB 向 Google Cloud 支付费用,这可能会降低转移费用。如需了解详情,请参阅价格 页面。您可能仍需支付 AWS 的操作费用(例如 LISTGET 调用);如需了解详情,请参阅其价格。

通过托管式专用网络进行的所有项目的转移作业共享相同的带宽。在用量高峰期,您的转移作业可能会变慢。与小文件相比,大文件的转移作业受到的影响更大。

如需了解详情,请参阅 通过 Google 管理的专用网络进行转移
客户管理的专用网络 通过客户管理的专用网络转移数据。使用现有的跨云互连、合作伙伴互连,或购买并使用新连接。互连在 Google Cloud 和 Amazon S3 或 Azure 之间提供专用物理连接。

如需了解详情,请参阅 通过客户管理的专用网络从 AWS 或 Azure 转移
代理驱动型 适用于所有与 S3 兼容的存储空间,包括 Amazon S3。通过在有权访问 S3 存储分区的机器上安装代理软件,您可以控制网络路径和带宽。此选项需要代理和代理池。

按照 从与 S3 兼容的来源转移中的说明使用 此选项。

支持的区域

Storage Transfer Service 支持以下 Amazon S3 区域:
af-south-1
ap-east-1
ap-east-2
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
us-gov-east-1
us-gov-west-1
使用 Google 管理的专用网络进行的转移作业支持以下 AWS 区域:
ap-east-1
ap-northeast-1
ap-northeast-2
ap-northeast-3
ap-south-1
ap-south-2
ap-southeast-1
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
us-east-1
us-east-2
us-west-1
us-west-2
 

转移选项

以下 Storage Transfer Service 功能可用于从 S3 到 Cloud Storage 的转移作业

使用清单转移特定文件
您可以传递文件列表,供 Storage Transfer Service 对其执行操作。如需了解详情,请参阅 使用清单转移特定文件或 对象。
按前缀或最后修改时间过滤源对象

您可以选择根据 文件名和路径或最后修改时间,在转移作业中包含或排除对象。

前缀过滤条件在 “前缀过滤条件”中进行了说明。

基于时间的过滤条件包括:

  • 自上次修改以来经过的最短时间和最长时间, 自上次修改以来。两者都接受以秒为单位的值,以过滤 对象,这些对象在特定时间段内被修改或未被修改。
  • 自上次修改以来和上次修改之前,两者都接受 a dateTime 值。

请注意,S3 转移作业的基于时间的过滤条件依赖于 AWS 对“上次修改时间”的定义,即对象开始上传的时间。由于对象在上传完成之前不可用,因此您 可能会发现某些对象的上次修改时间符合您的过滤条件 但仍在上传。这些对象不会包含在您的 转移作业中。为避免任何问题,我们建议您执行以下操作:

  • 使用 事件驱动型 转移作业,在对象可用时转移对象,而不是使用基于时间的过滤条件。
  • 为防止在周期性转移作业中遗漏对象,“上次修改 时间”回溯窗口应大于周期性时间表。 例如,对于每小时运行一次的作业,两小时的回溯窗口可提供缓冲。
指定存储类别
您可以指定 Cloud Storage 存储类别,以用于目标 存储桶中的数据。如需了解 REST 详情,请参阅 StorageClass 选项,或将 --custom-storage-class 标志与 Google Cloud CLI 搭配使用。

请注意,如果目标 存储桶启用了 Autoclass,则系统会忽略所有存储类别设置。如果启用了 Autoclass,则转移到存储桶中的对象最初会 设置为 Standard Storage。

元数据保留

从 S3 转移文件时,Storage Transfer Service 可以 选择将某些特性以自定义元数据的形式保留。

如需详细了解可以保留哪些元数据以及如何配置转移作业,请参阅 元数据保留Amazon S3 到 Cloud Storage 部分。

事件驱动型转移
Storage Transfer Service 可以监听发送到 Amazon SQS 的 Amazon S3 事件通知,以自动转移来源位置中添加或更新的 数据。如需了解相关信息,请参阅 事件驱动型 转移
日志记录和监控
您可以在 Cloud Logging 和 Cloud Monitoring 中查看从 S3 进行的转移作业。如需了解详情,请参阅 适用于 Storage Transfer Service 的 Cloud Logging监控转移 作业。您还可以配置 Pub/Sub 通知

创建转移作业

Storage Transfer Service 提供了多个界面,您可以通过这些界面创建转移作业。

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

Google Cloud 控制台

  1. 进入Storage Transfer Service页面,在 Google Cloud 控制台中。

    转到 Storage Transfer Service

  2. 点击创建转移作业 。此时系统会显示创建转移 作业 页面。

  3. 来源类型 下,选择 Amazon S3

  4. 目标类型 下,选择 Google Cloud Storage

  5. 选择时间安排模式批量转移 是一次性或按计划执行的。事件驱动型转移 会持续监控来源,并在添加或修改数据时转移数据。

    如需配置事件驱动型转移,请按照 事件驱动型 转移中的说明操作。

  6. 点击下一步

  7. 存储桶或文件夹名称 字段中,输入数据源 存储桶名称。

    存储桶名称是其在 AWS 管理控制台中显示的名称。

  8. 如果您使用 CloudFront 分配从 S3 转移,请在 CloudFront 域名 字段中输入分配域名。 例如,https://dy1h2n3l4ob56.cloudfront.net。如需配置 CloudFront 分配,请参阅 通过 CloudFront 从 S3 转移

  9. 选择 Amazon Web Services (AWS) 身份验证方法。如需了解详情,请参阅 配置对 来源的访问权限:Amazon S3

    • 密钥资源:选择此选项可使用保存在 Secret Manager 中的 Amazon 凭据。从列表中选择一个密钥,或手动输入一个密钥,格式为projects/PROJECT_NUMBER/secrets/SECRET_NAME

    • 访问密钥:在 访问密钥 ID 字段中输入访问密钥,在 私有访问密钥 字段中输入与访问密钥关联的密钥。

    • 适用于身份联合的 AWS IAM 角色:在 AWS IAM 角色 ARN 字段中输入您的 ARN,语法如下:

      • 标准 AWS 区域:

        arn:aws:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME
      • AWS GovCloud 区域:

        arn:aws-us-gov:iam::AWS_ACCOUNT:role/AWS_ROLE_NAME

      替换以下内容:

      • AWS_ACCOUNT:无 连字符的 AWS 账号 ID。
      • AWS_ROLE_NAME:AWS 角色名称。如果 您的组织使用路径来整理角色,请将路径 与角色名称一起添加。例如, developers/transfer_user

      如需详细了解 ARN,请参阅 IAM ARN

  10. 如果是事件驱动型转移,请输入 Amazon SQS 队列 ARN,格式如下

    • 标准 AWS 区域:

      arn:aws:sqs:us-east-1:1234567890:event-queue
    • AWS GovCloud 区域:

      arn:aws-us-gov:sqs:us-gov-east-1:1234567890:event-queue
  11. (可选)选择按 前缀 或上次修改日期过滤对象。如果您将文件夹指定为来源位置,则前缀过滤条件是相对于该文件夹的。例如,如果您的来源是 my-test-bucket/path/,则 file 的包含过滤条件会包含所有以 my-test-bucket/path/file 开头的文件。

  12. 点击下一步

  13. 存储桶或文件夹 字段中,输入目标存储桶以及(可选)文件夹名称,或点击浏览 从当前项目的现有存储桶列表中选择一个存储桶。如需创建新存储桶,请点击 存储桶图标 创建新存储桶

  14. 点击下一步

  15. 选择时间安排选项:

    注意:Storage Transfer Service 以本地时区时间显示转移作业时间表,但会以世界协调时间 (UTC) 存储作业时间。如果您所在的区域使用夏令时 (DST),则夏令时开始或结束时您的转移作业时间表可能会 发生变化。

    1. 运行一次 下拉列表中,选择以下选项之一:

      • 运行一次:从您选择的时间开始运行一次转移作业。
      • 每天运行:每天从您选择的时间开始,每天运行转移作业。

        您可以输入可选的结束日期,或者将 结束日期留空以持续运行转移作业 。

      • 每周运行:从您选择的时间开始,每周运行一次转移作业。
      • 按自定义频率运行:按您选择的频率运行转移作业。您可以选择按照小时的固定间隔来重复运行转移作业。

        您可以输入可选的结束日期,或者将 结束日期留空以持续运行转移作业 。

      • 按需运行:创建此 转移作业时不会触发运行。您需要 手动 启动作业
    2. 立即开始 下拉列表中,选择以下选项之一:

      • 立即开始:点击 创建后开始转移作业。
      • 开始日期:在您选择的日期和 时间开始转移作业。点击日历 ,以显示一个 日历来选择开始日期。
  16. 点击下一步

  17. 选择转移作业的设置。

    1. 说明 字段中,输入转移作业的 说明。最佳做法是输入有意义 且唯一的说明,以便区分作业。

    2. (可选)提供 清单以指定 要转移的确切对象。

    3. 元数据选项下,选择所需的存储 类别和创建时间行为。如需了解详情,请参阅 元数据 保留

    4. 何时覆盖下,选择以下选项之一:

      • 永不:如果源文件同名,则不覆盖目标文件。系统会跳过源文件。
      • 如果不同:如果同名的源文件具有不同的 ETag 或校验和值,则覆盖目标文件。
      • 始终:当源文件同名时,即使源文件相同,也始终覆盖目标文件。
    5. 何时删除 下,选择以下选项之一:

      • 永不:永不从源 或目标中删除文件。
      • 在转移文件后从数据源删除文件 :将文件转移到目标位置后,从数据源中删除文件。如果未转移源文件(例如,因为目标位置中已存在该文件),则不会删除源文件。

        重要提示:如果您没有本地备份,则此选项是 不可逆转的操作。

      • 如果文件不在数据源中则从目标位置删除文件:如果目标 Cloud Storage 存储桶中的文件也不在数据源中,则从 Cloud Storage 存储桶中删除文件。

        此选项可确保目标 Cloud Storage 存储桶与您的数据源完全匹配。

    6. 选择网络路由选项

      • 使用公共网络:通过 Amazon S3 和 Google Cloud 之间的标准 公共互联网对等互连路由进行数据转移。 所有 API 命令、身份验证标头和对象数据流 在传输过程中都使用 HTTPS 和传输层 安全协议 (TLS 1.3) 进行端到端加密。
      • 使用托管式专用网络:数据通过 Google 自动预配的安全专用路由流动,从而减少 AWS 互联网出站流量费用,并绕过公共 互联网端点,而无需设置物理互连。 请参阅 通过 Google 管理的专用网络进行转移
      • 利用您自己的专用网络:数据通过 您自己的预配置混合连接基础架构(例如 Cloud Interconnect、Cloud VPN 或 AWS Direct Connect)通过专用 IP 地址传输。请参阅 通过客户管理的专用网络进行转移
    7. 日志记录选项下,如果您想生成对每个转移的文件执行的操作的精细记录,请选择在 Cloud Logging 中启用日志记录。需支付 Cloud Logging 费用。 如需了解详情,请参阅记录转移 操作

    8. (可选)选择 通过 Cloud Pub/Sub 通知获取转移操作状态更新),选择 Pub/Sub 主题,然后选择触发 通知事件。如需了解详情,请参阅 Pub/Sub 通知

    9. 选择服务帐号下,选择要使用的身份:

      • Storage Transfer Service 服务代理:系统会自动向默认的 Google 代管式服务代理授予对来源和目标存储分区的访问权限。
      • 用户管理的服务代理:使用您创建的自定义服务 账号。在选择此选项之前,请确保 您的服务帐号有权访问来源 存储桶、目标存储桶和 Pub/Sub。请参阅 使用 用户代管式服务代理
  18. 点击创建 以创建转移作业。

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=differentalways),以及是否要在转移过程中或之后 删除某些文件(--delete-from=destination-if-uniquesource-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 启用 Cloud Logging。如需了解详情,请参阅 适用于 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}")