同じアカウントでのバケットのレプリケーションの設定 - Amazon Simple Storage Service

同じアカウントでのバケットのレプリケーションの設定

ライブレプリケーションは、同一または異なる AWS リージョン にあるバケット間でオブジェクトを自動的に非同期でコピーする機能です。ライブレプリケーションでは、新しく作成されたオブジェクトおよびオブジェクトの更新が、レプリケート元バケットからレプリケート先バケットにコピーされます。詳細については、「リージョン内およびリージョン間でのオブジェクトのレプリケート」を参照してください。

レプリケーションを設定するときは、レプリケート元バケットにレプリケーションルールを追加します。レプリケーションルールにより、レプリケート元のソースバケットオブジェクトと、レプリケートされたオブジェクトが保存されるレプリケート先バケットが定義されます。ルールを作成して、バケット内のすべてのオブジェクト、または特定のキー名のプレフィックス、1 つ以上のオブジェクトタグ、あるいはその両方を持つオブジェクトのサブセットをレプリケートできます。レプリケート先のバケットはレプリケート元バケットと同じ AWS アカウントにあっても、別のアカウントにあってもかまいません。

削除するオブジェクトバージョンの ID を指定した場合、Amazon S3 はソースバケット内のそのオブジェクトバージョンを削除します。しかし、レプリケート先バケット内でその削除をレプリケートすることはありません。つまり、レプリケート先バケットから同じオブジェクトバージョンを削除しません。これは悪意のある削除からデータを保護します。

バケットにレプリケーションルールを追加すると、ルールはデフォルトで有効になるため、保存するとすぐに動作を開始します。

この例では、同じ AWS アカウントがレプリケート元とレプリケート先のバケットを所有している場合の、ライブレプリケーションのセットアップを行います。Amazon S3 コンソールを使用する例については、AWS Command Line Interface (AWS CLI)、AWS SDK for Java、および AWS SDK for .NET を参照してください。

ソースバケットと同じ AWS アカウント に送信先バケットがある場合にレプリケーションルールを設定するには、以下の手順を実行します。

レプリケート先バケットがレプリケート元バケットとは別のアカウントにある場合は、レプリケート先バケットにバケットポリシーを追加して、レプリケート元バケットアカウントの所有者に、レプリケート先バケットのオブジェクトをレプリケートするアクセス許可を付与する必要があります。詳細については、「レプリケーション元とレプリケーション先のバケットが異なる AWS アカウントによって所有されている場合の許可の付与」を参照してください。

  1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

  2. 左側のナビゲーションペインで、[バケット] を選択します。

  3. [バケット] リストで、目的のバケットの名前を選択します。

  4. [管理] タブをクリックし、[レプリケーションルール] までスクロールして、[レプリケーションルールを作成] を選択します。

  5. [レプリケーションルールの設定] セクションの、[レプリケーションルール名] で、後でルールを識別しやすいようにルールの名前を入力します。ルール名は必須であり、バケット内で一意である必要があります。

  6. [ステータス] では、デフォルトで [有効] が選択されています。有効にされたルールは、保存するとすぐに機能し始めます。ルールを後から有効にする場合は、[無効] を選択します。

  7. バケットに既存のレプリケーションルールがある場合は、ルールの優先順位を指定するよう指示されます。ルールの優先順位を指定して、複数のルールの範囲に含まれるオブジェクトによって引き起こされる競合を回避する必要があります。ルールが重複している場合、Amazon S3 はルールの優先度を使用して適用するルールを決定します。数値が大きいほど、優先度が高くなります。ルーティングの優先度の詳細については、「レプリケーション設定ファイル要素」をご覧ください。

  8. [ソースバケット] には、レプリケーションソースを設定するための次のオプションがあります。

    • バケット全体をレプリケートするには、[Apply to all objects in the bucket] (バケット内のすべてのオブジェクトに適用) を選択します。

    • 同じプレフィックスを持つすべてのオブジェクトをレプリケートするには、[Limit the scope of this rule using one or more filters (1 つまたは複数のフィルターを使用してこのルールの適用範囲を制限します)] を選択します。これにより、指定したプレフィックスで始まる名前を持つすべてのオブジェクトにレプリケーションが制限されます (pictures など)。[プレフィックス] ボックスにプレフィックスを入力します。

      注記

      フォルダの名前をプレフィックスとして入力する場合は、最後の文字に [/] (スラッシュ) を使用する必要があります (例: pictures/)。

    • 1 つまたは複数のオブジェクトタグを持つすべてのオブジェクトをレプリケートするには、[タグを追加] を選択し、ボックスにキーと値のペアを入力します。別のタグを追加するには、この手順を繰り返します。プレフィックスとタグを組み合わせることができます。オブジェクトタグの詳細については、タグを使用してストレージを分類するを参照してください。

    新しいレプリケーション設定 XML スキーマでは、プレフィックスとタグのフィルタリング、およびルールの優先順位付けがサポートされています。新しいスキーマの詳細については、後方互換性に関する考慮事項を参照してください。ユーザーインターフェイスの背後で機能する Amazon S3 API で使用される XML の詳細については、「レプリケーション設定ファイル要素」を参照してください。新しいスキーマは、レプリケーション設定 XML V2 として記述されます。

  9. [レプリケート先] で、Amazon S3 がオブジェクトをレプリケートするバケットを選択します。

    注記

    レプリケート先バケットの数は、特定のパーティション内の AWS リージョンの数に制限されます。パーティションは、リージョンのグループです。AWS には、現在 aws (標準リージョン)、aws-cn (中国リージョン)、および aws-us-gov (AWS GovCloud (US) リージョン) の 3 つのパーティションがあります。レプリケート先バケット制限の増加をリクエストするには、サービスのクォータを使用できます。

    • アカウントのバケットにレプリケートするには、[このアカウントのバケットを選択] をクリックし、レプリケート先バケット名を入力または参照します。

    • 別の AWS アカウント のバケットにレプリケートするには、[別のアカウントのバケットを指定] を選択し、レプリケート先バケットのアカウント ID とバケット名を入力します。

      レプリケート先バケットがレプリケート元バケットとは別のアカウントにある場合は、レプリケート先バケットにバケットポリシーを追加して、レプリケート元バケットアカウントの所有者にオブジェクトをレプリケートするアクセス許可を付与する必要があります。詳細については、「レプリケーション元とレプリケーション先のバケットが異なる AWS アカウントによって所有されている場合の許可の付与」を参照してください。

      必要に応じて、レプリケート先バケット内の新しいオブジェクトの所有を標準化するために、[オブジェクト所有者を送信先バケット所有者に変更] を選択します。このオプションの詳細については、「オブジェクトの所有権の制御とバケットの ACL の無効化。」を参照してください。

    注記

    レプリケート先バケットでバージョニングが有効になっていない場合は、[バージョニングを有効化] ボタンを含む警告が表示されます。バケットでバージョニングを有効にするには、このボタンを選択します。

  10. Amazon S3 がユーザーのためにオブジェクトをレプリケートできる AWS Identity and Access Management (IAM) ロールを設定します。

    IAM ロールを設定するには、[IAM ロール] セクションで [IAM ロール] ドロップダウンリストから次のいずれかを選択します。

    • [Create new role (新しいロールの作成)] を選択して、Amazon S3 で新しい IAM ロールが自動的に作成されるようにすることを強くお勧めします。ルールを保存すると、選択したレプリケート元バケットとレプリケート先バケットに一致する IAM ロールに対して新しいポリシーが生成されます。

    • 既存の IAM ロールの使用も選択できます。その場合は、レプリケーションに必要なアクセス許可を Amazon S3 に付与するロールを選択する必要があります。このロールがレプリケーションルールに従うための十分なアクセス許可を Amazon S3 に付与しない場合、レプリケーションは失敗します。

    重要

    レプリケーションルールをバケットに追加する場合は、Amazon S3 にレプリケーションアクセス許可を付与する IAM ロールを渡すことができる iam:PassRole アクセス許可が必要です。詳細については、IAM ユーザーガイドの「AWS のサービス のサービスにロールを渡すアクセス権限をユーザーに付与する」を参照してください。

  11. AWS Key Management Service (AWS KMS) キーを使用したサーバー側の暗号化 (SSE-KMS) で暗号化されたソースバケット内のオブジェクトをレプリケートするには、[暗号化] で [AWS KMS で暗号化されたオブジェクトをレプリケート] を選択します。送信先オブジェクト暗号化用の AWS KMS キー には、レプリケーションでの使用を許可しているソースキーが示されています。デフォルトでは、すべてのソース KMS キーが含まれます。KMS キーの選択を絞り込むために、エイリアスまたはキー ID を選択できます。

    選択されていない AWS KMS keys で暗号化されたオブジェクトはレプリケートされません。KMS キーまたは KMS キーのグループが選択されていますが、必要に応じて KMS キーを選択できます。AWS KMS をレプリケーションで使用する方法については、暗号化されたオブジェクトのレプリケート (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C) を参照してください。

    重要

    AWS KMS で暗号化されたオブジェクトをレプリケートすると、AWS KMS リクエストレートは、ソースリージョンでは倍になり、送信先リージョンでは同じ量だけ増加します。AWS KMS に対するこれらの呼び出しレートの増加は、レプリケーションの送信先リージョンに対して定義した KMS キーを使用してデータが再暗号化された方法によるものです。AWS KMS では、リージョンごとに呼び出しアカウントあたりのリクエストレートが制限されています。制限のデフォルト値については、AWS Key Management Service デベロッパーガイドの「AWS KMS の制限 - 1 秒あたりのリクエスト数: 可変」を参照してください。

    レプリケーションにおける現在の Amazon S3 PUT オブジェクトリクエストレートが、アカウントでデフォルトで設定されている AWS KMS レート制限の半分を超えている場合は、AWS KMS リクエストレート制限の引き上げをリクエストすることをお勧めします。引き上げをリクエストするには、AWS Support センターのお問い合わせでケースを作成します。例えば、現在の PUT オブジェクトのリクエストレートが 1 秒あたり 1,000 リクエストであり、オブジェクトの暗号化に AWS KMS を使用しているとします。この場合、レプリケート元リージョンとレプリケート先リージョン (リージョンが異なる場合) の両方で AWS KMS レート制限を毎秒 2,500 リクエストに引き上げるよう AWS Support に依頼することをお勧めします。これにより、AWS KMS によるスロットリングがなくなります。

    レプリケート元バケットの PUT オブジェクトのリクエストレートを確認するには、Amazon S3 の Amazon CloudWatch リクエストメトリクスの PutRequests を確認します。CloudWatch メトリクスの表示方法については、「S3 コンソールの使用」を参照してください

    AWS KMS で暗号化されたオブジェクトをレプリケートを選択した場合は、以下の操作を実行します。

    1. [送信先オブジェクトを暗号化するための AWS KMS key] で、次のいずれかの方法で KMS キーを指定します。

      • 使用可能な KMS キーのリストから選択するには、[AWS KMS keys から選択する] を選択し、使用可能なキーのリストから自分の KMS キーを選択します。

        AWS マネージドキー (aws/s3) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、AWS Key Management Service デベロッパーガイドの「カスタマーキーと AWS キー」を参照してください。

      • KMS キー Amazon リソースネーム (ARN) を入力するには、[AWS KMS key ARN を入力] を選択し、表示されるフィールドに KMS キー ARN を入力します。これにより、レプリケート先バケットのレプリカが暗号化されます。[IAM コンソール]の [暗号化キー] で、KMS キーの ARN を検索できます。

      • AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、[KMS キーを作成] を選択します。

        AWS KMS key の作成の詳細については、「AWS Key Management Service デベロッパーガイド」の「キーの作成」を参照してください。

      重要

      バケットと同じ AWS リージョン で有効になっている KMS キーのみを使用できます。[KMS キーから選択する] を選択する場合、S3 コンソールにはリージョンごとに 100 個の KMS キーしか表示されません。同じリージョンに 100 個以上の KMS キーがある場合、S3 コンソールには最初の 100 個の KMS キーしか表示されません。コンソールに表示されていない KMS キーを使用するには、[AWS KMS key ARN を入力] を選択し、KMS キー ARN を入力します。

      Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 では、対称暗号化 KMS キーのみがサポートされ、非対称暗号化 KMS キーはサポートされません。詳細については、AWS Key Management Service デベロッパーガイドの「Identifying symmetric and asymmetric KMS keys」(対称および非対称 KMS キーの識別) を参照してください。

      AWS KMS key の作成の詳細については、AWS Key Management Service デベロッパーガイドのキーの作成を参照してください。Amazon S3 での AWS KMS の使用に関する詳細は、「AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用」を参照してください。

  12. [レプリケート先ストレージクラス] で、データをレプリケート先の特定のストレージクラスにレプリケートする場合は、[レプリケートされたオブジェクトのストレージクラスを変更] を選択します。次に、レプリケート先のレプリケートされたオブジェクトに使用するストレージクラスを選択します。このオプションを選択しない場合、レプリケートされたオブジェクトのストレージクラスは元のオブジェクトのクラスと同じになります。

  13. 追加のレプリケーションオプションを設定する際には、次の追加オプションから選択できます。

    注記

    S3 RTC または S3 レプリケーションメトリクスを使用する場合は、追加料金が適用されます。

  14. 終了するには、[Save (保存)] を選択します。

  15. ルールを保存したら、ルールを選択して [Edit rule (ルールの編集)] を選択することで、ルールを編集、有効化、無効化、または削除できます。

レプリケート元バケットとレプリケート先バケットが同じ AWS アカウント によって所有されている場合に、レプリケーションの設定に AWS CLI を使用するには

  • レプリケート元バケットとレプリケート先バケットを作成します。

  • バケットでのバージョニングを有効化します。

  • オブジェクトをレプリケートするための Amazon S3 許可を付与する AWS Identity and Access Management (IAM) ロールを作成します。

  • レプリケート元バケットにレプリケーション設定を追加します。

設定を確認するには、テストします。

レプリケート元バケットとレプリケート先バケットが同じ AWS アカウントによって所有されている場合にレプリケーションをセットアップするには

  1. AWS CLI の認証情報プロファイルを設定します。この例では、プロファイル名 acctA を使用します。名前付きプロファイルの設定と使用に関する詳細については、「AWS Command Line Interface ユーザーガイド」の「設定ファイルと認証情報ファイルの設定」を参照してください。

    重要

    この例に使用するプロファイルは、必要なアクセス権限を持っている必要があります。たとえば、レプリケーション設定で、Amazon S3 が引き受けることができる IAM ロールを指定します。使用するプロファイルに iam:PassRole アクセス権限がある場合のみ実行できます。詳細については、「IAM ユーザーガイド」の「AWS のサービス にロールを渡すアクセス権限をユーザーに付与する」を参照してください。管理者の認証情報を使用して名前付きプロファイルを作成すると、すべてのタスクを実行できるようになります。

  2. 次の AWS CLI コマンドを使用してレプリケート元バケットを作成し、バージョニングを有効にします。これらのコマンドを使用するには、user input placeholders をユーザー自身の情報に置き換えます。

    次の create-bucket コマンドは、米国東部 (バージニア北部) (us-east-1) リージョンに amzn-s3-demo-source-bucket バケットを作成します。

    aws s3api create-bucket \
--bucket amzn-s3-demo-source-bucket \
--region us-east-1 \
--profile acctA

    次の put-bucket-versioning コマンドは、amzn-s3-demo-source-bucket バケットで S3 バージョニングを有効にします。

    aws s3api put-bucket-versioning \
--bucket amzn-s3-demo-source-bucket \
--versioning-configuration Status=Enabled \
--profile acctA

  3. 次の AWS CLI コマンドを使用してレプリケート先バケットを作成し、バージョニングを有効にします。これらのコマンドを使用するには、user input placeholders をユーザー自身の情報に置き換えます。

    注記

    レプリケーション元とレプリケーション先バケットの両方が同じ AWS アカウントにある場合、レプリケーション設定をセットアップするには、レプリケート元バケットおよびレプリケート先バケットに同じプロファイルを使用します。この例では acctA を使用します。

    異なる AWS アカウントによってバケットが所有されている場合、レプリケーション設定をテストするには、それぞれのアカウント異なるプロファイルを指定します。例えば、レプリケート先バケットに acctB プロファイルを使用します。

    次の create-bucket コマンドは、米国西部 (オレゴン) (us-west-2) リージョンに amzn-s3-demo-destination-bucket というレプリケート先バケットを作成します。

    aws s3api create-bucket \
--bucket amzn-s3-demo-destination-bucket \
--region us-west-2 \
--create-bucket-configuration LocationConstraint=us-west-2 \
--profile acctA

    次の put-bucket-versioning コマンドは、amzn-s3-demo-destination-bucket バケットで S3 バージョニングを有効にします。

    aws s3api put-bucket-versioning \
--bucket amzn-s3-demo-destination-bucket \
--versioning-configuration Status=Enabled \
--profile acctA

  4. IAM ロールを作成します。レプリケート元バケットに後で追加するレプリケーション設定でこのロールを指定します。Amazon S3 は、ユーザーに代わってオブジェクトをレプリケートするこの ロールを引き受けます。IAM ロールは 2 つのステップで作成します。

    • ロールを作成します。

    • アクセス権限ポリシーをロールにアタッチします。

    1. IAM ロールを作成します。

      1. 次の信頼ポリシーをコピーして、ローカルコンピュータの現在のディレクトリにある s3-role-trust-policy.json という名前のファイルに保存します。このポリシーは、ロールを引き受けるアクセス許可を Amazon S3 サービスプリンシパルに付与します。

        {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":"s3.amazonaws.com"
         },
         "Action":"sts:AssumeRole"
      }
   ]
}

      2. 次のコマンドを実行して、ロールを作成します。

        $ aws iam create-role \
--role-name replicationRole \
--assume-role-policy-document file://s3-role-trust-policy.json  \
--profile acctA

    2. アクセス権限ポリシーをロールにアタッチします。

      1. 次のアクセス権限ポリシーをコピーして、ローカルコンピュータの現在のディレクトリにある s3-role-permissions-policy.json という名前のファイルに保存します。このポリシーは、さまざまな Amazon S3 バケットとオブジェクトアクションに対するアクセス許可を付与します。

        {
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "s3:GetObjectVersionForReplication",
            "s3:GetObjectVersionAcl",
            "s3:GetObjectVersionTagging"
         ],
         "Resource":[
            "arn:aws:s3:::amzn-s3-demo-source-bucket/*"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "s3:ListBucket",
            "s3:GetReplicationConfiguration"
         ],
         "Resource":[
            "arn:aws:s3:::amzn-s3-demo-source-bucket"
         ]
      },
      {
         "Effect":"Allow",
         "Action":[
            "s3:ReplicateObject",
            "s3:ReplicateDelete",
            "s3:ReplicateTags"
         ],
         "Resource":"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
      }
   ]
}

      2. ポリシーを作成してロールにアタッチするには、次のコマンドを実行します。user input placeholders を、ユーザー自身の情報に置き換えます。

        $ aws iam put-role-policy \
--role-name replicationRole \
--policy-document file://s3-role-permissions-policy.json \
--policy-name replicationRolePolicy \
--profile acctA

  5. レプリケート元バケットにレプリケーション設定を追加します。

    1. Amazon S3 API はレプリケーション設定を XML で指定する必要がありますが、AWS CLI はレプリケーション設定を JSON で指定する必要があります。以下の JSON を、コンピュータのローカルディレクトリの replication.json というファイルに保存します。

      {
  "Role": "IAM-role-ARN",
  "Rules": [
    {
      "Status": "Enabled",
      "Priority": 1,
      "DeleteMarkerReplication": { "Status": "Disabled" },
      "Filter" : { "Prefix": "Tax"},
      "Destination": {
        "Bucket": "arn:aws:s3:::amzn-s3-demo-destination-bucket"
      }
    }
  ]
}

    2. amzn-s3-demo-destination-bucket および IAM-role-ARN の値を独自の情報に置き換えて JSON を更新します。変更を保存します。

    3. 次の put-bucket-replication コマンドを実行して、レプリケート元バケットにレプリケーション設定を追加します。必ずレプリケート元バケット名を指定してください。

      $ aws s3api put-bucket-replication \
--replication-configuration file://replication.json \
--bucket amzn-s3-demo-source-bucket \
--profile acctA

    レプリケーション設定を取得するには、get-bucket-replication コマンドを使用します。

    $ aws s3api get-bucket-replication \
--bucket amzn-s3-demo-source-bucket \
--profile acctA

  6. 次の手順を実行して、Amazon S3 コンソールでセットアップをテストします。

    1. AWS Management Console にサインインし、Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。

    2. 左側のナビゲーションペインで、[バケット] を選択します。[汎用バケット] リストで、レプリケート元バケットの名前を選択します。

    3. レプリケート元バケットに Tax という名前のフォルダを作成します。

    4. レプリケート元バケット内の Tax フォルダにサンプルオブジェクトを追加します。

      注記

      Amazon S3 がオブジェクトをレプリケートするのにかかる時間は、オブジェクトのサイズによって異なります。レプリケーションのステータスを確認する方法については、「レプリケーションステータス情報の取得」を参照してください。

      レプリケート先バケットで、以下の点を確認します。

      • Amazon S3 がオブジェクトをレプリケートしたこと。

      • オブジェクトがレプリカであること。オブジェクトの [プロパティ] タブで、[オブジェクト管理の概要] セクションまでスクロールします。[管理設定] で、[レプリケーションステータス] の [値] を確認します。この値が REPLICA に設定されていることを確認します。

      • レプリカがレプリケート元バケットアカウントによって所有されていること。オブジェクトの [アクセス許可] タブで、オブジェクトの所有権を確認できます。

        レプリケート元とレプリケート先のバケットが、異なるアカウントによって所有されている場合、オプションの設定を追加して、レプリカの所有権をレプリケート先バケットに変更するように Amazon S3 に対して指示できます。例については、「レプリカの所有者を変更する方法」を参照してください。

以下のコード例を使用して、AWS SDK for Java および AWS SDK for .NET で、レプリケーション設定をバケットにそれぞれ追加します。

Java

以下の例では、まずバケットにレプリケーション設定を追加した後、その設定を取得して確認します。作業サンプルの作成およびテストの手順については、「AWS SDK for Java デベロッパーガイド」の「使用開始」を参照してください。


import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagement;
import com.amazonaws.services.identitymanagement.AmazonIdentityManagementClientBuilder;
import com.amazonaws.services.identitymanagement.model.CreateRoleRequest;
import com.amazonaws.services.identitymanagement.model.PutRolePolicyRequest;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.BucketReplicationConfiguration;
import com.amazonaws.services.s3.model.BucketVersioningConfiguration;
import com.amazonaws.services.s3.model.CreateBucketRequest;
import com.amazonaws.services.s3.model.DeleteMarkerReplication;
import com.amazonaws.services.s3.model.DeleteMarkerReplicationStatus;
import com.amazonaws.services.s3.model.ReplicationDestinationConfig;
import com.amazonaws.services.s3.model.ReplicationRule;
import com.amazonaws.services.s3.model.ReplicationRuleStatus;
import com.amazonaws.services.s3.model.SetBucketVersioningConfigurationRequest;
import com.amazonaws.services.s3.model.StorageClass;
import com.amazonaws.services.s3.model.replication.ReplicationFilter;
import com.amazonaws.services.s3.model.replication.ReplicationFilterPredicate;
import com.amazonaws.services.s3.model.replication.ReplicationPrefixPredicate;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CrossRegionReplication {

        public static void main(String[] args) throws IOException {
                Regions clientRegion = Regions.DEFAULT_REGION;
                String accountId = "*** Account ID ***";
                String roleName = "*** Role name ***";
                String sourceBucketName = "*** Source bucket name ***";
                String destBucketName = "*** Destination bucket name ***";
                String prefix = "Tax/";

                String roleARN = String.format("arn:aws:iam::%s:%s", accountId, roleName);
                String destinationBucketARN = "arn:aws:s3:::" + destBucketName;

                AmazonS3 s3Client = AmazonS3Client.builder()
                                .withCredentials(new ProfileCredentialsProvider())
                                .withRegion(clientRegion)
                                .build();

                createBucket(s3Client, clientRegion, sourceBucketName);
                createBucket(s3Client, clientRegion, destBucketName);
                assignRole(roleName, clientRegion, sourceBucketName, destBucketName);

                try {

                        // Create the replication rule.
                        List<ReplicationFilterPredicate> andOperands = new ArrayList<ReplicationFilterPredicate>();
                        andOperands.add(new ReplicationPrefixPredicate(prefix));

                        Map<String, ReplicationRule> replicationRules = new HashMap<String, ReplicationRule>();
                        replicationRules.put("ReplicationRule1",
                                        new ReplicationRule()
                                                        .withPriority(0)
                                                        .withStatus(ReplicationRuleStatus.Enabled)
                                                        .withDeleteMarkerReplication(
                                                                        new DeleteMarkerReplication().withStatus(
                                                                                        DeleteMarkerReplicationStatus.DISABLED))
                                                        .withFilter(new ReplicationFilter().withPredicate(
                                                                        new ReplicationPrefixPredicate(prefix)))
                                                        .withDestinationConfig(new ReplicationDestinationConfig()
                                                                        .withBucketARN(destinationBucketARN)
                                                                        .withStorageClass(StorageClass.Standard)));

                        // Save the replication rule to the source bucket.
                        s3Client.setBucketReplicationConfiguration(sourceBucketName,
                                        new BucketReplicationConfiguration()
                                                        .withRoleARN(roleARN)
                                                        .withRules(replicationRules));

                        // Retrieve the replication configuration and verify that the configuration
                        // matches the rule we just set.
                        BucketReplicationConfiguration replicationConfig = s3Client
                                        .getBucketReplicationConfiguration(sourceBucketName);
                        ReplicationRule rule = replicationConfig.getRule("ReplicationRule1");
                        System.out.println("Retrieved destination bucket ARN: "
                                        + rule.getDestinationConfig().getBucketARN());
                        System.out.println("Retrieved priority: " + rule.getPriority());
                        System.out.println("Retrieved source-bucket replication rule status: " + rule.getStatus());
                } catch (AmazonServiceException e) {
                        // The call was transmitted successfully, but Amazon S3 couldn't process
                        // it, so it returned an error response.
                        e.printStackTrace();
                } catch (SdkClientException e) {
                        // Amazon S3 couldn't be contacted for a response, or the client
                        // couldn't parse the response from Amazon S3.
                        e.printStackTrace();
                }
        }

        private static void createBucket(AmazonS3 s3Client, Regions region, String bucketName) {
                CreateBucketRequest request = new CreateBucketRequest(bucketName, region.getName());
                s3Client.createBucket(request);
                BucketVersioningConfiguration configuration = new BucketVersioningConfiguration()
                                .withStatus(BucketVersioningConfiguration.ENABLED);

                SetBucketVersioningConfigurationRequest enableVersioningRequest = new SetBucketVersioningConfigurationRequest(
                                bucketName, configuration);
                s3Client.setBucketVersioningConfiguration(enableVersioningRequest);

        }

        private static void assignRole(String roleName, Regions region, String sourceBucket, String destinationBucket) {
                AmazonIdentityManagement iamClient = AmazonIdentityManagementClientBuilder.standard()
                                .withRegion(region)
                                .withCredentials(new ProfileCredentialsProvider())
                                .build();
                StringBuilder trustPolicy = new StringBuilder();
                trustPolicy.append("{\\r\\n   ");
                trustPolicy.append("\\\"Version\\\":\\\"2012-10-17\\\",\\r\\n   ");
                trustPolicy.append("\\\"Statement\\\":[\\r\\n      {\\r\\n         ");
                trustPolicy.append("\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Principal\\\":{\\r\\n            ");
                trustPolicy.append("\\\"Service\\\":\\\"s3.amazonaws.com\\\"\\r\\n         },\\r\\n         ");
                trustPolicy.append("\\\"Action\\\":\\\"sts:AssumeRole\\\"\\r\\n      }\\r\\n   ]\\r\\n}");

                CreateRoleRequest createRoleRequest = new CreateRoleRequest()
                                .withRoleName(roleName)
                                .withAssumeRolePolicyDocument(trustPolicy.toString());

                iamClient.createRole(createRoleRequest);

                StringBuilder permissionPolicy = new StringBuilder();
                permissionPolicy.append(
                                "{\\r\\n   \\\"Version\\\":\\\"2012-10-17\\\",\\r\\n   \\\"Statement\\\":[\\r\\n      {\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Action\\\":[\\r\\n             ");
                permissionPolicy.append("\\\"s3:GetObjectVersionForReplication\\\",\\r\\n            ");
                permissionPolicy.append(
                                "\\\"s3:GetObjectVersionAcl\\\"\\r\\n         ],\\r\\n         \\\"Resource\\\":[\\r\\n            ");
                permissionPolicy.append("\\\"arn:aws:s3:::");
                permissionPolicy.append(sourceBucket);
                permissionPolicy.append("/*\\\"\\r\\n         ]\\r\\n      },\\r\\n      {\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Effect\\\":\\\"Allow\\\",\\r\\n         \\\"Action\\\":[\\r\\n            ");
                permissionPolicy.append(
                                "\\\"s3:ListBucket\\\",\\r\\n            \\\"s3:GetReplicationConfiguration\\\"\\r\\n         ");
                permissionPolicy.append("],\\r\\n         \\\"Resource\\\":[\\r\\n            \\\"arn:aws:s3:::");
                permissionPolicy.append(sourceBucket);
                permissionPolicy.append("\\r\\n         ");
                permissionPolicy
                                .append("]\\r\\n      },\\r\\n      {\\r\\n         \\\"Effect\\\":\\\"Allow\\\",\\r\\n         ");
                permissionPolicy.append(
                                "\\\"Action\\\":[\\r\\n            \\\"s3:ReplicateObject\\\",\\r\\n            ");
                permissionPolicy
                                .append("\\\"s3:ReplicateDelete\\\",\\r\\n            \\\"s3:ReplicateTags\\\",\\r\\n            ");
                permissionPolicy.append("\\\"s3:GetObjectVersionTagging\\\"\\r\\n\\r\\n         ],\\r\\n         ");
                permissionPolicy.append("\\\"Resource\\\":\\\"arn:aws:s3:::");
                permissionPolicy.append(destinationBucket);
                permissionPolicy.append("/*\\\"\\r\\n      }\\r\\n   ]\\r\\n}");

                PutRolePolicyRequest putRolePolicyRequest = new PutRolePolicyRequest()
                                .withRoleName(roleName)
                                .withPolicyDocument(permissionPolicy.toString())
                                .withPolicyName("crrRolePolicy");

                iamClient.putRolePolicy(putRolePolicyRequest);

        }
}
C#

以下の AWS SDK for .NET のコード例では、バケットにレプリケーション設定を追加してから、その設定を取得します。このコードを使用するには、バケットの名前と IAM ロールの Amazon リソースネーム (ARN) を入力します。コード例を設定および実行する方法の詳細については、「AWS SDK for .NET デベロッパーガイド」の「AWS SDK for .NET の開始方法」を参照してください。

using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class CrossRegionReplicationTest
    {
        private const string sourceBucket = "*** source bucket ***";
        // Bucket ARN example - arn:aws:s3:::destinationbucket
        private const string destinationBucketArn = "*** destination bucket ARN ***";
        private const string roleArn = "*** IAM Role ARN ***";
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint sourceBucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 s3Client;
        public static void Main()
        {
            s3Client = new AmazonS3Client(sourceBucketRegion);
            EnableReplicationAsync().Wait();
        }
        static async Task EnableReplicationAsync()
        {
            try
            {
                ReplicationConfiguration replConfig = new ReplicationConfiguration
                {
                    Role = roleArn,
                    Rules =
                        {
                            new ReplicationRule
                            {
                                Prefix = "Tax",
                                Status = ReplicationRuleStatus.Enabled,
                                Destination = new ReplicationDestination
                                {
                                    BucketArn = destinationBucketArn
                                }
                            }
                        }
                };

                PutBucketReplicationRequest putRequest = new PutBucketReplicationRequest
                {
                    BucketName = sourceBucket,
                    Configuration = replConfig
                };

                PutBucketReplicationResponse putResponse = await s3Client.PutBucketReplicationAsync(putRequest);

                // Verify configuration by retrieving it.
                await RetrieveReplicationConfigurationAsync(s3Client);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }
        private static async Task RetrieveReplicationConfigurationAsync(IAmazonS3 client)
        {
            // Retrieve the configuration.
            GetBucketReplicationRequest getRequest = new GetBucketReplicationRequest
            {
                BucketName = sourceBucket
            };
            GetBucketReplicationResponse getResponse = await client.GetBucketReplicationAsync(getRequest);
            // Print.
            Console.WriteLine("Printing replication configuration information...");
            Console.WriteLine("Role ARN: {0}", getResponse.Configuration.Role);
            foreach (var rule in getResponse.Configuration.Rules)
            {
                Console.WriteLine("ID: {0}", rule.Id);
                Console.WriteLine("Prefix: {0}", rule.Prefix);
                Console.WriteLine("Status: {0}", rule.Status);
            }
        }
    }
}