Amazon S3 から Cloud Storage への転送

このページでは、Amazon S3 から Cloud Storage への転送ジョブを作成して開始する方法について説明します。

権限を構成する

転送を作成する前に、Amazon S3 バケットの権限を構成する必要があります。詳細については、ソースへのアクセスを構成する: Amazon S3 をご覧ください。

次の Google Cloud エンティティの権限も構成する必要があります。

	転送の作成に使用されているユーザー アカウント 。これは、コンソールにログインしているアカウント、または「gcloud CLI」の認証時に指定されたアカウントです。 Google Cloud ユーザー アカウントは 通常のユーザー アカウントでも、ユーザーが管理するサービス アカウントでもかまいません。
	Google 管理のサービス アカウントは、サービス エージェントとも呼ばれ、Storage Transfer Service で使用されます。通常、このアカウントは、[e-mail] という形式を使用するメールアドレスで識別されます。

手順については、 エージェントレス転送の権限をご覧ください。

下り（外向き）オプション

Storage Transfer Service には、S3 データを Cloud Storage に転送する方法が複数用意されています。

下り（外向き）オプション	説明
デフォルトのエージェントレス	このオプションでは、S3 からのエージェントレス マネージド転送を使用します。下り（外向き）は Amazon によって課金されます。 このオプションを使用するには、このページの手順に沿って操作してください。
CloudFront ディストリビューション	Amazon CloudFront ディストリビューションを下り（外向き）パスとして使用します。CloudFront を介したデータ転送では、S3 から直接転送する場合と比較して、AWS の下り（外向き）コストが低くなる可能性があります。詳細については、 CloudFront の料金と S3 下り（外向き）料金 をご覧ください。 ディストリビューションを設定して転送を作成するには、 CloudFront 経由で S3 から転送するの手順に沿って操作してください。
Google が管理するプライベート ネットワーク	Google 管理のネットワーク経由でデータを転送します。S3 の下り（外向き）料金は発生しません。代わりに、GiB あたりの料金を Google Cloud に支払います。詳細については、料金 のページをご覧ください。AWS からオペレーション料金（LIST 呼び出しや GET 呼び出しなど）が請求される場合があります。詳細については、AWS の料金をご覧ください。 マネージド プライベート ネットワーク経由のすべてのプロジェクトの転送で、同じ帯域幅が共有されます。使用量が多い場合、転送が遅くなることがあります。サイズの小さいファイルよりもサイズの大きいファイルの方が影響を受けます。 このオプションを使用するには、このページの手順に沿って操作してください。 コンソールで [Managed private network] オプションを指定するか、 REST API で managedPrivateNetwork フィールドを指定します。 Google Cloud gcloud CLI とクライアント ライブラリは、マネージド プライベート ネットワーク転送をサポートしていません。サポートされているリージョンをご覧ください 。
顧客が管理するプライベート ネットワーク	顧客が管理するプライベート ネットワーク経由でデータを転送します。既存の Cross-Cloud Interconnect または Partner Interconnect を使用するか、新しい接続を購入して使用します。Interconnect は、Google Cloud と Amazon S3 または Azure の間に専用の物理接続を提供します。 詳細については、 顧客が管理するプライベート ネットワーク経由で AWS または Azure から転送する をご覧ください。
エージェント主導	Amazon S3 を含むすべての 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

us-gov-east-1 us-gov-west-1

マネージド プライベート ネットワークを使用する転送では、次の 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 Transfer Service 機能を使用できます。

マニフェストを使用して特定のファイルを転送する

Storage Transfer Service が処理するファイルのリストを渡すことができます。詳細については、 マニフェストを使用して特定のファイルまたは オブジェクトを転送するをご覧ください。

ソース オブジェクトを前方一致または最終更新日時でフィルタする

ファイル名とパス、または最終更新日時に基づいて、転送に含めるオブジェクトと除外するオブジェクトを選択できます。

接頭辞フィルタについては、 接頭辞 フィルタをご覧ください。

時間ベースのフィルタには次のものがあります。

• 最終更新からの経過時間の最小値と最大値。 どちらも秒単位の値を受け取り、特定の期間内に変更されたオブジェクトと変更されなかったオブジェクトをフィルタします。
• 最終更新日時以降と最終更新日時以前。どちらも dateTime 値を受け取ります。

S3 転送の時間ベースのフィルタは、AWS の 「最終更新日時」の定義（オブジェクトのアップロードが開始された時刻）に依存します。オブジェクトはアップロードが完了するまで使用できないため、最終更新日時がフィルタ条件を満たしているにもかかわらず、アップロード中のオブジェクトが見つかることがあります。これらのオブジェクトは転送ジョブに含まれません。問題を回避するため、次のことをおすすめします。

• 時間ベースのフィルタではなく、 イベント ドリブン 転送を使用して、オブジェクトが使用可能になったときに転送します。
• 定期的な転送でオブジェクトが欠落しないように、「最終更新日時」のルックバック ウィンドウを定期的なスケジュールよりも長くする必要があります。たとえば、1 時間ごとに実行されるジョブの場合、2 時間のルックバック ウィンドウを使用するとバッファが提供されます。

ストレージ クラスを指定する

転送先バケットのデータに使用する Cloud Storage ストレージ クラスを指定できます。REST の詳細については、 StorageClass オプションを参照するか、Google Cloud CLI で --custom-storage-class フラグを使用します。

転送先バケットで Autoclass が有効になっている場合、ストレージ クラスの設定は無視されることに留意してください。Autoclass が有効になっている場合、バケットに転送されたオブジェクトは最初に Standard Storage に設定されます。

メタデータの保持

S3 からファイルを転送する際に、Storage Transfer Service は 特定の属性をカスタム メタデータとして任意に保持できます。

保持できるメタデータの詳細と転送の構成方法については、 メタデータの保持のAmazon S3 から Cloud Storage セクションをご覧ください。

イベント ドリブン転送

Storage Transfer Service は、Amazon SQS に送信された Amazon S3 イベント通知をリッスンし、ソースのロケーションで追加または更新されたデータを自動的に転送できます。詳細については、 イベント ドリブン 転送をご覧ください。

ロギングとモニタリング

S3 からの転送は、Cloud Logging と Cloud Monitoring で確認できます。詳細については、 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. スケジュール モードを選択します。バッチ転送は、1 回限りまたはスケジュールに基づいて実行されます。イベント ドリブン転送は、ソースを継続的にモニタリングし、追加や変更が行われるとデータを転送します。

   イベント ドリブン転送を構成するには、イベント ドリブン転送の手順を実施します。

6. [次のステップ] をクリックします。

7. [バケットまたはフォルダの名前] フィールドに、転送元バケットの名前を入力します。

   このバケット名は、AWS Management Console に表示される名前です。

8. CloudFront ディストリビューションを使用して S3 から転送する場合は、[CloudFront ドメイン] フィールドにディストリビューション ドメイン名を入力します。たとえば、https://dy1h2n3l4ob56.cloudfront.net のようにします。CloudFront ディストリビューションを構成するには、CloudFront 経由で S3 から転送するをご覧ください。

9. この転送にマネージド プライベート ネットワーク を使用するには、チェックボックスをオンにします。詳細については、下り（外向き）オプションをご覧ください。

10. アマゾン ウェブ サービス（AWS）の認証方法を選択します。詳細については、 ソースへのアクセスを構成する: Amazon S3をご覧ください。

    • アクセスキー: [アクセスキー ID] フィールドにアクセスキーを入力し、[シークレット アクセスキー] フィールドにアクセス キーに関連付けられたシークレットを入力します。

    • 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 をご覧ください。

    • シークレット リソース: Secret Manager に保存されている Amazon 認証情報 を使用する場合は、このオプションを選択します。リストからシークレットを選択するか、 手動で入力します。 projects/PROJECT_NUMBER/secrets/SECRET_NAME

11. イベント ドリブン転送の場合は、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
    

12. 必要に応じて、オブジェクトを 前方一致でフィルタ するか、最終更新日時でフィルタします。ソースの場所としてフォルダを指定した場合、接頭辞フィルタはそのフォルダを基準とします。たとえば、ソースが my-test-bucket/path/ の場合、file の一致フィルタには my-test-bucket/path/file で始まるすべてのファイルが含まれます。

13. [次のステップ] をクリックします。

14. [バケットまたはフォルダ] フィールドに、ソースバケットと（必要に応じて）フォルダ名を入力するか、[参照] をクリックして、現在のプロジェクトにある既存のバケットリストからバケットを選択します。新しいバケットを作成するには、[新しいバケットを作成] をクリックします。

15. [次のステップ] をクリックします。

16. 転送ジョブの設定を選択します。

    1. [説明] フィールドに、転送の説明を入力します。ジョブを区別できるように、意味のある一意の説明を入力することをおすすめします。

    2. [メタデータのオプション] で、デフォルトのオプションを使用するか、[オプションを表示して選択する] をクリックして、サポートされているすべてのメタデータの値を指定します。詳細については、メタデータの保持をご覧ください。

    3. [上書きの条件] で、次のいずれかを選択します。

       • 異なる場合: ソースファイルの名前が同じで ETag またはチェックサムの値が異なる場合、宛先ファイルを上書きします。

       • 常に: ソースファイルが同じ名前の場合、同一であっても常に宛先ファイルを上書きします。

    4. [削除のタイミング] で、次のいずれかを選択します。

       • なし: ソースと宛先のどちらからもファイルを削除しません。

       • 転送後にソースからファイルを削除する: 転送先に移行した後、ソースからファイルを削除します。 転送先でソースファイルがすでに存在しているなどの理由で、ソースファイルが転送されない場合、ソースファイルは削除されません。

         重要: ローカル バックアップがない場合、このオプションは元に戻せません。

       • 転送元にもないファイルを転送先から削除する: 転送先の Cloud Storage バケット内のファイルが転送元にもない場合は、Cloud Storage バケットからファイルを削除します。

         このオプションにより、宛先の Cloud Storage バケットが移行元と完全に一致することが保証されます。

    5. [通知オプション] で、Pub/Sub トピックと通知するイベントを選択します。詳細については、Pub/Sub 通知をご覧ください。

17. [次のステップ] をクリックします。

18. スケジュール オプションを選択します。

    注: Storage Transfer Service では、転送ジョブ スケジュールがローカル タイムゾーンで表示されますが、時刻は世界協定時刻（UTC）で保存されます。夏時間（DST）の影響を受ける場合は、DST の開始時または終了時に転送ジョブ スケジュールの変更が発生することがあります。

    1. [1 回だけ実行] プルダウン リストから、次のいずれかを選択します。

       • 1 回だけ実行: 選択した時間に、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 または Azure 認証情報を含むマシン上のローカル ファイルへの相対パスを指定します。内容は次の 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 を使用して 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}")