Configurazione della replica per i bucket di origine e di destinazione di proprietà dello stesso account - Amazon Simple Storage Service

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Configurazione della replica per i bucket di origine e di destinazione di proprietà dello stesso account

La replica è la copia automatica e asincrona di oggetti tra bucket uguali o diversi Regioni AWS. La replica copia gli oggetti appena creati e gli aggiornamenti degli oggetti da un bucket di origine a uno o più bucket di destinazione. Per ulteriori informazioni, consulta Panoramica sulla replica degli oggetti.

Quando si configura la replica, vengono aggiunte le regole di replica al bucket di origine. Le regole di replica definiscono gli oggetti del bucket di origine da replicare e i bucket di destinazione in cui vengono archiviati gli oggetti replicati. È possibile creare una regola per replicare tutti gli oggetti in un bucket o un sottoinsieme di oggetti con un prefisso di nome di chiave specifico, uno o più tag di oggetto o entrambi gli elementi. Un bucket di destinazione può trovarsi nello stesso Account AWS come bucket di origine oppure può trovarsi in un account diverso.

Se specifichi l'ID della versione dell'oggetto da eliminare, Amazon S3 elimina la versione dell'oggetto nel bucket di origine. Ma non replica l'eliminazione nel bucket di destinazione. In altre parole, non elimina la stessa versione dell'oggetto dal bucket di destinazione. Ciò permette di proteggere i dati da eliminazioni da parte di utenti malintenzionati.

Quando si aggiunge una regola di replica a un bucket, la regola viene abilitata per impostazione predefinita e pertanto inizia a funzionare non appena viene salvata.

In questo esempio, si configura la replica per i bucket di origine e di destinazione che sono di proprietà dello stesso Account AWS. Vengono forniti esempi di utilizzo della console Amazon S3, AWS Command Line Interface (AWS CLI) e AWS SDK for Java e AWS SDK for .NET.

Per configurare una regola di replica quando il bucket di destinazione si trova nello stesso Account AWS come bucket di origine, segui questi passaggi.

Se il bucket di destinazione si trova in un account diverso rispetto al bucket di origine, è necessario aggiungere al bucket di destinazione una policy di bucket per concedere al proprietario dell'account del bucket di origine l'autorizzazione per replicare gli oggetti nel bucket di destinazione. Per ulteriori informazioni, consulta Concessione delle autorizzazioni quando i bucket di origine e di destinazione sono di proprietà di diversi Account AWS.

  1. Accedi a AWS Management Console e apri la console Amazon S3 all'indirizzo. https://console.aws.amazon.com/s3/

  2. Nel pannello di navigazione a sinistra, scegli Buckets (Bucket).

  3. Nell'elenco Bucket scegli il nome del bucket desiderato.

  4. Seleziona la scheda Gestione, scorri verso il basso fino a Regole di replica e quindi scegli Crea regola di replica.

  5. Nella sezione Configurazione della regola di replica, in Nome della regola di replica, specifica il nome della regola per semplificarne l'identificazione in un secondo momento. Il nome è obbligatorio e deve essere univoco all'interno del bucket.

  6. In Status (Stato), l'opzione Enabled (Abilitata) è selezionata per impostazione predefinita. Una regola abilitata inizia a funzionare non appena viene salvata. Se desideri abilitare la regola in un secondo momento, scegli Disabilitata.

  7. Se il bucket dispone di regole di replica esistenti, viene chiesto di impostare una priorità per la regola. È necessario impostare una priorità per la regola per evitare i conflitti causati dagli oggetti inclusi nell'ambito di più regole. In caso di regole sovrapposte, Amazon S3 utilizza la priorità delle regole per determinare quale regola applicare. Più elevato è il numero, maggiore è la priorità. Per ulteriori informazioni sulla priorità delle regole, consulta Configurazione di replica.

  8. In Bucket di origine sono disponibili le seguenti opzioni per l'impostazione dell'origine della replica:

    • Per replicare l'intero bucket, scegli Apply to all objects in the bucket (Applica a tutti gli oggetti nel bucket).

    • Per replicare tutti gli oggetti con lo stesso prefisso, scegli Limita l'ambito di questa regola utilizzando uno o più filtri. Ciò limita la replica a tutti gli oggetti con nomi che iniziano il prefisso specificato, ad esempio pictures. Immetti un prefisso nella casella Prefisso.

      Nota

      Se si immette un prefisso corrispondente al nome di una cartella, è necessario utilizzare / (barra) come ultimo carattere (ad esempio, pictures/).

    • Per replicare tutti gli oggetti con uno o più tag oggetto, scegli Aggiungi tag e specifica la coppia chiave-valore nelle caselle. Per aggiungere un altro tag, ripetere la procedura. È possibile combinare un prefisso con i tag. Per ulteriori informazioni sui tag degli oggetti, consulta Suddivisione in categorie dello storage utilizzando i tag.

    Il nuovo XML schema di configurazione della replica supporta il filtraggio di prefissi e tag e l'assegnazione di priorità alle regole. Per ulteriori informazioni sul nuovo schema, consulta Compatibilità con le versioni precedenti. Per ulteriori informazioni sull'XMLutilizzo con Amazon S3 API che funziona dietro l'interfaccia utente, consulta. Configurazione di replica Il nuovo schema è descritto come configurazione XML di replica V2.

  9. In Destinazione, scegli il bucket in cui desideri che Amazon S3 esegui la replica degli oggetti.

    Nota

    Il numero di bucket di destinazione è limitato al numero di Regioni AWS in una determinata partizione. Una partizione è un raggruppamento di regioni. AWS attualmente ha tre partizioni: aws (Regioni standard), aws-cn (Regioni cinesi) e (aws-us-govAWS GovCloud (US) Regioni). È possibile utilizzare le Service Quotas per richiedere un aumento del limite per i bucket di destinazione.

    • Per eseguire la replica in un periodo fisso nel tuo account, seleziona Scegli un bucket in questo account e digita o cerca i bucket di destinazione.

    • Da replicare in uno o più bucket in un altro Account AWS, scegli Specificare un bucket in un altro account e inserisci l'ID dell'account del bucket di destinazione e il nome del bucket.

      Se il bucket di destinazione si trova in un account diverso rispetto al bucket di origine, dovrai aggiungere ai bucket di destinazione una policy di bucket per concedere al proprietario dell'account del bucket di origine l'autorizzazione per replicare gli oggetti nei bucket di destinazione. Per ulteriori informazioni, consulta Concessione delle autorizzazioni quando i bucket di origine e di destinazione sono di proprietà di diversi Account AWS.

      Facoltativamente, se desideri standardizzare la proprietà dei nuovi oggetti nel bucket di destinazione, seleziona Assegna la proprietà degli oggetti al proprietario del bucket di destinazione. Per ulteriori informazioni su questa opzione, consulta Controllo della proprietà degli oggetti e disattivazione del ACLs bucket.

    Nota

    Se la funzione Controllo delle versioni non è abilitata nel bucket di destinazione, viene visualizzato un messaggio di avviso contenente un pulsante Abilita Controllo delle versioni. Seleziona questo pulsante per abilitare la funzione Controllo delle versioni nel bucket.

  10. Configura un AWS Identity and Access Management (IAM) ruolo che Amazon S3 può assumere per replicare oggetti per tuo conto.

    Per configurare un IAM ruolo, nella sezione IAMruolo, seleziona una delle seguenti opzioni dall'elenco a discesa dei IAMruoli:

    • Ti consigliamo vivamente di scegliere Crea nuovo ruolo per fare in modo che Amazon S3 crei un nuovo IAM ruolo per te. Quando salvi la regola, viene generata una nuova policy per il IAM ruolo che corrisponde ai bucket di origine e di destinazione che hai scelto.

    • Puoi scegliere di utilizzare un IAM ruolo esistente. In tal caso, è necessario scegliere un ruolo che conceda ad Amazon S3 le autorizzazioni necessarie per la replica. Se questo ruolo non concede autorizzazioni sufficienti ad Amazon S3 per seguire la regola di replica, la replica non riesce.

    Importante

    Quando aggiungi una regola di replica a un bucket, devi disporre dell'iam:PassRoleautorizzazione per poter passare il IAM ruolo che concede le autorizzazioni di replica di Amazon S3. Per ulteriori informazioni, consulta Concedere a un utente le autorizzazioni per passare un ruolo a un Servizio AWS nella Guida per l'utente di IAM.

  11. Per replicare gli oggetti nel bucket di origine che sono crittografati con la crittografia lato server con AWS Key Management Service (AWS KMS) chiavi (SSE-KMS), in Crittografia, seleziona Replica oggetti crittografati con AWS KMS. Sotto AWS KMS le chiavi per la crittografia degli oggetti di destinazione sono le chiavi di origine che consentite alla replica di utilizzare. Tutte le KMS chiavi di origine sono incluse per impostazione predefinita. Per restringere la selezione delle KMS chiavi, puoi scegliere un alias o un ID chiave.

    Oggetti crittografati da AWS KMS keys quelli che non vengono selezionati non vengono replicati. Una KMS chiave o un gruppo di KMS chiavi viene scelto automaticamente, ma puoi scegliere le KMS chiavi se lo desideri. Per informazioni sull'utilizzo AWS KMS con replica, vedereReplicazione di oggetti crittografati (SSE-C, -S3, -, SSE -) SSE KMS DSSE KMS.

    Importante

    Quando si replicano oggetti crittografati con AWS KMS, il AWS KMS il tasso di richiesta raddoppia nella regione di origine e aumenta nella regione di destinazione dello stesso importo. Queste tariffe di chiamata hanno aumentato a AWS KMS sono dovuti al modo in cui i dati vengono ricrittografati utilizzando la KMS chiave definita per la regione di destinazione della replica. AWS KMS ha una quota di frequenza di richiesta espressa per account chiamante per regione. Per informazioni sulle quote predefinite, vedere AWS KMS Quote - Richieste al secondo: varia nel AWS Key Management Service Guida per gli sviluppatori.

    Se la frequenza attuale di richieste di PUT oggetti di Amazon S3 durante la replica è superiore alla metà di quella predefinita AWS KMS limite di tariffa per il tuo account, ti consigliamo di richiedere un aumento del tuo AWS KMS richiedi una quota tariffaria. Per richiedere un aumento, crea un caso nel AWS Support Centra in Contattaci. Ad esempio, supponiamo che la frequenza attuale delle richieste di PUT oggetti sia di 1.000 richieste al secondo e che tu utilizzi AWS KMS per crittografare i tuoi oggetti. In questo caso, ti consigliamo di chiedere AWS Support per aumentare il tuo AWS KMS limite di velocità a 2.500 richieste al secondo, sia nella regione di origine che in quella di destinazione (se diversa), per garantire che non vi siano limitazioni da AWS KMS.

    Per visualizzare la frequenza delle richieste di PUT oggetti nel bucket di origine, consulta i parametri di CloudWatch richiesta di Amazon per Amazon S3. PutRequests Per informazioni sulla visualizzazione delle CloudWatch metriche, consulta. Utilizzo della console S3

    Se hai scelto di replicare oggetti crittografati con AWS KMS, effettuate le seguenti operazioni:

    1. In AWS KMS key per crittografare gli oggetti di destinazione, specificate la KMS chiave in uno dei seguenti modi:

      • Per scegliere da un elenco di KMS chiavi disponibili, scegli Scegli tra le AWS KMS keyse scegli la tua KMSchiave dall'elenco delle chiavi disponibili.

        Entrambi i Chiave gestita da AWS (aws/s3) e le chiavi gestite dai clienti vengono visualizzate in questo elenco. Per ulteriori informazioni sulle chiavi gestite dai clienti, consulta Customer keys e AWS chiavi in AWS Key Management Service Guida per gli sviluppatori.

      • Per inserire la KMS chiave Amazon Resource Name (ARN), scegli Invio AWS KMS key ARNe inserisci la tua KMS chiave ARN nel campo che appare. In questo modo vengono crittografate le repliche nel bucket di destinazione. Puoi trovare la chiave ARN per la tua KMS chiave nella IAMConsole, sotto Chiavi di crittografia.

      • Per creare una nuova chiave gestita dal cliente nel AWS KMS console, scegli Crea una KMS chiave.

        Per ulteriori informazioni sulla creazione di un AWS KMS key, vedi Creazione di chiavi in AWS Key Management Service Guida per gli sviluppatori.

      Importante

      È possibile utilizzare solo KMS chiavi abilitate nella stessa Regione AWS come secchio. Quando scegli Scegli tra KMS le tue chiavi, la console S3 elenca solo 100 KMS chiavi per regione. Se hai più di 100 KMS tasti nella stessa regione, puoi vedere solo i primi 100 KMS tasti nella console S3. Per utilizzare una KMS chiave non elencata nella console, scegli Invio AWS KMS key ARNe inserisci la tua KMS chiaveARN.

      Quando si utilizza un AWS KMS key per la crittografia lato server in Amazon S3, devi scegliere una chiave di crittografia simmetrica. KMS Amazon S3 supporta solo chiavi di crittografia simmetriche e non KMS chiavi asimmetriche. KMS Per ulteriori informazioni, consulta Identificazione delle chiavi simmetriche e asimmetriche nel KMS AWS Key Management Service Guida per gli sviluppatori.

      Per ulteriori informazioni sulla creazione di un AWS KMS key, vedi Creazione di chiavi in AWS Key Management Service Guida per gli sviluppatori. Per ulteriori informazioni sull'utilizzo AWS KMS con Amazon S3, vedi. Utilizzo della crittografia lato server con AWS KMS tasti (-) SSE KMS

  12. In Classe di storage di destinazione, per replicare i dati in una classe di archiviazione specifica nel bucket di destinazione, seleziona Modifica classe di archiviazione per gli oggetti replicati. Scegli quindi la classe di storage che desideri utilizzare per gli oggetti replicati nel bucket di destinazione. Se non selezioni questa opzione, la classe di storage per gli oggetti replicati sarà la stessa degli oggetti originali.

  13. Durante l'impostazione dei valori in Opzioni di replica aggiuntive, sono disponibili le seguenti opzioni aggiuntive:

    Nota

    Quando si utilizzano i parametri di replica S3 RTC o S3, si applicano costi aggiuntivi.

  14. Per terminare, seleziona Salva.

  15. Dopo aver salvato la regola, potrai modificare, abilitare, disabilitare o eliminare la regola selezionando la regola e scegliendo Modifica regola.

Per utilizzare nuovamente il plugin AWS CLI per configurare la replica quando i bucket di origine e di destinazione sono di proprietà dello stesso Account AWS, si effettuano le seguenti operazioni:

  • Creazione dei bucket di origine e di destinazione

  • Abilitazione del controllo delle versioni sui bucket

  • Crea un IAM ruolo che autorizzi Amazon S3 a replicare oggetti

  • Aggiunta della configurazione di replica al bucket di origine

Per verificare l'impostazione, testarla.

Per configurare la replica quando i bucket di origine e di destinazione sono di proprietà dello stesso Account AWS

  1. Impostare un profilo di credenziali per AWS CLI. In questo esempio, utilizziamo il nome del profiloacctA. Per informazioni sull'impostazione dei profili di credenziali, consulta Named Profiles nel AWS Command Line Interface Guida per l'utente.

    Importante

    Il profilo utilizzato per questo esercizio deve disporre delle autorizzazioni necessarie. Ad esempio, nella configurazione di replica, si specifica il IAM ruolo che Amazon S3 può assumere. Puoi effettuare questa operazione solo se il profilo che utilizzi dispone dell'autorizzazione iam:PassRole. Per ulteriori informazioni, consulta Concedere a un utente le autorizzazioni per passare un ruolo a un AWS Servizio nella Guida per l'IAMutente. Se utilizzi le credenziali di amministratore per creare un profilo con nome, puoi eseguire tutte le attività.

  2. Crea un bucket di source e abilita la funzione di controllo delle versioni. Il codice seguente crea un bucket di source nella regione Stati Uniti orientali (Virginia settentrionale) (us-east-1).

    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. Crea un bucket di destination e abilita la funzione di controllo delle versioni. Il codice seguente crea un bucket di destination nella regione Stati Uniti occidentali (Oregon) (us-west-2).

    Nota

    Per configurare la configurazione di replica quando i bucket di origine e di destinazione si trovano nello stesso Account AWS, si utilizza lo stesso profilo. Questo esempio usa acctA. Per testare la configurazione di replica quando i bucket sono di proprietà di diversi Account AWS, si specificano profili diversi per ciascuno di essi. Questo esempio utilizza il profilo acctB per il bucket di destinazione.

    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. Crea un IAM ruolo. Specificate questo ruolo nella configurazione di replica che aggiungete al source secchio più tardi. Amazon S3 assume questo ruolo per replicare gli oggetti per tuo conto. Puoi creare un IAM ruolo in due passaggi:

    • Creare un ruolo.

    • Collegare una policy di autorizzazione al ruolo.

    1. Crea il IAM ruolo.

      1. Copiare la seguente policy di attendibilità e salvarla in un file denominato s3-role-trust-policy.json nella directory corrente sul computer locale. Questa policy concede ad Amazon S3 le autorizzazioni ai principali del servizio per assumere il ruolo.

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

      2. Per creare un ruolo, eseguire il comando seguente.

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

    2. Collegare una policy di autorizzazione al ruolo.

      1. Copiare la seguente policy di autorizzazioni e salvarla in un file denominato s3-role-permissions-policy.json nella directory corrente sul computer locale. Questa policy di accesso concede le autorizzazioni per varie operazioni su oggetti e bucket 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. Eseguire il comando seguente per creare una policy e collegarla al ruolo.

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

  5. Aggiungi la configurazione di replica al bucket di source.

    1. Sebbene Amazon S3 API richieda una configurazione di replica come, XML AWS CLI richiede di specificare la configurazione di replica come. JSON Salvate quanto segue JSON in un file chiamato replication.json nella directory locale del computer.

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

    2. Aggiorna il JSON fornendo i valori per destination-bucket andIAM-role-ARN. Salvare le modifiche.

    3. Eseguire il comando seguente per aggiungere la configurazione di replica al bucket di origine. Assicurati di fornire il nome del bucket di source.

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

    Per recuperare la configurazione di replica, utilizzare il comando get-bucket-replication.

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

  6. Verifica la configurazione nella console di Amazon S3:

    1. Accedere a AWS Management Console e apri la console Amazon S3 all'indirizzo. https://console.aws.amazon.com/s3/

    2. Nel bucket di source, crea una cartella denominata Tax.

    3. Aggiungi oggetti di esempio alla cartella Tax del bucket di source.

      Nota

      Il tempo richiesto da Amazon S3 per la replica di un oggetto dipende dalle dimensioni dell'oggetto. Per informazioni su come visualizzare lo stato della replica, consulta la sezione Ottenimento delle informazioni sullo stato della replica.

      Nel bucket di destination, verifica quanto segue:

      • Amazon S3 ha replicato gli oggetti.

      • Nelle proprietà dell'oggetto, Stato di replica è impostato su Replica (che identifica l'oggetto come replica).

      • Nelle proprietà dell'oggetto, nella sezione delle autorizzazioni non viene visualizzata alcuna autorizzazione. Questo significa che la replica appartiene ancora al proprietario del bucket di source e il proprietario del bucket di destination non possiede alcuna autorizzazione per la replica dell'oggetto. È possibile aggiungere una configurazione facoltativa per indicare ad Amazon S3 di cambiare la proprietà della replica. Per vedere un esempio, consulta Come modificare il proprietario della replica.

        Screenshot delle proprietà di un oggetto che mostra lo stato di replica e le autorizzazioni.

Usa i seguenti esempi di codice per aggiungere una configurazione di replica a un bucket con AWS SDK for Java e AWS SDK for .NET, rispettivamente.

Java

L'esempio seguente aggiunge una configurazione di replica a un bucket e successivamente recupera e verifica la configurazione. Per istruzioni sulla creazione e sul test di un esempio funzionante, consulta la Guida introduttiva nella AWS SDK for Java Guida per gli sviluppatori.


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#

I seguenti AWS SDK for .NET esempio di codice aggiunge una configurazione di replica a un bucket e poi la recupera. Per utilizzare questo codice, fornisci i nomi dei tuoi bucket e l'Amazon Resource Name (ARN) per il tuo IAM ruolo. Per informazioni sulla configurazione e l'esecuzione degli esempi di codice, consulta Getting Started with the AWS SDKper. NETnel AWS SDKper. NETGuida per gli sviluppatori. 

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