將資料從 Amazon S3 移轉至 Cloud Storage

本頁說明如何建立及啟動從 Amazon S3 到 Cloud Storage 的移轉工作。

設定權限

建立轉移作業前，請務必先設定 Amazon S3 儲存空間的權限。詳情請參閱「設定來源存取權：Amazon S3」。

您也必須為下列Google Cloud 實體設定權限：

	用於建立轉移作業的使用者帳戶。這是登入 Google Cloud 控制台的帳戶，或是驗證 `gcloud` CLI 時指定的帳戶。使用者帳戶可以是一般使用者帳戶，也可以是使用者管理的服務帳戶。
	Storage 移轉服務使用的Google 代管服務帳戶，又稱為服務代理程式。這個帳戶通常會以電子郵件地址識別，格式為 [e-mail]。

如需操作說明，請參閱「無代理程式轉移權限」。

輸出選項

Storage 移轉服務提供多種選項，可將 S3 資料移轉至 Cloud Storage。

輸出選項	說明
預設無代理程式	這個選項會使用代管的無代理程式移轉服務，從 S3 移轉資料。Amazon 會向您收取輸出費用。 請按照這個頁面的說明操作，使用這項選項。
CloudFront 發布版本 <0x0A	將 Amazon CloudFront 分配指定為輸出路徑。相較於直接從 S3 移轉資料，透過 CloudFront 移轉資料可能享有較低的 AWS 輸出費用。詳情請參閱 CloudFront 定價和 S3 輸出費用。 請按照「透過 CloudFront 從 S3 轉移」一文的操作說明，設定發布作業並建立轉移作業。
代管的私人網路 <0x0A	透過 Google 管理的網路轉移資料。您不必支付 S3 輸出費用，而是要向Google Cloud支付每 GiB 的費率。詳情請參閱定價頁面。您可能仍須支付 AWS 的作業費用 (例如 LIST 或 GET通話)，詳情請參閱其定價。 所有專案透過代管私人網路進行的移轉作業，都會共用相同的頻寬。在用量較高的時段，轉移作業可能會變慢。相較於小型檔案，大型檔案的傳輸作業受到的影響較大。 如要使用這個選項，請按照這個頁面的指示操作。在 Google Cloud 控制台中指定「受管理私人網路」選項，或在 REST API 中指定 managedPrivateNetwork 欄位。gcloud CLI 和用戶端程式庫不支援代管私人網路轉移。請參閱支援的區域。
代理程式導向 <	適用於所有與 S3 相容的儲存空間，包括 Amazon S3。在可存取 S3 值區的機器上安裝代理程式軟體，即可控制網路路徑和頻寬。這個選項需要代理程式和代理程式集區。 如要使用這個選項，請按照「從與 S3 相容的來源轉移」一文中的操作說明進行。

支援的地區

Storage 移轉服務支援下列 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 區域：

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

轉移作業選項

從 S3 移轉至 Cloud Storage 時，可使用下列 Storage 移轉服務功能

使用資訊清單轉移特定檔案

您可以傳遞檔案清單，供 Storage 移轉服務處理。詳情請參閱「使用資訊清單轉移特定檔案或物件」。

依前置字串或上次修改時間篩選來源物件

您可以根據檔案名稱和路徑，或上次修改時間，選擇是否要將物件納入移轉作業。

前置字串篩選器說明請參閱「前置字串篩選器」。

依時間篩選的選項包括：

• 自上次修改以來經過的最短和最長時間。兩者都接受以秒為單位的時間值，用於篩選在特定時間範圍內修改或未修改的物件。
• 「上次修改時間晚於」和「上次修改日期早於」，兩者都接受 dateTime 值。

請注意，S3 傳輸作業的時間篩選器依據的是 AWS 對「上次修改時間」的定義，也就是物件開始上傳的時間。上傳完成前，物件都無法使用，因此您可能會發現上次修改時間符合篩選條件的物件仍在上傳中。這些物件不會納入移轉工作。為避免發生任何問題，建議採取下列做法：

• 請使用 [事件驅動式轉移](/storage-transfer/docs/event-driven-aws)功能，在物件可供轉移時轉移物件，而非使用時間篩選器。
• 為避免在週期性轉移作業中遺漏物件，「上次修改時間」回溯期應大於週期性排程。舉例來說，如果工作每小時執行一次，回溯時間範圍為兩小時，就能提供緩衝時間。

指定儲存空間級別

您可以指定目的地 bucket 中資料要使用的 Cloud Storage 儲存空間類別。如要查看 REST 詳細資料，請參閱 StorageClass 選項，或搭配 Google Cloud CLI 使用 --custom-storage-class 旗標。

請注意，如果目的地 bucket 啟用 Autoclass，系統會忽略所有儲存空間級別設定。如果啟用自動調整級別功能，轉移至 bucket 的物件一開始會設為 Standard Storage。

保存中繼資料

從 S3 移轉檔案時，Storage 移轉服務可以選擇保留特定屬性做為自訂中繼資料。

如要瞭解可保留的中繼資料，以及如何設定移轉作業，請參閱中繼資料保留一文的「Amazon S3 到 Cloud Storage」一節。

事件導向移轉作業

Storage 移轉服務可以監聽傳送至 Amazon SQS 的 Amazon S3 事件通知，自動移轉來源位置中新增或更新的資料。詳情請參閱「事件導向移轉作業」。

記錄和監控

您可以在 Cloud Logging 和 Cloud Monitoring 中查看從 S3 進行的轉移作業。詳情請參閱「適用於 Storage 移轉服務的 Cloud Logging」和「監控移轉工作」。您也可以設定 Pub/Sub 通知。

建立轉移作業

Storage 移轉服務提供多種介面，可供您建立移轉作業。

請勿在轉移作業名稱中加入個人識別資訊 (PII) 或安全性資料等私密資訊。資源名稱可能會傳播至其他 Google Cloud 資源的名稱，並可能向專案外部的 Google 內部系統公開。

Google Cloud 控制台

1. 前往 Google Cloud 控制台的「Storage Transfer Service」頁面。

   前往 Storage 移轉服務

2. 按一下「建立移轉工作」。系統隨即會顯示「建立移轉工作」頁面。

3. 在「來源類型」下方，選取「Amazon S3」。

4. 在「目的地類型」中選取「Google Cloud Storage」。

5. 選取「排程模式」。批次轉移作業會一次性或定期執行。事件驅動移轉會持續監控來源，並在資料新增或修改時移轉資料。

   如要設定以事件為依據的移轉作業，請按照「以事件為依據的移轉作業」中的操作說明進行。

6. 點選「下一步」。

7. 在「Bucket or folder name」(值區或資料夾名稱) 欄位中，輸入來源值區名稱。

   值區名稱即是在 AWS 管理主控台中顯示的名稱。

8. 如果使用 CloudFront 發布項目從 S3 轉移資料，請在「CloudFront 網域」欄位中輸入發布項目網域名稱。例如，https://dy1h2n3l4ob56.cloudfront.net。請參閱「透過 CloudFront 從 S3 轉移」一文，瞭解如何設定 CloudFront 發布。

9. 如要使用代管私人網路進行這項轉移作業，請選取核取方塊。詳情請參閱「輸出選項」。

10. 選取 Amazon Web Services (AWS) 驗證方法。詳情請參閱「設定來源的存取權：Amazon S3」一文。

    • 存取金鑰：在「Access key ID」(存取金鑰 ID) 欄位中輸入存取金鑰，並在「Secret access key」(私密存取金鑰) 欄位中輸入與存取金鑰相關聯的私密金鑰。

    • 用於連結身分識別的 AWS 身分與存取權管理角色：在「AWS IAM role ARN」(AWS 身分與存取權管理角色 ARN) 欄位中輸入 ARN，語法如下：

      arn:aws:iam::ACCOUNT:role/ROLE-NAME-WITH-PATH
      

      其中：

      • ACCOUNT：不含連字號的 AWS 帳戶 ID。
      • ROLE-NAME-WITH-PATH：AWS 角色名稱，包括路徑。

      如要進一步瞭解 ARN，請參閱 IAM ARN。

    • 密鑰資源：選取這個選項，即可使用儲存在 Secret Manager 中的 Amazon 憑證。從清單中選取密碼，或以 projects/PROJECT_NUMBER/secrets/SECRET_NAME 格式手動輸入密碼。

11. 如果是事件驅動型移轉，請輸入 Amazon SQS 佇列 ARN，格式如下：

    arn:aws:sqs:us-east-1:1234567890:event-queue
    

12. 視需要選擇依前置字元或上次修改日期篩選物件。如果您指定資料夾做為來源位置，前置字元篩選器會與該資料夾相關。舉例來說，如果來源是 my-test-bucket/path/，則 file 的納入篩選器會納入所有以 my-test-bucket/path/file 開頭的檔案。

13. 點選「下一步」。

14. 在「Bucket or folder」(值區或資料夾) 欄位中，輸入目的地值區和 (選用) 資料夾名稱，或按一下「Browse」(瀏覽)，從目前專案的現有值區清單中選取值區。如要建立新值區，請按一下「建立新值區」。

15. 點選「下一步」。

16. 選擇轉移工作的設定。

    1. 在「說明」欄位中輸入轉移作業的說明。最佳做法是輸入有意義且獨特的說明，方便您區分工作。

    2. 在「中繼資料選項」下方，選擇使用預設選項，或點選「查看及選取選項」，為所有支援的中繼資料指定值。詳情請參閱「保留中繼資料」。

    3. 在「何時要覆寫」下方，選取下列其中一個選項：

       • 如果不同：如果來源檔案與目的地檔案名稱相同，但 ETag 或總和檢查碼值不同，則覆寫目的地檔案。

       • 一律覆寫：來源檔案與目的地檔案的名稱相同時，一律覆寫目的地檔案 (即便檔案內容完全相同)。

    4. 在「何時刪除」下方，選取下列其中一個選項：

       • 永不：永不刪除來源或目的地的檔案。

       • 轉移檔案後，請從來源刪除檔案：將檔案轉移至目的地後，從來源刪除檔案。如果來源檔案未轉移 (例如目的地中已存在該檔案)，來源檔案就不會遭到刪除。

         重要事項： 如果沒有本機備份，這項操作就無法復原。

       • 如果檔案未同時存在於來源，則將檔案從目的地中刪除：如果目的地 Cloud Storage 值區中的檔案未同時存在於來源，則將檔案從 Cloud Storage 值區中刪除。

         這個選項可確保目的地 Cloud Storage bucket 與來源完全相符。

    5. 在「Notification options」(通知選項) 下方，選取 Pub/Sub 主題和要接收通知的事件。詳情請參閱「Pub/Sub 通知」。

17. 點選「下一步」。

18. 選擇排程選項：

    注意： 儲存空間移轉服務會以您的時區顯示移轉工作的時間表，但儲存時會採用世界標準時間 (UTC)。如果您所在位置會受到日光節約時間 (DST) 影響，則在 DST 開始或結束時，您的移轉工作時間表可能也會隨之改變。

    1. 在「Run once」下拉式選單中，選取下列其中一個選項：

       • 執行一次：執行一次移轉作業，開始時間由您選取。

       • 每天執行：每天執行一次轉移作業，開始時間由你選取。

         您可以視需要輸入結束日期，或將結束日期留白，讓轉移作業持續進行。

       • 每週執行：每週執行一次轉移作業，開始時間由您選取。

       • 按照自訂頻率執行：按照您選取的頻率執行移轉作業。你可以選擇以小時、天或週為間隔，定期重複轉移。

         您可以視需要輸入結束日期，或將結束日期留白，讓轉移作業持續進行。

    2. 在「Starting now」下拉式清單中，選取下列其中一個選項：

       • 立即開始：按一下「建立」後，系統會立即開始轉移。

       • 開始時間：在您選取的日期和時間開始轉移。按一下「日曆」，顯示日曆並選取開始日期。

    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 bucket。如要轉移至特定目錄，請指定 gs://STORAGE_BUCKET_NAME/STORAGE_FOLDER_PATH/，包括尾端斜線。

• --source-creds-file 會指定您電腦上本機檔案的相對路徑，其中包含轉移來源的 AWS 憑證。內容必須採用下列 JSON 格式：

  {
    "accessKeyId": string,
    "secretAccessKey": string
  }

其他選項包括：

• --do-not-run 可防止 Storage 移轉服務在提交指令後執行作業。如要執行工作，請更新工作以新增排程，或使用 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 啟用 Cloud Logging。詳情請參閱「適用於 Storage 移轉服務的 Cloud Logging」。

如要查看所有選項，請執行 gcloud transfer jobs create --help 或參閱gcloud參考說明文件。

REST

下列範例說明如何透過 REST API 使用 Storage 移轉服務。

使用 Storage 移轉服務 API 設定或編輯移轉工作時，系統時間必須為世界標準時間 (UTC)。如要進一步瞭解如何指定移轉工作排程，請參閱「排程」一文。

建立移轉工作時，請勿在 Amazon S3 值區來源名稱中加入 s3:// 前置字元。bucketName

免代理程式移轉

下列範例會使用標準無代理程式設定建立移轉工作。詳情請參閱 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 移轉服務。

以程式化方式設定或編輯移轉工作時，時間必須為世界標準時間 (UTC)。如要進一步瞭解如何指定移轉工作排程，請參閱「排程」一文。

如要進一步瞭解 Storage 移轉服務用戶端程式庫，請參閱開始使用 Storage 移轉服務用戶端程式庫。

將資料從 Amazon S3 移轉至 Cloud Storage

在此範例中，您會學習到如何將檔案從 Amazon S3 移至 Cloud Storage 值區。

建立移轉工作時，請勿在 Amazon S3 值區來源名稱中加入 s3:// 前置字元。bucketName

Storage 移轉服務用戶端程式庫不支援透過 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 移轉服務遷移指南。

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 移轉服務遷移指南。

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