Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utiliser point-in-time la restauration dans Amazon Keyspaces
Avec Amazon Keyspaces (pour Apache Cassandra), vous pouvez restaurer des tables à un moment précis à l'aide de Point-in-Time Restore (PITR). Le PITR vous permet de restaurer un état antérieur d'une table au cours des 35 derniers jours, en fournissant des fonctionnalités de protection et de restauration des données. Cette fonctionnalité est utile dans des cas tels que la suppression accidentelle de données, les erreurs d'application ou à des fins de test. Vous pouvez récupérer les données rapidement et efficacement, en minimisant les temps d'arrêt et les pertes de données. Les sections suivantes vous guident tout au long du processus de restauration des tables à l'aide du PITR dans Amazon Keyspaces, afin de garantir l'intégrité des données et la continuité des activités.
**Topics**
+ [Configurer les autorisations IAM de la table de restauration pour Amazon Keyspaces PITR](howitworks_restore_permissions.md)
+ [Configurer le PITR pour une table dans Amazon Keyspaces](configure_PITR.md)
+ [Désactiver le PITR pour une table Amazon Keyspaces](disable_PITR.md)
+ [Restaurer une table à partir d'une sauvegarde à un moment précis dans Amazon Keyspaces](restoretabletopointintime.md)
+ [Restaurer une table supprimée à l'aide d'Amazon Keyspaces PITR](restoredeleted.md)
# Configurer les autorisations IAM de la table de restauration pour Amazon Keyspaces PITR
Cette section explique comment configurer les autorisations permettant à un principal Gestion des identités et des accès AWS (IAM) de restaurer les tables Amazon Keyspaces. Dans IAM, la politique AWS gérée `AmazonKeyspacesFullAccess` inclut les autorisations de restauration des tables Amazon Keyspaces. Pour mettre en œuvre une politique personnalisée avec les autorisations minimales requises, tenez compte des exigences décrites dans la section suivante.
Pour restaurer correctement une table, le principal IAM a besoin des autorisations minimales suivantes :
+ `cassandra:Restore`— L'action de restauration est requise pour que la table cible soit restaurée.
+ `cassandra:Select`— L'action de sélection est requise pour lire dans la table source.
+ `cassandra:TagResource`— L'action de balise est facultative et n'est requise que si l'opération de restauration ajoute des balises.
Il s'agit d'un exemple de politique qui accorde les autorisations minimales requises à un utilisateur pour restaurer des tables dans 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*"
]
}
]
}
```
Des autorisations supplémentaires pour restaurer une table peuvent être requises en fonction d'autres fonctionnalités sélectionnées. Par exemple, si la table source est chiffrée au repos à l'aide d'une clé gérée par le client, Amazon Keyspaces doit être autorisé à accéder à la clé gérée par le client de la table source pour pouvoir restaurer correctement la table. Pour de plus amples informations, veuillez consulter [Restauration PITR de tables chiffrées](PointInTimeRecovery_HowItWorks.md#howitworks_backup_encryption).
Si vous utilisez des politiques IAM avec des [clés de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) pour restreindre le trafic entrant vers des sources spécifiques, vous devez vous assurer qu'Amazon Keyspaces est autorisé à effectuer une opération de restauration pour le compte de votre principal. Vous devez ajouter une clé de `aws:ViaAWSService` condition à votre politique IAM si celle-ci limite le trafic entrant à l'une des conditions suivantes :
+ Points de terminaison VPC avec `aws:SourceVpce`
+ plages d'adresses IP avec `aws:SourceIp`
+ VPCs avec `aws:SourceVpc`
La clé de `aws:ViaAWSService` condition autorise l'accès lorsqu'un AWS service fait une demande en utilisant les informations d'identification du principal. Pour plus d'informations, voir [Éléments de politique IAM JSON : clé de condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) dans le guide de l'*utilisateur IAM*.
Voici un exemple de politique qui limite le trafic source à une adresse IP spécifique et permet à Amazon Keyspaces de restaurer une table pour le compte du principal.
```
{
"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"
}
}
}
]
}
```
Pour un exemple de politique utilisant la clé de condition `aws:ViaAWSService` globale, voir[Politiques relatives aux terminaux VPC et restauration d'Amazon Keyspaces point-in-time (PITR)](vpc-endpoints.md#VPC_PITR_restore).
# Configurer le PITR pour une table dans Amazon Keyspaces
Vous pouvez configurer une table dans Amazon Keyspaces pour les opérations de sauvegarde et de restauration à l'aide de PITR avec la console, le CQL et le. AWS CLI
Lorsque vous créez une nouvelle table à l'aide de CQL ou du AWS CLI, vous devez activer explicitement le PITR dans l'instruction create table. Lorsque vous créez une nouvelle table à l'aide de la console, PITR est activé par défaut.
Pour savoir comment restaurer une table, consultez[Restaurer une table à partir d'une sauvegarde à un moment précis dans Amazon Keyspaces](restoretabletopointintime.md).
------
#### [ Console ]
**Configurer le PITR pour une table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Tables** et sélectionnez la table que vous souhaitez modifier.
1. Dans l'onglet **Sauvegardes**, choisissez **Modifier**.
1. Dans la section **Modifier les paramètres de point-in-time restauration**, sélectionnez **Activer Point-in-time la restauration**.
1. Sélectionnez **Enregistrer les modifications**.
------
#### [ Cassandra Query Language (CQL) ]
**Configurer le PITR pour une table à l'aide de CQL**
1. Vous pouvez gérer les paramètres PITR des tables à l'aide de la propriété `point_in_time_recovery` personnalisée.
Pour activer le PITR lorsque vous créez une nouvelle table, vous devez définir le statut de `point_in_time_recovery` à`enabled`. Vous pouvez utiliser la commande CQL suivante à titre d'exemple.
```
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'}
}
```
**Note**
Si aucune propriété personnalisée de point-in-time restauration n'est spécifiée, point-in-time la restauration est désactivée par défaut.
1. Pour activer le PITR pour une table existante à l'aide de CQL, exécutez la commande CQL suivante.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'enabled'}}
```
------
#### [ CLI ]
**Configurez le PITR pour une table à l'aide du AWS CLI**
1. Vous pouvez gérer les paramètres PITR des tables à l'aide de l'`UpdateTable`API.
Pour activer le PITR lorsque vous créez une nouvelle table, vous devez l'inclure `point-in-time-recovery 'status=ENABLED'` dans la commande create table. Vous pouvez utiliser la AWS CLI commande suivante à titre d'exemple. La commande a été divisée en lignes distinctes pour améliorer la lisibilité.
```
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'
```
**Note**
Si aucune valeur point-in-time de restauration n'est spécifiée, point-in-time la restauration est désactivée par défaut.
1. Pour confirmer le paramètre de point-in-time restauration d'une table, vous pouvez utiliser la AWS CLI commande suivante.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. Pour activer le PITR pour une table existante à l'aide de AWS CLI, exécutez la commande suivante.
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=ENABLED'
```
------
# Désactiver le PITR pour une table Amazon Keyspaces
Vous pouvez désactiver le PITR pour une table Amazon Keyspaces à tout moment à l'aide de la console, du CQL ou du. AWS CLI
**Important**
La désactivation du PITR supprime immédiatement l'historique de vos sauvegardes, même si vous réactivez le PITR sur la table dans les 35 jours.
Pour savoir comment restaurer une table, consultez[Restaurer une table à partir d'une sauvegarde à un moment précis dans Amazon Keyspaces](restoretabletopointintime.md).
------
#### [ Console ]
**Désactiver le PITR pour une table à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation, choisissez **Tables** et sélectionnez la table que vous souhaitez modifier.
1. Dans l'onglet **Sauvegardes**, choisissez **Modifier**.
1. Dans la section **Modifier les paramètres de point-in-time restauration**, décochez la case **Activer la Point-in-time restauration**.
1. Sélectionnez **Enregistrer les modifications**.
------
#### [ Cassandra Query Language (CQL) ]
**Désactiver le PITR pour une table à l'aide de CQL**
+ Pour désactiver le PITR pour une table existante, exécutez la commande CQL suivante.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'disabled'}}
```
------
#### [ CLI ]
**Désactivez le PITR pour une table à l'aide du AWS CLI**
+ Pour désactiver le PITR pour une table existante, exécutez la AWS CLI commande suivante.
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=DISABLED'
```
------
# Restaurer une table à partir d'une sauvegarde à un moment précis dans Amazon Keyspaces
La section suivante explique comment restaurer une table Amazon Keyspaces existante à un moment précis.
**Note**
Cette procédure suppose que la table que vous utilisez a été configurée avec la fonction point-in-time de restauration. Pour activer le PITR pour une table, consultez[Configurer le PITR pour une table dans Amazon Keyspaces](configure_PITR.md).
**Important**
Pendant qu'une restauration est en cours, ne modifiez ni ne supprimez les politiques Gestion des identités et des accès AWS (IAM) qui accordent au principal IAM (par exemple, utilisateur, groupe ou rôle) l'autorisation d'effectuer la restauration. Sinon, il peut en résulter un comportement inattendu. Par exemple, si vous supprimez les autorisations d'écriture pour une table alors que celle-ci est en cours de restauration, l'`RestoreTableToPointInTime`opération sous-jacente ne peut écrire aucune des données restaurées dans la table.
Vous ne pouvez modifier ou supprimer des autorisations qu'une fois l'opération de restauration terminée.
------
#### [ Console ]
**Restaurer une table à un moment précis à l'aide de la console**
1. [Connectez-vous à la AWS Management Console console Amazon Keyspaces et ouvrez-la chez https://console.aws.amazon.com/keyspaces/ vous.](https://console.aws.amazon.com/keyspaces/home)
1. Dans le volet de navigation sur le côté gauche de la console, choisissez **Tables**.
1. Dans la liste des tables, choisissez la table que vous souhaitez restaurer.
1. Dans l'onglet **Sauvegardes** du tableau, dans la section **Point-in-time de restauration**, choisissez **Restaurer**.
1. Pour le nouveau nom de table, entrez un nouveau nom pour la table restaurée, par exemple**mytable\$1restored**.
1. Pour définir le moment de l'opération de restauration, vous pouvez choisir entre deux options :
+ Sélectionnez l'heure la **plus ancienne** préconfigurée.
+ Sélectionnez **Spécifier la date et l'heure**, puis entrez la date et l'heure auxquelles vous souhaitez restaurer la nouvelle table.
**Note**
Vous pouvez effectuer une restauration à n'importe quel moment dans le **plus** bref délai et à l'heure actuelle. Amazon Keyspaces restaure les données de votre table dans leur état en fonction de la date et de l'heure sélectionnées (day:hour:minute:second).
1. Choisissez **Restaurer** pour démarrer le processus de restauration.
La table en cours de restauration s'affiche avec le statut **Restauration en cours**. Une fois le processus de restauration terminé, le statut de la table restaurée passe à **Actif**.
------
#### [ Cassandra Query Language (CQL) ]
**Restaurer une table à un point dans le temps à l'aide de CQL**
1. Vous pouvez rétablir une table active point-in-time entre l'heure actuelle `earliest_restorable_timestamp` et l'heure actuelle. L'heure actuelle est la valeur par défaut.
Pour confirmer que la point-in-time restauration est activée pour la table, interrogez le `system_schema_mcs.tables` comme indiqué dans cet exemple.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Point-in-time la restauration est activée comme indiqué dans l'exemple de sortie suivant.
```
custom_properties
-----------------
{
...,
"point_in_time_recovery": {
"earliest_restorable_timestamp":"2020-06-30T19:19:21.175Z"
"status":"enabled"
}
}
```
1.
+ Rétablissez le tableau à l'heure actuelle. Lorsque vous omettez la `WITH restore_timestamp = ...` clause, l'horodatage actuel est utilisé.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
+ Vous pouvez également effectuer une restauration à un moment précis, défini par un `restore_timestamp` au format ISO 8601. Vous pouvez spécifier n'importe quel instant dans le passé au cours des 35 derniers jours. Par exemple, la commande suivante restaure la table à la `EarliestRestorableDateTime`.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable
WITH restore_timestamp = '2020-06-30T19:19:21.175Z';
```
Pour une description complète de la syntaxe, voir [RESTAURER LA TABLE](cql.ddl.table.md#cql.ddl.table.restore) la référence du langage.
1. Pour vérifier que la restauration de la table a réussi, interrogez le `system_schema_mcs.tables` pour confirmer l'état de la table.
```
SELECT status
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable_restored'
```
La requête affiche le résultat suivant.
```
status
------
RESTORING
```
La table en cours de restauration s'affiche avec le statut **Restauration en cours**. Une fois le processus de restauration terminé, le statut de la table passe à **Actif**.
------
#### [ CLI ]
**Restaurez un tableau à un point dans le temps à l'aide du AWS CLI**
1. Créez une table simple nommée sur `myTable` laquelle le PITR est activé. La commande a été divisée en lignes distinctes pour des raisons de lisibilité.
```
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. Vérifiez les propriétés de la nouvelle table et vérifiez le `earliestRestorableTimestamp` PITR.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
La sortie de cette commande renvoie ce qui suit.
```
{
"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.
+ Pour restaurer un tableau à un point dans le temps, spécifiez un `restore_timestamp` au format ISO 8601. Vous pouvez choisir n'importe quel moment au cours des 35 derniers jours à intervalles d'une seconde. Par exemple, la commande suivante restaure la table à la `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"
```
La sortie de cette commande renvoie l'ARN de la table restaurée.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored"
}
```
+ Pour rétablir l'heure actuelle de la table, vous pouvez omettre le `restore-timestamp` paramètre.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored1'"
```
------
# Restaurer une table supprimée à l'aide d'Amazon Keyspaces PITR
La procédure suivante indique comment restaurer une table supprimée depuis la sauvegarde jusqu'au moment de sa suppression. Vous pouvez le faire en utilisant CQL ou le AWS CLI.
**Note**
Cette procédure suppose que le PITR a été activé sur la table supprimée.
------
#### [ Cassandra Query Language (CQL) ]
**Restaurer une table supprimée à l'aide de CQL**
1. Pour confirmer que point-in-time la restauration est activée pour une table supprimée, interrogez la table système. Seules les tables pour lesquelles point-in-time la restauration est activée sont affichées.
```
SELECT custom_properties
FROM system_schema_mcs.tables_history
WHERE keyspace_name = 'mykeyspace' AND table_name = 'my_table';
```
La requête affiche le résultat suivant.
```
custom_properties
------------------
{
...,
"point_in_time_recovery":{
"restorable_until_time":"2020-08-04T00:48:58.381Z",
"status":"enabled"
}
}
```
1. Restaurez le tableau au moment de sa suppression à l'aide de l'exemple d'instruction suivant.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
------
#### [ CLI ]
**Restaurez une table supprimée à l'aide du AWS CLI**
1. Supprimez une table que vous avez créée précédemment et sur laquelle le PITR est activé. Voici un exemple de commande.
```
aws keyspaces delete-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. Restaurez la table supprimée au moment de sa suppression à l'aide de la commande suivante.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored2'
```
La sortie de cette commande renvoie l'ARN de la table restaurée.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored2"
}
```
------