S3 互換ソースからの転送

Storage Transfer Service は、Amazon S3 API と互換性のあるクラウドまたはオンプレミスのオブジェクト ストレージ システムからの転送をサポートします。

Storage Transfer Service は、データソースに近い VM にデプロイされた転送エージェントを使用して、S3 互換のソースのデータにアクセスします。これらのエージェントは、Docker コンテナで実行され、エージェント プールに属します。エージェント プールは、同じ構成を使用し、データをまとめて並列に移動するエージェントの集合です。

この機能を使用すると、オンプレミスまたはクラウドのオブジェクト ストレージから Cloud Storage に移行できます。データをアーカイブしてオンプレミスのストレージ容量を解放したり、ビジネスの継続性を目的として Google Cloud にデータを複製できます。また、分析と処理を行うために Google Cloud にデータを転送することもできます。AWS S3 から Cloud Storage に移行する場合、この機能を使用すると、Google Cloud へのネットワーク ルートを制御できます。これにより、送信データ転送の費用が大幅に削減されます。

準備

転送を構成する前に、次の手順を行います。

エージェント ID 接頭辞、エージェント プール名、転送ジョブ名に、個人を特定できる情報（PII）やセキュリティ データなどの機密情報を含めないでください。リソース名は、他の Google Cloud リソースの名前に伝達され、プロジェクト外部の Google 内部システムに公開される場合があります。

ソースの認証情報を取得する

S3 互換ソースからの転送には、アクセスキー ID とシークレット アクセスキーが必要です。

この手順は、ストレージ プロバイダによって異なります。

ID とキーが生成されるアカウントには、次のいずれかの権限が必要です。

  • ソース オブジェクトに対する読み取り専用権限（ソースのオブジェクトを削除しない場合）。
  • ソース オブジェクトに対する完全アクセス権（転送中にソース側のオブジェクトを削除することを選択した場合）。

アカウントを作成して権限を追加し、アクセスキー ID とシークレット アクセスキーをダウンロードしたら、ID とキーを安全な場所に保管してください。

宛先バケットへのアクセスを構成する

シンクへのアクセスを構成する: Cloud Storage の手順に沿って、宛先バケットへのアクセスを構成します。

エージェント プールの作成

エージェント プール名に、個人を特定できる情報（PII）やセキュリティ データなどの機密情報を含めないでください。リソース名は、他の Google Cloud リソースの名前に伝達され、プロジェクト外部の Google 内部システムに公開される場合があります。

エージェント プールを作成するには:

Google Cloud コンソール

  1. Google Cloud コンソールで、[エージェント プール] ページに移動します。

    [エージェント プール] に移動

    [エージェント プール] ページが開き、既存のエージェント プールが一覧表示されます。

  2. [別のプールを作成] をクリックします。

  3. プールに名前を付け、必要に応じて説明を入力します。

  4. プール全体に適用される帯域幅上限を設定できます。指定された帯域幅（MB/秒）は、プール内のすべてのエージェント間で分割されます。詳細については、ネットワーク帯域幅の管理をご覧ください。

  5. [作成] をクリックします。

REST API

projects.agentPools.create を使用します。

POST https://storagetransfer.googleapis.com/v1/projects/PROJECT_ID/agentPools?agent_pool_id=AGENT_POOL_ID

ここで

  • PROJECT_ID: エージェント プールを作成するプロジェクト ID。
  • AGENT_POOL_ID: 作成するエージェント プール ID。

エージェント プールが Creating 状態で 30 分以上停止している場合は、エージェント プールを削除して再作成することをおすすめします。

エージェント プールが Creating 状態にあるときに、プロジェクトから必要な Storage Transfer Service の権限を取り消すと、サービスで誤った動作が発生します。

gcloud CLI

gcloud コマンドライン ツールでエージェント プールを作成するには、[gcloud transfer agent-pools create][agent-pools-create] を実行します。

gcloud transfer agent-pools create AGENT_POOL

次のオプションがあります。

  • AGENT_POOL は、このプールの一意の永続的な識別子です。

  • --no-async を使用すると、プールが作成されるまでターミナル内の他のタスクがブロックされます。指定しない場合は、プールの作成が非同期で実行されます。

  • --bandwidth-limit には、このプールのエージェントが利用できる帯域幅の量を MB/秒単位で定義します。帯域幅の上限はプール内のすべてのエージェントに適用されます。この上限により、プールの転送ワークロードによって、帯域幅を共有するほかのオペレーションが中断される事態を防ぐことができます。たとえば、「50」と入力すると、帯域幅の上限が 50 MB/秒に設定されます。このフラグを指定しないと、このプールのエージェントは使用可能なすべての帯域幅を使用します。

  • --display-name は、このプールを識別するための名前です。この名前は変更可能です。プールの一意の完全なリソース名に一致しない詳細情報を含めることもできます。

転送エージェントをインストールする

転送エージェントは、Storage Transfer Service を介してソースからの転送アクティビティを調整するソフトウェア エージェントです。これらは、ソースデータにアクセスできるシステムにインストールする必要があります。

gcloud CLI

gcloud CLI を使用して S3 互換のソースで使用するエージェントをインストールするには、transfer agents install コマンドを使用します。

アクセス認証情報は、AWS_ACCESS_KEY_ID および AWS_SECRET_ACCESS_KEY の値として環境変数に指定するか、システムの構成ファイルにデフォルトの認証情報として保存する必要があります。

export AWS_ACCESS_KEY_ID=ID
export AWS_SECRET_ACCESS_KEY=SECRET
gcloud transfer agents install --pool=POOL_NAME

サービス アカウント キーを使用してエージェントを実行するには、--creds-file オプションを使用します。

gcloud transfer agents install --pool=POOL_NAME \
  --creds-file=/relative/path/to/service-account-key.json

転送エージェントの実行に使用するユーザーまたはサービス アカウントに、次の IAM ロールを付与する必要があります。

転送ジョブを作成する

Google Cloud コンソール

S3 互換ソースから Cloud Storage バケットへの転送を作成するには、次の手順を行います。

  1. Google Cloud コンソールの [Storage Transfer Service] ページに移動します。

    Storage Transfer Service に移動

  2. [転送ジョブを作成] をクリックします。[転送ジョブの作成] ページが表示されます。

  3. [ソースタイプ] に [S3-compatible object storage] を選択します。宛先は Google Cloud Storage にする必要があります。

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

ソースを構成する

  1. この転送に必要な情報を指定します。

    1. この転送に構成したエージェント プールを選択します。

    2. エンドポイントに対応するバケット名を入力します。たとえば、データが次の場所に存在するとします。

      https://example.com/bucket_a

      「bucket_a」と入力します。

    3. エンドポイントを入力します。プロトコル（http:// または https://）は含めないでください。次に例を示します。

      example.com

  2. この転送の任意の属性を指定します。

    1. リクエストの署名に使用する署名のリージョンを入力します。

    2. このリクエストの署名プロセスを選択します。

    3. アドレス指定スタイルを選択します。これにより、バケット名がパススタイル（https://example.com/bucket-name/key-name など）で提供されるのか、仮想ホストタイプ（https://bucket-name.example.com/key-name）で提供されるのかが決まります。詳しくは、Amazon のドキュメントのバケットの仮想ホスティングをご覧ください。

    4. ネットワーク プロトコルを選択します。

    5. 使用する Listing API のバージョンを選択します。詳細については、ListObjectsV2 と ListObjects のドキュメントをご覧ください。

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

シンクを構成する

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

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

転送の設定を選択する

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

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

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

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

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

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

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

    • 転送後にソースからファイルを削除する: 転送先に移行した後、ソースからファイルを削除します。

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

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

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

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

転送のスケジュールを設定する

転送は 1 回だけ実行するようにスケジュールすることも、定期的な転送を構成することもできます。

[作成] をクリックして転送を作成します。

gcloud CLI

gcloud CLI を使用して転送を作成する前に、Cloud Storage シンクへのアクセスを構成するの手順を行ってください。

gcloud CLI を使用して、S3 互換ソースから Cloud Storage バケットへの転送を作成するには、次のコマンドを使用します。

gcloud transfer jobs create s3://SOURCE_BUCKET_NAME gs://SINK_BUCKET_NAME \
  --source-agent-pool=POOL_NAME \
  --source-endpoint=ENDPOINT \
  --source-signing-region=REGION \
  --source-auth-method=AWS_SIGNATURE_V2 | AWS_SIGNATURE_V4 \
  --source-request-model=PATH_STYLE | VIRTUAL_HOSTED_STYLE \
  --source-network-protocol=HTTP | HTTPS \
  --source-list-api=LIST_OBJECTS | LIST_OBJECTS_V2

次のフラグは必須です。

  • --source-agent-pool は、この転送に使用するエージェント プールの名前です。

  • --source-endpoint には、ストレージ システムのエンドポイントを指定します。例: s3.us-east.example.com。正しい形式についてはプロバイダにお問い合わせください。

残りのフラグは省略可能です。

  • --source-signing-region には、リクエストに署名するリージョンを指定します。ストレージ プロバイダが署名のリージョンを必要としない場合は、このフラグを省略します。
  • --source-auth-method には、使用する認証方法を指定します。有効な値は AWS_SIGNATURE_V2 または AWS_SIGNATURE_V4 です。詳しくは、Amazon の SigV4 と SigV2 のドキュメントをご覧ください。
  • --source-request-model には、使用するアドレス指定スタイルを指定します。有効な値は PATH_STYLE または VIRTUAL_HOSTED_STYLE です。パススタイルには https://s3.REGION.example.com/BUCKET_NAME/KEY_NAME の形式を使用します。仮想ホストスタイルでは、https://BUCKET_NAME.s3.REGION.example.com/KEY_NAME の形式を使用します。
  • --source-network-protocol には、エージェントがこのジョブに使用するネットワーク プロトコルを指定します。有効な値は HTTP または HTTPS です。
  • --source-list-api には、バケットからオブジェクトを返すための S3 Listing API のバージョンを指定します。有効な値は LIST_OBJECTS または LIST_OBJECTS_V2 です。詳しくは、Amazon の ListObjectsV2 と ListObjects のドキュメントをご覧ください。

その他の転送ジョブ オプションについては、gcloud transfer jobs create --help を実行するか、gcloud リファレンス ドキュメントをご覧ください。

REST API

REST API を使用して転送を作成する前に、Cloud Storage シンクへのアクセスを構成するの手順を行ってください。

REST API を使用して S3 互換ソースから転送を作成するには、次のような JSON オブジェクトを作成します。

POST https://storagetransfer.googleapis.com/v1/transferJobs
{
  ...
  "transferSpec": {
    "source_agent_pool_name":"POOL_NAME",
    "awsS3CompatibleData": {
      "region":"us-east-1",
      "s3Metadata":{
        "protocol": "NETWORK_PROTOCOL_HTTPS",
        "requestModel": "REQUEST_MODEL_VIRTUAL_HOSTED_STYLE",
        "authMethod": "AUTH_METHOD_AWS_SIGNATURE_V4"
      },
      "endpoint": "example.com",
      "bucketName": "BUCKET_NAME",
      "path": "PATH",
    },
    "gcsDataSink": {
      "bucketName": "SINK_NAME",
      "path": "SINK_PATH"
    },
    "transferOptions": {
      "deleteObjectsFromSourceAfterTransfer": false
    }
  }
}

フィールドの説明については、AwsS3CompatibleData API リファレンスをご覧ください。

クライアント ライブラリ

クライアント ライブラリを使用して転送を作成する前に、Cloud Storage シンクへのアクセスを構成するの手順を行ってください。

Go

Storage Transfer Service 用のクライアント ライブラリをインストールして使用する方法については、Storage Transfer Service のクライアント ライブラリをご覧ください。詳細については、Storage Transfer Service Go API のリファレンス ドキュメントをご覧ください。

Storage Transfer Service の認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。


import (
	"context"
	"fmt"
	"io"

	storagetransfer "cloud.google.com/go/storagetransfer/apiv1"
	"cloud.google.com/go/storagetransfer/apiv1/storagetransferpb"
)

func transferFromS3CompatibleSource(w io.Writer, projectID string, sourceAgentPoolName string, sourceBucketName string, sourcePath string, gcsSinkBucket string, gcsPath string) (*storagetransferpb.TransferJob, error) {
	// Your project id.
	// projectId := "my-project-id"

	// The agent pool associated with the S3 compatible data source. If not provided, defaults to the default agent.
	// sourceAgentPoolName := "projects/my-project/agentPools/transfer_service_default"

	// The S3 compatible bucket name to transfer data from.
	//sourceBucketName = "my-bucket-name"

	// The S3 compatible path (object prefix) to transfer data from.
	//sourcePath = "path/to/data"

	// The ID of the GCS bucket to transfer data to.
	//gcsSinkBucket = "my-sink-bucket"

	// The GCS path (object prefix) to transfer data to.
	//gcsPath = "path/to/data"

	// The S3 region of the source bucket.
	region := "us-east-1"

	// The S3 compatible endpoint.
	endpoint := "us-east-1.example.com"

	// The S3 compatible network protocol.
	protocol := storagetransferpb.S3CompatibleMetadata_NETWORK_PROTOCOL_HTTPS

	// The S3 compatible request model.
	requestModel := storagetransferpb.S3CompatibleMetadata_REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

	// The S3 Compatible auth method.
	authMethod := storagetransferpb.S3CompatibleMetadata_AUTH_METHOD_AWS_SIGNATURE_V4

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

	req := &storagetransferpb.CreateTransferJobRequest{
		TransferJob: &storagetransferpb.TransferJob{
			ProjectId: projectID,
			TransferSpec: &storagetransferpb.TransferSpec{
				SourceAgentPoolName: sourceAgentPoolName,
				DataSource: &storagetransferpb.TransferSpec_AwsS3CompatibleDataSource{
					AwsS3CompatibleDataSource: &storagetransferpb.AwsS3CompatibleData{
						BucketName: sourceBucketName,
						Path:       sourcePath,
						Endpoint:   endpoint,
						Region:     region,
						DataProvider: &storagetransferpb.AwsS3CompatibleData_S3Metadata{
							S3Metadata: &storagetransferpb.S3CompatibleMetadata{
								AuthMethod:   authMethod,
								RequestModel: requestModel,
								Protocol:     protocol,
							},
						},
					}},
				DataSink: &storagetransferpb.TransferSpec_GcsDataSink{
					GcsDataSink: &storagetransferpb.GcsData{
						BucketName: gcsSinkBucket,
						Path:       gcsPath,
					},
				},
			},
			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", sourceBucketName, gcsSinkBucket, resp.Name)
	return resp, nil
}

Java

Storage Transfer Service 用のクライアント ライブラリをインストールして使用する方法については、Storage Transfer Service のクライアント ライブラリをご覧ください。詳細については、Storage Transfer Service Java API のリファレンス ドキュメントをご覧ください。

Storage Transfer Service の認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.AuthMethod;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.NetworkProtocol;
import static com.google.storagetransfer.v1.proto.TransferTypes.S3CompatibleMetadata.RequestModel;

import com.google.storagetransfer.v1.proto.StorageTransferServiceClient;
import com.google.storagetransfer.v1.proto.TransferProto;
import com.google.storagetransfer.v1.proto.TransferTypes;
import com.google.storagetransfer.v1.proto.TransferTypes.GcsData;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferJob;
import com.google.storagetransfer.v1.proto.TransferTypes.TransferSpec;
import java.io.IOException;

public class TransferFromS3CompatibleSource {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Your project id
    String projectId = "my-project-id";

    // The agent pool associated with the S3 compatible data source. If not provided, defaults to
    // the default agent
    String sourceAgentPoolName = "projects/my-project-id/agentPools/transfer_service_default";

    // The S3 compatible bucket name to transfer data from
    String sourceBucketName = "my-bucket-name";

    // The S3 compatible path (object prefix) to transfer data from
    String sourcePath = "path/to/data";

    // The ID of the GCS bucket to transfer data to
    String gcsSinkBucket = "my-sink-bucket";

    // The GCS path (object prefix) to transfer data to
    String gcsPath = "path/to/data";

    // The S3 region of the source bucket
    String region = "us-east-1";

    // The S3 compatible endpoint
    String endpoint = "us-east-1.example.com";

    // The S3 compatible network protocol
    NetworkProtocol protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

    // The S3 compatible request model
    RequestModel requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

    // The S3 Compatible auth method
    AuthMethod authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

    transferFromS3CompatibleSource(
        projectId,
        sourceAgentPoolName,
        sourceBucketName,
        sourcePath,
        region,
        endpoint,
        protocol,
        requestModel,
        authMethod,
        gcsSinkBucket,
        gcsPath);
  }

  public static void transferFromS3CompatibleSource(
      String projectId,
      String sourceAgentPoolName,
      String sourceBucketName,
      String sourcePath,
      String region,
      String endpoint,
      NetworkProtocol protocol,
      RequestModel requestModel,
      AuthMethod authMethod,
      String gcsSinkBucket,
      String gcsPath)
      throws IOException {
    TransferJob transferJob =
        TransferJob.newBuilder()
            .setProjectId(projectId)
            .setTransferSpec(
                TransferSpec.newBuilder()
                    .setSourceAgentPoolName(sourceAgentPoolName)
                    .setAwsS3CompatibleDataSource(
                        TransferTypes.AwsS3CompatibleData.newBuilder()
                            .setRegion(region)
                            .setEndpoint(endpoint)
                            .setBucketName(sourceBucketName)
                            .setPath(sourcePath)
                            .setS3Metadata(
                                TransferTypes.S3CompatibleMetadata.newBuilder()
                                    .setProtocol(protocol)
                                    .setRequestModel(requestModel)
                                    .setAuthMethod(authMethod)
                                    .build())
                            .build())
                    .setGcsDataSink(
                        GcsData.newBuilder().setBucketName(gcsSinkBucket).setPath(gcsPath).build()))
            .setStatus(TransferJob.Status.ENABLED)
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources,
    // or use "try-with-close" statement to do this automatically.
    try (StorageTransferServiceClient storageTransfer = StorageTransferServiceClient.create()) {

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

      System.out.println(
          "Created a transfer job from "
              + sourceBucketName
              + " to "
              + gcsSinkBucket
              + " with "
              + "name "
              + response.getName());
    }
  }
}

Node.js

Storage Transfer Service 用のクライアント ライブラリをインストールして使用する方法については、Storage Transfer Service のクライアント ライブラリをご覧ください。詳細については、Storage Transfer Service Node.js API のリファレンス ドキュメントをご覧ください。

Storage Transfer Service の認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。


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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Useful enums for AWS S3-Compatible Transfers
// const {AuthMethod, NetworkProtocol, RequestModel} = storageTransfer.protos.google.storagetransfer.v1.S3CompatibleMetadata;

// Your project id
// const projectId = 'my-project';

// The agent pool associated with the S3-compatible data source. Defaults to the default agent
// const sourceAgentPoolName = 'projects/my-project/agentPools/transfer_service_default';

// The S3-compatible bucket name to transfer data from
// const sourceBucketName = "my-bucket-name";

// The S3-compatible path (object prefix) to transfer data from
// const sourcePath = "path/to/data/";

// The ID of the GCS bucket to transfer data to
// const gcsSinkBucket = "my-sink-bucket";

// The GCS path (object prefix) to transfer data to
// const gcsPath = "path/to/data/";

// The S3 region of the source bucket
// const region = 'us-east-1';

// The S3-compatible endpoint
// const endpoint = "us-east-1.example.com";

// The S3-compatible network protocol
// const protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS;

// The S3-compatible request model
// const requestModel = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE;

// The S3-compatible auth method
// const authMethod = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4;

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

/**
 * Creates a transfer from an AWS S3-compatible source to GCS
 */
async function transferFromS3CompatibleSource() {
  // Runs the request and creates the job
  const [transferJob] = await client.createTransferJob({
    transferJob: {
      projectId,
      transferSpec: {
        sourceAgentPoolName,
        awsS3CompatibleDataSource: {
          region,
          s3Metadata: {
            authMethod,
            protocol,
            requestModel,
          },
          endpoint,
          bucketName: sourceBucketName,
          path: sourcePath,
        },
        gcsDataSink: {
          bucketName: gcsSinkBucket,
          path: gcsPath,
        },
      },
      status: 'ENABLED',
    },
  });

  await client.runTransferJob({
    jobName: transferJob.name,
    projectId,
  });

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

transferFromS3CompatibleSource();

Python

Storage Transfer Service 用のクライアント ライブラリをインストールして使用する方法については、Storage Transfer Service のクライアント ライブラリをご覧ください。詳細については、Storage Transfer Service Python API のリファレンス ドキュメントをご覧ください。

Storage Transfer Service の認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

from google.cloud import storage_transfer

AuthMethod = storage_transfer.S3CompatibleMetadata.AuthMethod
NetworkProtocol = storage_transfer.S3CompatibleMetadata.NetworkProtocol
RequestModel = storage_transfer.S3CompatibleMetadata.RequestModel

def transfer_from_S3_compat_to_gcs(
    project_id: str,
    description: str,
    source_agent_pool_name: str,
    source_bucket_name: str,
    source_path: str,
    gcs_sink_bucket: str,
    gcs_path: str,
    region: str,
    endpoint: str,
    protocol: NetworkProtocol,
    request_model: RequestModel,
    auth_method: AuthMethod,
) -> None:
    """Creates a transfer from an AWS S3-compatible source to GCS"""

    client = storage_transfer.StorageTransferServiceClient()

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

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

    # The agent pool associated with the S3-compatible data source.
    # Defaults to 'projects/{project_id}/agentPools/transfer_service_default'
    # source_agent_pool_name = 'projects/my-project/agentPools/my-agent'

    # The S3 compatible bucket name to transfer data from
    # source_bucket_name = "my-bucket-name"

    # The S3 compatible path (object prefix) to transfer data from
    # source_path = "path/to/data/"

    # The ID of the GCS bucket to transfer data to
    # gcs_sink_bucket = "my-sink-bucket"

    # The GCS path (object prefix) to transfer data to
    # gcs_path = "path/to/data/"

    # The S3 region of the source bucket
    # region = 'us-east-1'

    # The S3-compatible endpoint
    # endpoint = "us-east-1.example.com"

    # The S3-compatible network protocol
    # protocol = NetworkProtocol.NETWORK_PROTOCOL_HTTPS

    # The S3-compatible request model
    # request_model = RequestModel.REQUEST_MODEL_VIRTUAL_HOSTED_STYLE

    # The S3-compatible auth method
    # auth_method = AuthMethod.AUTH_METHOD_AWS_SIGNATURE_V4

    transfer_job_request = storage_transfer.CreateTransferJobRequest(
        {
            "transfer_job": {
                "project_id": project_id,
                "description": description,
                "status": storage_transfer.TransferJob.Status.ENABLED,
                "transfer_spec": {
                    "source_agent_pool_name": source_agent_pool_name,
                    "aws_s3_compatible_data_source": {
                        "region": region,
                        "s3_metadata": {
                            "auth_method": auth_method,
                            "protocol": protocol,
                            "request_model": request_model,
                        },
                        "endpoint": endpoint,
                        "bucket_name": source_bucket_name,
                        "path": source_path,
                    },
                    "gcs_data_sink": {
                        "bucket_name": gcs_sink_bucket,
                        "path": gcs_path,
                    },
                },
            }
        }
    )

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

よくある質問

S3 互換ストレージからの移行には費用がかかりますか？

S3 互換ストレージからの転送の場合、エージェントを必要とする Storage Transfer Service の転送の料金は発生しません。その他の料金については、料金をご覧ください。転送元のクラウド プロバイダからの送信データ転送料金とオペレーションの料金が発生することもあります。

Cloud Logging は S3 互換ストレージ転送をサポートしていますか？

はい。Storage Transfer Service の Cloud Logging の手順に沿って、転送で Cloud Logging を有効にできます。

マニフェストを使用した転送はサポートされていますか？

はい。マニフェスト ファイルは S3 互換転送でサポートされています。

ジョブの開始後にオブジェクトをソースバケットに追加した場合、そのオブジェクトは転送されますか？

Storage Transfer Service は、ソースバケットでリスト オペレーションを実行し、宛先との差分を計算します。新しいオブジェクトが追加されたときにリスト オペレーションがすでに完了している場合、そのオブジェクトは次の転送までスキップされます。

Storage Transfer Service は、S3 互換のソースでチェックサム マッチングを行いますか？

Storage Transfer Service は、ソースから返されるチェックサム データを使用します。S3 互換ストレージの場合、Storage Transfer Service はオブジェクトの Etag がオブジェクトの MD5 ハッシュであると想定します。

ただし、S3 マルチパート アップロードを使用して S3 互換ストレージに転送されたオブジェクトには、MD5 ETag がありません。この場合、Storage Transfer Service はファイルサイズを使用して、転送されたオブジェクトを検証します。

S3 互換ストレージからの転送では、どのようなスループットを達成できますか？

転送エージェントを増やすことで、転送スループットをスケーリングできます。フォールト トレランスと 10 Gbps 未満のパイプを使用する際は、3 つのエージェントを使用することをおすすめします。さらにスケーリングするには、エージェントを追加します。転送の進行中に、エージェントを追加または削除できます。

Amazon S3 から Cloud Storage にデータを転送するには、転送エージェントをどこにデプロイすればよいですか？

Amazon EC2 または EKS のエージェントをバケットと同じリージョン内にインストールできます。最も近いリージョンの Google Cloud でエージェントを実行することもできます。