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. La réplication copie les objets nouvellement créés et les mises à jour d'objets d'un compartiment source vers un ou plusieurs compartiments de destination. Pour de plus amples informations, veuillez consulter Vue d'ensemble de la 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 Compte AWS comme compartiment source, ou il peut se trouver 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 appartenant à la même Compte AWS. Des exemples sont fournis pour l'utilisation de la console Amazon S3, le AWS Command Line Interface (AWS CLI), et le AWS SDK for Java and 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 en tant que 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.

Connectez-vous au AWS Management Console et ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.
Dans le panneau de navigation de gauche, choisissez Compartiments.
Dans la liste Compartiments, choisissez le nom du compartiment que vous souhaitez utiliser.
Sélectionnez Gestion, faites défiler jusqu'à Règles de réplication, puis sélectionnez Créer une règle de réplication.
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.
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é.
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.
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 XML schéma de configuration de réplication prend en charge le filtrage des préfixes et des balises ainsi que la hiérarchisation des règles. Pour plus d'informations sur le nouveau schéma, consultez Rétrocompatibilité. Pour plus d'informations sur l'XMLutilisation avec l'Amazon S3 API qui fonctionne derrière l'interface utilisateur, consultezConfiguration de réplication. Le nouveau schéma est décrit sous le nom de configuration de réplication XML V2.
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 Régions AWS dans une partition donnée. Une partition est un groupement de régions. AWS possède actuellement trois partitions : aws (Régions standard), aws-cn (Régions chinoises) 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 dans un ou plusieurs compartiments d'un autre 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 Contrôle de la propriété des objets et désactivation ACLs 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.
Configurez un AWS Identity and Access Management (IAM) rôle qu'Amazon S3 peut assumer pour répliquer des objets en votre nom.

Pour configurer un IAM rôle, dans la section IAMRôle, sélectionnez l'une des options suivantes IAMdans la liste déroulante des rôles :
- Nous vous recommandons vivement de choisir Create new role pour qu'Amazon S3 crée un nouveau IAM rôle pour vous. Lorsque vous enregistrez la règle, une nouvelle politique est générée pour le IAM rôle qui correspond aux compartiments source et de destination que vous choisissez.
- Vous pouvez choisir d'utiliser un IAM rôle 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 être iam:PassRole autorisé à transmettre le IAM rôle qui accorde les autorisations de réplication à Amazon S3. Pour plus d'informations, voir Accorder à un utilisateur l'autorisation de transmettre un rôle à un Service AWS dans le guide de l'utilisateur IAM.
Pour répliquer les objets du compartiment source qui sont chiffrés par chiffrement côté serveur avec AWS Key Management Service (AWS KMS) clés (SSE-KMS), sous Chiffrement, sélectionnez Répliquer les objets chiffrés avec AWS KMS. Sous AWS KMS les clés de chiffrement des objets de destination sont les clés source que vous autorisez la réplication à utiliser. Toutes les KMS clés de source sont incluses par défaut. Pour affiner la sélection KMS des clés, vous pouvez choisir un alias ou un identifiant de clé.

Objets chiffrés par AWS KMS keys que vous ne sélectionnez pas ne sont pas répliqués. Une KMS touche ou un groupe de KMS touches est choisi pour vous, mais vous pouvez choisir les KMS touches si vous le souhaitez. Pour plus d'informations sur l'utilisation AWS KMS avec réplication, voirRéplication d'objets chiffrés (SSE-C, SSE -S3, -, SSE -KMS) DSSE KMS.

Important
Lorsque vous répliquez des objets chiffrés avec AWS KMS, le AWS KMS le taux de demandes double dans la région source et augmente du même montant dans la région de destination. Ces tarifs d'appels accrus pour AWS KMS sont dus à la manière dont les données sont rechiffrées à l'aide de la KMS clé 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 plus d'informations sur les quotas par défaut, voir AWS KMS Quotas - Demandes par seconde : varie selon AWS Key Management Service Guide du développeur.
Si votre taux actuel de demandes PUT d'objets Amazon S3 pendant la réplication est supérieur à la moitié du taux par défaut AWS KMS limite de taux pour votre compte, nous vous recommandons de demander une augmentation de votre AWS KMS quota de taux de demande. Pour demander une augmentation, créez un dossier dans le AWS Support Centrez sur Contactez-nous. Supposons, par exemple, que votre taux actuel de demandes d'PUTobjets soit de 1 000 demandes par seconde et que vous utilisiez AWS KMS pour chiffrer vos objets. Dans ce cas, nous vous recommandons de demander AWS Support pour augmenter votre AWS KMS limite de débit à 2 500 demandes par seconde, à la fois dans vos régions source et de destination (si elles sont différentes), afin de garantir qu'il n'y ait pas de limitation par 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, consultezUtilisation de 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 chiffrer les objets de destination, spécifiez votre KMS clé de l'une des manières suivantes :
  - Pour choisir parmi une liste de KMS touches disponibles, choisissez Choisir parmi votre AWS KMS keys, puis choisissez votre KMSclé dans la liste des clés disponibles.
    
    Les deux Clé gérée par AWS (aws/s3) et vos clés gérées par le client apparaissent dans cette liste. Pour plus d'informations sur les clés gérées par le client, voir Clés client et AWS clés dans le AWS Key Management Service Guide du développeur.
  - Pour saisir la KMS clé Amazon Resource Name (ARN), choisissez Enter AWS KMS key ARN, et entrez votre KMS clé ARN dans le champ qui apparaît. Cela chiffre les réplicas dans le compartiment de destination. Vous pouvez trouver la ARN KMS clé correspondante dans la IAMconsole, sous Clés de chiffrement.
  - Pour créer une nouvelle clé gérée par le client dans le AWS KMS console, choisissez Créer une KMS clé.
    
    Pour plus d'informations sur la création d'un AWS KMS key, voir Création de clés dans AWS Key Management Service Guide du développeur.
  Important
  Vous ne pouvez utiliser que KMS les touches activées dans le même Région AWS comme le seau. Lorsque vous choisissez Choisir parmi vos KMS clés, la console S3 ne répertorie que 100 KMS clés par région. Si vous avez plus de 100 KMS clés dans la même région, seules les 100 premières KMS clés sont visibles dans la console S3. Pour utiliser une KMS clé qui n'est pas répertoriée dans la console, choisissez Enter AWS KMS key ARN, et entrez votre KMS cléARN.
  Lorsque vous utilisez un AWS KMS key pour le chiffrement côté serveur dans Amazon S3, vous devez choisir une clé de chiffrement symétrique. KMS Amazon S3 ne prend en charge que les clés de chiffrement symétriques et non KMS les clés asymétriquesKMS. Pour plus d'informations, consultez la section Identification des KMS clés symétriques et asymétriques dans le AWS Key Management Service Guide du développeur.
  
  Pour plus d'informations sur la création d'un AWS KMS key, voir Création de clés dans AWS Key Management Service Guide du développeur. Pour plus d'informations sur l'utilisation AWS KMS avec Amazon S3, voirUtilisation du chiffrement côté serveur avec AWS KMS clés (SSE-KMS).
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.
Vous disposez des options supplémentaires suivantes lors de la définition des Options de réplication supplémentaires :
- Si vous souhaitez activer S3 Replication Time Control (S3RTC) dans votre configuration de réplication, sélectionnez Replication Time Control (RTC). Pour plus d’informations sur cette option, consultez Respect des exigences de conformité grâce à S3 Replication Time Control (S3RTC).
- Si vous souhaitez activer les métriques de réplication S3 dans votre configuration de réplication, sélectionnez Replication metrics and events (Métriques et événements de réplication). Pour plus d'informations, consultez Surveillance de la réplication à l'aide de métriques, de notifications d'événements et de statuts.
- Si vous souhaitez activer la réplication de marqueurs de suppression dans votre configuration de réplication, sélectionnez Réplication des marqueurs de suppression. Pour plus d’informations, consultez Répliquer des marqueurs de suppression entre les compartiments.
- Si vous souhaitez activer la synchronisation des modifications de réplica Amazon S3 dans votre configuration de réplication, sélectionnez Synchronisation des modifications de réplica. Pour de plus amples informations, veuillez consulter Répliquer les modifications de métadonnées avec la synchronisation des modifications de réplica Amazon S3.
Note
Lorsque vous utilisez des métriques de réplication S3 RTC ou S3, des frais supplémentaires s'appliquent.
Pour terminer, choisissez Enregistrer.
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).

Pour utiliser le plugin AWS CLI pour configurer la réplication lorsque les compartiments source et de destination appartiennent à la même entité Compte AWS, vous devez effectuer les opérations suivantes :

Créer des compartiments source et de destination
Activer la gestion des versions sur les compartiments
Créez un IAM rôle qui autorise Amazon S3 à 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

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

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 IAM rôle qu'Amazon S3 peut assumer. Vous ne pouvez effectuer cette tâche que si le profil que vous utilisez dispose de l'autorisation iam:PassRole. Pour plus d'informations, voir Octroyer à un utilisateur l'autorisation de transmettre un rôle à un AWS Service indiqué dans le guide de IAM l'utilisateur. Si vous utilisez les informations d'identification d'un administrateur pour créer un profil nommé, vous pouvez exécuter toutes les tâches.

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

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 utilisez le même profil. Cet exemple utilise acctA. Pour tester la configuration de réplication lorsque les buckets appartiennent à différents Comptes AWS, vous spécifiez 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
```

Créez un IAM rôle. Vous spécifiez ce rôle dans la configuration de réplication que vous ajoutez au source seau plus tard. Amazon S3 endosse ce rôle pour répliquer des objets en votre nom. Vous créez un IAM rôle en deux étapes :

Créez un rôle
Attachez une stratégie d'autorisation au rôle.

Créez le IAM rôle.

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"
      }
   ]
}
```

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

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

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/*"
      }
   ]
}

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

Ajoutez une configuration de réplication au compartiment source.
1. Bien que l'Amazon S3 API nécessite une configuration de réplication XML en tant que AWS CLI nécessite que vous spécifiiez la configuration de réplication sous la formeJSON. Enregistrez ce qui suit JSON dans un fichier appelé 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 en JSON fournissant des valeurs pour le destination-bucket etIAM-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
```
Testez la configuration dans la console Amazon S3 :
1. Connectez-vous au AWS Management Console et ouvrez la console Amazon S3 à 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 Comment changer le propriétaire de la réplique.

Utilisez les exemples de code suivants pour ajouter une configuration de réplication à un compartiment avec AWS SDK for Java and 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 des instructions sur la création et le test d'un échantillon de travail, voir Getting Started dans AWS SDK for Java .



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

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

public class CrossRegionReplication {

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

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

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

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

                try {

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

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

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

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

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

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

        }

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

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

                iamClient.createRole(createRoleRequest);

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

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

                iamClient.putRolePolicy(putRolePolicyRequest);

        }
}

C#

Procédez comme suit : AWS SDK for .NET Un exemple de code ajoute une configuration de réplication à un compartiment, puis la récupère. Pour utiliser ce code, indiquez le nom de vos compartiments et le nom de ressource Amazon (ARN) correspondant à votre IAM rôle. Pour plus d'informations sur la configuration et l'exécution des exemples de code, voir Getting Started with AWS SDKpour. NETdans le AWS SDKpour. NETGuide du développeur.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Exemples de réplication

Configuration pour des compartiments dans des comptes distincts

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

Note

Note

Note

Important

Important

Important

Note

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

Important

Note

Note