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à.
# Usa point-in-time il ripristino in Amazon Keyspaces
Con Amazon Keyspaces (per Apache Cassandra), puoi ripristinare le tabelle in un momento specifico utilizzando Point-in-Time Restore (PITR). PITR consente di ripristinare una tabella a uno stato precedente negli ultimi 35 giorni, fornendo funzionalità di protezione e ripristino dei dati. Questa funzionalità è utile in casi quali l'eliminazione accidentale dei dati, gli errori delle applicazioni o per scopi di test. È possibile ripristinare i dati in modo rapido ed efficiente, riducendo al minimo i tempi di inattività e la perdita di dati. Le seguenti sezioni ti guidano nel processo di ripristino delle tabelle utilizzando PITR in Amazon Keyspaces, garantendo l'integrità dei dati e la continuità aziendale.
**Topics**
+ [Configura le autorizzazioni IAM della tabella di ripristino per Amazon Keyspaces PITR](howitworks_restore_permissions.md)
+ [Configurare PITR per una tabella in Amazon Keyspaces](configure_PITR.md)
+ [Disattiva PITR per una tabella Amazon Keyspaces](disable_PITR.md)
+ [Ripristina una tabella dal backup a un momento temporale specificato in Amazon Keyspaces](restoretabletopointintime.md)
+ [Ripristina una tabella eliminata utilizzando Amazon Keyspaces PITR](restoredeleted.md)
# Configura le autorizzazioni IAM della tabella di ripristino per Amazon Keyspaces PITR
Questa sezione riassume come configurare le autorizzazioni per un principale AWS Identity and Access Management (IAM) per ripristinare le tabelle Amazon Keyspaces. In IAM, la policy AWS gestita `AmazonKeyspacesFullAccess` include le autorizzazioni per ripristinare le tabelle Amazon Keyspaces. Per implementare una policy personalizzata con autorizzazioni minime richieste, considera i requisiti descritti nella sezione successiva.
Per ripristinare correttamente una tabella, il principale IAM necessita delle seguenti autorizzazioni minime:
+ `cassandra:Restore`— L'azione di ripristino è necessaria per ripristinare la tabella di destinazione.
+ `cassandra:Select`— L'azione di selezione è necessaria per leggere dalla tabella di origine.
+ `cassandra:TagResource`— L'azione tag è facoltativa e richiesta solo se l'operazione di ripristino aggiunge tag.
Questo è un esempio di policy che concede le autorizzazioni minime richieste a un utente per ripristinare le tabelle nel keyspace. `mykeyspace`
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"cassandra:Restore",
"cassandra:Select"
],
"Resource":[
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/mykeyspace/*",
"arn:aws:cassandra:us-east-1:111122223333:/keyspace/system*"
]
}
]
}
```
Potrebbero essere necessarie autorizzazioni aggiuntive per ripristinare una tabella in base ad altre funzionalità selezionate. Ad esempio, se la tabella di origine è crittografata a riposo con una chiave gestita dal cliente, Amazon Keyspaces deve disporre delle autorizzazioni per accedere alla chiave gestita dal cliente della tabella di origine per ripristinare correttamente la tabella. Per ulteriori informazioni, consulta [Ripristino PITR di tabelle crittografate](PointInTimeRecovery_HowItWorks.md#howitworks_backup_encryption).
Se utilizzi policy IAM con [chiavi di condizione](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) per limitare il traffico in entrata a fonti specifiche, devi assicurarti che Amazon Keyspaces sia autorizzato a eseguire un'operazione di ripristino per conto del tuo principale. Devi aggiungere una chiave di `aws:ViaAWSService` condizione alla tua policy IAM se la policy limita il traffico in entrata a uno dei seguenti fattori:
+ Endpoint VPC con `aws:SourceVpce`
+ Intervalli IP con `aws:SourceIp`
+ VPCs con `aws:SourceVpc`
La chiave di `aws:ViaAWSService` condizione consente l'accesso quando un AWS servizio effettua una richiesta utilizzando le credenziali del principale. Per ulteriori informazioni, consulta [IAM JSON Policy elements: Condition key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) nella *IAM User Guide*.
Di seguito è riportato un esempio di policy che limita il traffico di origine a un indirizzo IP specifico e consente ad Amazon Keyspaces di ripristinare una tabella per conto del principale.
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"CassandraAccessForCustomIp",
"Effect":"Allow",
"Action":"cassandra:*",
"Resource":"*",
"Condition":{
"Bool":{
"aws:ViaAWSService":"false"
},
"ForAnyValue:IpAddress":{
"aws:SourceIp":[
"123.45.167.89"
]
}
}
},
{
"Sid":"CassandraAccessForAwsService",
"Effect":"Allow",
"Action":"cassandra:*",
"Resource":"*",
"Condition":{
"Bool":{
"aws:ViaAWSService":"true"
}
}
}
]
}
```
Per un esempio di politica che utilizza la chiave `aws:ViaAWSService` global condition, vedi. [Policy degli endpoint VPC e ripristino di Amazon point-in-time Keyspaces (PITR)](vpc-endpoints.md#VPC_PITR_restore)
# Configurare PITR per una tabella in Amazon Keyspaces
Puoi configurare una tabella in Amazon Keyspaces per le operazioni di backup e ripristino utilizzando PITR con la console, CQL e. AWS CLI
Quando si crea una nuova tabella utilizzando CQL o il AWS CLI, è necessario abilitare esplicitamente PITR nell'istruzione create table. Quando si crea una nuova tabella utilizzando la console, PITR sarà abilitato per impostazione predefinita.
Per informazioni su come ripristinare una tabella, consulta[Ripristina una tabella dal backup a un momento temporale specificato in Amazon Keyspaces](restoretabletopointintime.md).
------
#### [ Console ]
**Configurare PITR per una tabella utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle** e seleziona la tabella che desideri modificare.
1. Nella scheda **Backup**, scegli **Modifica**.
1. Nella sezione **Modifica impostazioni point-in-time di ripristino**, seleziona **Abilita Point-in-time ripristino.**
1. Scegli **Save changes** (Salva modifiche).
------
#### [ Cassandra Query Language (CQL) ]
**Configura PITR per una tabella utilizzando CQL**
1. È possibile gestire le impostazioni PITR per le tabelle utilizzando la `point_in_time_recovery` proprietà personalizzata.
Per abilitare PITR durante la creazione di una nuova tabella, è necessario impostare lo stato su. `point_in_time_recovery` `enabled` È possibile utilizzare il seguente comando CQL come esempio.
```
CREATE TABLE "my_keyspace1"."my_table1"(
"id" int,
"name" ascii,
"date" timestamp,
PRIMARY KEY("id"))
WITH CUSTOM_PROPERTIES = {
'capacity_mode':{'throughput_mode':'PAY_PER_REQUEST'},
'point_in_time_recovery':{'status':'enabled'}
}
```
**Nota**
Se non viene specificata alcuna point-in-time proprietà personalizzata di point-in-time ripristino, il ripristino è disabilitato per impostazione predefinita.
1. Per abilitare PITR per una tabella esistente utilizzando CQL, esegui il seguente comando CQL.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'enabled'}}
```
------
#### [ CLI ]
**Configurare PITR per una tabella utilizzando il AWS CLI**
1. È possibile gestire le impostazioni PITR per le tabelle utilizzando l'`UpdateTable`API.
Per abilitare PITR durante la creazione di una nuova tabella, è necessario includere `point-in-time-recovery 'status=ENABLED'` nel comando di creazione della tabella. È possibile utilizzare il AWS CLI comando seguente come esempio. Il comando è stato suddiviso in righe separate per migliorare la leggibilità.
```
aws keyspaces create-table --keyspace-name 'myKeyspace' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--point-in-time-recovery 'status=ENABLED'
```
**Nota**
Se non viene specificato alcun valore di point-in-time ripristino, point-in-time il ripristino è disabilitato per impostazione predefinita.
1. Per confermare l'impostazione di point-in-time ripristino per una tabella, è possibile utilizzare il seguente AWS CLI comando.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. Per abilitare PITR per una tabella esistente utilizzando il AWS CLI, esegui il comando seguente.
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=ENABLED'
```
------
# Disattiva PITR per una tabella Amazon Keyspaces
Puoi disattivare PITR per una tabella Amazon Keyspaces in qualsiasi momento utilizzando la console, CQL o il. AWS CLI
**Importante**
La disabilitazione di PITR elimina immediatamente la cronologia di backup, anche se riattivi PITR sul tavolo entro 35 giorni.
Per informazioni su come ripristinare una tabella, consulta. [Ripristina una tabella dal backup a un momento temporale specificato in Amazon Keyspaces](restoretabletopointintime.md)
------
#### [ Console ]
**Disabilitare PITR per una tabella utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel pannello di navigazione, scegli **Tabelle** e seleziona la tabella che desideri modificare.
1. Nella scheda **Backup**, scegli **Modifica**.
1. Nella sezione **Modifica impostazioni point-in-time di ripristino**, deseleziona la casella di controllo **Abilita Point-in-time ripristino**.
1. Scegli **Save changes** (Salva modifiche).
------
#### [ Cassandra Query Language (CQL) ]
**Disabilita PITR per una tabella utilizzando CQL**
+ Per disabilitare PITR per una tabella esistente, esegui il seguente comando CQL.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'disabled'}}
```
------
#### [ CLI ]
**Disattivate PITR per una tabella utilizzando il AWS CLI**
+ Per disabilitare PITR per una tabella esistente, eseguite il comando seguente AWS CLI .
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=DISABLED'
```
------
# Ripristina una tabella dal backup a un momento temporale specificato in Amazon Keyspaces
La sezione seguente mostra come ripristinare una tabella Amazon Keyspaces esistente in un momento specifico.
**Nota**
Questa procedura presuppone che la tabella che stai utilizzando sia stata configurata con il ripristino. point-in-time Per abilitare PITR per una tabella, vedere. [Configurare PITR per una tabella in Amazon Keyspaces](configure_PITR.md)
**Importante**
Mentre è in corso un ripristino, non modificare o eliminare le policy AWS Identity and Access Management (IAM) che concedono al principale IAM (ad esempio, utente, gruppo o ruolo) l'autorizzazione a eseguire il ripristino. Diversamente, si potrebbero verificare comportamenti imprevisti. Ad esempio, se rimuovi i permessi di scrittura per una tabella durante il ripristino della tabella, l'`RestoreTableToPointInTime`operazione sottostante non può scrivere nessuno dei dati ripristinati nella tabella.
È possibile modificare o eliminare le autorizzazioni solo dopo il completamento dell'operazione di ripristino.
------
#### [ Console ]
**Ripristina una tabella in un momento specifico utilizzando la console**
1. [Accedi a e apri Console di gestione AWS la console Amazon Keyspaces a casahttps://console.aws.amazon.com/keyspaces/.](https://console.aws.amazon.com/keyspaces/home)
1. Nel riquadro di navigazione sul lato sinistro della console scegli **Tables (Tabelle)**.
1. Nell'elenco delle tabelle, scegli la tabella che desideri ripristinare.
1. Nella scheda **Backup** della tabella, nella sezione **Point-in-time Ripristino**, scegli **Ripristina**.
1. Per il nuovo nome della tabella, inserisci un nuovo nome per la tabella ripristinata, ad esempio**mytable\$1restored**.
1. Per definire il momento dell'operazione di ripristino, puoi scegliere tra due opzioni:
+ Seleziona l'ora **più vicina** preconfigurata.
+ Seleziona **Specificare data e ora** e inserisci la data e l'ora in cui desideri ripristinare la nuova tabella.
**Nota**
È possibile eseguire il ripristino in qualsiasi momento compreso tra la **prima** ora e l'ora corrente. Amazon Keyspaces ripristina i dati della tabella allo stato in base alla data e all'ora selezionate (giorno:ora:minuto:secondo).
1. **Scegli Ripristina per avviare il processo di ripristino.**
La tabella in fase di ripristino è visualizzata con lo stato **Restoring (Ripristino)**. Al termine del processo di ripristino, lo stato della tabella ripristinata diventa **Attivo**.
------
#### [ Cassandra Query Language (CQL) ]
**Ripristina una tabella in un determinato momento utilizzando CQL**
1. È possibile ripristinare una tabella attiva in un intervallo point-in-time compreso tra l'ora corrente `earliest_restorable_timestamp` e quella corrente. L'ora corrente è l'impostazione predefinita.
Per confermare che point-in-time il ripristino è abilitato per la tabella, interrogate il `system_schema_mcs.tables` file come mostrato in questo esempio.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Point-in-time il ripristino è abilitato come illustrato nell'output di esempio seguente.
```
custom_properties
-----------------
{
...,
"point_in_time_recovery": {
"earliest_restorable_timestamp":"2020-06-30T19:19:21.175Z"
"status":"enabled"
}
}
```
1.
+ Ripristina la tabella all'ora corrente. Quando si omette la `WITH restore_timestamp = ...` clausola, viene utilizzato il timestamp corrente.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
+ È inoltre possibile ripristinare un momento specifico, definito da un `restore_timestamp` formato ISO 8601. Puoi specificare un momento qualsiasi negli ultimi 35 giorni. Ad esempio, il comando seguente ripristina la tabella a `EarliestRestorableDateTime`.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable
WITH restore_timestamp = '2020-06-30T19:19:21.175Z';
```
Per una descrizione completa della sintassi, vedere [RIPRISTINARE LA TABELLA](cql.ddl.table.md#cql.ddl.table.restore) nella guida di riferimento del linguaggio.
1. Per verificare che il ripristino della tabella sia andato a buon fine, interrogate il `system_schema_mcs.tables` per confermare lo stato della tabella.
```
SELECT status
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable_restored'
```
L'interrogazione mostra il seguente risultato.
```
status
------
RESTORING
```
La tabella in fase di ripristino è visualizzata con lo stato **Restoring (Ripristino)**. Al termine del processo di ripristino, lo stato della tabella diventa **Attivo**.
------
#### [ CLI ]
**Ripristina una tabella in un determinato momento utilizzando il AWS CLI**
1. Crea una tabella semplice denominata `myTable` con PITR abilitato. Il comando è stato suddiviso in righe separate per motivi di leggibilità.
```
aws keyspaces create-table --keyspace-name 'myKeyspace' --table-name 'myTable'
--schema-definition 'allColumns=[{name=id,type=int},{name=name,type=text},{name=date,type=timestamp}],partitionKeys=[{name=id}]'
--point-in-time-recovery 'status=ENABLED'
```
1. Confermate le proprietà della nuova tabella ed esaminatela `earliestRestorableTimestamp` per PITR.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
L'output di questo comando restituisce quanto segue.
```
{
"keyspaceName": "myKeyspace",
"tableName": "myTable",
"resourceArn": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable",
"creationTimestamp": "2022-06-20T14:34:57.049000-07:00",
"status": "ACTIVE",
"schemaDefinition": {
"allColumns": [
{
"name": "id",
"type": "int"
},
{
"name": "date",
"type": "timestamp"
},
{
"name": "name",
"type": "text"
}
],
"partitionKeys": [
{
"name": "id"
}
],
"clusteringKeys": [],
"staticColumns": []
},
"capacitySpecification": {
"throughputMode": "PAY_PER_REQUEST",
"lastUpdateToPayPerRequestTimestamp": "2022-06-20T14:34:57.049000-07:00"
},
"encryptionSpecification": {
"type": "AWS_OWNED_KMS_KEY"
},
"pointInTimeRecovery": {
"status": "ENABLED",
"earliestRestorableTimestamp": "2022-06-20T14:35:13.693000-07:00"
},
"defaultTimeToLive": 0,
"comment": {
"message": ""
}
}
```
1.
+ Per ripristinare una tabella in un determinato momento, specificate a `restore_timestamp` in formato ISO 8601. Puoi scegliere qualsiasi momento negli ultimi 35 giorni a intervalli di un secondo. Ad esempio, il comando seguente ripristina la tabella a `EarliestRestorableDateTime`.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored' --restore-timestamp "2022-06-20 21:35:14.693"
```
L'output di questo comando restituisce l'ARN della tabella ripristinata.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored"
}
```
+ Per ripristinare la tabella all'ora corrente, è possibile omettere il `restore-timestamp` parametro.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored1'"
```
------
# Ripristina una tabella eliminata utilizzando Amazon Keyspaces PITR
La procedura seguente mostra come ripristinare una tabella eliminata dal backup al momento dell'eliminazione. È possibile eseguire questa operazione utilizzando CQL o il AWS CLI.
**Nota**
Questa procedura presuppone che PITR sia stato abilitato nella tabella eliminata.
------
#### [ Cassandra Query Language (CQL) ]
**Ripristina una tabella eliminata utilizzando CQL**
1. Per confermare che point-in-time il ripristino è abilitato per una tabella eliminata, interroga la tabella di sistema. Vengono mostrate solo le tabelle con point-in-time il ripristino abilitato.
```
SELECT custom_properties
FROM system_schema_mcs.tables_history
WHERE keyspace_name = 'mykeyspace' AND table_name = 'my_table';
```
L'interrogazione mostra il seguente risultato.
```
custom_properties
------------------
{
...,
"point_in_time_recovery":{
"restorable_until_time":"2020-08-04T00:48:58.381Z",
"status":"enabled"
}
}
```
1. Ripristina la tabella al momento dell'eliminazione con la seguente istruzione di esempio.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
------
#### [ CLI ]
**Ripristina una tabella eliminata utilizzando il AWS CLI**
1. Eliminare una tabella creata in precedenza con PITR abilitato. Il comando seguente è un esempio.
```
aws keyspaces delete-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. Ripristina la tabella eliminata al momento dell'eliminazione con il seguente comando.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored2'
```
L'output di questo comando restituisce l'ARN della tabella ripristinata.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored2"
}
```
------