Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Tabella globale per lo stesso account DynamoDB
<a name="globaltables-SameAccount"></a>

Le tabelle globali dello stesso account replicano automaticamente i dati delle tabelle DynamoDB tra le regioni all'interno di un singolo account. AWS AWS Le tabelle globali con lo stesso account forniscono il modello più semplice per l'esecuzione di applicazioni multiregionali perché tutte le repliche condividono lo stesso limite di account, proprietà e modello di autorizzazioni. Quando si scelgono le AWS regioni per le tabelle di replica, le tabelle globali gestiscono automaticamente tutte le repliche. Le tabelle globali sono disponibili in tutte le Regioni in cui DynamoDB è disponibile.

Le tabelle globali dello stesso account offrono i seguenti vantaggi:
+ Replica automaticamente i dati delle tabelle DynamoDB nelle aree AWS di tua scelta per localizzare i dati più vicino agli utenti
+ Maggiore disponibilità delle applicazioni durante l’isolamento o la riduzione delle prestazioni Regionale
+ Utilizza la risoluzione dei conflitti integrata in modo da poterti concentrare sulla logica di business dell'applicazione
+ Quando si crea una tabella globale per lo stesso account, è possibile scegliere tra [Coerenza finale multi-Regione (MREC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrec) [Elevata consistenza multi-Regione (MRSC)](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes.mrsc)

**Topics**
+ [Come funzionano le tabelle globali DynamoDB](V2globaltables_HowItWorks.md)
+ [Tutorial: creazione di tabelle globali](V2globaltables.tutorial.md)
+ [Sicurezza per tabelle globali DynamoDB](globaltables-security.md)

# Come funzionano le tabelle globali DynamoDB
<a name="V2globaltables_HowItWorks"></a>

Nelle sezioni seguenti sono riportate ulteriori informazioni sui concetti e i comportamenti delle tabelle globali in Amazon DynamoDB.

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

*Le tabelle globali* sono una funzionalità di DynamoDB che replica i dati delle tabelle tra le regioni. AWS 

Una *tabella di replica* (o replica) è una singola tabella DynamoDB che funziona come parte di una tabella globale. Una tabella globale è composta da due o più tabelle di replica in diverse regioni. AWS Ciascuna tabella globale può avere una sola tabella di replica per Regione AWS . Tutte le repliche in una tabella globale condividono lo stesso nome di tabella, lo stesso schema di chiave primaria e gli stessi dati degli elementi.

Quando un’applicazione scrive dati in una replica in una Regione, DynamoDB replica automaticamente la scrittura in tutte le altre repliche nella tabella globale. Per ulteriori informazioni su come iniziare a utilizzare le tabelle globali, consulta [Tutorial: creazione di tabelle globali](V2globaltables.tutorial.md).

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

Sono disponibili due versioni delle tabelle globali DynamoDB: versione 2019.11.21 (Corrente) e [versione 2017.11.29 (Legacy).](globaltables.V1.md) Sarebbe opportuno utilizzare la versione 2019.11.21 (Corrente) ogni volta che è possibile. Le informazioni contenute in questa sezione della documentazione si riferiscono alla versione 2019.11.21 (Corrente). Per ulteriori informazioni, consulta [Determinare la versione di una tabella globale](V2globaltables_versions.md#globaltables.DetermineVersion).

## Disponibilità
<a name="V2globaltables_HowItWorks.availability"></a>

Le tabelle globali aiutano a migliorare la continuità aziendale semplificando l’implementazione di un’architettura ad alta disponibilità multi-Regione. Se un carico di lavoro in una singola AWS regione viene compromesso, è possibile spostare il traffico delle applicazioni in una regione diversa ed eseguire letture e scritture su una tabella di replica diversa nella stessa tabella globale.

Ogni tabella di replica in una tabella globale offre la stessa durata e disponibilità di una tabella DynamoDB a Regione singola. Le tabelle globali offrono un [Accordo sul livello di servizio (SLA)](https://aws.amazon.com//dynamodb/sla/) con disponibilità del 99,999%, rispetto al 99,99% delle tabelle a Regione singola.

## Modalità di coerenza
<a name="V2globaltables_HowItWorks.consistency-modes"></a>

Quando si crea una tabella globale, è possibile configurarne la modalità di coerenza. Le tabelle globali supportano due modalità di coerenza: coerenza finale multi-Regione (MREC, Multi-Region Eventual Consistency) e elevata consistenza multi-Regione (MRSC, Multi-Region Strong Consistency).

Se non si specifica una modalità di coerenza durante la creazione di una tabella globale, la tabella globale utilizza come impostazione predefinita la coerenza finale multi-Regione (MREC). Una tabella globale non può contenere repliche configurate con modalità di coerenza diverse. Non è possibile modificare la modalità di coerenza di una tabella globale dopo la creazione.

### Coerenza finale multi-Regione (MREC)
<a name="V2globaltables_HowItWorks.consistency-modes.mrec"></a>

La coerenza finale multi-Regione (MREC) è la modalità di coerenza predefinita per le tabelle globali. Le modifiche agli elementi in una replica di tabella globale MREC vengono replicate in modo asincrono su tutte le altre repliche, in genere entro un secondo o meno. Nell’improbabile eventualità che una replica in una tabella globale MREC venga isolata o danneggiata, tutti i dati non ancora replicati in altre Regioni verranno replicati quando la replica diventa integra.

Se lo stesso elemento viene modificato in più Regioni contemporaneamente, DynamoDB risolverà il conflitto utilizzando la modifica con il timestamp interno più recente per elemento, denominato metodo di risoluzione dei conflitti basato sulla “priorità dell’ultima istanza di scrittura”. Un elemento alla fine convergerà in tutte le repliche alla versione creata dall’ultima scrittura.

Le [operazioni a elevata consistenza di lettura](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html#DDB-GetItem-request-ConsistentRead) restituiscono la versione più recente di un elemento se tale elemento è stato aggiornato l’ultima volta nella Regione in cui è avvenuta la lettura, ma possono restituire dati non aggiornati se l’elemento è stato aggiornato l’ultima volta in una Regione diversa. Le scritture condizionali valutano l’espressione della condizione rispetto alla versione dell’elemento nella Regione.

Si crea una tabella globale MREC aggiungendo una replica a una tabella DynamoDB esistente. L’aggiunta di una replica non ha alcun impatto sulle prestazioni sulle tabelle DynamoDB a Regione singola esistenti o sulle repliche di tabelle globali. È possibile aggiungere repliche a una tabella globale MREC per espandere il numero di Regioni in cui i dati vengono replicati o rimuovere le repliche da una tabella globale MREC se non sono più necessarie. Una tabella globale MREC può avere una replica in qualsiasi Regione in cui è disponibile DynamoDB e può avere tante repliche quante sono le Regioni nella [partizione AWS .](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/partitions.html)

### Elevata consistenza multi-Regione (MRSC)
<a name="V2globaltables_HowItWorks.consistency-modes.mrsc"></a>

È possibile configurare la modalità MRSC (Multi-region Strong Consistency) quando si crea una tabella globale. Le modifiche agli elementi in una replica di tabella globale MRSC vengono replicate in modo sincrono in almeno un’altra Regione prima che l’operazione di scrittura restituisca una risposta con esito positivo. Le operazioni a elevata consistenza di lettura su qualsiasi replica MRSC restituiscono sempre la versione più recente di un elemento. Le scritture condizionali valutano sempre l’espressione della condizione rispetto alla versione più recente di un elemento.

Una tabella globale MRSC deve essere implementata esattamente in tre Regioni. È possibile configurare una tabella globale MRSC con tre repliche o con due repliche e un testimone. Un witness è un componente di una tabella globale MRSC che contiene dati scritti su repliche di tabelle globali e fornisce un'alternativa opzionale a una replica completa, supportando al contempo l'architettura di disponibilità di MRSC. Non è possibile eseguire operazioni di lettura o scrittura su un testimone. Un testimone si trova in una Regione diversa rispetto alle due repliche. Quando si crea una tabella globale MRSC, si scelgono le Regioni sia per l’implementazione di replica che di testimone al momento della creazione della tabella MRSC. È possibile determinare se e in quale Regione una tabella globale MRSC ha un testimone configurato dall’output dell’API [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Il testimone è di proprietà e gestito da DynamoDB e non verrà visualizzato nel AWS tuo account nella regione in cui è configurato.

Le tabelle globali MRSC sono disponibili nei seguenti set di regioni: set di regioni Stati Uniti (Stati Uniti orientali Virginia, Stati Uniti orientali Ohio, Stati Uniti occidentali Oregon), set di regioni UE (Europa Irlanda, Europa Londra, Europa Parigi, Europa Francoforte) e set di regioni AP (Asia Pacifico Tokyo, Asia Pacifico Seul e Asia Pacifico Osaka). Le tabelle globali MRSC non possono estendersi a set di Regioni (ad esempio, una tabella globale MRSC non può contenere repliche di set di Regioni degli Stati Uniti e dell’Europa).

Si crea una tabella globale MRSC aggiungendo una replica e un testimone o due repliche a una tabella DynamoDB esistente che non contiene dati. Quando si converte una tabella a regione singola esistente in una tabella globale MRSC, è necessario assicurarsi che la tabella sia vuota. La conversione di una tabella a Regione singola in una tabella globale MRSC con elementi esistenti non è supportata. Assicurati che non venga scritto alcun dato nella tabella durante il processo di conversione. Non è possibile aggiungere repliche aggiuntive a una tabella globale MRSC esistente. Non è possibile eliminare una singola replica o un testimone da una tabella globale MRSC. È possibile eliminare due repliche o eliminare una replica e un testimone da una tabella globale MRSC, convertendo la replica rimanente in una tabella DynamoDB a Regione singola.

Un’operazione di scrittura ha esito negativo con una `ReplicatedWriteConflictException` quando tenta di modificare un elemento che è già stato modificato in un’altra Regione. Le scritture con esito negativo `ReplicatedWriteConflictException` possono essere ritentate e avranno esito positivo se l'elemento non viene più modificato in un'altra regione.

Le seguenti considerazioni si applicano alle tabelle globali MRSC:
+ Il valore Time to Live (TTL) non è supportato per le tabelle globali MRSC.
+ Gli indici secondari locali (LSIs) non sono supportati per le tabelle globali MRSC.
+ CloudWatch Le informazioni di Contributor Insights vengono riportate solo per la regione in cui si è verificata un'operazione.

## Scelta di una modalità di coerenza
<a name="V2globaltables_HowItWorks.choosing-consistency-mode"></a>

Il criterio chiave per la scelta di una modalità di coerenza multi-Regione è se l’applicazione dia priorità alle scritture a bassa latenza e alle operazioni a elevata consistenza di lettura o dia priorità alla elevata consistenza globale.

Le tabelle globali MREC avranno latenze per operazioni di scrittura e per operazioni a elevata consistenza di lettura inferiori rispetto alle tabelle globali MRSC. Le tabelle globali MREC hanno un Recovery Point Objective (RPO) pari al ritardo di replica tra le repliche, in genere di pochi secondi a seconda delle regioni di replica.

È necessario utilizzare la modalità MREC quando:
+ L’applicazione può tollerare la restituzione di dati obsoleti da operazioni a elevata consistenza di lettura se tali dati sono stati aggiornati in un’altra Regione.
+ Si dà la priorità a latenze per operazioni di e operazioni a elevata consistenza di lettura inferiori rispetto alla coerenza di lettura multi-Regione.
+ La strategia di alta disponibilità multi-Regione può tollerare un RPO superiore a zero.

Le tabelle globali MRSC avranno latenze superiori per operazioni di scrittura e operazioni a elevata consistenza di lettura rispetto alle tabelle globali MREC superiori. Le tabelle globali MRSC supportano un RPO pari a zero.

È necessario utilizzare la modalità MRSC quando:
+ Sono necessarie operazioni a elevata consistenza di lettura in più Regioni.
+ Si dà la priorità alla coerenza di lettura globale rispetto a una latenza di scrittura inferiore.
+ La strategia di alta disponibilità multi-Regione richiede un RPO pari a zero.

## Monitoraggio delle tabelle globali
<a name="monitoring-global-tables"></a>

Le tabelle globali configurate per la coerenza finale tra più regioni (MREC) pubblicano la metrica su. [`ReplicationLatency`](metrics-dimensions.md#ReplicationLatency) CloudWatch Questa metrica tiene traccia del tempo trascorso tra la scrittura di un elemento in una tabella di replica e la visualizzazione di tale elemento in un’altra replica nella tabella globale. `ReplicationLatency` è espresso in millisecondi e viene emesso per ogni coppia di Regioni di origine e di destinazione in una tabella globale. 

`ReplicationLatency`I valori tipici dipendono dalla distanza tra le AWS regioni scelte e da altre variabili come il tipo di carico di lavoro e la velocità effettiva. Ad esempio, una replica di origine nella Regione Stati Uniti occidentali (California settentrionale) (us-west-1) ha un `ReplicationLatency` inferiore rispetto alla Regione Stati Uniti occidentali (Oregon) (us-west-2) rispetto alla Regione Africa (Città del Capo) (af-south-1).

Un valore crescente per `ReplicationLatency` potrebbe indicare che gli aggiornamenti da una replica non si propagano ad altre tabelle di replica in modo tempestivo. In questo caso, puoi reindirizzare temporaneamente l'attività di lettura e scrittura dell'applicazione verso un'altra regione. AWS 

Le tabelle globali configurate per l’elevata consistenza multi-Regione (MRSC) non pubblicano una metrica `ReplicationLatency`.

## Test di iniezione di guasti
<a name="fault-injection-testing"></a>

Entrambe le tabelle globali MREC e MRSC si integrano con [AWSAWS Fault Injection Service](https://docs.aws.amazon.com/resilience-hub/latest/userguide/testing.html) (FIS), un servizio completamente gestito per l'esecuzione di esperimenti di iniezione di guasti controllati per migliorare la resilienza di un'applicazione. Utilizzando AWS FIS, è possibile:
+ Creare modelli di esperimenti che definiscono scenari di fallimento specifici.
+ Inietta gli errori per convalidare la resilienza delle applicazioni simulando l'isolamento di una regione (ovvero, mettendo in pausa la replica da e verso una replica selezionata) per testare la gestione degli errori, i meccanismi di ripristino e il comportamento dello spostamento del traffico tra più regioni quando un'area subisce un'interruzione. AWS 

Ad esempio, in una tabella globale con repliche negli Stati Uniti orientali (Virginia settentrionale), negli Stati Uniti orientali (Ohio) e negli Stati Uniti occidentali (Oregon), è possibile eseguire un esperimento negli Stati Uniti orientali (Ohio) per testare l'isolamento della regione mentre Stati Uniti orientali (Virginia settentrionale) e Stati Uniti occidentali (Oregon) continuano le normali operazioni. Questo test controllato consente di identificare e risolvere potenziali problemi prima che influiscano sui carichi di lavoro di produzione. 

Consulta [Action targets](https://docs.aws.amazon.com/fis/latest/userguide/action-sequence.html#action-targets) nella *guida per l'utente AWS FIS* per un elenco completo delle azioni supportate da AWS FIS e della [connettività interregionale per sospendere la replica di DynamoDB tra le regioni](https://docs.aws.amazon.com/fis/latest/userguide/cross-region-scenario.html).

*Per informazioni sulle azioni delle tabelle globali di Amazon DynamoDB disponibili AWS in FIS, [consulta il riferimento alle azioni delle tabelle globali di DynamoDB nella FIS User Guide](https://docs.aws.amazon.com/fis/latest/userguide/fis-actions-reference.html#dynamodb-actions-reference).AWS *

Per iniziare a eseguire esperimenti di fault injection, consulta [Planning your AWS FIS experiment (Pianificazione degli esperimenti FIS) nella guida per l'utente FIS](https://docs.aws.amazon.com/fis/latest/userguide/getting-started-planning.html). AWS 

**Nota**  
Durante AWS FIS gli esperimenti in MRSC, alla fine sono consentite letture coerenti, ma gli aggiornamenti delle impostazioni delle tabelle, come la modifica della modalità di fatturazione o la configurazione del throughput della tabella, non sono consentiti, analogamente a MREC. Controlla la CloudWatch metrica per ulteriori dettagli sul codice [`FaultInjectionServiceInducedErrors`](metrics-dimensions.md#FaultInjectionServiceInducedErrors)di errore.

## Time to live (TTL)
<a name="global-tables-ttl"></a>

Le tabelle globali configurate per MREC supportano la configurazione dell’eliminazione [Time to Live](TTL.md) (TTL). Le impostazioni del TTL vengono sincronizzate automaticamente per tutte le repliche in una tabella globale. Quando il TTL elimina un elemento da una replica in una Regione, l’eliminazione viene replicata su tutte le altre repliche nella tabella globale. Il TTL non consuma capacità di scrittura, quindi non viene addebitato alcun costo per l’eliminazione TTL nella Regione in cui è avvenuta l’eliminazione. Tuttavia, viene addebitato il costo dell’eliminazione replicata in ogni altra Regione con una replica nella tabella globale.

La replica di eliminazione TTL consuma la capacità di scrittura sulle repliche in cui viene replicata l’eliminazione. Le repliche configurate per la capacità allocata possono limitare le richieste se la combinazione di throughput di scrittura e throughput di eliminazione TTL è superiore alla capacità di scrittura allocata.

Le tabelle globali configurate per MRSC (elevata consistenza multi-Regione) non supportano la configurazione dell’eliminazione TTL.

## Streams
<a name="global-tables-streams"></a>

Le tabelle globali configurate per coerenza finale multi-Regione (MREC) replicano le modifiche leggendo tali modifiche da un [flusso DynamoDB](Streams.md) su una tabella di replica e applicandole a tutte le altre tabelle di replica. I flussi sono quindi abilitati per impostazione predefinita su tutte le repliche in una tabella globale MREC e non possono essere disabilitati su tali repliche. Il processo di replica MREC può combinare più modifiche in un breve periodo di tempo in un’unica scrittura replicata, con il risultato che il flusso di ogni replica contiene record leggermente diversi. I record dei flussi sulle repliche MREC vengono sempre ordinati per elemento, ma l’ordinamento tra gli elementi può differire tra le repliche.

Le tabelle globali configurate per elevata consistenza multi-Regione (MRSC) non utilizzano i flussi DynamoDB per la replica, pertanto i flussi non sono abilitati per impostazione predefinita sulle repliche MRSC. È possibile abilitare i flussi su una replica MRSC. I record dei flussi sulle repliche MRSC sono identici per ogni replica, incluso l’ordinamento dei record dei flussi.

Se si desidera scrivere un’applicazione che elabori i record dei flussi per le modifiche avvenute in una particolare Regione ma non in altre Regioni in una tabella globale, è possibile aggiungere un attributo a ogni elemento che definisce in quale Regione è avvenuta la modifica per quell’elemento. È possibile utilizzare questo attributo per filtrare i record dei flussi in base alle modifiche apportate in altre Regioni, incluso l’uso dei filtri di eventi Lambda per invocare le funzioni Lambda solo per le modifiche in una Regione specifica.

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

In una tabella globale configurata per MREC, le operazioni di transazione DynamoDB ([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)) sono atomiche solo all’interno della Regione in cui è stata invocata l’operazione. Le scritture transazionali non vengono replicate come unità tra le Regioni, il che significa che solo alcune delle scritture di una transazione possono essere restituite dalle operazioni di lettura in altre repliche in un determinato momento.

Ad esempio, se è presente una tabella globale con repliche nelle Regioni Stati Uniti orientali (Ohio) e Stati Uniti occidentali (Oregon) e si esegue un’operazione `TransactWriteItems` nella Regione Stati Uniti orientali (Ohio), potrebbe essere possibile osservare transazioni parzialmente completate nella Regione Stati Uniti occidentali (Oregon) man mano che le modifiche vengono replicate. Le modifiche vengono replicate in altre Regioni solo dopo essere state confermate nella Regione di origine.

Le tabelle globali configurate per MRSC (elevata consistenza multi-Regione) non supportano le operazioni di transazione e restituiranno un errore se tali operazioni vengono invocate su una replica MRSC.

## Velocità di trasmissione effettiva di lettura e di scrittura
<a name="V2globaltables_HowItWorks.Throughput"></a>

### Modalità provisioning
<a name="gt_throughput.provisioned"></a>

La replica consuma capacità di scrittura. Le repliche configurate per la capacità assegnata possono limitare le richieste se la combinazione del throughput di scrittura dell'applicazione e del throughput di scrittura della replica supera la capacità di scrittura assegnata. Per le tabelle globali che utilizzano la modalità provisioned, le impostazioni di ridimensionamento automatico per le capacità di lettura e scrittura sono sincronizzate tra le repliche.

È possibile configurare in modo indipendente le impostazioni della capacità di lettura per ogni replica in una tabella globale utilizzando il [https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_ProvisionedThroughputOverride.html)parametro a livello di replica. Per impostazione predefinita, le modifiche alla capacità di lettura assegnata vengono applicate a tutte le repliche nella tabella globale. Quando si aggiunge una nuova replica a una tabella globale, la capacità di lettura della tabella o della replica di origine viene utilizzata come valore iniziale, a meno che non venga specificata esplicitamente un'eccezione a livello di replica.

### Modalità on demand
<a name="gt_throughput.on-demand"></a>

Per le tabelle globali configurate per la modalità on demand, la capacità di scrittura viene sincronizzata automaticamente su tutte le repliche. DynamoDB regola automaticamente la capacità in base al traffico e non ci sono impostazioni di capacità di lettura o scrittura specifiche per la replica da gestire.

## Sincronizzazione delle impostazioni
<a name="V2globaltables_HowItWorks.setting-synchronization"></a>

Le impostazioni nelle tabelle globali di DynamoDB sono parametri di configurazione che controllano vari aspetti del comportamento e della replica delle tabelle. Queste impostazioni sono gestite tramite il APIs piano di controllo di DynamoDB e possono essere configurate durante la creazione o la modifica di tabelle globali. Le tabelle globali sincronizzano automaticamente determinate impostazioni su tutte le repliche per mantenere la coerenza e consentire al contempo la flessibilità per le ottimizzazioni specifiche della Regione. Comprendere quali impostazioni si sincronizzano e come si comportano aiuta a configurare la tabella globale in modo efficace. Le impostazioni rientrano in tre categorie principali in base al modo in cui sono sincronizzate tra le repliche.

Le seguenti impostazioni sono sempre sincronizzate tra le repliche in una tabella globale:
+ Modalità di capacità (capacità allocata o on demand)
+ Capacità di scrittura allocata alla tabella
+ Dimensionamento automatico della tabella
+ Definizione degli attributi dello schema chiave
+ Definizione degli indici secondari globali (GSI)
+ Capacità di scrittura allocata ai GSI
+ Dimensionamento automatico in scrittura dei GSI
+ Tipo di crittografia lato server (SSE)
+ Definizione dei flussi in modalità MREC
+ Time to live (TTL)
+ Throughput a caldo
+ Throughput massimo on demand

Le seguenti impostazioni sono sincronizzate tra le repliche, ma possono essere sostituite per ogni singola replica:
+ Capacità di lettura allocata alla tabella
+ Dimensionamento automatico in lettura della tabella
+ Capacità di lettura allocata ai GSI
+ Dimensionamento automatico in lettura dei GSI
+ Classe di tabella
+ Throughput massimo on demand

**Nota**  
I valori delle impostazioni sostituibili vengono modificati se l’impostazione viene modificata su qualsiasi altra replica. Ad esempio, è disponibile una tabella globale MREC con repliche nelle Regioni Stati Uniti orientali (Virginia settentrionale) e Stati Uniti occidentali (Oregon). La replica degli Stati Uniti orientali (Virginia settentrionale) ha assegnato un throughput di lettura impostato su 200. RCUs Per la replica negli Stati Uniti occidentali (Oregon), la velocità effettiva di lettura assegnata è impostata su 100. RCUs Se si aggiorna l'impostazione della velocità effettiva di lettura assegnata sulla replica degli Stati Uniti orientali (Virginia settentrionale) da 200 RCUs a 300 RCUs, il nuovo valore della velocità effettiva di lettura assegnata verrà applicato anche alla replica negli Stati Uniti occidentali (Oregon). Ciò modifica l'impostazione della velocità effettiva di lettura assegnata per la replica degli Stati Uniti occidentali (Oregon) dal valore sovrascritto di 100 al nuovo valore di 300. RCUs RCUs

Le seguenti impostazioni non vengono mai sincronizzate tra le repliche:
+ Protezione da eliminazione
+ Point-in-time Recupero
+ Tag
+ Attivazione di Table CloudWatch Contributor Insights
+ Abilitazione di GSI Contributor Insights CloudWatch 
+ Definizione del flusso di dati Kinesis
+ Policy delle risorse
+ Definizione dei flussi in modalità MRSC

Tutte le altre impostazioni non vengono sincronizzate tra le repliche.

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

Le scritture su repliche di tabelle globali ignorano DynamoDB Accelerator (DAX), aggiornando direttamente DynamoDB. Di conseguenza, le cache di DAX possono diventare obsolete poiché le scritture non le aggiornano. Le cache di DAX configurate per le repliche globali delle tabelle verranno aggiornate solo alla scadenza del TTL della cache.

## Considerazioni sulla gestione delle tabelle globali
<a name="management-considerations"></a>

Non è possibile eliminare una tabella utilizzata per aggiungere una nuova replica globale della tabella prima che siano trascorse 24 ore dalla creazione della nuova replica.

Se si disabilita una AWS regione che contiene repliche di tabelle globali, tali repliche vengono convertite in modo permanente in tabelle a regione singola 20 ore dopo la disattivazione della regione.

# Tutorial: creazione di tabelle globali
<a name="V2globaltables.tutorial"></a>

Questa sezione fornisce step-by-step istruzioni per creare tabelle globali DynamoDB configurate per la modalità di consistenza preferita. Seleziona la modalità a coerenza finale multi-Regione (MREC, Multi-Region Eventual Consistency) o elevata consistenza multi-Regione (MRSC, Multi-Region Strong Consistency) in base ai requisiti dell’applicazione.

Le tabelle globali MREC offrono una latenza di scrittura inferiore con una coerenza finale generale Regioni AWS. Le tabelle globali MRSC forniscono operazioni a elevata consistenza di lettura tra le Regioni con latenze di scrittura leggermente superiori rispetto a MREC. Sceglie la modalità di coerenza che meglio soddisfa le esigenze dell’applicazione in termini di coerenza, latenza e disponibilità dei dati.

**Topics**
+ [Creazione di una tabella globale configurata per MREC](#V2creategt_mrec)
+ [Creazione di una tabella globale configurata per MRSC](#create-gt-mrsc)

## Creazione di una tabella globale configurata per MREC
<a name="V2creategt_mrec"></a>

Questa sezione mostra come creare una tabella globale con la modalità a coerenza finale multi-Regione (MREC). MREC è la modalità di coerenza predefinita per le tabelle globali e fornisce scritture a bassa latenza con replica asincrona su tutte le Regioni AWS. Le modifiche apportate a un elemento in una Regione vengono in genere replicate in tutte le altre Regioni entro un secondo. Ciò rende la MREC ideale per le applicazioni che danno priorità a una bassa latenza di scrittura e possono tollerare brevi periodi in cui Regioni diverse possono restituire versioni di dati leggermente diverse.

È possibile creare tabelle globali MREC con repliche in qualsiasi regione in AWS cui è disponibile DynamoDB e aggiungere o rimuovere repliche in qualsiasi momento. Gli esempi seguenti mostrano come creare una tabella globale MREC con repliche in più Regioni.

### Creazione di una tabella globale MREC con la console DynamoDB
<a name="mrec-console"></a>

Completa questa procedura per creare una tabella globale utilizzando Console di gestione AWS. Il seguente esempio consente di creare una tabella globale con le tabelle di replica negli Stati Uniti e in Europa.

1. Accedi Console di gestione AWS e apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Per questo esempio, seleziona **Stati Uniti orientali (Ohio)** dal selettore delle Regioni nella barra di navigazione.

1. Nel riquadro di navigazione sul lato sinistro della console scegli **Tables (Tabelle)**.

1. Scegliere **Create Table (Crea tabella)**.

1. Nella pagina **Crea tabella**:

   1. Nel campo **Table name (Nome tabella)** immetti **Music**.

   1. In **Partition key** (Chiave di partizione), inserisci **Artist**.

   1. Per **Chiave di ordinamento**, immetti **SongTitle**.

   1. Mantieni le restanti impostazioni predefinite e seleziona **Crea tabella**.

      Questa nuova tabella funge da prima tabella di replica in una nuova tabella globale. È il prototipo per altre tabelle di replica che verranno aggiunte in seguito.

1. Dopo che la tabella è diventata attiva:

   1. Nell’elenco delle tabelle, seleziona la tabella **Musica**.

   1. Seleziona la scheda **Tabelle globali**.

   1. Scegliere **Crea replica**.

1. Dall’elenco a discesa **Regioni di replica disponibili**, seleziona **Stati Uniti occidentali (Oregon) us-west-2**.

   La console verifica che non esista una tabella con lo stesso nome nella Regione selezionata. Se esiste una tabella con lo stesso nome, è necessario eliminare la tabella esistente prima di poter creare una nuova tabella di replica in quella regione.

1. Scegliere **Crea replica**. Viene avviato il processo di creazione della tabella nella Regione Stati Uniti occidentali (Oregon) us-west-2.

   La scheda **Tabelle globali** per la tabella **Musica** (e per qualsiasi altra tabella di replica) mostra che la tabella è stata replicata in più Regioni.

1. Aggiungi un’altra Regione ripetendo le fasi precedenti, ma seleziona **Europa (Francoforte) eu-central-1** come Regione.

1. Per testare la replica:

   1. Assicurati di utilizzare la Console di gestione AWS regione Stati Uniti orientali (Ohio).

   1. Scegli **Explore table items** (Esplora elementi della tabella).

   1. Scegli **Crea elemento**.

   1. Entra **item\$11** per **Artista** e **Song Value 1** per **SongTitle**.

   1. Scegli **Crea elemento**.

1. Verifica la replica passando alle altre Regioni:

   1. Dal selettore delle Regioni in alto a destra, seleziona **Europa (Francoforte)**.

   1. Verifica che la tabella **Musica** contenga l’elemento creato.

   1. Ripeti la verifica per **Stati Uniti occidentali (Oregon)**.

### Creazione di una tabella globale MREC utilizzando o Java AWS CLI
<a name="mrec-cli-java"></a>

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

Gli esempi di codice seguenti mostrano come creare e gestire le tabelle DynamoDB globali con consistenza effettiva multi-Regione (MRSC).
+ Creare una tabella con replica multi-Regione (MREC).
+ Inserire e ottenere elementi dalle tabelle di replica.
+ Rimuovi le repliche. one-by-one
+ Eseguire la pulizia mediante l’eliminazione delle tabelle.

**AWS CLI con lo script Bash**  
Creare una tabella con replica multi-Regione.  

```
# 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
```
Descrivere la tabella multi-Regione.  

```
# 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}}'
```
Inserisce elementi in una tabella di replica.  

```
# 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
```
Ottiene elementi dalle tabelle di replica.  

```
# 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
```
Rimuove le repliche.  

```
# 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
```
Eseguire la pulizia mediante l’eliminazione delle tabelle.  

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

echo "Global table demonstration complete."
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dei comandi della 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 ]

L’esempio di codice seguente mostra come creare e gestire le tabelle globali DynamoDB con repliche tra più Regioni.
+ Creare una tabella con un indice secondario globale e flussi Amazon DynamoDB.
+ Aggiungere repliche in Regioni diverse per creare una tabella globale.
+ Rimuovere le repliche da una tabella globale.
+ Aggiungere elementi di test per verificare la replica tra Regioni.
+ Descrivere la configurazione della tabella globale e lo stato della replica.

**SDK per Java 2.x**  
Crea una tabella con Global Secondary Index e DynamoDB Streams utilizzando. 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;
        }
    }
```
Attendi che una tabella diventi attiva utilizzando. 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;
        }
    }
```
Aggiungi una replica per creare o estendere una tabella globale utilizzando 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;
        }
    }
```
Rimuovi una replica da una tabella globale utilizzando. 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;
        }
    }
```
Aggiungi elementi di test per verificare la replica utilizzando. AWS SDK for Java 2.x  

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

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

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

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

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

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

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
            throw e;
        }
    }
```
Descrivi la configurazione globale della tabella e le repliche utilizzando. 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;
        }
    }
```
Esempio completo di operazioni su tabelle globali utilizzando 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;
            }
        }
    }
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’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)

------

## Creazione di una tabella globale configurata per MRSC
<a name="create-gt-mrsc"></a>

Questa sezione mostra come creare una tabella globale a elevata consistenza multi-Regione (MRSC). Le tabelle globali MRSC replicano in modo sincrono le modifiche agli elementi tra le Regioni, garantendo che le operazioni a elevata consistenza di lettura su qualsiasi replica restituiscano sempre la versione più recente di un elemento. Quando si converte una tabella a Regione singola in una tabella globale MRSC, è necessario assicurarsi che la tabella sia vuota. La conversione di una tabella a Regione singola in una tabella globale MRSC con elementi esistenti non è supportata. Assicurati che non venga scritto alcun dato nella tabella durante il processo di conversione.

È possibile configurare una tabella globale MRSC con tre repliche o con due repliche e un testimone. Quando si crea una tabella globale MRSC, si scelgono le Regioni in cui vengono distribuite le repliche e un testimone opzionale. L’esempio seguente crea una tabella globale MRSC con repliche nelle Regioni Stati Uniti orientali (Virginia settentrionale) e Stati Uniti orientali (Ohio), con un testimone nella Regione Stati Uniti occidentali (Oregon).

**Nota**  
Prima di creare una tabella globale, verifica che i limiti di throughput della quota di servizio siano coerenti in tutte le Regioni di destinazione, poiché ciò è necessario per creare una tabella globale. Per ulteriori informazioni sui limiti di throughput delle tabelle globali, consulta [Quote delle tabelle globali](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ServiceQuotas.html#gt-limits-throughput).

### Creazione di una tabella globale MRSC con la console DynamoDB
<a name="mrsc_console"></a>

Completa questa procedura per creare una tabella globale MRSC utilizzando la Console di gestione AWS.

1. Accedi Console di gestione AWS e apri la console DynamoDB all'indirizzo. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Dal selettore delle Regioni nella barra di navigazione, seleziona una Regione in cui sono [supportate](V2globaltables_HowItWorks.md#V2globaltables_HowItWorks.consistency-modes) le tabelle globali con MRSC, ad esempio **us-east-2**.

1. Nel pannello di navigazione, seleziona **Tabelle**.

1. Scegliere **Create table (Crea tabella)**.

1. Nella pagina **Crea tabella**:

   1. Nel campo **Table name (Nome tabella)** immetti **Music**.

   1. Per **Chiave di partizione** immetti **Artist** e mantieni il tipo di **Stringa** predefinito.

   1. Per **Chiave di ordinamento** immetti **SongTitle** e mantieni il tipo di **Stringa** predefinito.

   1. Mantieni le restanti impostazioni predefinite e seleziona **Crea tabella**.

      Questa nuova tabella funge da prima tabella di replica in una nuova tabella globale. È il prototipo per altre tabelle di replica che verranno aggiunte in seguito.

1. Attendi che la tabella diventi attiva, quindi selezionala dall’elenco delle tabelle.

1. Seleziona la scheda **Tabelle globali**, quindi seleziona **Crea replica**.

1. Nella pagina **Crea replica**:

   1. In **Coerenza multi-Regione**, seleziona **Coerenza forte**.

   1. Per **Regione di replica 1**, seleziona **US East (N. Virginia) us-east-1**.

   1. Per **Regione di replica 2**, seleziona **US West (Oregon) us-west-2**.

   1. Seleziona **Configura come testimone** per la Regione Stati Uniti occidentali (Oregon).

   1. Seleziona **Crea repliche**.

1. Attendi il completamento della replica e del processo di creazione del testimone. Lo stato della replica verrà visualizzato come **Attivo** quando la tabella sarà pronta per l’uso.

### Creazione di una tabella globale MRSC utilizzando o Java AWS CLI
<a name="mrsc-cli-java"></a>

Prima di iniziare, assicurati che il principale IAM disponga delle autorizzazioni necessarie per creare una tabella globale MRSC con una Regione testimone.

La seguente policy IAM di esempio consente di creare una tabella DynamoDB (`MusicTable`) negli Stati Uniti orientali (Ohio) con una replica nella Regione Stati Uniti orientali (Virginia settentrionale) e una Regione testimone negli Stati Uniti occidentali (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"
                }
            }
        }
    ]
}
```

------

Gli esempi di codice seguenti mostrano come creare e gestire tabelle globali DynamoDB con elevata consistenza multi-Regione (MRSC).
+ Creare una tabella con consistenza avanzata multi-Regione.
+ Verificare la configurazione MRSC e lo stato della replica.
+ Verificare l’elevata consistenza tra Regioni con letture immediate.
+ Eseguire scritture condizionali con garanzie MRSC.
+ Eseguire la pulizia delle risorse della tabella globale MRSC.

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

**AWS CLI con lo script Bash**  
Creare una tabella con consistenza avanzata multi-Regione.  

```
# 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
```
Verificare la configurazione MRSC e lo stato della replica.  

```
# 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}}'
```
Verifica l’elevata consistenza con letture immediate tra Regioni.  

```
# 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
```
Eseguire scritture condizionali con garanzie 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
```
Eseguire la pulizia delle risorse della tabella globale 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
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dei comandi della 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 per Java 2.x**  
Crea una tabella regionale pronta per la conversione MRSC utilizzando. 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();
        }
    }
```
Converti una tabella regionale in MRSC con repliche e verifica utilizzando. 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();
        }
    }
```
Descrivi una configurazione di tabella globale MRSC utilizzando. 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();
        }
    }
```
Aggiunge elementi di test per verificare l’elevata consistenza MRSC con AWS SDK for Java 2.x.  

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

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

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

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

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

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

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

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to add test item to table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to add test item to table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Leggi gli elementi con letture coerenti dalle repliche MRSC utilizzando. AWS SDK for Java 2.x  

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

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

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

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

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

            GetItemResponse response = dynamoDbClient.getItem(getItemRequest);

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

            return response;

        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to read item from table: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to read item from table: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Esegui aggiornamenti condizionali con garanzie MRSC utilizzando. AWS SDK for Java 2.x  

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

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

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

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

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

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

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

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

            return response;

        } catch (ConditionalCheckFailedException e) {
            LOGGER.warning("Conditional check failed: " + e.getMessage());
            throw e;
        } catch (DynamoDbException e) {
            LOGGER.severe("Failed to perform conditional update: " + tableName + " - " + e.getMessage());
            throw DynamoDbException.builder()
                .message("Failed to perform conditional update: " + tableName)
                .cause(e)
                .build();
        }
    }
```
Attendi che le repliche e i testimoni MRSC diventino attivi utilizzando. 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;
        }
    }
```
Pulisci le repliche e i testimoni MRSC utilizzando. 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();
        }
    }
```
Dimostrazione completa del flusso di lavoro MRSC utilizzando. 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;
        }
    }
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’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)

------

# Sicurezza per tabelle globali DynamoDB
<a name="globaltables-security"></a>

Le repliche delle tabelle globali sono tabelle DynamoDB, quindi si utilizzano gli stessi metodi per controllare l'accesso alle repliche utilizzati per le tabelle a regione singola, AWS Identity and Access Management incluse le politiche di identità (IAM) e le politiche basate sulle risorse.

Questo argomento spiega come proteggere le tabelle globali DynamoDB utilizzando le autorizzazioni AWS Key Management Service IAM e la crittografia ().AWS KMS Scopri i ruoli collegati ai servizi (SLR) che consentono la replica e l'auto-scaling tra regioni, le autorizzazioni IAM necessarie per creare, aggiornare ed eliminare tabelle globali e le differenze tra le tabelle MREC (Multi-region Eventual Consistency) e Multi-region Strong Consistency (MRSC). Scopri AWS KMS anche le chiavi di crittografia per gestire in modo sicuro la replica tra regioni.

## Ruoli collegati ai servizi per tabelle globali
<a name="globaltables-slr"></a>

Le tabelle globali DynamoDB si basano su ruoli collegati ai servizi SLRs () per gestire la replica tra regioni e le funzionalità di auto-scaling.

È sufficiente configurare questi ruoli una sola volta per account. AWS Una volta creati, gli stessi ruoli servono a tutte le tabelle globali del tuo account. Per ulteriori informazioni sui ruoli collegati al servizio, consulta [Utilizzo dei ruoli collegati al servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html) nella *Guida per l'utente IAM*.

### Ruolo collegato al servizio
<a name="globaltables-replication-slr"></a>

Amazon DynamoDB crea automaticamente il ruolo collegato `AWSServiceRoleForDynamoDBReplication` al servizio (SLR) quando crei la tua prima tabella globale. Questo ruolo gestisce la replica tra regioni per te.

Quando applichi politiche basate sulle risorse alle repliche, assicurati di non negare nessuna delle autorizzazioni definite nella scheda principale SLR, poiché ciò interromperebbe `AWSServiceRoleForDynamoDBReplicationPolicy` la replica. Se si negano le autorizzazioni SLR richieste, la replica da e verso le repliche interessate verrà interrotta e lo stato della tabella di replica cambierà in `REPLICATION_NOT_AUTHORIZED`.
+ Per le tabelle globali Multi-region Eventual Consistency (MREC), se una replica rimane nello `REPLICATION_NOT_AUTHORIZED` stato per più di 20 ore, viene convertita in modo irreversibile in una tabella DynamoDB a regione singola.
+ Per le tabelle globali MRSC (Multi-region Strong Consistency), la negazione delle autorizzazioni richieste comporta operazioni di scrittura e lettura fortemente coerenti. `AccessDeniedException` Se una replica rimane nello `REPLICATION_NOT_AUTHORIZED` stato per più di sette giorni, diventa definitivamente inaccessibile e le operazioni di scrittura e lettura fortemente coerenti continueranno a fallire con un errore. Alcune operazioni di gestione, come l’eliminazione delle repliche, avranno esito positivo.

### Dimensionamento automatico del ruolo collegato al servizio
<a name="globaltables-autoscaling-slr"></a>

Quando si configura una tabella globale per la modalità di capacità fornita, è necessario configurare la scalabilità automatica per la tabella globale. La scalabilità automatica di DynamoDB utilizza il servizio Application AWS Auto Scaling per regolare dinamicamente la capacità di throughput assegnata sulle repliche di tabelle globali. Il servizio Application Auto Scaling crea un ruolo collegato al servizio (SLR) denominato. [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) Questo ruolo collegato al servizio viene creato automaticamente nel tuo AWS account quando configuri per la prima volta la scalabilità automatica per una tabella DynamoDB. Consente ad Application Auto Scaling di gestire la capacità delle tabelle assegnate e di creare allarmi. CloudWatch 

 Quando applicate politiche basate sulle risorse alle repliche, assicuratevi di non negare alcuna autorizzazione definita nel principio di Application [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSApplicationAutoscalingDynamoDBTablePolicy.html)Auto Scaling SLR, poiché ciò interromperà la funzionalità di auto scaling.

### Esempi di politiche IAM per ruoli collegati ai servizi
<a name="globaltables-example-slr"></a>

Una policy IAM con la seguente condizione non influisce sulle autorizzazioni richieste per la SLR di replica DynamoDB e la Auto Scaling SLR. AWS Questa condizione può essere aggiunta a policy altrimenti ampiamente restrittive per evitare l'interruzione involontaria della replica o della scalabilità automatica.

#### Esclusione delle autorizzazioni SLR richieste dalle politiche di negazione
<a name="example-exclude-slr-policy"></a>

L'esempio seguente mostra come escludere i ruoli principali collegati ai servizi dalle dichiarazioni di negazione:

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

## In che modo le tabelle globali utilizzano IAM AWS
<a name="globaltables-iam"></a>

Le sezioni seguenti descrivono le autorizzazioni richieste per le diverse operazioni delle tabelle globali e forniscono esempi di policy per aiutarti a configurare l'accesso appropriato per utenti e applicazioni.

**Nota**  
Tutte le autorizzazioni descritte devono essere applicate alla risorsa della tabella ARN specifica nelle regioni interessate. La risorsa della tabella ARN segue il formato`arn:aws:dynamodb:region:account-id:table/table-name`, in cui è necessario specificare i valori effettivi della regione, dell'ID dell'account e del nome della tabella.

**Topics**
+ [Creazione di tabelle globali e aggiunta di repliche](#globaltables-creation-iam)
+ [Aggiornamento delle tabelle globali](#globaltables-update-iam)
+ [Eliminazione di tabelle globali e rimozione di repliche](#globaltables-delete-iam)

### Creazione di tabelle globali e aggiunta di repliche
<a name="globaltables-creation-iam"></a>

Le tabelle globali DynamoDB supportano due modalità di coerenza: Multi-region Eventual Consistency (MREC) e Multi-region Strong Consistency (MRSC). Le tabelle globali MREC possono avere più repliche in un numero qualsiasi di regioni e garantire la coerenza finale. Le tabelle globali MRSC richiedono esattamente tre regioni (tre repliche o due repliche e un testimone) e forniscono una forte coerenza con zero Recovery Point Objective (RPO).

Le autorizzazioni necessarie per creare tabelle globali dipendono dal fatto che si stia creando una tabella globale con o senza un testimone.

#### Autorizzazioni per la creazione di tabelle globali
<a name="globaltables-creation-iam-all-types"></a>

Le seguenti autorizzazioni sono necessarie sia per la creazione iniziale della tabella globale che per l'aggiunta di repliche in un secondo momento. Queste autorizzazioni si applicano alle tabelle globali Multi-Region Eventual Consistency (MREC) e Multi-Region Strong Consistency (MRSC).
+ Le tabelle globali richiedono la replica tra regioni, che DynamoDB gestisce tramite il ruolo collegato al servizio (SLR). [`AWSServiceRoleForDynamoDBReplication`](#globaltables-replication-slr) La seguente autorizzazione consente a DynamoDB di creare questo ruolo automaticamente quando si crea una tabella globale per la prima volta:
  + `iam:CreateServiceLinkedRole`
+ Per creare una tabella globale o aggiungere una replica utilizzando l'[https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API, è necessario disporre della seguente autorizzazione sulla risorsa della tabella di origine:
  + `dynamodb:UpdateTable`
+ È necessario disporre delle seguenti autorizzazioni sulla risorsa della tabella nelle Regioni per aggiungere le repliche:
  + `dynamodb:CreateTable`
  + `dynamodb:CreateTableReplica`
  + `dynamodb:Query`
  + `dynamodb:Scan`
  + `dynamodb:UpdateItem`
  + `dynamodb:PutItem`
  + `dynamodb:GetItem`
  + `dynamodb:DeleteItem`
  + `dynamodb:BatchWriteItem`

#### Autorizzazioni aggiuntive per le tabelle globali MRSC che utilizzano un testimone
<a name="globaltables-creation-iam-witness"></a>

Quando si crea una tabella globale MRSC (Multi-Region Strong Consistency) con una regione di riferimento, è necessario disporre della seguente autorizzazione sulla risorsa della tabella in tutte le regioni partecipanti (incluse sia le regioni di replica che la regione di riferimento):
+ `dynamodb:CreateGlobalTableWitness`

#### Esempi di politiche IAM per la creazione di tabelle globali
<a name="globaltables-creation-iam-example"></a>

##### Creazione di una tabella globale MREC o MRSC in tre regioni
<a name="globaltables-creation-iam-example-three-regions"></a>

La seguente politica basata sull'identità consente di creare una tabella globale MREC o MRSC denominata «users» in tre regioni, inclusa la creazione del ruolo collegato al servizio di replica DynamoDB richiesto.

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

------

##### Limitazione della creazione di tabelle globali MREC o MRSC a regioni specifiche
<a name="globaltables-creation-iam-example-restrict-regions"></a>

La seguente policy basata sull'identità consente di creare repliche di tabelle globali DynamoDB in regioni specifiche utilizzando la RequestedRegion chiave [aws:](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) condition, inclusa la creazione del ruolo collegato al servizio di replica DynamoDB richiesto.

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

------

##### Creazione di una tabella globale MRSC con testimone
<a name="globaltables-creation-iam-example-witness"></a>

La seguente policy basata sull'identità consente di creare una tabella globale DynamoDB MRSC denominata «users» con repliche in us-east-1 e us-east-2 e un testimone in us-west-2, inclusa la creazione del ruolo collegato al servizio di replica DynamoDB richiesto.

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

------

##### Limitazione della creazione di testimoni MRSC a regioni specifiche
<a name="globaltables-creation-iam-example-restrict-witness-regions"></a>

Questa policy basata sull'identità consente di creare una tabella globale MRSC con repliche limitate a regioni specifiche utilizzando la chiave [aws: RequestedRegion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion) condition e la creazione di testimoni senza restrizioni in tutte le regioni, inclusa la creazione del ruolo collegato al servizio di replica DynamoDB richiesto.

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

------

### Aggiornamento delle tabelle globali
<a name="globaltables-update-iam"></a>

Per modificare le impostazioni di replica per una tabella globale esistente utilizzando l'[https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API, è necessaria la seguente autorizzazione sulla risorsa della tabella nella regione in cui stai effettuando la chiamata API:
+ `dynamodb:UpdateTable`

È inoltre possibile aggiornare altre configurazioni di tabelle globali, come i criteri di ridimensionamento automatico e le impostazioni Time to Live. Per queste operazioni di aggiornamento aggiuntive sono necessarie le seguenti autorizzazioni:
+ Per aggiornare una politica di ridimensionamento automatico delle repliche con l'[https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTableReplicaAutoScaling.html)API, è necessario disporre delle seguenti autorizzazioni sulla risorsa della tabella in tutte le regioni contenenti repliche:
  + `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`
+ Per aggiornare le impostazioni Time to Live con l'[https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTimeToLive.html)API, è necessario disporre delle seguenti autorizzazioni sulla risorsa della tabella in tutte le regioni contenenti repliche:
  + `dynamodb:UpdateTimeToLive`

  Tieni presente che Time to Live (TTL) è supportato solo per le tabelle globali configurate con Multi-Region Eventual Consistency (MREC). Per ulteriori informazioni su come funzionano le tabelle globali con TTL, consulta [Come funzionano le tabelle globali DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2globaltables_HowItWorks.html).

### Eliminazione di tabelle globali e rimozione di repliche
<a name="globaltables-delete-iam"></a>

Per eliminare una tabella globale, è necessario rimuovere tutte le repliche. Le autorizzazioni richieste per questa operazione variano a seconda che si stia eliminando una tabella globale con o senza una regione di riferimento.

#### Autorizzazioni per l'eliminazione di tabelle globali e la rimozione di repliche
<a name="globaltables-delete-iam-all-types"></a>

Le seguenti autorizzazioni sono necessarie sia per rimuovere singole repliche sia per eliminare completamente le tabelle globali. L'eliminazione di una configurazione di tabella globale rimuove solo la relazione di replica tra tabelle in regioni diverse. Non elimina la tabella DynamoDB sottostante nell'ultima regione rimanente. La tabella nell'ultima regione continua a esistere come tabella DynamoDB standard con gli stessi dati e le stesse impostazioni. Queste autorizzazioni si applicano alle tabelle globali Multi-Region Eventual Consistency (MREC) e Multi-Region Strong Consistency (MRSC). 
+ Per rimuovere le repliche da una tabella globale utilizzando l'[https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateTable.html)API, è necessaria la seguente autorizzazione sulla risorsa della tabella nella regione da cui si sta effettuando la chiamata API:
  + `dynamodb:UpdateTable`
+ Sono necessarie le seguenti autorizzazioni sulla risorsa della tabella in ogni regione in cui stai rimuovendo una replica:
  + `dynamodb:DeleteTable`
  + `dynamodb:DeleteTableReplica`

#### Autorizzazioni aggiuntive per le tabelle globali MRSC che utilizzano un testimone
<a name="globaltables-delete-iam-witness"></a>

Per eliminare una tabella globale MRSC (Multi-region Strong Consistency) con un testimone, devi disporre della seguente autorizzazione sulla risorsa della tabella in tutte le regioni partecipanti (incluse sia le regioni di replica che la regione di riferimento):
+ `dynamodb:DeleteGlobalTableWitness`

#### Esempi: politiche IAM per eliminare le repliche di una tabella globale
<a name="globaltables-delete-iam-example"></a>

##### Eliminazione di repliche di tabelle globali
<a name="globaltables-delete-replicas-iam-example"></a>

Questa policy basata sull'identità consente di eliminare una tabella globale DynamoDB denominata «users» e le relative repliche in tre regioni:

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

------

##### Eliminazione di una tabella globale MRSC con un testimone
<a name="globaltables-delete-witness-iam-example"></a>

Questa politica basata sull'identità consente di eliminare la replica e il testimone di una tabella globale MRSC denominata «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"
      ]
    }
  ]
}
```

------

## Come vengono utilizzate le tabelle globali AWS KMS
<a name="globaltables-kms"></a>

Come tutte le tabelle DynamoDB, le repliche delle tabelle globali crittografano sempre i dati inattivi utilizzando chiavi di crittografia archiviate AWS in Key Management Service ().AWS KMS

Tutte le repliche in una tabella globale devono essere configurate con lo stesso tipo di chiave KMS (chiave di proprietà di AWS , chiave gestita da AWS o chiave gestita dal cliente).

**Importante**  
DynamoDB richiede l’accesso alla chiave di crittografia della replica per eliminare una replica. Se si desidera disabilitare o eliminare una chiave gestita dal cliente utilizzata per crittografare una replica perché si sta eliminando la replica, è necessario prima eliminare la replica, attendere che lo stato della tabella su una delle repliche rimanenti cambi in `ACTIVE`, quindi disabilitare o eliminare la chiave.

Per una tabella globale configurata per coerenza finale multi-Regione (MREC), se si disabilita o si revoca l’accesso di DynamoDB a una chiave gestita dal cliente utilizzata per crittografare una replica, la replica da e verso la replica verrà interrotta e lo stato della replica cambierà in `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Se una replica in una tabella globale MREC rimane nello stato `INACCESSIBLE_ENCRYPTION_CREDENTIALS` per più di 20 ore, viene convertita in modo irreversibile in una tabella DynamoDB a Regione singola.

Per una tabella globale configurata per elevata consistenza multi-Regione (MRSC), se si disabilita o si revoca l’accesso di DynamoDB a una chiave gestita dal cliente utilizzata per crittografare una replica, la replica da e verso la replica si interromperà, i tentativi di eseguire scritture oppure operazioni a elevata consistenza di lettura sulla replica restituiranno un errore e lo stato della replica cambierà in `INACCESSIBLE_ENCRYPTION_CREDENTIALS`. Se una replica in una tabella globale MRSC rimane nello stato `INACCESSIBLE_ENCRYPTION_CREDENTIALS` per più di sette giorni, a seconda delle autorizzazioni specifiche revocate, la replica verrà archiviata o diventerà definitivamente inaccessibile.