Configuración de la replicación para buckets de origen y destino que son propiedad de la misma cuenta

La replicación consiste en la copia automática y asíncrona de los objetos de los buckets en las mismas o en diferentes Regiones de AWS. La replicación copia los objetos recientemente creados y las actualizaciones de objetos de un bucket de origen a un bucket o buckets de destino. Para obtener más información, consulte Replicación de objetos.

Al configurar la replicación, se agregan reglas de replicación al bucket de origen. Las reglas de replicación definen qué objetos del bucket de origen se deben replicar y el bucket o buckets de destino donde se almacenan los objetos replicados. Puede crear una regla para replicar todos los objetos en un bucket o un subconjunto de objetos con un prefijo de nombre de clave específico, una o varias etiquetas de objeto, o ambos métodos. El bucket de destino puede estar en la misma Cuenta de AWS que el bucket de origen o puede estar en una cuenta diferente.

Si especifica el ID de versión de objeto que desea eliminar, Amazon S3 elimina esa versión del objeto en el bucket de origen. Pero no replica la eliminación en el bucket de destino. En otras palabras, no elimina la misma versión del objeto del bucket de destino. Esto protege los datos de eliminaciones malintencionadas.

Cuando se añade una regla de replicación a un bucket, la regla está activada de forma predeterminada, por lo que comienza a funcionar tan pronto como se guarda.

En este ejemplo, configurará la replicación de los buckets de origen y destino que son propiedad de la misma Cuenta de AWS. Se proporcionan ejemplos de cómo utilizar la consola de Amazon S3, la AWS Command Line Interface (AWS CLI), y AWS SDK for Java y AWS SDK for .NET.

Siga estos pasos para configurar una regla de replicación cuando el bucket de destino esté en la misma Cuenta de AWS que el bucket de origen.

Si el bucket de destino está en una cuenta distinta de la del bucket de origen, se debe añadir una política de bucket al bucket de destino para conceder al propietario de la cuenta del bucket de origen permiso para replicar objetos en el bucket de destino. Para obtener más información, consulte Concesión de permisos cuando los buckets de origen y destino son propiedad de diferentes Cuentas de AWS.

Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.
En el panel de navegación izquierdo, elija Instancias.
En la lista Buckets, elija el nombre del bucket en cuestión.
Elija Administración, desplácese hacia abajo hasta Reglas de replicación y, a continuación, elija Crear regla de replicación.
En la sección Configuración de la regla de replicación en Nombre de la regla de replicación, introduzca un nombre para la regla para poder identificarla más adelante. El nombre es obligatorio y debe ser único dentro del bucket.
En Status (Estado), Enabled (Habilitada) está seleccionado de forma predeterminada. Una regla activada comienza a funcionar tan pronto se guarda. Si desea habilitar la regla más adelante, elija Deshabilitada.
Si el bucket tiene reglas de replicación existentes, se le indicará que establezca una prioridad para la regla. Debe establecer una prioridad para la regla para evitar conflictos causados por objetos incluidos en el ámbito de más de una regla. En caso de solaparse las reglas, Amazon S3 usará la prioridad de la regla para determinar la regla que se va a aplicar. Cuanto mayor sea el número, mayor será la prioridad. Para obtener más información acerca de la prioridad de regla, consulte Configuración de replicación.
En Bucket de origen, tiene las siguientes opciones para establecer el origen de la replicación:
- Para replicar todo el bucket, elija Apply to all objects in the bucket (Aplicar a todos los objetos del bucket).
- Para replicar todos los objetos que tengan mismo prefijo, elija Limit the scope of this rule using one or more filters (Limitar el ámbito de esta regla mediante uno o varios filtros). Esto limita la replicación a todos los objetos que tienen nombres que comienzan con el prefijo que ha especificado (por ejemplo, pictures). Introduzca un prefijo en el cuadro Prefijo.
  
  nota
  Si utiliza un prefijo que es el nombre de una carpeta, debe introducir / (barra inclinada) como último carácter (por ejemplo, pictures/).
- Para replicar todos los objetos con una o varias etiquetas de objeto, seleccione Agregar etiqueta y escriba el par clave-valor en los cuadros. Repita el procedimiento para añadir otra etiqueta. Puede hacer uso combinado de un prefijo y etiquetas. Para obtener más información acerca de las etiquetas de objeto, consulte Categorización del almacenamiento mediante etiquetas.
El nuevo esquema XML de configuración de replicación admite el filtrado por prefijos y etiquetas y la priorización de reglas. Para obtener más información acerca del nuevo esquema, consulte Compatibilidad con versiones anteriores. Para obtener más información sobre el XML utilizado con la API de Amazon S3 que funciona detrás de la interfaz de usuario, consulte Configuración de replicación. El nuevo esquema se describe como configuración de replicación XML V2.
En Destino, seleccione el bucket en el que desea que Amazon S3 replique los objetos.

nota
El número de buckets de destino está limitado al número de Regiones de AWS en una partición determinada. Una partición es una agrupación de regiones. AWS actualmente tiene tres particiones: aws (regiones estándar), aws-cn (regiones de China) y aws-us-gov (regiones de AWS GovCloud (US)). Puede usar cuotas de servicio para solicitar un aumento de la cuota del bucket de destino.
- Para replicar en un bucket o buckets de la cuenta, seleccione Elegir un bucket en esta cuenta y escriba o examine los nombres del bucket de destino.
- Para replicar en un bucket o buckets de una Cuenta de AWS diferente, seleccione Elegir un bucket de otra cuenta) e ingrese el ID de la cuenta del bucket de destino y el nombre del bucket.
  
  Si el destino está en una cuenta diferente de la del bucket de origen, debe agregar una política de bucket a los buckets de destino a fin de otorgar al propietario de la cuenta del bucket de origen permiso para replicar objetos. Para obtener más información, consulte Concesión de permisos cuando los buckets de origen y destino son propiedad de diferentes Cuentas de AWS.
  
  De forma opcional, si desea ayudar a estandarizar la propiedad de nuevos objetos en el bucket de destino, elija Cambiar la propiedad del objeto al propietario del bucket de destino. Para obtener más información acerca de esta opción, consulte Control de la propiedad de los objetos y desactivación de las ACL del bucket.
nota
Si el control de versiones no está habilitado en el bucket de destino, recibirá una advertencia que contiene un botón Enable versioning (Habilitar control de versiones). Elija este botón para activar el control de versiones en el bucket.
Configure un rol de AWS Identity and Access Management (IAM) que Amazon S3 pueda asumir para reproducir objetos en su nombre.

Para configurar un rol de IAM, en la sección Rol de IAM, seleccione una de las opciones siguientes en la lista desplegable Rol de IAM:
- Es absolutamente recomendable que elija Create new role (Crear nuevo rol) para que Amazon S3 cree un nuevo rol de IAM automáticamente. Cuando se guarda la regla, se genera una política nueva para el rol de IAM que coincide con los buckets de origen y de destino elegidos.
- Puede elegir usar un rol de IAM existente. Si lo hace, debe elegir un rol que conceda a Amazon S3 los permisos necesarios para la replicación. La replicación dará un error si este rol no concede a Amazon S3 permisos suficientes para seguir la regla de replicación.
importante
Cuando añada una regla de replicación a un bucket, debe tener el permiso iam:PassRole para poder pasar el rol de IAM que concede los permisos de replicación de Amazon S3. Para obtener más información, consulte Concesión de permisos a un usuario para transferir un rol a un Servicio de AWS en la Guía del usuario de IAM.
Para replicar objetos en el bucket de origen cifrados en el lado del servidor con claves de AWS Key Management Service (AWS KMS) (SSE-KMS), en Cifrado seleccione Replicar objetos cifrados con AWS KMS. En Claves de AWS KMS para cifrar objetos de destino están las claves de origen que permiten utilizar la replicación. De forma predeterminada, se incluyen todas las claves de KMS de origen. Para acotar la selección de claves de KMS puede seleccionar una alias o ID de clave.

Los objetos cifrados por AWS KMS keys que no seleccione no se replican. Una clave KMS o un grupo de claves de KMS se seleccionan para usted, pero puede elegir las claves de KMS que desee. Para obtener información acerca del uso de AWS KMS con replicación, consulte Replicación de objetos creados con cifrado del servidor (SSE-C, SSE-S3, SSE-KMS, DSSE-KMS).

importante
Cuando replica objetos que están cifrados con AWS KMS, la tasa de solicitudes de AWS KMS se duplica en la región de origen y aumenta en la región de destino por la misma cantidad. Estas mayores tasas de llamada a AWS KMS se deben a la forma en la que los datos se vuelven a cifrar por medio de la clave de KMS que define para la región de destino de la replicación. AWS KMS tiene un cuota de tasa de solicitud por cada cuenta que realiza la llamada por cada región. Para obtener información acerca de los valores predeterminados de las cuotas, consulte Cuotas de AWS KMS - Solicitudes por segundo: varían en la Guía para desarrolladores de AWS Key Management Service.
Si su tasa de solicitud actual de objeto PUT de Amazon S3 durante la replicación es más que la mitad del límite de la tasa de AWS KMS predeterminado para la cuenta, recomendamos que solicite un aumento de la cuaota de tasa de solicitud de AWS KMS. Para solicitar un aumento, abra un caso en el AWS Support Center en Contáctese con nosotros. Por ejemplo, suponga que su tasa de solicitud de objeto PUT actual es de 1000 solicitudes por segundo y utiliza AWS KMS para cifrar sus objetos. En ese caso, recomendamos que pida a AWS Support que aumente su límite de tasa de AWS KMS a 2500 solicitudes por segundo, tanto en la región de origen como en la de destino (si son diferentes), para garantizar que no haya una limitación controlada por AWS KMS.
Para ver su tasa de solicitud de objeto PUT en el bucket de origen, consulte PutRequests en las métricas de solicitudes de Amazon CloudWatch para Amazon S3. Para obtener información sobre cómo ver las métricas de CloudWatch, consulte Uso de la consola de S3.

Si ha elegido los objetos replicados cifrados con AWS KMS, haga lo siguiente:
1. En AWS KMS key para cifrar objetos de destino, especifique su clave de KMS de una de las siguientes maneras:
  - Para seleccionar de una lista de claves de KMS disponibles, marque Elija entre sus claves de AWS KMS keys y seleccione su clave de KMS en la lista de claves disponibles.
    
    En esta lista aparecen tanto la Clave administrada de AWS (aws/s3) como las claves administradas por el cliente. Para obtener más información acerca de las claves administradas por el cliente, consulte Claves de cliente y claves de AWS en la Guía para desarrolladores de AWS Key Management Service.
  - Para introducir el nombre de recurso de Amazon (ARN) de la clave de KMS, elija Introducir el ARN de AWS KMS key e introduzca el ARN de la clave de KMS en el campo que aparece. Esto cifra las réplicas en el bucket de destino. Puede buscar el ARN de su clave de KMS en la Consola de IAM bajo Claves de cifrado.
  - Para crear una nueva clave administrada por el cliente en la consola de AWS KMS, elija Crear una clave de KMS.
    
    Para obtener más información acerca de cómo crear una AWS KMS key, consulte Creación de claves en la AWS Key Management Service Guía para desarrolladores.
  importante
  Solo puede utilizar las claves de KMS que estén habilitadas en la misma Región de AWS que el bucket. Cuando elige Elegir entre las claves de KMS, la consola de S3 solo muestra 100 claves de KMS por región. Si tiene más de 100 claves de KMS en la misma región, solo podrá ver las primeras 100 KMS en la consola S3. Para utilizar una clave de KMS que no aparece en la consola, elija Introducir el ARN de AWS KMS key y escriba el ARN de la clave de KMS.
  Cuando utilice una AWS KMS key para el cifrado en el lado del servidor en Amazon S3, debe elegir una clave de cifrado de KMS simétrica. Amazon S3 admite solo claves de KMS de cifrado simétricas y no claves de KMS asimétricas. Para obtener más información, consulte Identificación de claves de KMS simétricas y asimétricas en la Guía para desarrolladores de AWS Key Management Service.
  
  Para obtener más información acerca de cómo crear una AWS KMS key, consulte Creación de claves en la AWS Key Management Service Guía para desarrolladores. Para obtener más información acerca del uso de AWS KMS con Amazon S3, consulte Uso del cifrado del servidor con claves de AWS KMS (SSE-KMS).
Si desea replicar los datos en una clase de almacenamiento específica del destino, en Clase de almacenamiento de destino, elija Cambiar la clase de almacenamiento para los objetos replicados. A continuación, elija la clase de almacenamiento que desea utilizar para los objetos replicados en el destino. Si no selecciona esta opción, la clase de almacenamiento de objetos replicados es la misma que la de los objetos originales.
Tiene las siguientes opciones adicionales al configurar las Opciones de replicación adicionales:
- Si desea habilitar el Control del tiempo de replicación de S3 (S3 RTC) en la configuración de replicación, seleccione Control de tiempo de replicación (RTC). Para obtener más información acerca de esta opción, consulte Cumplimiento de los requisitos de conformidad mediante el control de tiempo de replicación de S3 (S3 RTC).
- Si desea habilitar métricas de replicación de S3 en la configuración de replicación, seleccione Replication metrics and events (Métricas y eventos de replicación). Para obtener más información, consulte, Monitoreo del progreso con métricas de replicación y notificaciones de eventos de S3.
- Si desea habilitar la replicación de marcador de eliminación en la configuración de replicación, seleccione Delete marker replication (Eliminar replicación de marcadores). Para obtener más información, consulte Replicación de marcadores de eliminación entre buckets.
- Si desea habilitar la sincronización de modificación de réplica de Amazon S3 en la configuración de replicación, seleccione Replica modification sync (Sincronización de modificación de réplica). Para obtener más información, consulte, Replicación de cambios de metadatos con la sincronización de modificación de réplica de Amazon S3.
nota
Cuando utiliza métricas de replicación S3 o S3 RTC, se aplican tarifas adicionales.
Para terminar, elija Save (Guardar).
Después de guardar la regla, puede seleccionar la regla y elegir Edit rule (Editar regla) para editarla, habilitarla, deshabilitarla o eliminarla.

Para utilizar la AWS CLI con el objetivo de configurar la replicación cuando los buckets de origen y destino son propiedad de la misma Cuenta de AWS, debe hacer lo siguiente:

crear buckets de origen y destino
habilitar el control de versiones en un bucket
crear un rol de IAM que conceda permisos para replicar objetos en Amazon S)
agregar la configuración de replicación al bucket de origen

Para verificar la configuración, debe probarla.

Para configurar la replicación cuando los buckets de origen y destino son propiedad de la misma Cuenta de AWS

Configure un perfil de credenciales para la AWS CLI. En este ejemplo, usamos el nombre de perfil acctA. Para obtener información acerca de la configuración de perfiles de credenciales, consulte Perfiles con nombre en la Guía del usuario de la AWS Command Line Interface.

importante
El perfil utilizado para este ejercicio tiene que tener los permisos necesarios. Por ejemplo, en la configuración de replicación especifica el rol de IAM que Amazon S3 puede asumir. Solo puede hacer esto si el perfil que utiliza tiene el permiso iam:PassRole. Para obtener más información, consulte Concesión de permisos a un usuario para transferir un rol a un servicio de AWS en la Guía del usuario de IAM. Si utiliza credenciales de administrador para crear un perfil con nombre, puede realizar todas las tareas.

Cree un bucket source y habilite el control de versiones. El siguiente código crea un bucket source en la región Este de EE. UU. (Norte de Virginia) (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

Cree un bucket destination y habilite el control de versiones. El siguiente código crea un bucket destination en la región Oeste de EE. UU. (Oregón) (us-west-2).

nota
Para establecer la configuración de replicación cuando los buckets de origen y destino están en la misma Cuenta de AWS, debe utilizar el mismo perfil. En este ejemplo se utiliza acctA. Para probar la configuración de replicación cuando los buckets son propiedad de diferentes Cuentas de AWS, debe especificar diferentes perfiles para cada uno. En este ejemplo se usa el perfil acctB para el bucket de destino.
```
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
```

Cree un rol de IAM. Especifique este rol en la configuración de replicación que agregue al bucket de origen más adelante. Amazon S3 asume este rol para replicar objetos en su nombre. Crea el rol de IAM en dos pasos:

Crear un rol.
Asocie una política de permisos al rol.

Cree el rol de IAM.

Copie la siguiente política de confianza y guárdela en un archivo llamado s3-role-trust-policy.json en el directorio actual en su equipo local. Esta política concede a la entidad principal de servicio de Amazon S3 permisos para asumir el rol.
```
{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Principal":{
            "Service":"s3.amazonaws.com"
         },
         "Action":"sts:AssumeRole"
      }
   ]
}
```

Ejecute el siguiente comando para crear un rol.


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

Asocie una política de permisos al rol.

Copie la siguiente política de permisos y guárdela en un archivo llamado s3-role-permissions-policy.json en el directorio actual en su equipo local. Esta política concede permisos para varias acciones de buckets y objetos de 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/*"
      }
   ]
}

Ejecute el siguiente comando para crear una política y asociarla al rol.


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

Agregue la configuración de replicación al bucket source.
1. Si bien la API de Amazon S3 requiere la configuración de replicación como XML, la AWS CLI requiere que especifique la configuración de reproducción como JSON. Guarde la siguiente JSON en un archivo denominado replication.json en el directorio local en su equipo.
```
{
  "Role": "IAM-role-ARN",
  "Rules": [
    {
      "Status": "Enabled",
      "Priority": 1,
      "DeleteMarkerReplication": { "Status": "Disabled" },
      "Filter" : { "Prefix": "Tax"},
      "Destination": {
        "Bucket": "arn:aws:s3:::destination-bucket"
      }
    }
  ]
}
```
2. Actualice JSON proporcionando valores para la destination-bucket y IAM-role-ARN. Guarde los cambios.
3. Ejecute el siguiente comando para añadir la configuración de replicación al bucket de origen. Asegúrese de proporcionar el nombre del bucket source.
```
$ aws s3api put-bucket-replication \
--replication-configuration file://replication.json \
--bucket source \
--profile acctA
```
Para recuperar la configuración de replicación, utilice el comando get-bucket-replication.
```
$ aws s3api get-bucket-replication \
--bucket source \
--profile acctA
```
Pruebe la configuración en la consola de Amazon S3:
1. Inicie sesión AWS Management Console Management Console y abra la consola de Amazon S3 en https://console.aws.amazon.com/s3/.
2. En el bucket source, cree una carpeta llamada Tax.
3. Agregue objetos de ejemplo a la carpeta Tax en el bucket source.
  
  nota
  La cantidad de tiempo que Amazon S3 tarda en replicar un objeto depende del tamaño del objeto. Para obtener más información sobre cómo ver el estado de la replicación, consulte Obtención de información del estado de replicación.
  
  En el bucket destination, compruebe lo siguiente:
  - Que Amazon S3 haya replicado los objetos.
  - En las properties (propiedades) del objeto, que Replication Status (Estado de replicación) está establecido en Replica (lo que lo identifica como un objeto de réplica).
  - En las propiedades del objeto, que la sección de permisos no muestra ningún permiso. Esto significa que la réplica aún pertenece al propietario del bucket source y que el propietario del bucket destination no tiene permisos en la réplica del objeto. Puede agregar opciones de configuración adicionales para indicar a Amazon S3 que cambie la titularidad de la réplica. Para ver un ejemplo, consulte Cambio del propietario de la réplica cuando los buckets de origen y destino son propiedad de diferentes cuentas.

Utilice los siguientes ejemplos de código para añadir una configuración de replicación a un bucket con AWS SDK for Java y AWS SDK for .NET, respectivamente.

Java

El siguiente ejemplo añade una configuración de replicación a un bucket y luego recupera y verifica la configuración. Para obtener instrucciones sobre la creación y comprobación de una muestra funcional, consulte Prueba de los ejemplos de código de Java de 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#

El siguiente código de ejemplo de AWS SDK for .NET añade una configuración de replicación a un bucket y luego la recupera. Para usar este código, proporcione los nombres de los buckets y el nombre de recurso de Amazon (ARN) para el rol de IAM. Para obtener instrucciones acerca de cómo crear y probar una muestra funcional, consulte Ejecución de ejemplos de código .NET de 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);
            }
        }
    }
}

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Ejemplos de replicación

Configuración de buckets en cuentas diferentes

Configuración de la replicación para buckets de origen y destino que son propiedad de la misma cuenta

nota

nota

nota

importante

importante

importante

nota

Para configurar la replicación cuando los buckets de origen y destino son propiedad de la misma Cuenta de AWS

importante

nota

nota