# Tabela global da mesma conta do DynamoDB
As tabelas globais da mesma conta replicam automaticamente os dados da tabela do DynamoDB em várias regiões da AWS em uma única conta da AWS. As tabelas globais da mesma conta são o modelo mais simples para executar aplicações multirregionais porque todas as réplicas compartilham o mesmo modelo de limite de conta, propriedade e permissões. Quando você escolhe as regiões da AWS para suas tabelas-réplica, as tabelas globais lidam com todas as replicações automaticamente. As tabelas globais estão disponíveis em todas as regiões onde o DynamoDB está disponível.
As tabelas globais da mesma conta oferecem os seguintes benefícios:
+ Replicação automática dos dados da tabela do DynamoDB em todas as regiões da AWS de sua escolha para posicionar os dados mais perto dos usuários
+ Maior disponibilidade de aplicações durante isolamento ou degradação regional.
+ Utilização da resolução de conflitos integrada para que você possa se concentrar na lógica de negócios da sua aplicação.
+ Possibilidade de escolher entre [Consistência final multirregional (MREC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrec) ou [Consistência forte multirregional (MRSC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrsc) ao criar uma tabela global da mesma conta.
**Topics**
+ [Como funcionam as tabelas globais do DynamoDB](V2globaltables_HowItWorks.md)
+ [Tutoriais: Criação de tabelas globais](V2globaltables.tutorial.md)
+ [Segurança de tabelas globais do DynamoDB](globaltables-security.md)
# Como funcionam as tabelas globais do DynamoDB
As seções a seguir descrevem os conceitos e os comportamentos das tabelas globais no Amazon DynamoDB.
## Conceitos
*As tabelas globais* são um recurso do DynamoDB que replica os dados da tabela em todas as regiões da AWS.
Uma *tabela-réplica* (ou réplica) é uma única tabela do DynamoDB que funciona como parte de uma tabela global. Uma tabela global consiste em duas ou mais tabelas de réplica em diferentes regiões da AWS. Cada tabela global só pode ter uma réplica por região da AWS. Todas as réplicas em uma tabela global compartilham o mesmo nome da tabela, esquema de chave primária e dados do item.
Quando uma aplicação grava dados em uma réplica em uma região, o DynamoDB replica automaticamente a gravação para as outras réplicas na tabela global. Para obter mais informações sobre conceitos básicos de tabelas globais, consulte [Tutoriais: Criação de tabelas globais](V2globaltables.tutorial.md).
## Versões
Há duas versões disponíveis das tabelas globais do DynamoDB: versão 2019.11.21 (atual) e [versão 2017.11.29 (legada)](globaltables.V1.md). Você deve usar a versão 2019.11.21 (atual) sempre que possível. As informações nesta seção de documentação são para a versão 2019.11.21 (atual). Para obter mais informações, consulte [Determinar a versão de uma tabela global](V2globaltables_versions.md#globaltables.DetermineVersion).
## Disponibilidade
As tabelas globais ajudam a melhorar a continuidade de seus negócios, facilitando a implementação de uma arquitetura de alta disponibilidade multirregional. Se uma workload em uma única região da AWS se tornar prejudicada, você poderá transferir o tráfego do aplicativo para uma região diferente e executar leituras e gravações em uma tabela de réplica diferente na mesma tabela global.
Cada tabela de réplica em uma tabela global oferece a mesma durabilidade e disponibilidade de uma tabela do DynamoDB de região única. As tabelas globais oferecem um [Acordo de Serviço (SLA)](https://aws.amazon.com//dynamodb/sla/) com 99,999% de disponibilidade, em comparação com 99,99% das tabelas de região única.
## Modos de consistência
Ao criar uma tabela global, você pode configurar o modo de consistência. As tabelas globais permitem dois modos de consistência: consistência final multirregional (MREC) e consistência forte multirregional (MRSC).
Se você não especificar um modo de consistência ao criar uma tabela global, ela usará como padrão a consistência final multirregional (MREC). Uma tabela global não pode conter réplicas configuradas com modos de consistência diferentes. Não é possível alterar o modo de consistência de uma tabela global depois da criação.
### Consistência final multirregional (MREC)
A consistência final multirregional (MREC) é o modo de consistência padrão para tabelas globais. As alterações feitas em um item em uma réplica da tabela global MREC são replicadas de forma assíncrona em todas as outras réplicas, normalmente em um segundo ou menos. No caso improvável de uma réplica em uma tabela global do MREC ficar isolada ou danificada, todos os dados ainda não replicados para outras regiões serão replicados quando a réplica ficar íntegra.
Se o mesmo item for modificado em várias regiões simultaneamente, o DynamoDB resolverá o conflito usando a modificação com o registro de data e hora interno mais recente por item, conhecido como método de resolução de conflitos do tipo “último escritor vence”. Um item acabará por convergir em todas as réplicas para a versão criada pela última gravação.
[Operações de leitura altamente consistentes](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html#DDB-GetItem-request-ConsistentRead) retornam a versão mais recente de um item se ele tiver sido atualizado pela última vez na região onde a leitura ocorreu, mas podem retornar dados obsoletos se o item tiver sido atualizado pela última vez em uma região diferente. As gravações condicionais avaliam a expressão da condição em relação à versão do item na região.
Você cria uma tabela global MREC adicionando uma réplica a uma tabela existente do DynamoDB. Adicionar uma réplica não afeta o desempenho das tabelas existentes do DynamoDB de região única ou nas réplicas de tabelas globais existentes. Você pode adicionar réplicas a uma tabela global do MREC para expandir o número de regiões em que os dados são replicados ou remover réplicas de uma tabela global do MREC se elas não forem mais necessárias. Uma tabela global do MREC pode ter uma réplica em qualquer região onde o DynamoDB esteja disponível e pode ter quantas réplicas houver regiões na partição [AWS](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/partitions.html).
### Consistência forte multirregional (MRSC)
Você pode configurar o modo de consistência forte multirregional (MRSC) ao criar uma tabela global. As alterações de item em uma réplica da tabela global do MRSC são replicadas de forma síncrona em pelo menos uma outra região antes que a operação de gravação retorne uma resposta bem-sucedida. Operações de leitura altamente consistentes em qualquer réplica do MRSC sempre retornam a versão mais recente de um item. As gravações condicionais sempre avaliam a expressão da condição em relação à versão mais recente de um item.
Uma tabela global do MRSC deve ser implantada em exatamente três regiões. Você pode configurar uma tabela global MRSC com três réplicas ou duas réplicas e uma testemunha. Uma testemunha é um componente de uma tabela global com MRSC que contém dados gravados em réplicas da tabela global e pode ser usado opcionalmente no lugar de uma réplica completa, ao mesmo tempo em que é compatível com a arquitetura de disponibilidade de MRSC. Você não pode realizar operações de leitura ou gravação em uma testemunha. Uma testemunha está localizada em uma região diferente das duas réplicas. Ao criar uma tabela global do MRSC, você escolhe as regiões para suas réplicas e para a implantação da testemunha no momento da criação da tabela MRSC. Você pode determinar se e em qual região uma tabela global do MRSC tem uma testemunha configurada a partir da saída da API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). A testemunha pertence e é gerenciada pelo DynamoDB, e a testemunha não aparecerá na sua conta da AWS na região em que está configurada.
As tabelas globais com MRSC estão disponíveis nos seguintes conjuntos de regiões: dos EUA [Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio), Oeste dos EUA (Oregon)], da UE [Europa (Irlanda), Europa (Londres), Europa (Paris), Europa (Frankfurt)] e da Ásia-Pacífico [Ásia-Pacífico (Tóquio), Ásia-Pacífico (Seul) e Ásia-Pacífico (Osaka)]. As tabelas globais do MRSC não podem abranger conjuntos de regiões (por exemplo, uma tabela global do MRSC não pode conter réplicas dos conjuntos de regiões dos EUA e da UE).
Você cria uma tabela global MRSC adicionando uma réplica e uma testemunha ou duas réplicas a uma tabela existente do DynamoDB que não contém dados. Ao converter uma tabela de região única existente em uma tabela global com MRSC, é necessário garantir que a tabela esteja vazia. Não é possível converter uma tabela de região única em uma tabela global com MRSC que já contenha itens. Nenhum dado deve ser gravado na tabela durante o processo de conversão. Você não pode adicionar réplicas adicionais a uma tabela global MRSC existente. Não é possível excluir uma única réplica ou testemunha de uma tabela global do MRSC. Você pode excluir duas réplicas ou excluir uma réplica e uma testemunha de uma tabela global do MRSC, convertendo a réplica restante em uma tabela do DynamoDB de região única.
Uma operação de gravação falha com um erro `ReplicatedWriteConflictException` quando ela tenta modificar um item que já está sendo modificado em outra região. As gravações que falharem, exibindo o erro `ReplicatedWriteConflictException`, poderão ser repetidas e terão êxito se o item não estiver mais sendo modificado em outra região.
As seguintes considerações se aplicam às tabelas globais do MRSC:
+ Tempo de vida (TTL) não é aceito em tabelas globais do MRSC.
+ Índices secundários locais (LSIs) não são aceitos em tabelas globais do MRSC.
+ As informações do CloudWatch Contributor Insights são relatadas somente para a região em que uma operação ocorreu.
## Escolher um modo de consistência
O principal critério para escolher um modo de consistência multirregional é se seu aplicativo prioriza gravações de menor latência e leituras altamente consistentes ou prioriza uma consistência global forte.
As tabelas globais MREC terão latências de gravação e de leitura altamente consistente mais baixas em comparação às tabelas globais MRSC. As tabelas globais com MREC têm um objetivo de ponto de recuperação (RPO) igual ao atraso de replicação entre as réplicas, geralmente de alguns segundos, dependendo das regiões da réplica.
Você deve usar o modo MREC quando:
+ A aplicação pode tolerar dados obsoletos exibidos por operações de leitura altamente consistente se esses dados tiverem sido atualizados em outra região.
+ Você prioriza latências de gravação e de leitura altamente consistente mais baixas em relação à consistência de leitura multirregional.
+ Sua estratégia de alta disponibilidade multirregional pode tolerar um RPO maior que zero.
As tabelas globais MRSC terão latências de gravação e leitura altamente consistente mais altas em comparação às tabelas globais MREC. As tabelas globais do MRSC oferecem suporte a um objetivo de ponto de recuperação (RPO) de zero.
É necessário usar o modo MRSC quando:
+ Você precisa de leituras altamente consistentes em várias regiões.
+ Você prioriza a consistência global de leitura em detrimento da menor latência de gravação.
+ Sua estratégia de alta disponibilidade multirregional exige um RPO igual a zero.
## Monitorar tabelas globais
Tabelas globais configuradas para consistência final em várias regiões (MREC) publicam a métrica [`ReplicationLatency`](metrics-dimensions.md#ReplicationLatency) no CloudWatch. Essa métrica controla o tempo decorrido entre quando um item foi gravado em uma tabela-réplica e quando esse item aparece em outra réplica na tabela global. `ReplicationLatency` é expresso em milissegundos e é emitido para cada par de regiões de origem e destino em uma tabela global.
Os valores típicos de `ReplicationLatency` dependem da distância entre as regiões da AWS escolhidas, bem como de outras variáveis como tipo de workload e throughput. Por exemplo, uma réplica de origem na região Oeste dos EUA (N. da Califórnia) (us-west-1) tem uma `ReplicationLatency` menor para a região Oeste dos EUA (Oregon) (us-west-2) em comparação com a região África (Cidade do Cabo) (af-south-1).
Um valor elevado para `ReplicationLatency` pode indicar que as atualizações de uma réplica não se propagaram para outras tabelas-réplica em tempo hábil. Nesse caso, você pode redirecionar temporariamente as atividades de leitura e gravação da aplicação para outra região da AWS.
As tabelas globais configuradas para consistência forte multirregional (MRSC) não publicam uma métrica de `ReplicationLatency`.
## Teste de injeção de falhas
As tabelas globais MREC e MRSC integram-se ao [Serviço de Injeção de Falhas da AWS](https://docs.aws.amazon.com/resilience-hub/latest/userguide/testing.html) (AWS FIS), um serviço totalmente gerenciado para executar experimentos de injeção de falhas controladas para melhorar a resiliência de uma aplicação. Por meio do AWS FIS, é possível:
+ Criar modelos de experimentos que definam cenários de falha específicos.
+ Injetar falhas para validar a resiliência da aplicação simulando o isolamento de região (isto é, pausando a replicação de e para uma réplica selecionada) para testar o tratamento de erros, os mecanismos de recuperação e o comportamento de mudança de tráfego em várias regiões quando uma região da AWS sofre interrupções.
Por exemplo, em uma tabela global com réplicas nas regiões Leste dos EUA (Norte da Virgínia), Leste dos EUA (Ohio) e Oeste dos EUA (Oregon), é possível executar um experimento na região Leste dos EUA (Ohio) para testar o isolamento de região lá e, ao mesmo tempo, continuar as operações normais na região Oeste dos EUA (Oregon). Esse teste controlado ajuda você a identificar e resolver possíveis problemas antes que eles afetem as workloads de produção.
Consulte [Destinos da ação](https://docs.aws.amazon.com/fis/latest/userguide/action-sequence.html#action-targets) no *Guia do usuário do AWS FIS* para ver uma lista completa das ações permitidas pelo AWS FIS e da [conectividade entre regiões](https://docs.aws.amazon.com/fis/latest/userguide/cross-region-scenario.html) para pausar a replicação do DynamoDB entre regiões.
Para ter informações sobre as ações de tabelas globais do Amazon DynamoDB disponíveis no AWS FIS, consulte [Referência de ações de tabelas globais do DynamoDB](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#dynamodb-actions-reference) no *Guia do usuário do AWS*.
Para começar a realizar experimentos de injeção de falhas, consulte [Planejar experimentos do AWS FIS](https://docs.aws.amazon.com/fis/latest/userguide/getting-started-planning.html) no “Guia do usuário do AWS FIS”.
**nota**
Durante experimentos do AWS FIS no modo de consistência forte multirregional (MRSC), leituras finais consistentes são permitidas, mas atualizações de configuração de tabela, como alterar o modo de cobrança ou configurar o throughput da tabela, não são permitidas, de maneira semelhante ao modo de consistência final multirregional (MREC). Verifique a métrica [`FaultInjectionServiceInducedErrors`](metrics-dimensions.md#FaultInjectionServiceInducedErrors) do CloudWatch para ver detalhes adicionais sobre o código de erro.
## Vida útil (TTL)
As tabelas globais configuradas para o MREC dão suporte à configuração da exclusão [Time To Live](TTL.md) (TTL). As configurações de TTL são sincronizadas automaticamente para todas as réplicas em uma tabela global. Quando o TTL exclui um item de uma réplica em uma região, a exclusão é replicada para todas as outras réplicas na tabela global. O TTL não consome capacidade de gravação, portanto, você não é cobrado pela exclusão TTL na região em que a exclusão ocorreu. No entanto, você é cobrado pela exclusão replicada em cada outra região com uma réplica na tabela global.
A replicação de exclusão TTL consome capacidade de gravação nas réplicas nas quais a exclusão está sendo replicada. As réplicas configuradas para capacidade provisionada podem limitar as solicitações de controle de utilização se a combinação de throughput de gravação e throughput de exclusão TTL for maior que a capacidade de gravação provisionada.
As tabelas globais configuradas para consistência forte multirregional (MRSC) não suportam a configuração da exclusão Time To Live (TTL).
## Fluxos
As tabelas globais configuradas para consistência final multirregional (MREC) replicam as alterações lendo essas alterações de um [DynamoDB Stream](Streams.md) em uma tabela de réplica e aplicando essa alteração a todas as outras tabelas de réplica. Portanto, os streams são habilitados por padrão em todas as réplicas em uma tabela global do MREC e não podem ser desativados nessas réplicas. O processo de replicação do MREC pode combinar várias alterações em um curto período de tempo em uma única gravação replicada, resultando em cada fluxo de réplica contendo registros ligeiramente diferentes. Os registros de streams em réplicas do MREC são sempre ordenados por item, mas a ordenação entre itens pode ser diferente entre as réplicas.
As tabelas globais configuradas para consistência forte multirregionais (MRSC) não usam o DynamoDB Streams para replicação, portanto, o Streams não é habilitado por padrão nas réplicas do MRSC. Você pode habilitar o Streams em uma réplica do MRSC. Os registros de streams nas réplicas do MRSC são idênticos para cada réplica, incluindo a ordenação dos registros do Stream.
Se você quiser escrever um aplicativo que processe registros do Streams para alterações que ocorreram em uma determinada região, mas não em outras em uma tabela global, você pode adicionar um atributo a cada item que define em qual região a alteração desse item ocorreu. Você pode usar esse atributo para filtrar os registros do Streams em busca de alterações que ocorreram em outras regiões, incluindo o uso de filtros de eventos do Lambda para invocar somente as funções do Lambda para alterações em uma região específica.
## Transações
Em uma tabela global configurada para MREC, as operações de transação ([https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) e [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactGetItems.html)) do DynamoDB são atômicas somente na região em que a operação foi invocada. As gravações transacionais não são replicadas como uma unidade em todas as regiões, o que significa que somente algumas das gravações em uma transação podem ser retornadas por operações de leitura em outras réplicas em um determinado momento.
Por exemplo, se você tiver uma tabela global com réplicas nas regiões Leste dos EUA (Ohio) e Oeste dos EUA (Oregon) e realizar uma operação `TransactWriteItems` na região Leste dos EUA (Ohio), poderá observar transações parcialmente concluídas na região Oeste dos EUA (Oregon) à medida que as alterações forem replicadas. As alterações só serão replicadas para outras regiões quando forem confirmadas na região de origem.
As tabelas globais configuradas para consistência forte multirregional (MRSC) não dão suporte a operações de transação e retornarão um erro se essas operações forem invocadas em uma réplica do MRSC.
## Throughput de leitura e gravação
### Modo provisionado
A replicação consome capacidade de gravação. As réplicas configuradas para capacidade provisionada podem controlar a utilização de solicitações se a soma do throughput de gravação de aplicação e do throughput de gravação de replicação ultrapassar a capacidade de gravação provisionada. Para tabelas globais que usam o modo provisionado, as configurações de ajuste de escala automático das capacidades de leitura e gravação são sincronizadas entre as réplicas.
É possível definir de forma independente as configurações de capacidade de leitura para cada réplica em uma tabela global usando o parâmetro [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html) em nível de réplica. Por padrão, as alterações na capacidade de leitura provisionada são aplicadas a todas as réplicas na tabela global. Ao adicionar uma nova réplica a uma tabela global, a capacidade de leitura da tabela ou réplica de origem é usada como valor inicial, a menos que uma substituição em nível de réplica seja especificada explicitamente.
### Modo sob demanda
Para tabelas globais configuradas para o modo sob demanda, a capacidade de gravação é sincronizada automaticamente em todas as réplicas. O DynamoDB ajusta automaticamente a capacidade com base no tráfego, e não há configurações de capacidade de leitura ou gravação específicas da réplica para gerenciar.
## Sincronização das configurações
As configurações nas tabelas globais do DynamoDB são parâmetros de configuração que controlam vários aspectos do comportamento e da replicação da tabela. Essas configurações são gerenciadas por meio das APIs do ambiente de gerenciamento do DynamoDB e podem ser configuradas ao criar ou modificar tabelas globais. As tabelas globais sincronizam automaticamente determinadas configurações em todas as réplicas para manter a consistência e, ao mesmo tempo, permitir flexibilidade para otimizações específicas da região. Entender quais configurações são sincronizadas e como elas se comportam ajuda você a configurar sua tabela global de forma eficaz. As configurações se dividem em três categorias principais com base em como elas são sincronizadas entre as réplicas.
As configurações a seguir são sempre sincronizadas entre as réplicas em uma tabela global:
+ Modo de capacidade (capacidade provisionada ou sob demanda)
+ Capacidade de gravação provisionada da tabela
+ Ajuste de escala automático de gravação da tabela
+ Definição de atributo do esquema de chaves
+ Definição do Índice Secundário Global (GSI)
+ Capacidade de gravação provisionada do GSI
+ Ajuste de escala automático de gravação do GSI
+ Tipo de criptografia do lado do servidor (SSE)
+ Definição de streams no modo MREC
+ Vida útil (TTL)
+ Throughput a quente
+ Throughput máximo de gravação sob demanda
As configurações a seguir são sincronizadas entre as réplicas, mas podem ser substituídas por réplica:
+ Capacidade de leitura provisionada da tabela
+ Ajuste de escala automático de leitura de tabela
+ Capacidade de leitura provisionadas do GSI
+ Ajuste de escala automático de leitura do GSI
+ Classe de tabela
+ Throughput máximo de leitura sob demanda
**nota**
Os valores de configuração substituíveis são alterados se a configuração for modificada em qualquer outra réplica. Como exemplo, você tem uma tabela global do MREC com réplicas nas regiões Leste dos EUA (Norte da Virgínia) e Oeste dos EUA (Oregon). A réplica do Leste dos EUA (Norte da Virgínia) tem o throughput de leitura provisionada definido para 200 RCUs. A réplica no Oeste dos EUA (Oregon) tem a substituição do throughput de leitura provisionada definido para 100 RCUs. Se você atualizar a configuração de throughput de leitura provisionada na réplica do Leste dos EUA (Norte da Virgínia) de 200 RCUs para 300 RCUs, o novo valor da taxa de transferência de leitura provisionada também será aplicado à réplica no Oeste dos EUA (Oregon). Isso altera a configuração de throughput de leitura provisionada para a réplica do Oeste dos EUA (Oregon) do valor substituído de 100 RCUs para o novo valor de 300 RCUs.
As configurações a seguir nunca são sincronizadas entre as réplicas:
+ Proteção contra exclusão
+ Recuperação para um ponto no tempo
+ Tags
+ Habilitação da tabela do CloudWatch Contributor Insights
+ Habilitação do GSI do CloudWatch Contributor Insights
+ Definição do Kinesis Data Streams
+ Políticas de recursos
+ Definição de streams no modo MRSC
Todas as outras configurações não são sincronizadas entre as réplicas.
## DynamoDB Accelerator (DAX)
As gravações em réplicas de tabelas globais ignoram o DynamoDB Accelerator (DAX), atualizando o DynamoDB diretamente. Como resultado, os caches do DAX podem ficar obsoletos, pois as gravações não estão atualizando o cache do DAX. Os caches do DAX configurados para réplicas de tabelas globais só serão atualizados quando o TTL do cache expirar.
## Considerações para gerenciar tabelas globais
Você não pode excluir uma tabela usada para adicionar uma nova réplica de tabela global até que tenham decorrido 24 horas desde que a nova réplica foi criada.
Se você desabilitar uma região da AWS que contém réplicas de tabelas globais, essas réplicas serão convertidas permanentemente em tabelas de região única 20 horas após a desativação da região.
# Tutoriais: Criação de tabelas globais
Esta seção fornece instruções passo a passo para criar tabelas globais do DynamoDB configuradas para o modo de consistência preferido. Escolha entre os modos consistência final multirregional (MREC) ou consistência forte multirregional (MRSC) com base nos requisitos do seu aplicativo.
As tabelas globais MREC fornecem menor latência de gravação com consistência final entre Regiões da AWS. As tabelas globais MRSC fornecem leituras altamente consistentes em todas as regiões com latências de gravação ligeiramente maiores do que as do MREC. Escolha o modo de consistência que melhor atenda às necessidades de consistência, latência e disponibilidade dos dados do seu aplicativo.
**Topics**
+ [Criação de uma tabela global configurada para MREC](#V2creategt_mrec)
+ [Criação de uma tabela global configurada para MRSC](#create-gt-mrsc)
## Criação de uma tabela global configurada para MREC
Esta seção mostra como criar uma tabela global com o modo consistência final multirregional (MREC). MREC é o modo de consistência padrão para tabelas globais e fornece gravações de baixa latência com replicação assíncrona em Regiões da AWS. As alterações feitas em um item em uma região geralmente são replicadas em todas as outras regiões em um segundo. Isso torna o MREC ideal para aplicativos que priorizam a baixa latência de gravação e podem tolerar breves períodos em que diferentes regiões podem retornar versões de dados ligeiramente diferentes.
Você pode criar tabelas globais MREC com réplicas em qualquer região da AWS que o DynamoDB esteja disponível e adicionar ou remover réplicas a qualquer momento. Os exemplos a seguir mostram como criar uma tabela global MREC com réplicas em várias regiões.
### Criação de uma tabela global MREC usando o DynamoDB Console
Siga estas etapas para criar uma tabela global usando o Console de gerenciamento da AWS. O exemplo a seguir cria uma tabela global com tabelas-réplica nos Estados Unidos e na Europa.
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. Para este exemplo, escolha **Leste dos EUA (Ohio)** no seletor de região na barra de navegação.
1. No painel de navegação, no lado esquerdo do console, selecione **Tables** (Tabelas).
1. Selecione **Create Table** (Criar tabela).
1. Na página **Criar tabela**:
1. Em **Table name** (Nome da tabela), insira **Music**.
1. Em **Partition key**, (Chave de partição), insira **Artist**.
1. Em **Chave de classificação**, insira **SongTitle**.
1. Mantenha o restante das configurações padrão e escolha **Criar tabela**.
Essa nova tabela serve como a primeira tabela de réplica em uma nova tabela global. Ela é o protótipo das outras tabelas-réplica que serão adicionadas posteriormente.
1. Depois que a tabela ficar ativa:
1. Selecione a tabela **Music** (Música) na lista de tabelas.
1. Selecione a guia **Global Tables (Tabelas globais)**.
1. Escolha **Create replica (Criar réplica)**.
1. Na lista suspensa **Regiões de replicação disponíveis**, escolha **US West (Oregon) us-west-2** (Oeste dos EUA [Oregon], us-west-2).
O console garante que não exista uma tabela com o mesmo nome na região selecionada. Se existir uma tabela com o mesmo nome, será necessário excluir a tabela existente para criar outra tabela-réplica nessa região.
1. Escolha **Create replica (Criar réplica)**. Isso inicia o processo de criação da tabela na região Oeste dos EUA (Oregon), us-west-2.
A guia **Tabelas globais** da tabela **Music** (e de qualquer outra tabela-réplica) mostra que a tabela foi replicada em várias regiões.
1. Adicione outra região repetindo as etapas anteriores, mas escolha **Europa (Frankfurt) eu-central-1** como região.
1. Como testar a replicação:
1. Continue usando o Console de gerenciamento da AWS na região Leste dos EUA (Ohio).
1. Escolha **Explore table items** (Explorar itens da tabela).
1. Selecione **Create Item** (Criar item).
1. Insira **item\$11** para **Artist (Artista)** e **Song Value 1** para **SongTitle (Título da música)**.
1. Selecione **Create Item** (Criar item).
1. Verifique a replicação mudando para outras regiões:
1. No seletor de regiões no canto superior direito, escolha **Europa (Frankfurt)**.
1. Verifique se a tabela **Music (Música)** contém o item que você criou.
1. Repita a verificação para **Oeste dos EUA (Oregon)**.
### Criar uma tabela global MREC usando a AWS CLI ou Java
------
#### [ CLI ]
O exemplo de código a seguir mostra como gerenciar tabelas globais do DynamoDB com consistência final de replicação mutirregional (MREC).
+ Crie uma tabela com replicação mutirregional (MREC).
+ Insira e obtenha itens de tabelas-réplica.
+ Remova as réplicas uma por uma.
+ Exclua a tabela para fazer uma limpeza.
**AWS CLI com script Bash**
Crie uma tabela com replicação mutirregional.
```
# 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
```
Descreva a tabela multirregional.
```
# 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}}'
```
Insira itens em uma tabela-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
```
Obtenha itens de tabelas-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
```
Remova as 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
```
Exclua a tabela para fazer uma limpeza.
```
# Clean up: Delete the primary table
aws dynamodb delete-table --table-name MusicTable --region us-east-2
echo "Global table demonstration complete."
```
+ Consulte detalhes da API nos tópicos a seguir na *Referência de comandos da 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 ]
O exemplo de código a seguir mostra como criar e gerenciar tabelas globais do DynamoDB com réplicas entre várias regiões.
+ Crie uma tabela com um índice secundário global e DynamoDB Streams.
+ Adicione réplicas em diferentes regiões para criar uma tabela global.
+ Remova réplicas de uma tabela global.
+ Adicione itens de teste para verificar a replicação entre regiões.
+ Descreva a configuração da tabela global e o status da réplica.
**SDK para Java 2.x**
Crie uma tabela com um índice secundário global e DynamoDB Streams usando 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;
}
}
```
Aguarde até que uma tabela se torne ativa usando 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;
}
}
```
Adicione uma réplica para criar ou estender uma tabela global usando 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;
}
}
```
Remova uma réplica de uma tabela global usando 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;
}
}
```
Adicione itens de teste para verificar a replicação usando 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 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;
}
}
```
Descreva a configuração e as réplicas da tabela global usando 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;
}
}
```
Exemplo completo de operações de tabela global usando 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 obter detalhes da API, consulte os tópicos a seguir na *Referência da API 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)
------
## Criação de uma tabela global configurada para MRSC
Esta seção mostra como criar uma tabela global de consistência forte multirregional (MRSC). As tabelas globais do MRSC replicam de forma síncrona as alterações de itens em todas as regiões, garantindo que as operações de leitura altamente consistentes em qualquer réplica sempre retornem a versão mais recente de um item. Ao converter uma tabela de região única em uma tabela global com MRSC, você deve garantir que a tabela esteja vazia. Não é possível converter uma tabela de região única em uma tabela global com MRSC que já contenha itens. Nenhum dado deve ser gravado na tabela durante o processo de conversão.
Você pode configurar uma tabela global MRSC com três réplicas ou duas réplicas e uma testemunha. Ao criar uma tabela global do MRSC, você escolhe as regiões em que as réplicas e uma testemunha opcional são implantadas. O exemplo a seguir cria uma tabela global MRSC com réplicas nas regiões Leste dos EUA (Norte da Virgínia) e Leste dos EUA (Ohio), com uma testemunha na região Oeste dos EUA (Oregon).
**nota**
Antes de criar uma tabela global, verifique se os limites de throughput da cota de serviço são consistentes em todas as regiões de destino, pois isso é necessário para criar uma tabela global. Para ter mais informações sobre os limites globais de throughput de tabelas, consulte as [cotas para tabelas globais](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ServiceQuotas.html#gt-limits-throughput).
### Criação de uma tabela global MRSC usando o DynamoDB Console
Siga estas etapas para criar uma tabela global MRSC usando o Console de gerenciamento da AWS.
1. Faça login no Console de gerenciamento da AWS e abra o console do DynamoDB em [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. No seletor de regiões na barra de navegação, escolha a região onde as tabelas globais com MRSC são [aceitas](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes), por exemplo, **us-east-2**.
1. No painel de navegação, selecione **Tabelas**.
1. Escolha **Criar tabela**.
1. Na página **Criar tabela**:
1. Em **Table name** (Nome da tabela), insira **Music**.
1. Para a **Chave de partição**, insira **Artist** e mantenha o tipo **String** padrão.
1. Em **Chave de classificação**, insira **SongTitle** e mantenha o tipo **String** padrão.
1. Mantenha o restante das configurações padrão e escolha **Criar tabela**.
Essa nova tabela serve como a primeira tabela de réplica em uma nova tabela global. Ela é o protótipo das outras tabelas-réplica que serão adicionadas posteriormente.
1. Aguarde até que a tabela fique ativa e, em seguida, selecione-a na lista de tabelas.
1. Selecione a guia **Tabelas globais** e escolha **Criar réplica**.
1. Na página **Criar réplica**:
1. Em **Consistência multirregional**, escolha **Consistência forte**.
1. Para a **Região de Replicação 1**, escolha **US East (N. Virginia) us-east-1**.
1. Para a **Região de Replicação 2**, escolha **US West (Oregon) us-west-2**.
1. Marque **Configurar como Testemunha** para a região Oeste dos EUA (Oregon).
1. Escolha **Criar réplicas**.
1. Aguarde a conclusão do processo de criação da réplica e da testemunha. O status da tabela será exibido como **Ativo** quando a tabela estiver pronta para uso.
### Criar uma tabela global MRSC usando a AWS CLI ou Java
Antes de começar, verifique se a entidade principal do IAM tem as permissões necessárias para criar uma tabela global com MRSC com uma região testemunha.
O seguinte exemplo de política do IAM permite que você crie uma tabela do DynamoDB (`MusicTable`) no Leste dos EUA (Ohio) com uma réplica no Leste dos EUA (Norte da Virgínia) e uma região testemunha no Oeste dos EUA (Oregon):
------
#### [ 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"
}
}
}
]
}
```
------
O exemplo de código a seguir mostra como criar e gerenciar tabelas globais do DynamoDB com consistência forte multirregional (MRSC).
+ Crie uma tabela com consistência forte multirregional.
+ Verifique a configuração de MRSC e o status da réplica.
+ Teste a consistência forte entre regiões com leituras imediatas.
+ Faça gravações condicionais com garantia de MRSC.
+ Limpe os recursos da tabela global com MRSC.
------
#### [ Bash ]
**AWS CLI com script Bash**
Crie uma tabela com consistência forte multirregional.
```
# 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 a configuração de MRSC e o status da 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}}'
```
Teste a consistência forte com leituras imediatas entre regiões.
```
# 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
```
Faça gravações condicionais com garantia 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
```
Limpe os recursos da tabela global com 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
```
+ Consulte detalhes da API nos tópicos a seguir na *Referência de comandos da 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**
Crie uma tabela regional pronta para conversão MRSC usando 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();
}
}
```
Converta uma tabela regional para MRSC com réplicas e testemunhas usando 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();
}
}
```
Descreva uma configuração de tabela global do MRSC usando 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();
}
}
```
Adicione itens de teste para verificar a forte consistência do MRSC usando 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 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();
}
}
```
Leia itens com leituras consistentes de réplicas do MRSC usando 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 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();
}
}
```
Faça atualizações condicionais com garantias de MRSC usando 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 key = new HashMap<>();
key.put("Artist", AttributeValue.builder().s(artist).build());
key.put("SongTitle", AttributeValue.builder().s(songTitle).build());
Map expressionAttributeNames = new HashMap<>();
expressionAttributeNames.put("#rating", "Rating");
Map 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();
}
}
```
Aguarde até que as réplicas e testemunhas do MRSC se tornem ativas usando 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;
}
}
```
Limpe as réplicas e testemunhas do MRSC usando 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();
}
}
```
Demonstração completa do fluxo de trabalho do MRSC usando 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 obter detalhes da API, consulte os tópicos a seguir na *Referência da API 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)
------
# Segurança de tabelas globais do DynamoDB
As réplicas de tabelas globais são tabelas do DynamoDB, então você usa os mesmos métodos para controlar o acesso às réplicas que usa para tabelas de região única, incluindo políticas de identidade e políticas baseadas em recursos do AWS Identity and Access Management (IAM).
Este tópico aborda como proteger tabelas globais do DynamoDB usando permissões do IAM e criptografia AWS Key Management Service (AWS KMS). Você aprenderá mais sobre os perfis vinculados a serviços (SLR) que permitem a replicação e o ajuste de escala automático entre regiões, as permissões do IAM necessárias para criar, atualizar e excluir tabelas globais e as diferenças entre as tabelas com consistência final multirregional (MREC) e com consistência forte multirregional (MRSC). Você também aprenderá mais sobre chaves de criptografia do AWS KMS para gerenciar a replicação entre regiões com segurança.
## Perfis vinculados a serviços para tabelas globais
As tabelas globais do DynamoDB dependem de perfis vinculados a serviços (SLRs) para gerenciar a replicação entre regiões e os recursos de ajuste de escala automático.
Você precisa configurar esses perfis somente uma vez por conta da AWS. Depois de criados, os mesmos perfis atendem a todas as tabelas globais da sua conta. Para ter mais informações sobre perfis vinculados ao serviço, consulte [Criar um perfil vinculado ao serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) no *Guia do usuário do IAM*.
### Função vinculada ao serviço de replicação
O Amazon DynamoDB cria automaticamente o perfil vinculado a serviços `AWSServiceRoleForDynamoDBReplication` (SLR) quando você cria sua primeira tabela global. Esse perfil gerencia a replicação entre regiões para você.
Ao aplicar políticas baseadas em recursos às réplicas, não negue nenhuma das permissões definidas em `AWSServiceRoleForDynamoDBReplicationPolicy` à entidade principal SLR, pois isso interromperá a replicação. Se você negar as permissões SLR necessárias, a replicação de e para as réplicas afetadas será interrompida e o status da tabela de réplicas mudará para `REPLICATION_NOT_AUTHORIZED`.
+ No caso de tabelas globais de consistência eventual multirregional (MREC), se uma réplica permanecer no estado `REPLICATION_NOT_AUTHORIZED` por mais de 20 horas, ela será convertida irreversivelmente em uma tabela do DynamoDB de região única.
+ Para tabelas globais de consistência forte multirregional (MRSC), negar as permissões necessárias resulta em `AccessDeniedException` para operações de gravação e leitura altamente consistente. Se uma réplica permanecer no estado `REPLICATION_NOT_AUTHORIZED` por mais de sete dias, a réplica ficará permanentemente inacessível e as operações de gravação e leitura altamente consistentes continuarão falhando com um erro. Algumas operações de gerenciamento, como a exclusão de réplicas, serão bem-sucedidas.
### Função vinculada a serviço do IAM para ajuste de escala automático
Quando você configura uma tabela global para o modo de capacidade provisionada, também deve configurar o ajuste de escala automático para ela. O ajuste de escala automático do DynamoDB usa o serviço AWS Application Auto Scaling para ajustar dinamicamente a capacidade de throughput em suas réplicas de tabela global. O serviço Application Auto Scaling cria um perfil vinculado ao serviço (SLR) chamado [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). Esse perfil vinculado a serviços é criado automaticamente em sua conta da AWS quando você configura o ajuste de escala automático para uma tabela do DynamoDB. Ele permite que o Application Auto Scaling gerencie a capacidade provisionada da tabela e crie alarmes do CloudWatch.
Quando você aplicar políticas baseadas em recursos às réplicas, não negue nenhuma das permissões definidas em [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html) à entidade principal de SLR do Application Auto Scaling, pois isso interromperá a funcionalidade de ajuste de escala automático.
### Exemplo de políticas do IAM para perfis vinculados a serviços
Uma política do IAM com a condição a seguir não afeta as permissões necessárias para a SLR de replicação e a SLR de ajuste de escala automático da AWS do DynamoDB. Essa condição pode ser adicionada a políticas amplamente restritivas para evitar a interrupção involuntária da replicação ou do ajuste de escala automático:
#### Excluir as permissões SLR necessárias das políticas de negação
O exemplo a seguir mostra como excluir as entidades principais do perfil vinculado a serviços das instruções de negação:
```
"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"
]
}
}
```
## Como as tabelas globais usam o IAM da AWS
As seções a seguir descrevem as permissões necessárias para diferentes operações de tabela global e contêm exemplos de políticas para ajudar você a configurar o acesso apropriado para seus usuários e aplicações.
**nota**
Todas as permissões descritas devem ser aplicadas ao ARN do recurso de tabela específico nas regiões afetadas. O ARN do recurso de tabela segue o formato `arn:aws:dynamodb:region:account-id:table/table-name`, no qual você precisa especificar os valores reais de região, ID da conta e nome da tabela.
**Topics**
+ [Criar tabelas globais e adicionar réplicas](#globaltables-creation-iam)
+ [Atualizar tabelas globais](#globaltables-update-iam)
+ [Excluir tabelas globais e remover réplicas](#globaltables-delete-iam)
### Criar tabelas globais e adicionar réplicas
As tabelas globais do DynamoDB comportam dois modos de consistência: consistência eventual multirregional (MREC) e consistência forte multirregional (MRSC). As tabelas globais MREC podem ter várias réplicas em qualquer número de regiões e fornecer consistência eventual. As tabelas globais MRSC exigem exatamente três regiões (três réplicas ou duas réplicas e uma testemunha) e fornecem consistência forte com objetivo de ponto de recuperação (RPO) zero.
As permissões necessárias para criar tabelas globais dependem de você criar uma tabela global com ou sem uma testemunha.
#### Permissões para criar tabelas globais
As permissões a seguir são necessárias tanto para a criação de tabelas globais iniciais quanto para adicionar réplicas posteriormente. Essas permissões se aplicam às tabelas globais de consistência final multirregional (MREC) e consistência forte multirregional (MRSC).
+ As tabelas globais exigem replicação entre regiões, que o DynamoDB gerencia por meio do perfil vinculado a serviços (SLR) [`AWSServiceRoleForDynamoDBReplication`](#globaltables-replication-slr). A permissão a seguir permite que o DynamoDB crie esse perfil automaticamente quando você cria uma tabela global pela primeira vez:
+ `iam:CreateServiceLinkedRole`
+ Para criar uma tabela global ou adicionar uma réplica usando a API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), é necessário ter a seguinte permissão no recurso da tabela de origem:
+ `dynamodb:UpdateTable`
+ É necessário ter as seguintes permissões no recurso de tabela nas regiões para que as réplicas sejam adicionadas:
+ `dynamodb:CreateTable`
+ `dynamodb:CreateTableReplica`
+ `dynamodb:Query`
+ `dynamodb:Scan`
+ `dynamodb:UpdateItem`
+ `dynamodb:PutItem`
+ `dynamodb:GetItem`
+ `dynamodb:DeleteItem`
+ `dynamodb:BatchWriteItem`
#### Permissões adicionais para tabelas globais MRSC usando uma testemunha
Ao criar uma tabela global de consistência forte multirregional (MRSC) com uma região testemunha, você deve ter a seguinte permissão no recurso de tabela em todas as regiões participantes (incluindo as regiões de réplica e a região testemunha):
+ `dynamodb:CreateGlobalTableWitness`
#### Exemplos de política do IAM para criar tabelas globais
##### Criar uma tabela global MREC ou MRSC em três regiões
A política baseada em identidade a seguir permite criar uma tabela global MREC ou MRSC chamada “usuários” em três regiões, incluindo a criação do perfil vinculado a serviços de replicação do DynamoDB necessário.
------
#### [ 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"
]
}
]
}
```
------
##### Restringir a criação de tabelas globais MREC ou MRSC a regiões específicas
A política baseada em identidade a seguir permite criar réplicas de tabelas globais do DynamoDB em regiões específicas usando a chave de condição [aws:RequestedRegion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion), incluindo a criação do perfil vinculado a serviços de replicação do DynamoDB necessário.
------
#### [ 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"
]
}
]
}
```
------
##### Criar uma tabela global MRSC com testemunha
A política baseada em identidade a seguir permite criar uma tabela global do DynamoDB MRSC chamada “users” com réplicas em us-east-1 e us-east-2 e uma testemunha em us-west-2, incluindo a criação do perfil vinculado a serviços de replicação do DynamoDB necessário.
------
#### [ 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"
]
}
]
}
```
------
##### Restringir a criação de testemunhas MRSC a regiões específicas
A política baseada em identidade permite criar uma tabela global MRSC com réplicas restrita a regiões específicas usando a chave de condição [aws:RequestedRegion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) e criação de testemunhas sem restrições em todas as regiões, incluindo a criação do perfil vinculado a serviços de replicação do DynamoDB necessário.
------
#### [ 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"
]
}
]
}
```
------
### Atualizar tabelas globais
Para modificar as configurações de réplica de uma tabela global existente usando a API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), é preciso ter a seguinte permissão no recurso de tabela na região em que você está fazendo a chamada de API:
+ `dynamodb:UpdateTable`
Além disso, você pode atualizar outras configurações da tabela global, como políticas de ajuste de escala automático e configurações de tempo de vida. As seguintes permissões são necessárias para essas operações adicionais de atualização:
+ Para atualizar uma política de ajuste de escala automático da réplica com a API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html), é necessário ter as seguintes permissões no recurso de tabela em todas as regiões que contêm 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 atualizar as configurações de tempo de vida com a API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html), você deve ter a seguinte permissão no recurso de tabela em todas as regiões que contêm réplicas:
+ `dynamodb:UpdateTimeToLive`
Observe que o tempo de vida (TTL) é compatível somente com tabelas globais configuradas com consistência eventual multirregional (MREC). Para acessar mais informações sobre como tabelas globais funcionam com TTL, consulte [Como funcionam as tabelas globais do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html).
### Excluir tabelas globais e remover réplicas
Para excluir uma tabela global, você deve remover todas as réplicas. As permissões necessárias para essa operação variam dependendo se você está excluindo uma tabela global com ou sem uma região testemunha.
#### Permissões para excluir tabelas globais e remover réplicas
As permissões a seguir são necessárias tanto para remover réplicas individuais quanto para excluir completamente as tabelas globais. A exclusão de uma configuração de tabela global só remove o relacionamento de replicação entre tabelas em diferentes regiões. Ela não exclui a tabela subjacente do DynamoDB na última região restante. A tabela na última região continua existindo como uma tabela padrão do DynamoDB com os mesmos dados e configurações. Essas permissões se aplicam às tabelas globais de consistência final multirregional (MREC) e consistência forte multirregional (MRSC).
+ Para remover réplicas de uma tabela global usando a API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html), você precisa da seguinte permissão no recurso de tabela na região em que está fazendo a chamada de API:
+ `dynamodb:UpdateTable`
+ Você precisa das seguintes permissões no recurso de tabela em cada região em que você está removendo uma réplica:
+ `dynamodb:DeleteTable`
+ `dynamodb:DeleteTableReplica`
#### Permissões adicionais para tabelas globais MRSC usando uma testemunha
Ao excluir uma tabela global de consistência forte multirregional (MRSC) com uma testemunha, você deve ter a seguinte permissão no recurso de tabela em todas as regiões participantes (incluindo as regiões de réplica e a região testemunha):
+ `dynamodb:DeleteGlobalTableWitness`
#### Exemplos de política do IAM para excluir réplicas de uma tabela global
##### Excluir réplicas de tabelas globais
Essa política baseada em identidade permite que você exclua uma tabela global do DynamoDB chamada “users” e suas respectivas réplicas em três regiões:
------
#### [ 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"
]
}
]
}
```
------
##### Excluir uma tabela global MRSC com uma testemunha
Essa política baseada em identidade permite que você exclua a réplica e a testemunha de uma tabela global MRSC chamada “users”:
------
#### [ 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"
]
}
]
}
```
------
## Como as tabelas globais usam AWS KMS
Como todas as tabelas do DynamoDB, as réplicas de tabelas globais sempre criptografam dados em repouso usando chaves de criptografia armazenadas no AWS Key Management Service (AWS KMS).
Todas as réplicas em uma tabela global devem ser configuradas com o mesmo tipo de chave KMS (chave própria da AWS, chave gerenciada da AWS ou chave gerenciada pelo cliente).
**Importante**
O DynamoDB exige acesso à chave de criptografia da réplica para excluir uma réplica. Se você quiser desativar ou excluir uma chave gerenciada pelo cliente usada para criptografar uma réplica porque você está excluindo a réplica, primeiro exclua a réplica, aguarde até que o status da tabela em uma das réplicas restantes mude para `ACTIVE`, então desative ou exclua a chave.
Para uma tabela global configurada para consistência final multirregional (MREC), se você desativar ou revogar o acesso do DynamoDB a uma chave gerenciada pelo cliente usada para criptografar uma réplica, a replicação de e para a réplica será interrompida e o status da réplica mudará para `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Se uma réplica em uma tabela global do MREC permanecer no estado `INACCESSIBLE_ENCRYPTION_CREDENTIALS` por mais de 20 horas, a réplica será convertida irreversivelmente em uma tabela do DynamoDB de região única.
Para uma tabela global configurada para consistência forte multirregional (MRSC), se você desativar ou revogar o acesso do DynamoDB a uma chave gerenciada pelo cliente usada para criptografar uma réplica, a replicação de e para a réplica será interrompida, as tentativas de realizar gravações ou leituras altamente consistentes na réplica retornarão um erro, e o status da réplica mudará para `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Se uma réplica em uma tabela global do MRSC permanecer no estado `INACCESSIBLE_ENCRYPTION_CREDENTIALS` por mais de sete dias, dependendo das permissões específicas revogadas, a réplica será arquivada ou ficará permanentemente inacessível.