Configuration d'une réplication pour des compartiments source et destination appartenant au même compte - Amazon Simple Storage Service

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Configuration d'une réplication pour des compartiments source et destination appartenant au même compte

La réplication est la copie automatique et asynchrone d'objets dans des compartiments identiques ou différents. Régions AWS Elle réplique les objets nouvellement créés et les mises à jour d'objets d'un compartiment source vers un ou plusieurs compartiments de destination. Pour plus d’informations, consultez Réplication d'objets.

Lorsque vous configurez la réplication, vous ajoutez des règles de réplication au compartiment source. Les règles de réplication définissent les objets du compartiment source à répliquer, ainsi que le ou les compartiments de destination dans lesquels les objets répliqués seront stockés. Vous pouvez créer une règle pour répliquer tous les objets ou un sous-ensemble d'objets d'un compartiment à l'aide de préfixes de nom de clé ou d'autres balises d'objet, ou les deux. Un compartiment de destination peut se trouver dans le même compartiment Compte AWS que le compartiment source ou dans un autre compte.

Si vous spécifiez un ID de version d'objet à supprimer, Amazon S3 supprime cette version de l'objet dans le compartiment source. Mais le service ne réplique pas la suppression dans le compartiment de destination. En d'autres termes, il ne supprime pas la même version de l'objet dans le compartiment de destination. Les données sont ainsi protégées contre les suppressions malencontreuses.

Lorsque vous ajoutez une règle de réplication à un compartiment, celle-ci est activée par défaut et entre en fonctionnement dès que vous l'enregistrez.

Dans cet exemple, vous configurez la réplication pour les compartiments source et de destination qui appartiennent au même Compte AWS. Des exemples d'utilisation de la console Amazon S3, du AWS Command Line Interface (AWS CLI) et du AWS SDK for Java and sont fournis AWS SDK for .NET.

Pour configurer une règle de réplication lorsque le compartiment de destination se trouve dans le même compartiment Compte AWS que le compartiment source, procédez comme suit.

Si le compartiment de destination se trouve dans un compte différent du compartiment source, vous devez ajouter une stratégie de compartiment au compartiment de destination pour accorder au propriétaire du compte du compartiment source l'autorisation d'effectuer des réplications d'objets dans le compartiment de destination. Pour de plus amples informations, veuillez consulter Octroi d'autorisations lorsque les compartiments source et de destination appartiennent à des entités différentes Comptes AWS.

  1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

  2. Dans le panneau de navigation de gauche, choisissez Compartiments.

  3. Dans la liste Compartiments, choisissez le nom du compartiment que vous souhaitez utiliser.

  4. Sélectionnez Gestion, faites défiler jusqu'à Règles de réplication, puis sélectionnez Créer une règle de réplication.

  5. Dans la section Configuration de la règle de réplication, sous Nom de la règle de réplication, saisissez un nom pour votre règle afin de l'identifier facilement plus tard. Ce nom est obligatoire et doit être unique dans le compartiment.

  6. Sous Statut, Activé est sélectionné par défaut. Un règle activée entre en fonctionnement dès que l'avez enregistrée. Si vous souhaitez activer la règle ultérieurement, sélectionnez Désactivé.

  7. Si le compartiment possède des règles de réplication existantes, il vous est demandé de définir une priorité pour la règle. Vous devez définir une priorité pour la règle pour éviter les conflits provoqués par les objets inclus dans l'étendue de plusieurs règles. En cas de chevauchement de règles, Amazon S3 utilise la priorité des règles pour déterminer la règle à appliquer. Plus le nombre est élevé, plus la priorité est haute. Pour plus d'informations sur la priorité des règles, consultez Configuration de réplication.

  8. Sous Compartiment source, vous disposez des options suivantes pour définir la source de réplication :

    • Pour répliquer l'ensemble du compartiment, choisissez Apply to all objects in the bucket (Appliquer à tous les objets du compartiment).

    • Pour répliquer tous les objets ayant le même préfixe, choisissez Limit the scope of this rule using one or more filters (Limiter la portée de cette règle en utilisant un ou plusieurs filtres). Cela limite la réplication à tous les objets dont les noms commencent par le préfixe que vous spécifiez (par exemple, pictures). Saisissez un préfixe dans la zone Préfixe.

      Note

      Si vous entrez un préfixe correspondant à un nom de dossier, vous devez insérer le caractère / (barre oblique) à la fin (par exemple, pictures/).

    • Pour répliquer tous les objets avec une ou plusieurs balises d'objet, sélectionnez Ajouter une balise et saisissez la paire clé-valeur dans les zones. Répétez la procédure pour ajouter une autre balise. Vous pouvez combiner un préfixe et des balises. Pour en savoir plus sur les balises d'objet, consultez Catégorisation de votre stockage à l'aide de balises.

    Le nouveau schéma XML de configuration de la réplication prend en charge le balisage de préfixe et de balise, et la priorité des règles. Pour plus d'informations sur le nouveau schéma, consultez Rétrocompatibilité. Pour plus d'informations sur le XML utilisé avec l'API Amazon S3 qui fonctionne derrière l'interface utilisateur, reportez-vous à Configuration de réplication. Le nouveau schéma est décrit comme configuration de réplication XML V2.

  9. Sous Destination, sélectionnez le compartiment où vous souhaitez qu'Amazon S3 réplique les objets.

    Note

    Le nombre de compartiments de destination est limité au nombre de compartiments contenus Régions AWS dans une partition donnée. Une partition est un regroupement de régions. AWS possède actuellement trois partitions : aws (Régions standard), aws-cn (Régions de Chine) et aws-us-gov (AWS GovCloud (US) Régions). Vous pouvez utiliser Service Quotas pour demander une augmentation de votre limite de compartiments de destination.

    • Pour répliquer vers un compartiment ou plusieurs compartiments de votre compte, sélectionnez Choisir un compartiment dans ce compte et saisissez ou recherchez le nom du compartiment de destination.

    • Pour effectuer une réplication vers un ou plusieurs compartiments d'un autre compte Compte AWS, choisissez Spécifier un compartiment dans un autre compte, puis entrez l'ID du compte du compartiment de destination et le nom du compartiment.

      Si la destination se trouve dans un compte différent du compartiment source, vous devez ajouter une stratégie de compartiment aux compartiments de destination pour accorder au propriétaire du compte du compartiment source l'autorisation d'effectuer des réplications d'objets. Pour plus d’informations, consultez Octroi d'autorisations lorsque les compartiments source et de destination appartiennent à des entités différentes Comptes AWS.

      (Facultatif) Si vous souhaitez aider à normaliser la propriété des nouveaux objets dans le compartiment de destination, choisissez Remplacer la propriété de l'objet par le propriétaire du compartiment de destination. Pour plus d’informations sur cette option, consultez Consultez Contrôle de la propriété des objets et désactivation des listes ACL pour votre compartiment.

    Note

    Si la gestion des versions n'est pas activée sur le compartiment de destination, un message d'avertissement avec le bouton Activer la gestion des versions s'affiche. Cliquez sur ce bouton pour activer la gestion des versions sur le compartiment.

  10. Configurez un rôle AWS Identity and Access Management (IAM) qu'Amazon S3 peut assumer pour répliquer des objets en votre nom.

    Pour configurer un rôle IAM, dans la section Rôle IAM, sélectionnez l'une des options suivantes dans la liste déroulante des rôles IAM :

    • Nous vous recommandons vivement de choisir Create new role (Créer un nouveau rôle) pour demander à Amazon S3 de créer nouveau rôle IAM pour vous. Lorsque vous enregistrez la règle, une nouvelle stratégie est générée pour le rôle IAM correspondant aux compartiments source et cible que vous choisissez.

    • Vous pouvez également choisir d'utiliser un rôle IAM existant. Dans ce cas, vous devez choisir un rôle qui octroie à Amazon S3 les autorisations nécessaires pour la réplication. La réplication échoue si ce rôle n'accorde pas à Amazon S3 les autorisations suffisantes pour suivre votre règle de réplication.

    Important

    Lorsque vous ajoutez une règle de réplication à un compartiment, vous devez disposer de l'autorisation iam:PassRole pour pouvoir transmettre le rôle IAM qui accorde les autorisations de réplication Amazon S3. Pour plus d'informations, consultez Octroi d'autorisations à un utilisateur pour transférer un rôle à un Service AWS dans le Guide de l'utilisateur IAM.

  11. Pour répliquer les objets du compartiment source chiffrés à l'aide du chiffrement côté serveur à l'aide de clés AWS Key Management Service (AWS KMS) (SSE-KMS), sous Chiffrement, sélectionnez Répliquer les objets chiffrés avec. AWS KMS Sous Clés AWS KMS pour le chiffrement des objets de destination se trouvent les clés source que la réplication est autorisée à utiliser. Toutes les clés source KMS sont incluses par défaut. Vous pouvez choisir un alias ou un ID de clé afin de restreindre la sélection des clés KMS.

    Les objets chiffrés par AWS KMS keys ceux que vous ne sélectionnez pas ne sont pas répliqués. Une clé KMS ou un groupe de clés KMS est sélectionné pour vous, mais vous pouvez choisir les clés KMS que vous souhaitez utiliser si vous le souhaitez. Pour plus d'informations sur l'utilisation AWS KMS avec la réplication, consultezRéplication d'objets créés avec le chiffrement côté serveur (SSE-C, SSE-S3, SSE-KMS, DSSE-KMS).

    Important

    Lorsque vous répliquez des objets chiffrés avec AWS KMS, le taux de AWS KMS demandes double dans la région source et augmente d'autant dans la région de destination. Ces taux d'appels accrus AWS KMS sont dus à la manière dont les données sont rechiffrées à l'aide de la clé KMS que vous définissez pour la région de destination de la réplication. AWS KMS dispose d'un quota de taux de demandes par compte d'appel et par région. Pour obtenir des informations sur les quotas par défaut, consultez Quotas AWS KMS – nombre de demandes par seconde : variable dans le Guide du développeur AWS Key Management Service .

    Si votre taux actuel de demandes d'PUTobjets Amazon S3 pendant la réplication est supérieur à la moitié de la limite de AWS KMS débit par défaut de votre compte, nous vous recommandons de demander une augmentation de votre quota de taux de AWS KMS demandes. Pour demander une augmentation, contactez-nous afin de créer un cas dans le Centre AWS Support . Supposons, par exemple, que votre taux de demandes d'PUTobjets actuel soit de 1 000 requêtes par seconde et que vous l'utilisiez AWS KMS pour chiffrer vos objets. Dans ce cas, nous vous recommandons de demander AWS Support à augmenter votre limite de AWS KMS débit à 2 500 requêtes par seconde, dans vos régions source et de destination (si elles sont différentes), afin de garantir qu'il n'y ait pas de limitation. AWS KMS

    Pour connaître le taux de demandes d'PUTobjets dans le compartiment source, consultez PutRequests les métriques des CloudWatch demandes Amazon pour Amazon S3. Pour plus d'informations sur l'affichage CloudWatch des métriques, consultezUtiliser la console S3..

    Si vous avez choisi de répliquer des objets chiffrés avec AWS KMS, procédez comme suit :

    1. Sous AWS KMS key pour le chiffrement des objets de destination, spécifiez votre clé KMS de l'une des manières suivantes :

      • Pour choisir parmi une liste de clés KMS disponibles, choisissez Choisir parmi vos clés AWS KMS keys, puis sélectionnez votre Clé KMS dans la liste des clés disponibles.

        La clé Clé gérée par AWS (aws/s3) et la clé gérée par votre client apparaissent toutes deux dans cette liste. Pour plus d'informations sur les clés gérées par le client, consultez Clés de client et clés AWS dans le Guide du développeur AWS Key Management Service .

      • Pour saisir l'Amazon Resource Name (ARN) de la clé KMS, choisissez Saisir l'ARN de AWS KMS key , puis saisissez l'ARN de votre clé KMS dans le champ qui s'affiche. Cela chiffre les réplicas dans le compartiment de destination. Vous trouverez l'ARN de votre clé KMS dans la console IAM, sous Clés de chiffrement.

      • Pour créer une nouvelle clé gérée par le client dans la AWS KMS console, choisissez Create a KMS key.

        Pour plus d'informations sur la création d'un AWS KMS key, consultez la section Création de clés dans le Guide du AWS Key Management Service développeur.

      Important

      Vous ne pouvez utiliser que les clés KMS activées au même endroit Région AWS que le bucket. Lorsque vous choisissez Choisir parmi vos clés KMS, la console S3 ne répertorie que 100 clés KMS par région. Si vous avez plus de 100 clés KMS dans la même Région, vous pourrez uniquement afficher les 100 premières clés KMS dans la console S3. Pour utiliser une clé KMS qui n'est pas répertoriée dans la console, choisissez Saisir l'ARN de AWS KMS key , puis saisissez l'ARN de la clé KMS.

      Lorsque vous utilisez un AWS KMS key pour le chiffrement côté serveur dans Amazon S3, vous devez choisir une clé KMS de chiffrement symétrique. Amazon S3 prend uniquement en charge les clés KMS symétriques de chiffrement et ne prend pas en charge les clés KMS asymétriques. Pour plus d'informations, consultez la section Identifying symmetric and asymmetric KMS keys (Identification des clés KMS symétriques et asymétriques) dans le Guide du développeur AWS Key Management Service .

      Pour plus d'informations sur la création d'un AWS KMS key, consultez la section Création de clés dans le Guide du AWS Key Management Service développeur. Pour plus d'informations sur l'utilisation AWS KMS avec Amazon S3, consultezUtilisation du chiffrement côté serveur à l'aide de AWS KMS clés (SSE-KMS).

  12. Sous Classe de stockage de destination, si vous voulez répliquer vos données dans une classe de stockage spécifique dans le compartiment de destination, sélectionnez Modifier la classe de stockage pour les objets répliqués. Choisissez ensuite la classe de stockage que vous voulez utiliser pour les objets répliqués dans la destination. Si vous ne sélectionnez pas cette option, la classe de stockage utilisée pour les objets répliqués est identique à celle des objets d'origine.

  13. Vous disposez des options supplémentaires suivantes lors de la définition des Options de réplication supplémentaires :

    Note

    Des frais supplémentaires s'appliquent lorsque vous utilisez des métriques de réplication S3 RTC ou S3.

  14. Pour terminer, choisissez Enregistrer.

  15. Une fois votre règle enregistrée, vous pouvez la modifier, l'activer, la désactiver ou la supprimer en la sélectionnant et en choisissant Edit rule (Modifier la règle).

AWS CLI Pour configurer la réplication lorsque les compartiments source et de destination appartiennent à la même entité Compte AWS, procédez comme suit :

  • Créer des compartiments source et de destination

  • Activer la gestion des versions sur les compartiments

  • Créer un rôle IAM qui octroie à Simple Storage Service (Amazon S3) l'autorisation de répliquer des objets

  • Ajouter la configuration de réplication au compartiment source

Testez votre configuration pour la vérifier.

Pour configurer la réplication lorsque les compartiments source et de destination appartiennent à la même entité Compte AWS

  1. Définissez un profil d'informations d'identification pour l' AWS CLI. Dans cet exemple, nous utilisons le nom de profil acctA. Pour plus d’informations sur la définition des profils d’informations d’identification, consultez Profils nommés dans le Guide de l’utilisateur AWS Command Line Interface .

    Important

    Le profil que vous utilisez pour cet exercice doit disposer des autorisations nécessaires. Par exemple, dans la configuration de réplication, vous spécifiez le rôle IAM qu'Amazon S3 peut endosser. Vous ne pouvez effectuer cette tâche que si le profil que vous utilisez dispose de l'autorisation iam:PassRole. Pour plus d’informations, consultez Octroi d’autorisations à un utilisateur pour transférer un rôle à un service AWS dans le Guide de l’utilisateur IAM. Si vous utilisez les informations d'identification d'un administrateur pour créer un profil nommé, vous pouvez exécuter toutes les tâches.

  2. Créez un compartiment source et activez la gestion des versions sur ce dernier. Le code suivant crée un compartiment source dans la Région USA Est (Virginie du Nord) (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. Créez un compartiment destination et activez la gestion des versions sur ce dernier. Le code suivant crée un compartiment destination dans la Région USA Ouest (Oregon) (us-west-2).

    Note

    Pour configurer la configuration de réplication lorsque les compartiments source et de destination se trouvent dans le même compartiment Compte AWS, vous devez utiliser le même profil. Cet exemple utilise acctA. Pour tester la configuration de réplication lorsque les buckets appartiennent à des propriétaires différents Comptes AWS, vous devez spécifier des profils différents pour chacun d'entre eux. Cet exemple utilise le profil acctB pour le compartiment de destination.

    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. Créez un rôle IAM. Vous précisez ce rôle dans la configuration de réplication que vous ajouterez ultérieurement au compartiment source. Amazon S3 endosse ce rôle pour répliquer des objets en votre nom. Vous créez un rôle IAM en deux étapes.

    • Créez un rôle

    • Attachez une stratégie d'autorisation au rôle.

    1. Créez le rôle IAM.

      1. Copiez la stratégie d'approbation suivante et enregistrez-la dans un fichier nommé s3-role-trust-policy.json dans le répertoire actif sur votre ordinateur local. Cette stratégie accorde au principal de service Amazon S3 les autorisations principales pour endosser ce rôle.

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

      2. Exécutez la commande suivante pour créer un rôle.

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

    2. Attachez une stratégie d'autorisation au rôle.

      1. Copiez la politique d'autorisations suivante et enregistrez-la dans un fichier nommé s3-role-permissions-policy.json dans le répertoire actuel de votre ordinateur local. Cette stratégie accorde des autorisations pour diverses actions sur les compartiments et les objets 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. Exécutez la commande suivante pour créer une stratégie et l'attacher au rôle.

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

  5. Ajoutez une configuration de réplication au compartiment source.

    1. Bien que l'API Amazon S3 nécessite une configuration de réplication au AWS CLI format XML, vous devez spécifier la configuration de réplication au format JSON. Enregistrez la configuration JSON dans un fichier (replication.json) dans le répertoire local de votre ordinateur.

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

    2. Mettez à jour le fichier JSON en fournissant des valeurs pour destination-bucket et IAM-role-ARN. Enregistrez les modifications.

    3. Pour ajouter la configuration de réplication à votre compartiment source, exécutez la commande suivante. Veillez à saisir le nom du compartiment source.

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

    Pour récupérer la configuration de réplication, utilisez la commande get-bucket-replication.

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

  6. Testez la configuration dans la console Amazon S3 :

    1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/s3/.

    2. Dans le compartiment source, créez un dossier nommé Tax.

    3. Ajoutez les exemples d'objets au dossier Tax du compartiment source.

      Note

      Le temps nécessaire à Simple Storage Service (Amazon S3) pour répliquer un objet dépend de la taille de ce dernier. Pour obtenir des informations sur la consultation du statut de la réplication, consultez Obtention d'informations sur le statut de la réplication.

      Dans le compartiment destination, vérifiez les éléments suivants :

      • Simple Storage Service (Amazon S3) a répliqué les objets.

      • Dans les propriétés de l'objet, le Statut de réplication est défini avec la valeur Replica (identifiant celui-ci comme objet de réplication).

      • Dans les propriétés de l'objet, la section des autorisations n'affiche aucune autorisation. Cela signifie que le réplica continue d'être la propriété du propriétaire du compartiment source et que le propriétaire du compartiment destination n'a aucune autorisation sur le réplica de l'objet. Vous pouvez ajouter une configuration facultative pour indiquer à Simple Storage Service (Amazon S3) de modifier le propriétaire du réplica. Pour obtenir un exemple, consultez Modification du propriétaire d'un réplica lorsque les compartiments source et de destination appartiennent à des comptes différents.

        Capture d'écran des propriétés d'un objet illustrant le statut de réplication et les autorisations.

Utilisez les exemples de code suivants pour ajouter une configuration de réplication à un compartiment avec le AWS SDK for Java et AWS SDK for .NET, respectivement.

Java

L'exemple suivant ajoute une configuration de réplication à un compartiment, puis la récupère et la vérifie. Pour obtenir les instructions sur la création et le test d'un exemple pratique, consultez Test des exemples de code Java Amazon S3. 


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#

L'exemple de AWS SDK for .NET code suivant ajoute une configuration de réplication à un compartiment, puis la récupère. Pour utiliser ce code, fournissez les noms de vos compartiments et l'Amazon Resource Name (ARN) de votre rôle IAM. Pour obtenir des instructions sur la façon de créer et de tester un exemple pratique, consultez Exécution des exemples de code .NET Amazon S3.

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