# Tabla global de la misma cuenta de DynamoDB
<a name="globaltables-SameAccount"></a>

Las tablas globales de la misma cuenta replican automáticamente los datos de las tablas de DynamoDB en todas las regiones de AWS dentro de una sola cuenta de AWS. Las tablas globales de la misma cuenta proporcionan el modelo más sencillo para ejecutar aplicaciones de varias regiones, ya que todas las réplicas comparten el mismo modelo de límites de cuentas, propiedad y permisos. Cuando elige las regiones de AWS para las tablas de réplicas, las tablas globales gestionan toda la replicación automáticamente. Las tablas globales están disponibles en todas las regiones donde DynamoDB está disponible.

Las tablas globales de la misma cuenta proporcionan los siguientes beneficios:
+ Replicación de forma automática de los datos de las tablas de DynamoDB en las regiones de AWS que elija para ubicar los datos más cerca de los usuarios
+ Habilitación de una mayor disponibilidad de las aplicaciones durante el aislamiento o la degradación regional
+ Use la resolución de conflictos integrada para centrarse en la lógica empresarial de la aplicación.
+ Al crear una tabla global de la misma cuenta, puede elegir entre [Consistencia posterior de varias regiones (MREC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrec) o [Coherencia alta de varias regiones (MRSC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrsc).

**Topics**
+ [Funcionamiento de las tablas globales de DynamoDB](V2globaltables_HowItWorks.md)
+ [Tutoriales: creación de tablas globales](V2globaltables.tutorial.md)
+ [Seguridad de las tablas globales de DynamoDB](globaltables-security.md)

# Funcionamiento de las tablas globales de DynamoDB
<a name="V2globaltables_HowItWorks"></a>

En las siguientes secciones, se describen los conceptos y los comportamientos de las tablas globales en Amazon DynamoDB.

## Conceptos
<a name="V2globaltables_HowItWorks.KeyConcepts"></a>

Las *tablas globales* son una característica de DynamoDB que replica los datos de las tablas en todas las regiones de AWS. 

Una *tabla de réplica* (o réplica) es una tabla de DynamoDB que funciona como parte de una tabla global. Una tabla global consta de dos o más tablas de réplica en diferentes regiones de AWS. Cada tabla global solo puede tener una réplica por región de AWS. Todas las réplicas de una tabla global comparten el mismo nombre de tabla, esquema de clave principal y datos de elementos.

Cuando una aplicación escribe datos en una réplica en una región, DynamoDB replica automáticamente la escritura en el resto de las réplicas en la tabla global. Para obtener más información sobre cómo empezar a usar tablas globales, consulte [Tutoriales: creación de tablas globales](V2globaltables.tutorial.md).

## Versiones
<a name="V2globaltables_HowItWorks.versions"></a>

Hay disponibles dos versiones de las tablas globales de DynamoDB: versión 2019.11.21 (actual) y [versión 2017.11.29 (antigua)](globaltables.V1.md). Debe utilizar la versión 2019.11.21 (actual) siempre que sea posible. La información de esta sección de la documentación corresponde a la versión 2019.11.21 (actual). Para obtener más información, consulte [Determinación de la versión de una tabla global](V2globaltables_versions.md#globaltables.DetermineVersion).

## Disponibilidad
<a name="V2globaltables_HowItWorks.availability"></a>

Las tablas globales ayudan a mejorar la continuidad empresarial al facilitar la implementación de una arquitectura de alta disponibilidad de varias regiones. Si una carga de trabajo en una única región de AWS se ve afectada, puede cambiar el tráfico de la aplicación a otra región y realizar las operaciones de lectura y escritura en una tabla de réplica diferente en la misma tabla global.

Cada tabla réplica en una tabla global proporciona la misma durabilidad y disponibilidad que una tabla de DynamoDB de una sola región. Las tablas globales ofrecen un [Acuerdo de nivel de servicio (SLA)](https://aws.amazon.com//dynamodb/sla/) con una disponibilidad del 99,999 %, en comparación con el 99,99 % de las tablas de una sola región.

## Modos de coherencia
<a name="V2globaltables_HowItWorks.consistency-modes"></a>

Al crear una tabla global, puede configurar el modo de consistencia. Las tablas globales admiten dos modos de coherencia: coherencia final de varias regiones (MREC) y coherencia alta de varias regiones (MRSC).

Si no especifica un modo de coherencia al crear una tabla global, esta adoptará de forma predeterminada la coherencia final de varias regiones (MREC). Una tabla global no puede contener réplicas configuradas con diferentes modos de coherencia. No puede cambiar el modo de coherencia de una tabla global después de la creación.

### Consistencia posterior de varias regiones (MREC)
<a name="V2globaltables_HowItWorks.consistency-modes.mrec"></a>

La coherencia final de varias regiones (MREC) es el modo de coherencia predeterminado para las tablas globales. Los cambios de elementos en una réplica de tabla global de MREC se replican de forma asíncrona en todas las demás réplicas, normalmente en un segundo o menos. En el improbable caso de que una réplica de una tabla global de MREC quede aislada o se vea afectada, cualquier dato que aún no se haya replicado en otras regiones se replicará cuando la réplica recupere el estado correcto.

Si el mismo elemento se modifica simultáneamente en varias regiones, DynamoDB resolverá el conflicto mediante la modificación con la última marca temporal interna por elemento, lo que se denomina método de resolución de conflictos “el último escritor gana”. Al final, un elemento convergerá en todas las réplicas a la versión creada por la última escritura.

Las [operaciones de lectura altamente coherente](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html#DDB-GetItem-request-ConsistentRead) devuelven la versión más reciente de un elemento si este se ha actualizado por última vez en la región en la que se ha producido la lectura, pero podrían devolver datos obsoletos si el elemento se ha actualizado por última vez en una región diferente. Las escrituras condicionales evalúan la expresión de la condición comparándola con la versión del elemento en la región.

Para crear una tabla global de MREC, se agrega una réplica a una tabla de DynamoDB existente. La agregación de una réplica no tiene impacto en el rendimiento de las tablas de DynamoDB de una sola región ni de las réplicas de tablas globales existentes. Puede agregar réplicas a una tabla global de MREC para ampliar el número de regiones en las que se replican los datos o eliminar réplicas de una tabla global de MREC si ya no son necesarias. Una tabla global de MREC puede tener una réplica en cualquier región en la que DynamoDB esté disponible y puede tener tantas réplicas como regiones haya en la [partición de AWS.](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/partitions.html)

### Coherencia alta de varias regiones (MRSC)
<a name="V2globaltables_HowItWorks.consistency-modes.mrsc"></a>

Puede configurar el modo de coherencia alta de varias regiones (MRSC) al crear una tabla global. Los cambios de elementos en la réplica de una tabla global de MRSC se replican de forma sincrónica en al menos otra región antes de que la operación de escritura devuelva una respuesta correcta. Las operaciones de lectura altamente coherente en cualquier réplica de MRSC siempre devuelven la versión más reciente de un elemento. Las escrituras condicionales siempre evalúan la expresión de la condición comparándola con la versión más reciente de un elemento.

Una tabla global de MRSC se debe implementar exactamente en tres regiones. Puede configurar una tabla global de MRSC con tres réplicas o con dos réplicas y un testigo. Un testigo es un componente de una tabla global de MRSC que contiene datos escritos en réplicas de tablas globales y proporciona una alternativa opcional a una réplica completa, al tiempo que admite la arquitectura de disponibilidad de MRSC. No puede realizar operaciones de lectura o escritura en un testigo. Un testigo se encuentra en una región diferente a las dos réplicas. Al crear una tabla global de MRSC, debe elegir las regiones para las réplicas y para la implementación de testigos en el momento de crear la tabla de MRSC. Puede determinar si una tabla global de MRSC tiene un testigo configurado y en qué región, a partir de la salida de la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). El testigo es propiedad y lo administra DynamoDB, y no aparecerá en la cuenta de AWS en la región en la que esté configurado.

Las tablas globales del MRSC están disponibles en los siguientes conjuntos de regiones: conjunto de regiones de EE. UU. (Este de EE. UU. (Norte de Virginia, Este de EE. UU. (Ohio), Oeste de EE. UU. (Oregón)), conjunto de regiones de la UE (Europa Irlanda, Europa Londres, Europa París, Europa Fráncfort) y conjunto de regiones de Asia-Pacífico (Asia Pacífico Tokio, Asia Pacífico Seúl y Asia Pacífico Osaka). Las tablas globales de MRSC no pueden abarcar conjuntos de regiones (por ejemplo, una tabla global de MRSC no puede contener réplicas de conjuntos de regiones de EE. UU. y de la UE).

Se crea una tabla global de MRSC mediante la agregación de una réplica y un testigo o dos réplicas a una tabla de DynamoDB existente que no contenga datos. Al convertir una tabla de una sola región existente en una tabla global de MRSC, debe asegurarse de que la tabla esté vacía. No se admite la conversión de una tabla de una sola región en una tabla global de MRSC con los elementos existentes. Asegúrese de que no se escriba ningún dato en la tabla durante el proceso de conversión. No puede agregar réplicas adicionales a una tabla global de MRSC existente. No puede eliminar una réplica única o un testigo de una tabla global de MRSC. Puede eliminar dos réplicas o eliminar una réplica y un testigo de una tabla global de MRSC, convirtiendo la réplica restante en una tabla de DynamoDB de una sola región.

Una operación de escritura produce un error con una `ReplicatedWriteConflictException` cuando intenta modificar un elemento que ya se está modificando en otra región. Las escrituras que tengan un error con la `ReplicatedWriteConflictException` se pueden reintentar y se realizarán correctamente si el elemento ya no se está modificando en otra región.

Las siguientes consideraciones se aplican a las tablas globales de MRSC:
+ El Tiempo de vida (TTL) no se admite para las tablas globales de MRSC.
+ Los índices secundarios locales (LSI) no se admiten para las tablas globales de MRSC.
+ La información de CloudWatch Contributor Insights solo se comunica para la región en la que se ha producido una operación.

## Elección de un modo de coherencia
<a name="V2globaltables_HowItWorks.choosing-consistency-mode"></a>

El criterio clave para elegir un modo de coherencia de varias regiones es si la aplicación prioriza las escrituras de menor latencia y las lecturas altamente coherentes, o si prioriza la coherencia alta global.

Las tablas globales de MREC tendrán latencias de escritura y lectura altamente coherente inferiores en comparación con las tablas globales de MRSC. Las tablas globales de MREC tienen un objetivo de punto de recuperación (RPO) igual al retraso de replicación entre réplicas, normalmente unos segundos, en función de las regiones de las réplicas.

Debe utilizar el modo MREC cuando:
+ La aplicación puede tolerar que se devuelvan datos obsoletos de operaciones de lectura altamente coherentes si esos datos se han actualizado en otra región.
+ Prioriza las latencias de escritura y de lectura altamente coherente más bajas sobre la consistencia de lectura de varias regiones.
+ La estrategia de alta disponibilidad de varias regiones puede tolerar un RPO superior a cero.

Las tablas globales de MRSC tendrán latencias de escritura y de lectura altamente coherente más elevadas que las tablas globales de MREC. Las tablas globales de MRSC admiten un objetivo de punto de recuperación (RPO) de cero.

Debe utilizar el modo MRSC cuando:
+ Necesita lecturas altamente coherentes en varias regiones.
+ Dé prioridad a la consistencia de lectura global sobre una latencia de escritura menor.
+ La estrategia de alta disponibilidad de varias regiones requiera un RPO de cero.

## Monitoreo de tablas globales
<a name="monitoring-global-tables"></a>

Las tablas globales configuradas para una coherencia final de varias regiones (MREC) publican la métrica [`ReplicationLatency`](metrics-dimensions.md#ReplicationLatency) en CloudWatch. Esta métrica realiza un seguimiento del tiempo transcurrido entre el momento en que un elemento se escribe en una tabla de réplica y el momento en que dicho elemento aparece en otra réplica de la tabla global. `ReplicationLatency` se expresa en milisegundos y se emite para cada par de región de origen y destino en una tabla global. 

Los valores típicos de `ReplicationLatency` dependen de la distancia entre las regiones de AWS elegidas, así como de otras variables, como el tipo de carga de trabajo y el rendimiento. Por ejemplo, una réplica de origen en la región Oeste de EE. UU. (Norte de California) (us-west-1) tiene un nivel más bajo de `ReplicationLatency` hacia la región Oeste de EE. UU. (Oregón) (us-west-2) en comparación con la región África (Ciudad del Cabo) (af-south-1).

Un valor en aumento de `ReplicationLatency` podría indicar que las actualizaciones de una réplica no se están propagando hacia otras tablas de réplica de manera puntual. En este caso, puede redirigir temporalmente la actividad de lectura y escritura de la aplicación a otra región de AWS.

Las tablas globales configuradas para coherencia alta de varias regiones (MRSC) no publican una métrica de `ReplicationLatency`.

## Pruebas de inyección de errores
<a name="fault-injection-testing"></a>

Las tablas globales de MREC y MRSC se integran con el [Servicio de inyección de errores de AWS](https://docs.aws.amazon.com/resilience-hub/latest/userguide/testing.html) (AWS FIS), un servicio totalmente gestionado para ejecutar experimentos controlados de inyección de errores con el fin de mejorar la resiliencia de una aplicación. Con el AWS FIS, puede hacer lo siguiente:
+ Crear plantillas de experimentos que definen escenarios de error específicos.
+ Inyectar errores para validar la resiliencia de la aplicación simulando el aislamiento de una región (es decir, deteniendo la replicación hacia y desde una réplica seleccionada) para probar la gestión de errores, los mecanismos de recuperación y el comportamiento del cambio de tráfico entre regiones cuando una región de AWS sufre una interrupción.

Por ejemplo, en una tabla global con réplicas en el Este de EE. UU. (Norte de Virginia), el Este de EE. UU. (Ohio) y el Oeste de EE. UU. (Oregón), puede realizar un experimento en el Este de EE. UU. (Ohio) para probar el aislamiento de la región allí, mientras que el Este de EE. UU. (Norte de Virginia) y el Oeste de EE. UU. (Oregón) continúan con sus operaciones normales. Estas pruebas controladas le ayudan a identificar y resolver posibles problemas antes de que afecten a las cargas de trabajo de producción. 

Consulte los [objetivos de acción](https://docs.aws.amazon.com/fis/latest/userguide/action-sequence.html#action-targets) en la *Guía del usuario de AWS FIS* para obtener una lista completa de las acciones respaldadas por AWS FIS y [Conectividad entre regiones](https://docs.aws.amazon.com/fis/latest/userguide/cross-region-scenario.html) para detener la replicación de DynamoDB entre regiones.

Para obtener información sobre las acciones de las tablas globales de Amazon DynamoDB disponibles en AWS FIS, consulte [Referencia de acciones de tablas globales de DynamoDB](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#dynamodb-actions-reference) en la *Guía del usuario de AWS FIS*.

Para empezar a realizar experimentos de inyección de errores, consulte [Planificación de los experimentos de AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/getting-started-planning.html) en la Guía del usuario de AWS FIS.

**nota**  
Durante los experimentos de AWS FIS en la MRSC, se permiten lecturas coherentes posteriores, pero no se permiten actualizaciones de configuración de las tablas, como cambiar el modo de facturación o configurar el rendimiento de las tablas, de forma similar a lo que ocurre con la MREC. Consulte la métrica de CloudWatch [`FaultInjectionServiceInducedErrors`](metrics-dimensions.md#FaultInjectionServiceInducedErrors) para obtener información adicional sobre el código de errores.

## Tiempo de vida (TTL)
<a name="global-tables-ttl"></a>

Las tablas globales configuradas para MREC admiten la configuración de la eliminación de [Tiempo de vida](TTL.md) (TTL). La configuración de TTL se sincroniza automáticamente para todas las réplicas en una tabla global. Cuando TTL elimina un elemento de una réplica en una región, la eliminación se replica en todas las demás réplicas de la tabla global. El TTL no consume capacidad de escritura, por lo que no se le cobrará por la eliminación de TTL en la región donde se realizó la eliminación. Sin embargo, se le cobrará por la eliminación replicada en cada una de las demás regiones con una réplica en la tabla global.

La replicación de eliminación de TTL consume la capacidad de escritura de las réplicas en las que se está replicando la eliminación. Las réplicas configuradas para la capacidad aprovisionada pueden limitar las solicitudes si la combinación del rendimiento de escritura y el rendimiento de eliminación de TTL es superior a la capacidad de escritura aprovisionada.

Las tablas globales configuradas para la coherencia alta de varias regiones (MRSC) no admiten la configuración de la eliminación de Tiempo de vida (TTL).

## Transmisión
<a name="global-tables-streams"></a>

Las tablas globales configuradas para una coherencia final de varias regiones (MREC) replican los cambios leyendo esos cambios desde un [Flujo de DynamoDB](Streams.md) en una tabla de réplica y aplicándolos a todas las demás tablas de réplica. Por lo tanto, los flujos están habilitados de forma predeterminada en todas las réplicas de una tabla global de MREC y no se pueden desactivar en esas réplicas. El proceso de replicación de MREC puede combinar varios cambios en un corto periodo de tiempo en una sola escritura replicada, lo que hace que el flujo de cada réplica contenga registros ligeramente diferentes. Los registros de flujos en las réplicas de MREC siempre se ordenan por elemento, pero el orden entre los elementos puede variar entre las réplicas.

Las tablas globales configuradas para una coherencia sólida de varias regiones (MRSC) no utilizan los flujos de DynamoDB para la replicación, por lo que los flujos no están habilitados de forma predeterminada en las réplicas de MRSC. Puede habilitar flujos en una réplica de MRSC. Los registros de flujos en las réplicas de MRSC son idénticos para todas las réplicas, incluido el orden de los registros de flujos.

Si desea escribir una aplicación que procese los registros de flujos para cambios que se produjeron en una región específica pero no en otras regiones de una tabla global, puede agregar un atributo a cada elemento que defina en qué región se produjo el cambio para ese elemento. Puede usar este atributo para filtrar los registros de flujos en busca de cambios que se hayan producido en otras regiones, incluido el uso de filtros de eventos de Lambda para invocar solo las funciones de Lambda para los cambios en una región específica.

## Transacciones
<a name="global-tables-transactions"></a>

En una tabla global configurada para MREC, las operaciones de transacción de DynamoDB ([https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) y [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html)) son solo atómicas dentro de la región donde se invocó la operación. Las escrituras transaccionales no se replican como una unidad en todas las regiones, lo que significa que solo algunas de las escrituras de una transacción pueden devolverse mediante operaciones de lectura en otras réplicas en un momento dado.

Por ejemplo, si tiene una tabla global con réplicas en las regiones Este de EE. UU. (Ohio) y Oeste de EE. UU. (Oregón) y realiza una operación `TransactWriteItems` en la región Este de EE. UU. (Ohio), puede observar transacciones completadas parcialmente en la región Oeste de EE. UU. (Oregón) a medida que los cambios se replican. Solo se replicarán los cambios en otras regiones cuando se hayan confirmado en la región de origen.

Las tablas globales configuradas para lograr una coherencia alta de varias regiones (MRSC) no admiten operaciones de transacción y devolverán un error si esas operaciones se invocan en una réplica de MRSC.

## Rendimiento de lectura y escritura
<a name="V2globaltables_HowItWorks.Throughput"></a>

### Modo aprovisionado
<a name="gt_throughput.provisioned"></a>

La replicación consume capacidad de escritura. Las réplicas configuradas para la capacidad aprovisionada pueden limitar las solicitudes si la combinación del rendimiento de escritura de la aplicación y el rendimiento de escritura de la replicación supera la capacidad de escritura aprovisionada. En el caso de las tablas globales que utilizan el modo aprovisionado, la configuración de escalado automático para las capacidades de lectura y escritura se sincroniza entre las réplicas.

Puede configurar de forma independiente los ajustes de capacidad de lectura para cada réplica en una tabla global usando el parámetro [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html) a nivel de réplica. De forma predeterminada, los cambios en la capacidad de lectura aprovisionada se aplican a todas las réplicas de la tabla global. Al agregar una nueva réplica a una tabla global, se utiliza la capacidad de lectura de la tabla de origen o de la réplica como valor inicial, a menos que se especifique explícitamente una sustitución a nivel de réplica.

### Modo bajo demanda
<a name="gt_throughput.on-demand"></a>

En las tablas globales configuradas para el modo bajo demanda, la capacidad de escritura se sincroniza automáticamente en todas las réplicas. DynamoDB ajusta automáticamente la capacidad en función del tráfico y no hay que gestionar ninguna configuración de capacidad de lectura o escritura específica para las réplicas.

## Sincronización de ajustes
<a name="V2globaltables_HowItWorks.setting-synchronization"></a>

Los ajustes de las tablas globales de DynamoDB son parámetros de configuración que controlan varios aspectos del comportamiento y la replicación de las tablas. Estos ajustes se administran mediante las API del plano de control de DynamoDB y se pueden configurar al crear o modificar tablas globales. Las tablas globales sincronizan automáticamente determinados ajustes en todas las réplicas para mantener la coherencia, al tiempo que permiten flexibilidad para optimizaciones específicas de cada región. Entender qué ajustes se sincronizan y cómo se comportan le ayuda a configurar la tabla global de manera efectiva. Los ajustes se dividen en tres categorías principales en función de cómo se sincronizan entre las réplicas.

Los siguientes ajustes siempre se sincronizan entre las réplicas de una tabla global:
+ Modo de capacidad (capacidad aprovisionada o bajo demanda)
+ Capacidad de escritura aprovisionada de tabla
+ Escalado automático de la escritura de tablas
+ Definición de atributos del esquema de claves
+ Definición del índice secundario global (GSI)
+ Capacidad de escritura aprovisionada por GSI
+ Escalado automático de escritura de GSI
+ Tipo de cifrado del servidor (SSE)
+ Definición de flujos en modo de MREC
+ Tiempo de vida (TTL)
+ Rendimiento en caliente
+ Rendimiento de escritura máximo bajo demanda

Los siguientes ajustes se sincronizan entre las réplicas, pero se pueden invalidar por réplica:
+ La capacidad de lectura aprovisionada de la tabla
+ Escalado automático de lectura de tablas
+ Capacidad de lectura aprovisionada de GSI
+ Escalado automático de lectura de GSI
+ Clase de tabla
+ Rendimiento de lectura máximo bajo demanda

**nota**  
Los valores de configuración anulables se modifican si la configuración se cambia en cualquier otra réplica. Como ejemplo, tiene una tabla global de MREC con réplicas en Este de EE. UU. (Norte de Virginia) y Oeste de EE. UU. (Oregón). La réplica de Este de EE. UU. (Norte de Virginia) tiene un rendimiento de lectura aprovisionado establecido en 200 RCU. La réplica en Oeste de EE. UU. (Oregón) tiene una invalidación del rendimiento de lectura aprovisionada establecida en 100 RCU. Si actualiza la configuración de rendimiento de lectura aprovisionada en la réplica de Este de EE. UU. (Norte de Virginia) de 200 a 300 RCU, el nuevo valor de rendimiento de lectura aprovisionado también se aplicará a la réplica en Oeste de EE. UU. (Oregón). Esto cambia la configuración de rendimiento de lectura aprovisionada para la réplica de Oeste de EE. UU. (Oregón) del valor invalidado de 100 RCU al nuevo valor de 300 RCU.

Los siguientes ajustes nunca se sincronizan entre réplicas:
+ Protección contra eliminación
+ Recuperación en un momento dado
+ Etiquetas
+ Habilitación de CloudWatch Contributor Insights para tablas
+ Habilitación de CloudWatch Contributor Insights para GSI
+ Definición de Kinesis Data Streams
+ Políticas de recursos
+ Definición de flujos en modo de MRSC

Todos los demás ajustes no están sincronizados entre réplicas.

## DynamoDB Accelerator (DAX)
<a name="V2globaltables_HowItWorks.dax"></a>

Las réplicas de escrituras en tablas globales omiten DynamoDB Accelerator (DAX) y actualizan DynamoDB directamente. Como resultado, las cachés de DAX pueden quedar obsoletas, ya que las escrituras no actualizan la caché de DAX. Las cachés de DAX configuradas para réplicas de tablas globales solo se actualizarán cuando caduque el TTL de la caché.

## Consideraciones para la administración de tablas globales
<a name="management-considerations"></a>

No puede eliminar una tabla utilizada para agregar una nueva réplica de tabla global hasta que hayan transcurrido 24 horas desde que se creó la nueva réplica.

Si desactiva una región de AWS que contiene réplicas de tablas globales, esas réplicas se convierten permanentemente en tablas de una sola región 20 horas después de desactivar la región.

# Tutoriales: creación de tablas globales
<a name="V2globaltables.tutorial"></a>

Esta sección proporciona instrucciones paso a paso para crear tablas globales de DynamoDB configuradas para su modo de coherencia preferido. Elija los modos de coherencia final de varias regiones (MREC) o coherencia alta de varias regiones (MRSC) según los requisitos de la aplicación.

Las tablas globales de MREC proporcionan una latencia de escritura más baja con coherencia final en todas las Regiones de AWS. Las tablas globales de MRSC proporcionan lecturas altamente coherentes en todas las regiones, con latencias de escritura ligeramente superiores a las de MREC. Elija el modo de coherencia que mejor se adapte a las necesidades de la aplicación en cuanto a coherencia de datos, latencia y disponibilidad.

**Topics**
+ [Creación de una tabla global configurada para MREC](#V2creategt_mrec)
+ [Creación de una tabla global configurada para MRSC](#create-gt-mrsc)

## Creación de una tabla global configurada para MREC
<a name="V2creategt_mrec"></a>

En esta sección se muestra cómo crear una tabla global con el modo de coherencia final de varias regiones (MREC). MREC es el modo de coherencia predeterminado para tablas globales y proporciona escrituras de baja latencia con replicación asincrónica en todas las Regiones de AWS. Los cambios realizados en un elemento de una región suelen replicarse en todas las demás regiones en un segundo. Esto hace que MREC sea ideal para aplicaciones que priorizan una baja latencia de escritura y pueden tolerar breves periodos en los que diferentes regiones pueden devolver versiones de datos ligeramente diferentes.

Puede crear tablas globales de MREC con réplicas en cualquier región de AWS donde DynamoDB esté disponible y agregar o eliminar réplicas en cualquier momento. Los ejemplos siguientes muestran cómo crear una tabla global de MREC con réplicas en varias regiones.

### Creación de una tabla global de MREC mediante la consola de DynamoDB
<a name="mrec-console"></a>

Siga estos pasos para crear una tabla global mediante la Consola de administración de AWS. En el ejemplo siguiente, se crea una tabla global con tablas de réplica en Estados Unidos y Europa.

1. Inicie sesión en la Consola de administración de AWS y abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).

1. Para este ejemplo, elija **Este de EE. UU. (Ohio)** en el selector de regiones en la barra de navegación.

1. En el panel de navegación del lado izquierdo de la consola, elija **Tablas**.

1. Seleccione **Create Table (Crear tabla)**.

1. En la página **Crear tabla**:

   1. En **Nombre de la tabla**, introduzca **Music**.

   1. En **Partition key** (Clave de partición), ingrese **Artist**.

   1. Para **Clave de clasificación**, ingrese **SongTitle**.

   1. Deje los demás valores predeterminados y elija **Crear tabla**.

      Esta nueva tabla le servirá de primera tabla de réplica en una nueva tabla global. Será el prototipo para crear otras tablas de réplica que quiera añadir más tarde.

1. Cuando la tabla se active:

   1. Elija la tabla **Música** en la lista de tablas.

   1. Elija la pestaña **Tablas globales**.

   1. Elija **Create replica (Crear réplica)**.

1. En el menú desplegable **Regiones de replicación disponibles**, elija **Oeste de EE. UU. (Oregón) us-west-2**.

   La consola asegura que no haya ninguna tabla con el mismo nombre en la región seleccionada. Si ya existe una tabla con el mismo nombre, debe eliminar la tabla existente antes de crear una nueva tabla de réplica en esa región.

1. Elija **Create replica (Crear réplica)**. Esto comienza el proceso de creación de la tabla en la región Oeste de EE. UU (Oregón) us-west-2.

   La pestaña **Tablas globales** de la tabla **Música** (y de cualquier otra tabla de réplica) indica que la tabla se ha replicado en varias regiones.

1. Agregue otra región repitiendo los pasos anteriores, pero elija **Europa (Fráncfort) eu-central-1** como región.

1. Para probar la replicación:

   1. Asegúrese de que utiliza la Consola de administración de AWS en la región Este de EE. UU. (Ohio).

   1. Elija **Explorar elementos de la tabla**.

   1. Seleccione **Crear elemento**.

   1. Ingrese **item\$11** para **Artista** y **Song Value 1** para **Título de la canción**.

   1. Seleccione **Crear elemento**.

1. Compruebe la replicación cambiando a las otras regiones:

   1. En el selector de regiones en la esquina superior derecha, elija **Europa (Fráncfort)**.

   1. Compruebe que la tabla **Música** contiene el elemento que ha creado.

   1. Repita la verificación para **Oeste de EE. UU. (Oregón)**.

### Creación de una tabla global de MREC mediante AWS CLI o Java
<a name="mrec-cli-java"></a>

------
#### [ CLI ]

En el siguiente ejemplo de código, se muestra cómo administrar las tablas globales de DynamoDB con replicación de varias regiones con coherencia final (MREC).
+ Cree una tabla con replicación de varias regiones (MREC).
+ Coloque y obtenga elementos de las tablas de réplica.
+ Elimine réplicas una por una.
+ Efectúe una limpieza eliminando la tabla.

**AWS CLI con Bash script**  
Cree una tabla con replicación de varias regiones.  

```
# Step 1: Create a new table (MusicTable) in US East (Ohio), with DynamoDB Streams enabled (NEW_AND_OLD_IMAGES)
aws dynamodb create-table \
    --table-name MusicTable \
    --attribute-definitions \
        AttributeName=Artist,AttributeType=S \
        AttributeName=SongTitle,AttributeType=S \
    --key-schema \
        AttributeName=Artist,KeyType=HASH \
        AttributeName=SongTitle,KeyType=RANGE \
    --billing-mode PAY_PER_REQUEST \
    --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES \
    --region us-east-2

# Step 2: Create an identical MusicTable table in US East (N. Virginia)
aws dynamodb update-table --table-name MusicTable --cli-input-json \
'{
  "ReplicaUpdates":
  [
    {
      "Create": {
        "RegionName": "us-east-1"
      }
    }
  ]
}' \
--region us-east-2

# Step 3: Create a table in Europe (Ireland)
aws dynamodb update-table --table-name MusicTable --cli-input-json \
'{
  "ReplicaUpdates":
  [
    {
      "Create": {
        "RegionName": "eu-west-1"
      }
    }
  ]
}' \
--region us-east-2
```
Describa la tabla de varias regiones.  

```
# Step 4: View the list of replicas created using describe-table
aws dynamodb describe-table \
    --table-name MusicTable \
    --region us-east-2 \
    --query 'Table.{TableName:TableName,TableStatus:TableStatus,MultiRegionConsistency:MultiRegionConsistency,Replicas:Replicas[*].{Region:RegionName,Status:ReplicaStatus}}'
```
Coloque elementos en una tabla de réplica.  

```
# Step 5: To verify that replication is working, add a new item to the Music table in US East (Ohio)
aws dynamodb put-item \
    --table-name MusicTable \
    --item '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
    --region us-east-2
```
Obtenga elementos de las tablas de réplica.  

```
# Step 6: Wait for a few seconds, and then check to see whether the item has been 
# successfully replicated to US East (N. Virginia) and Europe (Ireland)
aws dynamodb get-item \
    --table-name MusicTable \
    --key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
    --region us-east-1

aws dynamodb get-item \
    --table-name MusicTable \
    --key '{"Artist": {"S":"item_1"},"SongTitle": {"S":"Song Value 1"}}' \
    --region eu-west-1
```
Elimine réplicas.  

```
# Step 7: Delete the replica table in Europe (Ireland) Region
aws dynamodb update-table --table-name MusicTable --cli-input-json \
'{
  "ReplicaUpdates":
  [
    {
      "Delete": {
        "RegionName": "eu-west-1"
      }
    }
  ]
}' \
--region us-east-2

# Delete the replica table in US East (N. Virginia) Region
aws dynamodb update-table --table-name MusicTable --cli-input-json \
'{
  "ReplicaUpdates":
  [
    {
      "Delete": {
        "RegionName": "us-east-1"
      }
    }
  ]
}' \
--region us-east-2
```
Efectúe una limpieza eliminando la tabla.  

```
# Clean up: Delete the primary table
aws dynamodb delete-table --table-name MusicTable --region us-east-2

echo "Global table demonstration complete."
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de comandos de AWS CLI*.
  + [CreateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/CreateTable)
  + [DeleteTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DeleteTable)
  + [DescribeTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DescribeTable)
  + [GetItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/GetItem)
  + [PutItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem)
  + [UpdateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/UpdateTable)

------
#### [ Java ]

En el ejemplo de código siguiente, se muestra cómo crear y administrar las tablas globales de DynamoDB con réplicas en varias regiones.
+ Cree una tabla con un índice secundario global y flujos de DynamoDB.
+ Agregue réplicas en diferentes regiones para crear una tabla global.
+ Elimine réplicas de una tabla global.
+ Agregue elementos de prueba para verificar la replicación en todas las regiones.
+ Describa la configuración de la tabla global y el estado de las réplicas.

**SDK para Java 2.x**  
Cree una tabla con un índice secundario global y flujos de DynamoDB mediante AWS SDK for Java 2.x.  

```
    public static CreateTableResponse createTableWithGSI(
        final DynamoDbClient dynamoDbClient, final String tableName, final String indexName) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (indexName == null || indexName.trim().isEmpty()) {
            throw new IllegalArgumentException("Index name cannot be null or empty");
        }

        try {
            LOGGER.info("Creating table: " + tableName + " with GSI: " + indexName);

            CreateTableRequest createTableRequest = CreateTableRequest.builder()
                .tableName(tableName)
                .attributeDefinitions(
                    AttributeDefinition.builder()
                        .attributeName("Artist")
                        .attributeType(ScalarAttributeType.S)
                        .build(),
                    AttributeDefinition.builder()
                        .attributeName("SongTitle")
                        .attributeType(ScalarAttributeType.S)
                        .build())
                .keySchema(
                    KeySchemaElement.builder()
                        .attributeName("Artist")
                        .keyType(KeyType.HASH)
                        .build(),
                    KeySchemaElement.builder()
                        .attributeName("SongTitle")
                        .keyType(KeyType.RANGE)
                        .build())
                .billingMode(BillingMode.PAY_PER_REQUEST)
                .globalSecondaryIndexes(GlobalSecondaryIndex.builder()
                    .indexName(indexName)
                    .keySchema(KeySchemaElement.builder()
                        .attributeName("SongTitle")
                        .keyType(KeyType.HASH)
                        .build())
                    .projection(
                        Projection.builder().projectionType(ProjectionType.ALL).build())
                    .build())
                .streamSpecification(StreamSpecification.builder()
                    .streamEnabled(true)
                    .streamViewType(StreamViewType.NEW_AND_OLD_IMAGES)
                    .build())
                .build();

            CreateTableResponse response = dynamoDbClient.createTable(createTableRequest);
            LOGGER.info("Table creation initiated. Status: "
                + response.tableDescription().tableStatus());

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to create table: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Espere a que una tabla se active mediante AWS SDK for Java 2.x.  

```
    public static void waitForTableActive(final DynamoDbClient dynamoDbClient, final String tableName) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }

        try {
            LOGGER.info("Waiting for table to become active: " + tableName);

            try (DynamoDbWaiter waiter =
                DynamoDbWaiter.builder().client(dynamoDbClient).build()) {
                DescribeTableRequest request =
                    DescribeTableRequest.builder().tableName(tableName).build();

                waiter.waitUntilTableExists(request);
                LOGGER.info("Table is now active: " + tableName);
            }

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to wait for table to become active: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Agregue una réplica para crear o ampliar una tabla global mediante AWS SDK for Java 2.x.  

```
    public static UpdateTableResponse addReplica(
        final DynamoDbClient dynamoDbClient,
        final String tableName,
        final Region replicaRegion,
        final String indexName,
        final Long readCapacity) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (replicaRegion == null) {
            throw new IllegalArgumentException("Replica region cannot be null");
        }
        if (indexName == null || indexName.trim().isEmpty()) {
            throw new IllegalArgumentException("Index name cannot be null or empty");
        }
        if (readCapacity == null || readCapacity <= 0) {
            throw new IllegalArgumentException("Read capacity must be a positive number");
        }

        try {
            LOGGER.info("Adding replica in region: " + replicaRegion.id() + " for table: " + tableName);

            // Create a ReplicationGroupUpdate for adding a replica
            ReplicationGroupUpdate replicationGroupUpdate = ReplicationGroupUpdate.builder()
                .create(builder -> builder.regionName(replicaRegion.id())
                    .globalSecondaryIndexes(ReplicaGlobalSecondaryIndex.builder()
                        .indexName(indexName)
                        .provisionedThroughputOverride(ProvisionedThroughputOverride.builder()
                            .readCapacityUnits(readCapacity)
                            .build())
                        .build())
                    .build())
                .build();

            UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
                .tableName(tableName)
                .replicaUpdates(replicationGroupUpdate)
                .build();

            UpdateTableResponse response = dynamoDbClient.updateTable(updateTableRequest);
            LOGGER.info("Replica addition initiated in region: " + replicaRegion.id());

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to add replica in region: " + replicaRegion.id() + " - " + e.getMessage());
            throw e;
        }
    }
```
Elimine una réplica de una tabla global mediante AWS SDK for Java 2.x.  

```
    public static UpdateTableResponse removeReplica(
        final DynamoDbClient dynamoDbClient, final String tableName, final Region replicaRegion) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (replicaRegion == null) {
            throw new IllegalArgumentException("Replica region cannot be null");
        }

        try {
            LOGGER.info("Removing replica in region: " + replicaRegion.id() + " for table: " + tableName);

            // Create a ReplicationGroupUpdate for removing a replica
            ReplicationGroupUpdate replicationGroupUpdate = ReplicationGroupUpdate.builder()
                .delete(builder -> builder.regionName(replicaRegion.id()).build())
                .build();

            UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
                .tableName(tableName)
                .replicaUpdates(replicationGroupUpdate)
                .build();

            UpdateTableResponse response = dynamoDbClient.updateTable(updateTableRequest);
            LOGGER.info("Replica removal initiated in region: " + replicaRegion.id());

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to remove replica in region: " + replicaRegion.id() + " - " + e.getMessage());
            throw e;
        }
    }
```
Agregue elementos de prueba para verificar la replicación mediante AWS SDK for Java 2.x.  

```
    public static PutItemResponse putTestItem(
        final DynamoDbClient dynamoDbClient, final String tableName, final String artist, final String songTitle) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (artist == null || artist.trim().isEmpty()) {
            throw new IllegalArgumentException("Artist cannot be null or empty");
        }
        if (songTitle == null || songTitle.trim().isEmpty()) {
            throw new IllegalArgumentException("Song title cannot be null or empty");
        }

        try {
            LOGGER.info("Adding test item to table: " + tableName);

            Map<String, software.amazon.awssdk.services.dynamodb.model.AttributeValue> item = new HashMap<>();
            item.put(
                "Artist",
                software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder()
                    .s(artist)
                    .build());
            item.put(
                "SongTitle",
                software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder()
                    .s(songTitle)
                    .build());

            PutItemRequest putItemRequest =
                PutItemRequest.builder().tableName(tableName).item(item).build();

            PutItemResponse response = dynamoDbClient.putItem(putItemRequest);
            LOGGER.info("Test item added successfully");

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Describa la configuración de la tabla global y las réplicas mediante AWS SDK for Java 2.x.  

```
    public static DescribeTableResponse describeTable(final DynamoDbClient dynamoDbClient, final String tableName) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }

        try {
            LOGGER.info("Describing table: " + tableName);

            DescribeTableRequest request =
                DescribeTableRequest.builder().tableName(tableName).build();

            DescribeTableResponse response = dynamoDbClient.describeTable(request);

            LOGGER.info("Table status: " + response.table().tableStatus());
            if (response.table().replicas() != null
                && !response.table().replicas().isEmpty()) {
                LOGGER.info("Number of replicas: " + response.table().replicas().size());
                response.table()
                    .replicas()
                    .forEach(replica -> LOGGER.info(
                        "Replica region: " + replica.regionName() + ", Status: " + replica.replicaStatus()));
            }

            return response;

        } catch (ResourceNotFoundException e) {
            LOGGER.severe("Table not found: " + tableName + " - " + e.getMessage());
            throw e;
        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to describe table: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Ejemplo completo de operaciones de tablas globales mediante AWS SDK for Java 2.x.  

```
    public static void exampleUsage(final Region sourceRegion, final Region replicaRegion) {

        String tableName = "Music";
        String indexName = "SongTitleIndex";
        Long readCapacity = 15L;

        // Create DynamoDB client for the source region
        try (DynamoDbClient dynamoDbClient =
            DynamoDbClient.builder().region(sourceRegion).build()) {

            try {
                // Step 1: Create the initial table with GSI and streams
                LOGGER.info("Step 1: Creating table in source region: " + sourceRegion.id());
                createTableWithGSI(dynamoDbClient, tableName, indexName);

                // Step 2: Wait for table to become active
                LOGGER.info("Step 2: Waiting for table to become active");
                waitForTableActive(dynamoDbClient, tableName);

                // Step 3: Add replica in destination region
                LOGGER.info("Step 3: Adding replica in region: " + replicaRegion.id());
                addReplica(dynamoDbClient, tableName, replicaRegion, indexName, readCapacity);

                // Step 4: Wait a moment for replica creation to start
                Thread.sleep(5000);

                // Step 5: Describe table to view replica information
                LOGGER.info("Step 5: Describing table to view replicas");
                describeTable(dynamoDbClient, tableName);

                // Step 6: Add a test item to verify replication
                LOGGER.info("Step 6: Adding test item to verify replication");
                putTestItem(dynamoDbClient, tableName, "TestArtist", "TestSong");

                LOGGER.info("Global table setup completed successfully!");
                LOGGER.info("You can verify replication by checking the item in region: " + replicaRegion.id());

                // Step 7: Remove replica and clean up table
                LOGGER.info("Step 7: Removing replica from region: " + replicaRegion.id());
                removeReplica(dynamoDbClient, tableName, replicaRegion);
                DeleteTableResponse deleteTableResponse = dynamoDbClient.deleteTable(
                    DeleteTableRequest.builder().tableName(tableName).build());
                LOGGER.info("MREC global table demonstration completed successfully!");

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Thread was interrupted", e);
            } catch (DynamoDbException e) {
                LOGGER.severe("DynamoDB operation failed: " + e.getMessage());
                throw e;
            }
        }
    }
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK for Java 2.x*.
  + [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)
  + [DescribeTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DescribeTable)
  + [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)
  + [UpdateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateTable)

------

## Creación de una tabla global configurada para MRSC
<a name="create-gt-mrsc"></a>

En esta sección se muestra cómo crear una tabla global de coherencia alta de varias regiones (MRSC). Las tablas globales de MRSC replican de forma sincrónica los cambios de los elementos en todas las regiones, lo que garantiza que las operaciones de lectura altamente coherente en cualquier réplica siempre devuelvan la versión más reciente de un elemento. Al convertir una tabla de una sola región en una tabla global de MRSC, debe asegurarse de que la tabla esté vacía. No se admite la conversión de una tabla de una sola región en una tabla global de MRSC con los elementos existentes. Asegúrese de que no se escriba ningún dato en la tabla durante el proceso de conversión.

Puede configurar una tabla global de MRSC con tres réplicas o dos réplicas y un testigo. Al crear una tabla global de MRSC, debe elegir las regiones en las que se despliegan las réplicas y un testigo opcional. En el siguiente ejemplo, se crea una tabla global de MRSC con réplicas en las regiones Este de EE. UU. (Norte de Virginia) y Este de EE. UU. (Ohio), con un testigo en la región Oeste de EE. UU. (Oregón).

**nota**  
Antes de crear una tabla global, compruebe que los límites de rendimiento de la cuota de servicio sean coherentes en todas las regiones de destino, ya que es necesario para crear una tabla global. Para obtener más información sobre los límites de rendimiento de las tablas globales, consulte [Cuotas de tablas globales](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ServiceQuotas.html#gt-limits-throughput).

### Creación de una tabla global de MRSC mediante la consola de DynamoDB
<a name="mrsc_console"></a>

Siga estos pasos para crear una tabla global de MRSC mediante la Consola de administración de AWS.

1. Inicie sesión en la Consola de administración de AWS y abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).

1. En el selector de regiones de la barra de navegación, elija una región en la que [se admiten](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes) tablas globales con MRSC, como **us-east-2**.

1. En el panel de navegación, elija **Tablas**.

1. Seleccione **Create table (Creación de tabla)**.

1. En la página **Crear tabla**:

   1. En **Nombre de la tabla**, introduzca **Music**.

   1. En **Clave de partición**, ingrese **Artist** y mantenga la **Cadena** predeterminada.

   1. En **Clave de clasificación**, ingrese **SongTitle** y mantenga el tipo de **Cadena** predeterminada.

   1. Deje los demás valores predeterminados y elija **Crear tabla**

      Esta nueva tabla le servirá de primera tabla de réplica en una nueva tabla global. Será el prototipo para crear otras tablas de réplica que quiera añadir más tarde.

1. Espere a que la tabla se active y luego selecciónela en la lista de tablas.

1. Elija la pestaña **Tablas globales** y, a continuación, seleccione **Crear réplica**.

1. En la página **Crear réplica**:

   1. En **Consistencia de varias regiones**, elija **Consistencia alta**.

   1. Para **Región de replicación 1**, elija **US East (N. Virginia) us-east-1**.

   1. Para **Región de replicación 2**, elija **US West (Oregon) us-west-2**.

   1. Compruebe **Configurar como testigo** para la región Oeste de EE. UU. (Oregón).

   1. Elija **Crear réplicas**.

1. Espere a que se complete el proceso de creación de la réplica y el testigo. El estado de la réplica se mostrará como **Activo** cuando la tabla esté lista para usarse.

### Creación de una tabla global de MRSC mediante la AWS CLI o Java
<a name="mrsc-cli-java"></a>

Antes de empezar, asegúrese de que la entidad principal de IAM tenga los permisos necesarios para crear una tabla global de MRSC con una región testigo.

La política de IAM de ejemplo siguiente le permite crear una tabla de DynamoDB (`MusicTable`) en Este de EE. UU. (Ohio) con una réplica en Este de EE. UU. (Norte de Virginia) y una región testigo en Oeste de EE. UU. (Oregón):

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:CreateTable",
                "dynamodb:CreateTableReplica",
                "dynamodb:CreateGlobalTableWitness",
                "dynamodb:DescribeTable",
                "dynamodb:UpdateTable",
                "dynamodb:DeleteTable",
                "dynamodb:DeleteTableReplica",
                "dynamodb:DeleteGlobalTableWitness",
                "dynamodb:Scan",
                "dynamodb:Query",
                "dynamodb:UpdateItem",
                "dynamodb:PutItem",
                "dynamodb:GetItem",
                "dynamodb:DeleteItem",
                "dynamodb:BatchWriteItem"
            ],
            "Resource": [
                "arn:aws:dynamodb:us-east-1:123456789012:table/MusicTable",
                "arn:aws:dynamodb:us-east-2:123456789012:table/MusicTable",
                "arn:aws:dynamodb:us-west-2:123456789012:table/MusicTable"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "iam:CreateServiceLinkedRole",
            "Resource": "arn:aws:iam::*:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication",
            "Condition": {
                "StringLike": {
                    "iam:AWSServiceName": "replication.dynamodb.amazonaws.com"
                }
            }
        }
    ]
}
```

------

Los ejemplos de código siguientes, muestran cómo crear y administrar las tablas globales de DynamoDB con coherencia alta de varias regiones (MRSC).
+ Cree una tabla con coherencia alta de varias regiones.
+ Verifique la configuración de MRSC y el estado de la réplica.
+ Pruebe la coherencia alta entre regiones con lecturas inmediatas.
+ Realice escrituras condicionales con garantías de MRSC.
+ Limpie los recursos de la tabla global de MRSC.

------
#### [ Bash ]

**AWS CLI con Bash script**  
Cree una tabla con coherencia alta de varias regiones.  

```
# Step 1: Create a new table in us-east-2 (primary region for MRSC)
# Note: Table must be empty when enabling MRSC
aws dynamodb create-table \
    --table-name MusicTable \
    --attribute-definitions \
        AttributeName=Artist,AttributeType=S \
        AttributeName=SongTitle,AttributeType=S \
    --key-schema \
        AttributeName=Artist,KeyType=HASH \
        AttributeName=SongTitle,KeyType=RANGE \
    --billing-mode PAY_PER_REQUEST \
    --region us-east-2

# Wait for table to become active
aws dynamodb wait table-exists --table-name MusicTable --region us-east-2

# Step 2: Add replica and witness with Multi-Region Strong Consistency
# MRSC requires exactly three replicas in supported regions
aws dynamodb update-table \
    --table-name MusicTable \
    --replica-updates '[{"Create": {"RegionName": "us-east-1"}}]' \
    --global-table-witness-updates '[{"Create": {"RegionName": "us-west-2"}}]' \
    --multi-region-consistency STRONG \
    --region us-east-2
```
Verifique la configuración de MRSC y el estado de la réplica.  

```
# Verify the global table configuration and MRSC setting
aws dynamodb describe-table \
    --table-name MusicTable \
    --region us-east-2 \
    --query 'Table.{TableName:TableName,TableStatus:TableStatus,MultiRegionConsistency:MultiRegionConsistency,Replicas:Replicas[*],GlobalTableWitnesses:GlobalTableWitnesses[*].{Region:RegionName,Status:ReplicaStatus}}'
```
Pruebe la coherencia alta con lecturas inmediatas entre regiones.  

```
# Write an item to the primary region
aws dynamodb put-item \
    --table-name MusicTable \
    --item '{"Artist": {"S":"The Beatles"},"SongTitle": {"S":"Hey Jude"},"Album": {"S":"The Beatles 1967-1970"},"Year": {"N":"1968"}}' \
    --region us-east-2

# Read the item from replica region to verify strong consistency (cannot read or write to witness)
# No wait time needed - MRSC provides immediate consistency
echo "Reading from us-east-1 (immediate consistency):"
aws dynamodb get-item \
    --table-name MusicTable \
    --key '{"Artist": {"S":"The Beatles"},"SongTitle": {"S":"Hey Jude"}}' \
    --consistent-read \
    --region us-east-1
```
Realice escrituras condicionales con garantías de MRSC.  

```
# Perform a conditional update from a different region
# This demonstrates that conditions work consistently across all regions
aws dynamodb update-item \
    --table-name MusicTable \
    --key '{"Artist": {"S":"The Beatles"},"SongTitle": {"S":"Hey Jude"}}' \
    --update-expression "SET #rating = :rating" \
    --condition-expression "attribute_exists(Artist)" \
    --expression-attribute-names '{"#rating": "Rating"}' \
    --expression-attribute-values '{":rating": {"N":"5"}}' \
    --region us-east-1
```
Limpie los recursos de la tabla global de MRSC.  

```
# Remove replica tables (must be done before deleting the primary table)
aws dynamodb update-table \
    --table-name MusicTable \
    --replica-updates '[{"Delete": {"RegionName": "us-east-1"}}]' \
    --global-table-witness-updates '[{"Delete": {"RegionName": "us-west-2"}}]' \
    --region us-east-2

# Wait for replicas to be deleted
echo "Waiting for replicas to be deleted..."
sleep 30

# Delete the primary table
aws dynamodb delete-table \
    --table-name MusicTable \
    --region us-east-2
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de comandos de AWS CLI*.
  + [CreateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/CreateTable)
  + [DeleteTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DeleteTable)
  + [DescribeTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/DescribeTable)
  + [GetItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/GetItem)
  + [PutItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem)
  + [UpdateItem](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/UpdateItem)
  + [UpdateTable](https://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/UpdateTable)

------
#### [ Java ]

**SDK para Java 2.x**  
Cree una tabla regional lista para la conversión de MRSC con AWS SDK for Java 2.x.  

```
    public static CreateTableResponse createRegionalTable(final DynamoDbClient dynamoDbClient, final String tableName) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }

        try {
            LOGGER.info("Creating regional table: " + tableName + " (must be empty for MRSC)");

            CreateTableRequest createTableRequest = CreateTableRequest.builder()
                .tableName(tableName)
                .attributeDefinitions(
                    AttributeDefinition.builder()
                        .attributeName("Artist")
                        .attributeType(ScalarAttributeType.S)
                        .build(),
                    AttributeDefinition.builder()
                        .attributeName("SongTitle")
                        .attributeType(ScalarAttributeType.S)
                        .build())
                .keySchema(
                    KeySchemaElement.builder()
                        .attributeName("Artist")
                        .keyType(KeyType.HASH)
                        .build(),
                    KeySchemaElement.builder()
                        .attributeName("SongTitle")
                        .keyType(KeyType.RANGE)
                        .build())
                .billingMode(BillingMode.PAY_PER_REQUEST)
                .build();

            CreateTableResponse response = dynamoDbClient.createTable(createTableRequest);
            LOGGER.info("Regional table creation initiated. Status: "
                + response.tableDescription().tableStatus());

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to create regional table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to create regional table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Convierta una tabla regional en MRSC utilizando réplicas y testigos con AWS SDK for Java 2.x.  

```
    public static UpdateTableResponse convertToMRSCWithWitness(
        final DynamoDbClient dynamoDbClient,
        final String tableName,
        final Region replicaRegion,
        final Region witnessRegion) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (replicaRegion == null) {
            throw new IllegalArgumentException("Replica region cannot be null");
        }
        if (witnessRegion == null) {
            throw new IllegalArgumentException("Witness region cannot be null");
        }

        try {
            LOGGER.info("Converting table to MRSC with replica in " + replicaRegion.id() + " and witness in "
                + witnessRegion.id());

            // Create replica update using ReplicationGroupUpdate
            ReplicationGroupUpdate replicaUpdate = ReplicationGroupUpdate.builder()
                .create(CreateReplicationGroupMemberAction.builder()
                    .regionName(replicaRegion.id())
                    .build())
                .build();

            // Create witness update
            GlobalTableWitnessGroupUpdate witnessUpdate = GlobalTableWitnessGroupUpdate.builder()
                .create(CreateGlobalTableWitnessGroupMemberAction.builder()
                    .regionName(witnessRegion.id())
                    .build())
                .build();

            UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
                .tableName(tableName)
                .replicaUpdates(List.of(replicaUpdate))
                .globalTableWitnessUpdates(List.of(witnessUpdate))
                .multiRegionConsistency(MultiRegionConsistency.STRONG)
                .build();

            UpdateTableResponse response = dynamoDbClient.updateTable(updateTableRequest);
            LOGGER.info("MRSC conversion initiated. Status: "
                + response.tableDescription().tableStatus());
            LOGGER.info("UpdateTableResponse full object: " + response);
            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to convert table to MRSC: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to convert table to MRSC: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Describa la configuración de una tabla global de MRSC con AWS SDK for Java 2.x.  

```
    public static DescribeTableResponse describeMRSCTable(final DynamoDbClient dynamoDbClient, final String tableName) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }

        try {
            LOGGER.info("Describing MRSC global table: " + tableName);

            DescribeTableRequest request =
                DescribeTableRequest.builder().tableName(tableName).build();

            DescribeTableResponse response = dynamoDbClient.describeTable(request);

            LOGGER.info("Table status: " + response.table().tableStatus());
            LOGGER.info("Multi-region consistency: " + response.table().multiRegionConsistency());

            if (response.table().replicas() != null
                && !response.table().replicas().isEmpty()) {
                LOGGER.info("Number of replicas: " + response.table().replicas().size());
                response.table()
                    .replicas()
                    .forEach(replica -> LOGGER.info(
                        "Replica region: " + replica.regionName() + ", Status: " + replica.replicaStatus()));
            }

            if (response.table().globalTableWitnesses() != null
                && !response.table().globalTableWitnesses().isEmpty()) {
                LOGGER.info("Number of witnesses: "
                    + response.table().globalTableWitnesses().size());
                response.table()
                    .globalTableWitnesses()
                    .forEach(witness -> LOGGER.info(
                        "Witness region: " + witness.regionName() + ", Status: " + witness.witnessStatus()));
            }

            return response;

        } catch (ResourceNotFoundException e) {
            LOGGER.severe("Table not found: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Table not found: " + tableName)
                .cause(e)
                .build();
        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to describe table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to describe table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Agregue elementos de prueba para verificar la coherencia alta de MRSC con AWS SDK for Java 2.x.  

```
    public static PutItemResponse putTestItem(
        final DynamoDbClient dynamoDbClient,
        final String tableName,
        final String artist,
        final String songTitle,
        final String album,
        final String year) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (artist == null || artist.trim().isEmpty()) {
            throw new IllegalArgumentException("Artist cannot be null or empty");
        }
        if (songTitle == null || songTitle.trim().isEmpty()) {
            throw new IllegalArgumentException("Song title cannot be null or empty");
        }

        try {
            LOGGER.info("Adding test item to MRSC global table: " + tableName);

            Map<String, AttributeValue> item = new HashMap<>();
            item.put("Artist", AttributeValue.builder().s(artist).build());
            item.put("SongTitle", AttributeValue.builder().s(songTitle).build());

            if (album != null && !album.trim().isEmpty()) {
                item.put("Album", AttributeValue.builder().s(album).build());
            }
            if (year != null && !year.trim().isEmpty()) {
                item.put("Year", AttributeValue.builder().n(year).build());
            }

            PutItemRequest putItemRequest =
                PutItemRequest.builder().tableName(tableName).item(item).build();

            PutItemResponse response = dynamoDbClient.putItem(putItemRequest);
            LOGGER.info("Test item added successfully with strong consistency");

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to add test item to table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Lea los elementos con lecturas coherentes de las réplicas de MRSC con AWS SDK for Java 2.x.  

```
    public static GetItemResponse getItemWithConsistentRead(
        final DynamoDbClient dynamoDbClient, final String tableName, final String artist, final String songTitle) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (artist == null || artist.trim().isEmpty()) {
            throw new IllegalArgumentException("Artist cannot be null or empty");
        }
        if (songTitle == null || songTitle.trim().isEmpty()) {
            throw new IllegalArgumentException("Song title cannot be null or empty");
        }

        try {
            LOGGER.info("Reading item from MRSC global table with consistent read: " + tableName);

            Map<String, AttributeValue> key = new HashMap<>();
            key.put("Artist", AttributeValue.builder().s(artist).build());
            key.put("SongTitle", AttributeValue.builder().s(songTitle).build());

            GetItemRequest getItemRequest = GetItemRequest.builder()
                .tableName(tableName)
                .key(key)
                .consistentRead(true)
                .build();

            GetItemResponse response = dynamoDbClient.getItem(getItemRequest);

            if (response.hasItem()) {
                LOGGER.info("Item found with strong consistency - no wait time needed");
            } else {
                LOGGER.info("Item not found");
            }

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to read item from table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to read item from table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Realice actualizaciones condicionales con garantías de MRSC mediante AWS SDK for Java 2.x.  

```
    public static UpdateItemResponse performConditionalUpdate(
        final DynamoDbClient dynamoDbClient,
        final String tableName,
        final String artist,
        final String songTitle,
        final String rating) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (artist == null || artist.trim().isEmpty()) {
            throw new IllegalArgumentException("Artist cannot be null or empty");
        }
        if (songTitle == null || songTitle.trim().isEmpty()) {
            throw new IllegalArgumentException("Song title cannot be null or empty");
        }
        if (rating == null || rating.trim().isEmpty()) {
            throw new IllegalArgumentException("Rating cannot be null or empty");
        }

        try {
            LOGGER.info("Performing conditional update on MRSC global table: " + tableName);

            Map<String, AttributeValue> key = new HashMap<>();
            key.put("Artist", AttributeValue.builder().s(artist).build());
            key.put("SongTitle", AttributeValue.builder().s(songTitle).build());

            Map<String, String> expressionAttributeNames = new HashMap<>();
            expressionAttributeNames.put("#rating", "Rating");

            Map<String, AttributeValue> expressionAttributeValues = new HashMap<>();
            expressionAttributeValues.put(
                ":rating", AttributeValue.builder().n(rating).build());

            UpdateItemRequest updateItemRequest = UpdateItemRequest.builder()
                .tableName(tableName)
                .key(key)
                .updateExpression("SET #rating = :rating")
                .conditionExpression("attribute_exists(Artist)")
                .expressionAttributeNames(expressionAttributeNames)
                .expressionAttributeValues(expressionAttributeValues)
                .build();

            UpdateItemResponse response = dynamoDbClient.updateItem(updateItemRequest);
            LOGGER.info("Conditional update successful - demonstrates strong consistency");

            return response;

        } catch (ConditionalCheckFailedException e) {
            LOGGER.warning("Conditional check failed: " + e.getMessage());
            throw e;
        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to perform conditional update: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to perform conditional update: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Espere a que las réplicas de MRSC y los testigos se activen mediante AWS SDK for Java 2.x.  

```
    public static void waitForMRSCReplicasActive(
        final DynamoDbClient dynamoDbClient, final String tableName, final int maxWaitTimeSeconds)
        throws InterruptedException {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (maxWaitTimeSeconds <= 0) {
            throw new IllegalArgumentException("Max wait time must be positive");
        }

        try {
            LOGGER.info("Waiting for MRSC replicas and witnesses to become active: " + tableName);

            final long startTime = System.currentTimeMillis();
            final long maxWaitTimeMillis = maxWaitTimeSeconds * 1000L;
            int backoffSeconds = 5; // Start with 5 second intervals
            final int maxBackoffSeconds = 30; // Cap at 30 seconds

            while (System.currentTimeMillis() - startTime < maxWaitTimeMillis) {
                DescribeTableResponse response = describeMRSCTable(dynamoDbClient, tableName);

                boolean allActive = true;
                StringBuilder statusReport = new StringBuilder();

                if (response.table().multiRegionConsistency() == null
                    || !MultiRegionConsistency.STRONG
                        .toString()
                        .equals(response.table().multiRegionConsistency().toString())) {
                    allActive = false;
                    statusReport
                        .append("MultiRegionConsistency: ")
                        .append(response.table().multiRegionConsistency())
                        .append(" ");
                }
                if (response.table().replicas() == null
                    || response.table().replicas().isEmpty()) {
                    allActive = false;
                    statusReport.append("No replicas found. ");
                }
                if (response.table().globalTableWitnesses() == null
                    || response.table().globalTableWitnesses().isEmpty()) {
                    allActive = false;
                    statusReport.append("No witnesses found. ");
                }

                // Check table status
                if (!"ACTIVE".equals(response.table().tableStatus().toString())) {
                    allActive = false;
                    statusReport
                        .append("Table: ")
                        .append(response.table().tableStatus())
                        .append(" ");
                }

                // Check replica status
                if (response.table().replicas() != null) {
                    for (var replica : response.table().replicas()) {
                        if (!"ACTIVE".equals(replica.replicaStatus().toString())) {
                            allActive = false;
                            statusReport
                                .append("Replica(")
                                .append(replica.regionName())
                                .append("): ")
                                .append(replica.replicaStatus())
                                .append(" ");
                        }
                    }
                }

                // Check witness status
                if (response.table().globalTableWitnesses() != null) {
                    for (var witness : response.table().globalTableWitnesses()) {
                        if (!"ACTIVE".equals(witness.witnessStatus().toString())) {
                            allActive = false;
                            statusReport
                                .append("Witness(")
                                .append(witness.regionName())
                                .append("): ")
                                .append(witness.witnessStatus())
                                .append(" ");
                        }
                    }
                }

                if (allActive) {
                    LOGGER.info("All MRSC replicas and witnesses are now active: " + tableName);
                    return;
                }

                LOGGER.info("Waiting for MRSC components to become active. Status: " + statusReport.toString());
                LOGGER.info("Next check in " + backoffSeconds + " seconds...");

                tempWait(backoffSeconds);

                // Exponential backoff with cap
                backoffSeconds = Math.min(backoffSeconds * 2, maxBackoffSeconds);
            }

            throw DynamoDbException.builder()
                .message("Timeout waiting for MRSC replicas to become active after " + maxWaitTimeSeconds + " seconds")
                .build();

        } catch (DynamoDbException | InterruptedException e) {
            LOGGER.severe("Failed to wait for MRSC replicas to become active: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Limpie las réplicas y los testigos de MRSC mediante AWS SDK for Java 2.x.  

```
    public static UpdateTableResponse cleanupMRSCReplicas(
        final DynamoDbClient dynamoDbClient,
        final String tableName,
        final Region replicaRegion,
        final Region witnessRegion) {

        if (dynamoDbClient == null) {
            throw new IllegalArgumentException("DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (replicaRegion == null) {
            throw new IllegalArgumentException("Replica region cannot be null");
        }
        if (witnessRegion == null) {
            throw new IllegalArgumentException("Witness region cannot be null");
        }

        try {
            LOGGER.info("Cleaning up MRSC replicas and witnesses for table: " + tableName);

            // Remove replica using ReplicationGroupUpdate
            ReplicationGroupUpdate replicaUpdate = ReplicationGroupUpdate.builder()
                .delete(DeleteReplicationGroupMemberAction.builder()
                    .regionName(replicaRegion.id())
                    .build())
                .build();

            // Remove witness
            GlobalTableWitnessGroupUpdate witnessUpdate = GlobalTableWitnessGroupUpdate.builder()
                .delete(DeleteGlobalTableWitnessGroupMemberAction.builder()
                    .regionName(witnessRegion.id())
                    .build())
                .build();

            UpdateTableRequest updateTableRequest = UpdateTableRequest.builder()
                .tableName(tableName)
                .replicaUpdates(List.of(replicaUpdate))
                .globalTableWitnessUpdates(List.of(witnessUpdate))
                .build();

            UpdateTableResponse response = dynamoDbClient.updateTable(updateTableRequest);
            LOGGER.info("MRSC cleanup initiated - removing replica and witness. Response: " + response);

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to cleanup MRSC replicas: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to cleanup MRSC replicas: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Complete la demostración del flujo de trabajo de MRSC mediante AWS SDK for Java 2.x.  

```
    public static void demonstrateCompleteMRSCWorkflow(
        final DynamoDbClient primaryClient,
        final DynamoDbClient replicaClient,
        final String tableName,
        final Region replicaRegion,
        final Region witnessRegion)
        throws InterruptedException {

        if (primaryClient == null) {
            throw new IllegalArgumentException("Primary DynamoDB client cannot be null");
        }
        if (replicaClient == null) {
            throw new IllegalArgumentException("Replica DynamoDB client cannot be null");
        }
        if (tableName == null || tableName.trim().isEmpty()) {
            throw new IllegalArgumentException("Table name cannot be null or empty");
        }
        if (replicaRegion == null) {
            throw new IllegalArgumentException("Replica region cannot be null");
        }
        if (witnessRegion == null) {
            throw new IllegalArgumentException("Witness region cannot be null");
        }

        try {
            LOGGER.info("=== Starting Complete MRSC Workflow Demonstration ===");

            // Step 1: Create an empty single-Region table
            LOGGER.info("Step 1: Creating empty single-Region table");
            createRegionalTable(primaryClient, tableName);

            // Use the existing GlobalTableOperations method for basic table waiting
            LOGGER.info("Intermediate step: Waiting for table [" + tableName + "] to become active before continuing");
            GlobalTableOperations.waitForTableActive(primaryClient, tableName);

            // Step 2: Convert to MRSC with replica and witness
            LOGGER.info("Step 2: Converting to MRSC with replica and witness");
            convertToMRSCWithWitness(primaryClient, tableName, replicaRegion, witnessRegion);

            // Wait for MRSC conversion to complete using MRSC-specific waiter
            LOGGER.info("Waiting for MRSC conversion to complete...");
            waitForMRSCReplicasActive(primaryClient, tableName);

            LOGGER.info("Intermediate step: Waiting for table [" + tableName + "] to become active before continuing");
            GlobalTableOperations.waitForTableActive(primaryClient, tableName);

            // Step 3: Verify MRSC configuration
            LOGGER.info("Step 3: Verifying MRSC configuration");
            describeMRSCTable(primaryClient, tableName);

            // Step 4: Test strong consistency with data operations
            LOGGER.info("Step 4: Testing strong consistency with data operations");

            // Add test item to primary region
            putTestItem(primaryClient, tableName, "The Beatles", "Hey Jude", "The Beatles 1967-1970", "1968");

            // Immediately read from replica region (no wait needed with MRSC)
            LOGGER.info("Reading from replica region immediately (strong consistency):");
            GetItemResponse getResponse =
                getItemWithConsistentRead(replicaClient, tableName, "The Beatles", "Hey Jude");

            if (getResponse.hasItem()) {
                LOGGER.info("✓ Strong consistency verified - item immediately available in replica region");
            } else {
                LOGGER.warning("✗ Item not found in replica region");
            }

            // Test conditional update from replica region
            LOGGER.info("Testing conditional update from replica region:");
            performConditionalUpdate(replicaClient, tableName, "The Beatles", "Hey Jude", "5");
            LOGGER.info("✓ Conditional update successful - demonstrates strong consistency");

            // Step 5: Cleanup
            LOGGER.info("Step 5: Cleaning up resources");
            cleanupMRSCReplicas(primaryClient, tableName, replicaRegion, witnessRegion);

            // Wait for cleanup to complete using basic table waiter
            LOGGER.info("Waiting for replica cleanup to complete...");
            GlobalTableOperations.waitForTableActive(primaryClient, tableName);

            // "Halt" until replica/witness cleanup is complete
            DescribeTableResponse cleanupVerification = describeMRSCTable(primaryClient, tableName);
            int backoffSeconds = 5; // Start with 5 second intervals
            while (cleanupVerification.table().multiRegionConsistency() != null) {
                LOGGER.info("Waiting additional time (" + backoffSeconds + " seconds) for MRSC cleanup to complete...");
                tempWait(backoffSeconds);

                // Exponential backoff with cap
                backoffSeconds = Math.min(backoffSeconds * 2, 30);
                cleanupVerification = describeMRSCTable(primaryClient, tableName);
            }

            // Delete the primary table
            deleteTable(primaryClient, tableName);

            LOGGER.info("=== MRSC Workflow Demonstration Complete ===");
            LOGGER.info("");
            LOGGER.info("Key benefits of Multi-Region Strong Consistency (MRSC):");
            LOGGER.info("- Immediate consistency across all regions (no eventual consistency delays)");
            LOGGER.info("- Simplified application logic (no need to handle eventual consistency)");
            LOGGER.info("- Support for conditional writes and transactions across regions");
            LOGGER.info("- Consistent read operations from any region without waiting");

        } catch (DynamoDbException | InterruptedException e) {
            LOGGER.severe("MRSC workflow failed: " + e.getMessage());
            throw e;
        }
    }
```
+ Para obtener detalles sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK for Java 2.x*.
  + [CreateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/CreateTable)
  + [DeleteTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DeleteTable)
  + [DescribeTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/DescribeTable)
  + [GetItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/GetItem)
  + [PutItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/PutItem)
  + [UpdateItem](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateItem)
  + [UpdateTable](https://docs.aws.amazon.com/goto/SdkForJavaV2/dynamodb-2012-08-10/UpdateTable)

------

# Seguridad de las tablas globales de DynamoDB
<a name="globaltables-security"></a>

Las réplicas de tablas globales son tablas de DynamoDB, por lo que se utilizan los mismos métodos para controlar el acceso a las réplicas que se utilizan para las tablas de una sola región, incluyendo las políticas de identidad y las políticas basadas en recursos de AWS Identity and Access Management (IAM).

En este tema, se describe cómo proteger las tablas globales de DynamoDB mediante permisos de IAM y cifrado de AWS Key Management Service (AWS KMS). Obtendrá información sobre los roles vinculados a servicios (SLR) que permiten la replicación y el escalado automático entre regiones, los permisos de IAM necesarios para crear, actualizar y eliminar tablas globales y las diferencias entre las tablas de coherencia final multirregional (MREC) y multirregional de coherencia sólida (MRSC). También obtendrá información sobre las claves de cifrado de AWS KMS para administrar de forma segura la replicación entre regiones.

## Roles vinculados a servicios para tablas globales
<a name="globaltables-slr"></a>

Las tablas globales de DynamoDB se basan en roles vinculados a servicios (SLR) para administrar la replicación entre regiones y las capacidades de escalado automático.

Solo tiene que configurar estos roles una vez por cuenta de AWS. Una vez creados, los mismos roles sirven en todas las tablas globales de la cuenta. Para obtener más información acerca de los roles vinculados a servicios, consulte [Uso de roles vinculados a servicios](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) en la *Guía del usuario de IAM*.

### Rol vinculado a servicios de replicación
<a name="globaltables-replication-slr"></a>

Amazon DynamoDB crea automáticamente el rol vinculado al servicio (SLR) `AWSServiceRoleForDynamoDBReplication` cuando se crea la primera tabla global. Este rol administra la replicación entre regiones por usted.

Al aplicar políticas basadas en recursos a las réplicas, asegúrese de no denegar ninguno de los permisos definidos en `AWSServiceRoleForDynamoDBReplicationPolicy` a la entidad principal de SLR, ya que esto interrumpiría la replicación. Si deniega los permisos de SLR necesarios, la replicación hacia y desde las réplicas afectadas se detendrá y el estado de la tabla de réplicas cambiará a `REPLICATION_NOT_AUTHORIZED`.
+ Para tablas globales de coherencia final multirregional (MREC), si una réplica permanece en el estado `REPLICATION_NOT_AUTHORIZED` durante más de 20 horas, la réplica se convierte irreversiblemente en una tabla de DynamoDB de una sola región.
+ Para las tablas globales de coherencia alta multirregionales (MRSC), la denegación de los permisos necesarios se traduce en `AccessDeniedException` para operaciones de escritura y lectura altamente coherentes. Si una réplica permanece en el estado `REPLICATION_NOT_AUTHORIZED` durante más de siete días, la réplica se vuelve permanentemente inaccesible y las operaciones de escritura y de lectura altamente coherentes seguirán produciendo un error. Algunas operaciones de administración, como la eliminación de réplicas, se realizarán correctamente.

### Rol vinculado a un servicio de escalado automático
<a name="globaltables-autoscaling-slr"></a>

Al configurar una tabla global para el modo de capacidad aprovisionada, se debe configurar el escalado automático para la tabla global. El escalado automático de DynamoDB utiliza el servicio de escalado automático de aplicaciones de AWS para ajustar dinámicamente la capacidad de rendimiento aprovisionada en las réplicas de tabla global. El servicio de escalado automático de aplicaciones crea un rol vinculado a un servicio (SLR) denominado [https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html). Este rol vinculado al servicio se crea automáticamente en la cuenta de AWS al configurar el escalado automático para una tabla de DynamoDB. Permite al escalado automático de aplicaciones administrar la capacidad de la tabla aprovisionada y crear alarmas de CloudWatch. 

 Al aplicar políticas basadas en recursos a las réplicas, asegúrese de no denegar ninguno de los permisos definidos en la [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html) a la entidad principal de SLR de escalado automático de aplicaciones, ya que esto interrumpiría la funcionalidad de escalado automático.

### Políticas de IAM de ejemplo para roles vinculados a servicios
<a name="globaltables-example-slr"></a>

Una política de IAM con la siguiente condición no afecta a los permisos necesarios para la SLR de replicación de DynamoDB y SLR de escalado automático de AWS. Esta condición se puede agregar a políticas que, de otro modo, serían ampliamente restrictivas para evitar interrumpir involuntariamente la replicación o el escalado automático.

#### Exclusión de los permisos de SLR necesarios de las políticas de denegación
<a name="example-exclude-slr-policy"></a>

En el siguiente ejemplo, se muestra cómo excluir a las entidades principales de roles vinculados al servicio de las instrucciones de denegación:

```
"Condition": {
    "StringNotEquals": {
        "aws:PrincipalArn": [
            "arn:aws::iam::111122223333:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication",
            "arn:aws::iam::111122223333:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable"
        ]
    }
}
```

## Uso de las tablas globales de AWS IAM
<a name="globaltables-iam"></a>

En las siguientes secciones, se describen los permisos necesarios para las distintas operaciones de las tablas globales y se proporcionan ejemplos de políticas que le ayudarán a configurar el acceso adecuado para los usuarios y aplicaciones.

**nota**  
Todos los permisos descritos se deben aplicar al ARN del recurso de tabla específico en las regiones afectadas. El ARN del recurso de tabla sigue el formato `arn:aws:dynamodb:region:account-id:table/table-name`, en el que debe especificar los valores reales de la región, el ID de cuenta y el nombre de la tabla.

**Topics**
+ [Creación de tablas globales y agregación de réplicas](#globaltables-creation-iam)
+ [Actualización de tablas globales](#globaltables-update-iam)
+ [Eliminación de tablas globales y réplicas](#globaltables-delete-iam)

### Creación de tablas globales y agregación de réplicas
<a name="globaltables-creation-iam"></a>

Las tablas globales de DynamoDB admiten dos modos de coherencia: coherencia final multirregional (MREC) y coherencia alta multirregional (MRSC). Las tablas globales de MREC pueden tener varias réplicas en cualquier número de regiones y proporcionar coherencia final. Las tablas globales de MRSC requieren exactamente tres regiones (tres réplicas o dos réplicas y un testigo) y proporcionan una coherencia sólida con un objetivo de punto de recuperación (RPO).

Los permisos necesarios para crear tablas globales dependen de si se crea una tabla global con o sin un testigo.

#### Permisos para crear tablas globales
<a name="globaltables-creation-iam-all-types"></a>

Los siguientes permisos son necesarios para la creación inicial de la tabla global y para agregar réplicas posteriormente. Estos permisos se aplican a las tablas globales de coherencia final multirregional (MREC) y coherencia alta multirregional (MRSC).
+ Las tablas globales requieren la replicación entre regiones, que DynamoDB administra mediante el rol vinculado a servicios [`AWSServiceRoleForDynamoDBReplication`](#globaltables-replication-slr) (SLR). El siguiente permiso permite a DynamoDB crear este rol automáticamente al crear una tabla global por primera vez:
  + `iam:CreateServiceLinkedRole`
+ Para crear una tabla global o agregar una réplica mediante la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), debe tener el siguiente permiso en el recurso de la tabla de origen:
  + `dynamodb:UpdateTable`
+ Debe tener los siguientes permisos en el recurso de la tabla en las regiones para que se agreguen las réplicas:
  + `dynamodb:CreateTable`
  + `dynamodb:CreateTableReplica`
  + `dynamodb:Query`
  + `dynamodb:Scan`
  + `dynamodb:UpdateItem`
  + `dynamodb:PutItem`
  + `dynamodb:GetItem`
  + `dynamodb:DeleteItem`
  + `dynamodb:BatchWriteItem`

#### Permisos adicionales para las tablas globales de MRSC mediante un testigo
<a name="globaltables-creation-iam-witness"></a>

Al crear una tabla global de coherencia alta multirregional (MRSC) con una región testigo, debe tener el siguiente permiso en el recurso de tabla en todas las regiones participantes (incluidas las regiones réplica y la región testigo):
+ `dynamodb:CreateGlobalTableWitness`

#### Políticas de IAM de ejemplo para crear tablas globales
<a name="globaltables-creation-iam-example"></a>

##### Creación de una tabla global de MREC o MRSC en tres regiones
<a name="globaltables-creation-iam-example-three-regions"></a>

La siguiente política basada en la identidad le permite crear una tabla global de MREC o MRSC denominada “usuarios” en tres regiones, incluida la creación del rol vinculado al servicio de replicación de DynamoDB necesario.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowCreatingUsersGlobalTable",
      "Effect": "Allow",
      "Action": [
        "dynamodb:CreateTable",
        "dynamodb:CreateTableReplica",
        "dynamodb:UpdateTable",
        "dynamodb:Query",
        "dynamodb:Scan",
        "dynamodb:UpdateItem",
        "dynamodb:PutItem",
        "dynamodb:GetItem",
        "dynamodb:DeleteItem",
        "dynamodb:BatchWriteItem"
      ],
      "Resource": [
        "arn:aws:dynamodb:us-east-1:123456789012:table/users",
        "arn:aws:dynamodb:us-east-2:123456789012:table/users",
        "arn:aws:dynamodb:us-west-2:123456789012:table/users"
      ]
    },
    {
      "Sid": "AllowCreatingSLR",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::123456789012:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication"
      ]
    }
  ]
}
```

------

##### Restricción de la creación de tablas globales de MREC o MRSC a regiones específicas
<a name="globaltables-creation-iam-example-restrict-regions"></a>

La siguiente política basada en la identidad le permite crear réplicas de tablas globales de DynamoDB en regiones específicas mediante la clave de condición [aws:RequestedRegion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion), incluida la creación del rol vinculado al servicio de replicación de DynamoDB necesario.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowAddingReplicasToSourceTable",
      "Effect": "Allow",
      "Action": [
        "dynamodb:UpdateTable"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:RequestedRegion": [
            "us-east-1"
          ]
        }
      }
    },
    {
      "Sid": "AllowCreatingReplicas",
      "Effect": "Allow",
      "Action": [
        "dynamodb:CreateTable",
        "dynamodb:CreateTableReplica",
        "dynamodb:UpdateTable",
        "dynamodb:Query",
        "dynamodb:Scan",
        "dynamodb:UpdateItem",
        "dynamodb:PutItem",
        "dynamodb:GetItem",
        "dynamodb:DeleteItem",
        "dynamodb:BatchWriteItem"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:RequestedRegion": [
            "us-east-2",
            "us-west-2"
          ]
        }
      }
    },
    {
      "Sid": "AllowCreatingSLR",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::123456789012:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication"
      ]
    }
  ]
}
```

------

##### Creación de una tabla global de MRSC con un testigo
<a name="globaltables-creation-iam-example-witness"></a>

La siguiente política basada en la identidad le permite crear una tabla global de MRSC de DynamoDB denominada “usuarios” con réplicas en us-east-1 y us-east-2 y un testigo en us-west-2, incluida la creación del rol vinculado al servicio de replicación de DynamoDB necesario.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowCreatingUsersGlobalTableWithWitness",
      "Effect": "Allow",
      "Action": [
        "dynamodb:CreateTable",
        "dynamodb:CreateTableReplica",
        "dynamodb:CreateGlobalTableWitness",
        "dynamodb:UpdateTable",
        "dynamodb:Query",
        "dynamodb:Scan",
        "dynamodb:UpdateItem",
        "dynamodb:PutItem",
        "dynamodb:GetItem",
        "dynamodb:DeleteItem",
        "dynamodb:BatchWriteItem"
      ],
      "Resource": [
        "arn:aws:dynamodb:us-east-1:123456789012:table/users",
        "arn:aws:dynamodb:us-east-2:123456789012:table/users"
      ]
    },
    {
      "Sid": "AllowCreatingSLR",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::123456789012:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication"
      ]
    }
  ]
}
```

------

##### Restricción de la creación de testigos de MRSC a regiones específicas
<a name="globaltables-creation-iam-example-restrict-witness-regions"></a>

Esta política basada en la identidad le permite crear una tabla global de MRSC con réplicas restringidas en regiones específicas mediante la clave de condición [aws:RequestedRegion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) y la creación de testigos sin restricción en todas las regiones, incluida la creación del rol vinculado al servicio de replicación de DynamoDB necesario.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowCreatingReplicas",
      "Effect": "Allow",
      "Action": [
        "dynamodb:CreateTable",
        "dynamodb:CreateTableReplica",
        "dynamodb:UpdateTable",
        "dynamodb:Query",
        "dynamodb:Scan",
        "dynamodb:UpdateItem",
        "dynamodb:PutItem",
        "dynamodb:GetItem",
        "dynamodb:DeleteItem",
        "dynamodb:BatchWriteItem"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:RequestedRegion": [
            "us-east-1",
            "us-east-2"
          ]
        }
      }
    },
    {
      "Sid": "AllowCreatingWitness",
      "Effect": "Allow",
      "Action": [
        "dynamodb:CreateGlobalTableWitness"
      ],
      "Resource": "*"
    },
    {
      "Sid": "AllowCreatingSLR",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::123456789012:role/aws-service-role/replication.dynamodb.amazonaws.com/AWSServiceRoleForDynamoDBReplication"
      ]
    }
  ]
}
```

------

### Actualización de tablas globales
<a name="globaltables-update-iam"></a>

Para modificar la configuración de réplica de una tabla global existente mediante la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), necesita el siguiente permiso en el recurso de tabla de la región en la que va a realizar la llamada a la API:
+ `dynamodb:UpdateTable`

Además, puede actualizar otras configuraciones de tablas globales, como las políticas de escalado automático y la configuración del tiempo de vida. Se requieren los siguientes permisos para estas operaciones de actualización adicionales:
+ Para actualizar una política de escalado automático de réplicas con la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html), debe tener los siguientes permisos en el recurso de la tabla en todas las regiones que contengan réplicas:
  + `application-autoscaling:DeleteScalingPolicy`
  + `application-autoscaling:DeleteScheduledAction`
  + `application-autoscaling:DeregisterScalableTarget`
  + `application-autoscaling:DescribeScalableTargets`
  + `application-autoscaling:DescribeScalingActivities`
  + `application-autoscaling:DescribeScalingPolicies`
  + `application-autoscaling:DescribeScheduledActions`
  + `application-autoscaling:PutScalingPolicy`
  + `application-autoscaling:PutScheduledAction`
  + `application-autoscaling:RegisterScalableTarget`
+ Para actualizar la configuración de Tiempo de vida con la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html), debe tener el siguiente permiso en el recurso de la tabla en todas las regiones que contienen réplicas:
  + `dynamodb:UpdateTimeToLive`

  Tenga en cuenta que el Tiempo de vida (TTL) solo se admite para tablas globales configuradas con coherencia final multirregional (MREC). Para obtener más información sobre cómo funcionan las tablas globales con TTL, consulte [Cómo funcionan las tablas globales de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html).

### Eliminación de tablas globales y réplicas
<a name="globaltables-delete-iam"></a>

Para eliminar una tabla global, debe eliminar todas las réplicas. Los permisos necesarios para esta operación varían en función de si se elimina una tabla global con o sin una región testigo.

#### Permisos para eliminar tablas globales y réplicas
<a name="globaltables-delete-iam-all-types"></a>

Los siguientes permisos son necesarios para eliminar réplicas individuales y para eliminar por completo tablas globales. Al eliminar una configuración de tabla global, solo se elimina la relación de replicación entre tablas de distintas regiones. No se eliminará la tabla de DynamoDB de la última región restante. La tabla de la última región sigue existiendo como tabla estándar de DynamoDB con los mismos datos y configuraciones. Estos permisos se aplican a las tablas globales de coherencia final multirregional (MREC) y coherencia alta multirregional (MRSC). 
+ Para eliminar réplicas de una tabla global mediante la API de [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), necesita el siguiente permiso en el recurso de tabla de la región desde la que va a realizar la llamada a la API:
  + `dynamodb:UpdateTable`
+ Necesita los siguientes permisos en el recurso de tabla en cada región en la que vaya a eliminar una réplica:
  + `dynamodb:DeleteTable`
  + `dynamodb:DeleteTableReplica`

#### Permisos adicionales para las tablas globales de MRSC mediante un testigo
<a name="globaltables-delete-iam-witness"></a>

Para eliminar una tabla global de coherencia alta multirregional (MRSC) con una región testigo, debe tener el siguiente permiso en el recurso de tabla en todas las regiones participantes (incluidas las regiones réplica y la región testigo):
+ `dynamodb:DeleteGlobalTableWitness`

#### Políticas de IAM de ejemplo para eliminar las réplicas de una tabla global
<a name="globaltables-delete-iam-example"></a>

##### Eliminación de réplicas de tablas globales
<a name="globaltables-delete-replicas-iam-example"></a>

Esta política basada en la identidad le permite eliminar una tabla global de DynamoDB denominada “usuarios” y sus réplicas en tres regiones:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:UpdateTable",
        "dynamodb:DeleteTable",
        "dynamodb:DeleteTableReplica"
      ],
      "Resource": [
        "arn:aws:dynamodb:us-east-1:123456789012:table/users",
        "arn:aws:dynamodb:us-east-2:123456789012:table/users",
        "arn:aws:dynamodb:us-west-2:123456789012:table/users"
      ]
    }
  ]
}
```

------

##### Eliminación de una tabla global de MRSC con un testigo
<a name="globaltables-delete-witness-iam-example"></a>

Esta política basada en la identidad le permite eliminar la réplica y el testigo de una tabla global de MRSC denominada “usuarios”:

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "dynamodb:UpdateTable",
        "dynamodb:DeleteTable",
        "dynamodb:DeleteTableReplica",
        "dynamodb:DeleteGlobalTableWitness"
      ],
      "Resource": [
        "arn:aws:dynamodb:us-east-1:123456789012:table/users",
        "arn:aws:dynamodb:us-east-2:123456789012:table/users"
      ]
    }
  ]
}
```

------

## Uso de las tablas globales de AWS KMS
<a name="globaltables-kms"></a>

Como todas las tablas de DynamoDB, las réplicas de tablas globales siempre cifran los datos en reposo mediante claves de cifrado almacenadas en AWS Key Management Service (AWS KMS).

Todas las réplicas de una tabla global se deben configurar con el mismo tipo de clave de KMS (clave propia de AWS, clave administrada de AWS o clave administrada por el cliente).

**importante**  
DynamoDB requiere acceso a la clave de cifrado de la réplica para eliminarla. Si desea desactivar o eliminar una clave administrada por el cliente que se utiliza para cifrar una réplica porque va a eliminar la réplica, primero debe eliminar la réplica, esperar a que el estado de la tabla en una de las réplicas restantes cambie a `ACTIVE` y luego desactivar o eliminar la clave.

Para una tabla global configurada para una coherencia final de varias regiones (MREC), si desactiva o revoca el acceso de DynamoDB a una clave administrada por el cliente que se utiliza para cifrar una réplica, la replicación hacia y desde la réplica se detendrá y el estado de la réplica cambiará a `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Si una réplica de una tabla global de MREC permanece en el estado `INACCESSIBLE_ENCRYPTION_CREDENTIALS` durante más de 20 horas, la réplica se convierte irreversiblemente en una tabla de DynamoDB de una sola región.

Para una tabla global configurada para una coherencia alta de varias regiones (MRSC), si desactiva o revoca el acceso de DynamoDB a una clave administrada por el cliente que se utiliza para cifrar una réplica, la replicación hacia y desde la réplica se detendrá, los intentos para realizar escrituras o lecturas altamente coherentes en la réplica devolverán un error y el estado de la réplica cambiará a `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Si una réplica de una tabla global de MRSC permanece en el estado `INACCESSIBLE_ENCRYPTION_CREDENTIALS` durante más de siete días, dependiendo de los permisos específicos revocados, la réplica se archivará o quedará inaccesible permanentemente.