為相同帳戶擁有的來源和目的地儲存貯體設定複寫

複製是在相同或不同值區之間對物件進行自動、非同步複製 AWS 區域。複寫會將來源儲存貯體中新建立的物件和物件更新複製至目的地儲存貯體。如需詳細資訊，請參閱 複寫物件。

設定複寫時，會將複寫規則新增至來源儲存貯體。複寫規則會定義要複寫的來源儲存貯體物件，以及存放已複寫物件的目的地儲存貯體。您可以建立規則，以特定的金鑰名稱前綴、一或多個物件標籤、或兩種都用，複寫儲存貯體中的所有物件，或一部分的物件。目的地值區可以位於與來源值區 AWS 帳戶 相同，也可以位於不同的帳戶中。

如果您指定要刪除的物件版本 ID，Amazon S3 會刪除來源儲存貯體中的該物件版本。但不會在目的地儲存貯體中進行刪除。換句話說，它不會從目的地儲存貯體中刪除相同的物件版本。這可防止資料遭到惡意刪除。

當您將複寫規則新增至儲存貯體時，預設會啟用此規則，讓它在您儲存它之後立即運作。

在此範例中，您會設定來源與目的地儲存貯體為同一 AWS 帳戶所擁有的複寫。提供了使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI) 和 AWS SDK for Java 和的範例 AWS SDK for .NET。

使用 S3 主控台

若要在目的地值區與來源值區位於相同 AWS 帳戶 時設定複製規則，請依照下列步驟執行。

如果目的地儲存貯體位在與來源儲存貯體不同的帳戶中，您必須將儲存貯體政策新增至目的地儲存貯體，以將複寫目的地儲存貯體中物件的許可授予來源儲存貯體帳戶擁有者。如需詳細資訊，請參閱 當來源和目的地值區屬於不同的值區時，授與權限 AWS 帳戶。

1. 登入 AWS Management Console 並開啟 Amazon S3 主控台，網址為 https://console.aws.amazon.com/s3/。

2. 在左側導覽窗格中，選擇 Buckets (儲存貯體)。

3. 在 Buckets (儲存貯體) 清單中，選擇您所需的儲存貯體名稱。

4. 選擇管理標籤，向下捲動至複寫規則，然後選擇建立複寫規則。

5. 在複寫規則設定區段的複寫規則名稱下，輸入規則名稱，以便之後識別規則。此名稱為必要，且在儲存貯體內必須是唯一的。

6. 在 Status (狀態) 下，預設會選取 Enabled (已啟用)。已啟用規則在您儲存它之後就會立即運作。如果希望稍後再啟用此規則，請選擇已停用。

7. 如果儲存貯體有現存的複寫規則，系統會指示您設定規則的優先順序。您必須設定規則優先順序，以免多項規則範圍內的物件引發衝突。如果發生規則重疊的情況，Amazon S3 會使用規則優先順序來判斷要套用哪一個規則。數字愈高，優先順序愈高。如需有關規則優先順序的詳細資訊，請參閱 複寫組態。

8. 在來源儲存貯體之下，您有下列選項可用來設定複寫來源：

   • 若要複寫整個儲存貯體，請選擇 Apply to all objects in the bucket (套用至儲存貯體中的所有物件)。

   • 若要複寫具有相同字首的所有物件，請選擇Limit the scope of this rule using one or more filters (使用一或多個篩選器限制此規則的範圍)。這會將複寫限制為具有以您指定字首開頭的所有物件 (例如 pictures) 名稱。在字首方塊中輸入字首。

     注意

     如果您輸入的字首是資料夾名稱，最後一個字元必須使用 / (正斜線) (例如，pictures/)。

   • 若要複寫具有一個或多個物件標籤的所有物件，請選擇新增標籤，然後在方塊中輸入關鍵值比對。重複此過程，添加另一個標籤。您可以合併字首與標籤。如需物件標籤的詳細資訊，請參閱 使用標籤分類儲存空間。

   新的複寫組態 XML 結構描述支援字首和標籤篩選條件以及規則的優先順序。如需有關新結構描述的資訊，請參閱 回溯相容性。如需與在使用者介面後工作之 Amazon S3 API 搭配使用的 XML 的相關資訊，請參閱 複寫組態。新的結構描述會被描述為複寫組態 XML V2。

9. 在目的地下，選擇要 Amazon S3 複寫物件的儲存貯體。

   注意

   目的地儲存貯體的數目限制為指定分割區 AWS 區域 中的數目。分割區是區域的群組。 AWS 目前有三個分區：aws(標準區域)、aws-cn (中國地區) 和 aws-us-gov (AWS GovCloud (US) 區域)。您可以使用服務配額來要求增加目的地儲存貯體配額。

   • 若要複寫到帳戶中的儲存貯體，請選擇選擇此帳戶中的儲存貯體，然後輸入或瀏覽目的地儲存貯體名稱。

   • 若要複製到另一個或多個值區中的值區 AWS 帳戶，請選擇「在其他帳戶中指定值區」，然後輸入目的地時段科目 ID 與值區名稱。

     如果目的地儲存貯體位在與來源儲存貯體不同的帳戶中，您必須將儲存貯體原則新增至目的地儲存貯體，以將複寫物件的許可授予來源儲存貯體帳戶擁有者。如需詳細資訊，請參閱 當來源和目的地值區屬於不同的值區時，授與權限 AWS 帳戶。

     或者，如果您想要啟用協助標準化目的地儲存貯體中新物件的擁有權，請選擇將物件擁有權變更為目的地儲存貯體擁有者。如需有關此選項的詳細資訊，請參閱 控制物件的擁有權並停用儲存貯體的 ACL。

   注意

   如果未在目的地儲存貯體上啟用版本控制，您會收到包含啟用版本控制按鈕的警告訊息。選擇此按鈕，以在儲存貯體上啟用版本控制。

10. 設定 Amazon S3 可假設為代表您複寫物件的 AWS Identity and Access Management (IAM) 角色。

    若要設定 IAM 角色，請在 IAM 角色區段中，從 IAM 角色下拉式清單選取下列其中一項：

    • 強烈建議您選擇建立新角色，讓 Amazon S3 為您建立新 IAM 角色。當您儲存規則時，系統會為符合所選擇來源與目的地儲存貯體的 IAM 角色產生新原則。

    • 您可以選擇使用現有 IAM 角色。如果這麼做，則必須選擇將必要複寫許可授予 Amazon S3 的角色。如果此角色未將遵循您複寫規則的足夠許可授予 Amazon S3，則複寫會失敗。

    重要

    當您新增複寫規則至儲存貯體時，必須擁有 iam:PassRole 許可，方能透過 IAM 角色授予 Amazon S3 複寫許可。如需詳細資訊，請參閱《IAM 使用者指南》中授予使用者將角色傳遞至 AWS 服務的許可。

11. 若要複製使用 () 金鑰 AWS Key Management Service (SSE-KMS AWS KMS) 進行伺服器端加密的來源儲存貯體中的物件，請在「加密」下選取「複製使用加密的物件」。 AWS KMS在用於加密目的地物件的AWS KMS 金鑰下，是您允許複寫使用的來源金鑰。根據預設，會包含所有來源 KMS 金鑰。您可以選擇別名或 ID，縮小 KMS 金鑰的選取範圍。

    不會複製由 AWS KMS keys 您未選取的加密物件。系統會為您選擇一個 KMS 金鑰或一組 KMS 金鑰，但您也可以自行選擇 KMS 金鑰。如需 AWS KMS 搭配複製使用的資訊，請參閱複寫使用伺服器端加密建立的物件 (SSE-C、SSE-S3、SSE-KMS、DSSE-KMS)。

    重要

    當您複寫使用加密的物件時 AWS KMS，來源區域中的 AWS KMS 要求率會加倍，而且目的地區域的要求率會增加相同的數量。這些增加的通話費率 AWS KMS 是因為使用您為複寫目的地區域定義的 KMS 金鑰重新加密資料的方式所致。 AWS KMS 具有每個區域每個呼叫帳戶的請求率配額。如需配額預設值的資訊，請參閱《AWS Key Management Service 開發人員指南》中的 AWS KMS 配額 – 每秒請求數：各有不同。

    如果複寫期間目前的 Amazon S3 PUT 物件請求率超過帳戶預設 AWS KMS 速率限制的一半以上，建議您請求提高 AWS KMS 請求率配額。若要請求提高，請在 AWS Support 中心的聯絡我們中內建立案例。例如，假設您目前的PUT物件要求率為每秒 1,000 個要求，而您用 AWS KMS 來加密物件。在這種情況下，我們建議您要求 AWS Support 將來源區域和目的地區域 (如果不同) 的 AWS KMS 速率限制提高到每秒 2,500 個請求，以確保沒有限制。 AWS KMS

    若要在來源儲存貯體中查看PUT物件請求率，請PutRequests在 Amazon Amazon S3 的 Amazon CloudWatch 請求指標中查看。如需檢視 CloudWatch 測量結果的資訊，請參閱使用 S3 主控台。

    如果您選擇複製使用加密的物件 AWS KMS，請執行下列動作：

    1. 在用於加密目的地物件的AWS KMS key 下，使用下列其中一種方式指定 KMS 金鑰：

       • 若要從可用的 KMS 金鑰清單中選擇，請選擇從 AWS KMS keys中選擇，然後從可用金鑰清單中選擇您的 KMS 金鑰。

         AWS 受管金鑰 (aws/s3) 和您的客戶管理金鑰都會出現在此清單中。如需詳細了解客戶受管金鑰，請參閱《AWS Key Management Service 開發人員指南》中的客戶金鑰和 AWS 金鑰。

       • 若要輸入 KMS 金鑰 Amazon Resource Name (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 開發人員指南》中的識別對稱和非對稱 KMS 金鑰。

       如需有關建立金鑰的詳細資訊 AWS KMS key，請參閱AWS Key Management Service 開發人員指南中的建立金鑰。如需 AWS KMS 搭配 Amazon S3 搭配使用的詳細資訊，請參閱使用伺服器端加密搭配 AWS KMS 金鑰 (SSE-KMS)。

12. 在目的地儲存方案之下,若要將資料複寫至目的地中的特定儲存方案，請選取變更已複寫物件的儲存方案。然後選擇您要用於目的地中已複寫物件的儲存體方案。如果您未選擇此選項，則已複寫物件的儲存體方案會與原始物件的類別相同。

13. 設定其他複寫選項時，您具有下列其他選項：

    • 如果您想要在複製組態中啟用 S3 複寫時間控制 (S3 RTC)，請選取 複製時間控制。如需有關此選項的詳細資訊，請參閱 使用 S3 複寫時間控制 (S3 RTC) 來達到合規要求。

    • 如果您想要在複寫組態中啟用 S3 複寫指標，請選取 Replication metrics and events (複寫指標和事件)。如需詳細資訊，請參閱 使用複寫指標和 S3 事件通知監控進度。

    • 如果您想要在複寫組態中啟用刪除標記複寫，請選取 Delete marker replication (刪除標記複寫)。如需詳細資訊，請參閱 複寫儲存貯體之間的刪除標記。

    • 如果您想要在複寫組態中啟用 Amazon S3 複本修改同步，請選取 Replica modification sync (複本修改同步)。如需詳細資訊，請參閱 使用 Amazon S3 複本修改同步複寫中繼資料變更。

    注意

    當您使用 S3 RTC 或 S3 複寫指標時，需支付額外費用。

14. 若要完成，請選擇 Save (儲存)。

15. 儲存規則之後，您可以選取規則並選擇編輯規則來編輯、啟用、停用或刪除規則。

使用 AWS CLI

若要在 AWS CLI 來源值區和目的地儲存貯體擁有時使用來設定複製 AWS 帳戶，請執行下列操作：

• 建立來源與目的地儲存貯體

• 在儲存貯體啟用版本控制

• 建立 IAM 角色，授予 Amazon S3 複寫物件的許可。

• 將複寫組態新增至來源儲存貯體

您可以測試以驗證設定。

若要在來源和目的地儲存貯體擁有相同值區時設定複製 AWS 帳戶

1. 設定 AWS CLI的憑證描述檔。在此範例中，我們使用描述檔名稱 acctA。如需設定憑證描述檔的相關資訊，請參閱《AWS Command Line Interface 使用者指南》中的具名描述檔。

   重要

   用於此練習的描述檔必須有必要的許可。例如，您可以在複寫組態中指定 Amazon S3 可以擔任的 IAM 角色。只有當您所用的描述檔有 iam:PassRole 許可時才可執行此作業。如需詳細資訊，請參閱《IAM 使用者指南》中的授予使用者將角色傳遞至 AWS 服務的許可。如果您使用管理員憑證建立具名描述檔，即可執行所有任務。

2. 建立 source 儲存貯體並對它啟用版本控制。下列程式碼會在美國東部 (維吉尼亞北部) (us-east-1) 區域中建立 source 儲存貯體。

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

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

3. 建立 destination 儲存貯體並對它啟用版本控制。下列程式碼會在美國西部 (奧勒岡) (us-west-2) 區域中建立 destination 儲存貯體。

   注意

   若要在來源儲存貯體和目的地儲存貯體位於相同時設定複製組態 AWS 帳戶，請使用相同的設定檔。此範例使用 acctA。若要在不同值區擁有時測試複製組態 AWS 帳戶，請為每個值區指定不同的設定檔。此範例的目標儲存貯體使用 acctB 描述檔。

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

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

4. 建立 IAM 角色。您可以在複寫組態中指定稍後要新增至 source 儲存貯體的角色，Amazon S3 就會擔任此角色以代您複寫物件。建立 IAM 角色需要兩個步驟：

   • 建立角色。

   • 將許可政策連接到角色。

   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:::source-bucket/*"
                  ]
               },
               {
                  "Effect":"Allow",
                  "Action":[
                     "s3:ListBucket",
                     "s3:GetReplicationConfiguration"
                  ],
                  "Resource":[
                     "arn:aws:s3:::source-bucket"
                  ]
               },
               {
                  "Effect":"Allow",
                  "Action":[
                     "s3:ReplicateObject",
                     "s3:ReplicateDelete",
                     "s3:ReplicateTags"
                  ],
                  "Resource":"arn:aws:s3:::destination-bucket/*"
               }
            ]
         }

      2. 執行下列命令以建立政策，並將它連接至角色。

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

5. 將複寫組態新增至 source 儲存貯體。

   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:::destination-bucket"
            }
          }
        ]
      }

   2. 提供 destination-bucket 和 IAM-role-ARN 的值以更新 JSON。儲存變更。

   3. 執行下列命令，將複寫組態新增至您的來源儲存貯體。請務必提供 source 儲存貯體名稱。

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

   使用 get-bucket-replication 命令來擷取複寫組態。

   $ aws s3api get-bucket-replication \
   --bucket source \
   --profile acctA

6. 在 Amazon S3 主控台中測試設定：

   1. 登入 AWS Management Console 並開啟 Amazon S3 主控台，網址為 https://console.aws.amazon.com/s3/。

   2. 在 source 儲存貯體中，建立名為 Tax 的資料夾。

   3. 將範例物件新增至 source 儲存貯體的 Tax 資料夾。

      注意

      Amazon S3 複寫物件所需的時間長短取決於物件大小。如需如何查看複寫狀態的相關資訊，請參閱 取得複寫狀態資訊。

      在 destination 儲存貯體中驗證下列事項：

      • Amazon S3 已複寫物件。

      • 在物件 properties (屬性) 中，Replication Status (複寫狀態) 已設定為 Replica (將此識別為複本物件)。

      • 在物件 properties (屬性) 中，permission (許可) 區段顯示無許可。這表示複本仍為 source 儲存貯體的擁有者所有，而 destination 儲存貯體擁有者沒有物件複本的任何許可。您可以新增選用組態以指示 Amazon S3 變更複本擁有權。如需範例，請參閱當不同帳戶擁有來源與目的地儲存貯體時變更複本擁有者。

        

使用 AWS 軟體開發套件

使用下列程式碼範例 AWS SDK for .NET，將複寫組態分別新增至含有 AWS SDK for Java 和的值區。

Java

下列範例會將複寫組態新增至儲存貯體，然後擷取它，並驗證組態。如需建立及測試可行範例的說明，請參閱 測試 Amazon S3 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 Resource Name (ARN)。如需如何建立及測試工作範例的說明，請參閱「執行 Amazon S3 .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);
            }
        }
    }
}