# Backup and restore data with point-in-time recovery for Amazon Keyspaces
Point-in-time recovery (PITR) helps protect your Amazon Keyspaces tables from accidental write or delete operations by providing you continuous backups of your table data.
For example, suppose that a test script writes accidentally to a production Amazon Keyspaces table. With point-in-time recovery, you can restore that table's data to any second in time since PITR was enabled within the last 35 days. If you delete a table with point-in-time recovery enabled, you can query for the deleted table's data for 35 days (at no additional cost), and restore it to the state it was in just before the point of deletion.
You can restore an Amazon Keyspaces table to a point in time by using the console, the AWS SDK and the AWS Command Line Interface (AWS CLI), or Cassandra Query Language (CQL). For more information, see [Use point-in-time recovery in Amazon Keyspaces](PointInTimeRecovery_Tutorial.md).
Point-in-time operations have no performance or availability impact on the base table, and restoring a table doesn't consume additional throughput.
For information about PITR quotas, see [Quotas for Amazon Keyspaces (for Apache Cassandra)](quotas.md).
For information about pricing, see [Amazon Keyspaces (for Apache Cassandra) pricing](https://aws.amazon.com/keyspaces/pricing).
**Topics**
+ [How point-in-time recovery works in Amazon Keyspaces](PointInTimeRecovery_HowItWorks.md)
+ [Use point-in-time recovery in Amazon Keyspaces](PointInTimeRecovery_Tutorial.md)
# How point-in-time recovery works in Amazon Keyspaces
This section provides an overview of how Amazon Keyspaces point-in-time recovery (PITR) works. For more information about pricing, see [Amazon Keyspaces (for Apache Cassandra) pricing](https://aws.amazon.com/keyspaces/pricing).
**Topics**
+ [Time window for PITR continuous backups](#howitworks_backup_window)
+ [PITR restore settings](#howitworks_backup_settings)
+ [PITR restore of encrypted tables](#howitworks_backup_encryption)
+ [PITR restore of multi-Region tables](#howitworks_backup_multiRegion)
+ [PITR restore of tables with user-defined types (UDTs)](#howitworks_backup_udt)
+ [Table restore time with PITR](#howitworks_restore_time)
+ [Amazon Keyspaces PITR and integration with AWS services](#howitworks_integration)
## Time window for PITR continuous backups
Amazon Keyspaces PITR uses two timestamps to maintain the time frame for which restorable backups are available for a table.
+ Earliest restorable time – Marks the time of the earliest restorable backup. The earliest restorable backup goes back up to 35 days or when PITR was enabled, whichever is more recent. The maximum backup window of 35 days can't be modified.
+ Current time – The timestamp for the latest restorable backup is the current time. If no timestamp is provided during a restore, current time is used.
When PITR is enabled, you can restore to any point in time between `EarliestRestorableDateTime` and `CurrentTime`. You can only restore table data to a time when PITR was enabled.
If you disable PITR and later reenable it again, you reset the start time for the first available backup to when PITR was reenabled. This means that disabling PITR erases your backup history.
**Note**
Data definition language (DDL) operations on tables, such as schema changes, are performed asynchronously. You can only see completed operations in your restored table data, but you might see additional actions on your source table if they were in progress at the time of the restore. For a list of DDL statements, see [DDL statements (data definition language) in Amazon Keyspaces](cql.ddl.md).
A table doesn't have to be active to be restored. You can also restore deleted tables if PITR was enabled on the deleted table and the deletion occurred within the backup window (or within the last 35 days).
**Note**
If a new table is created with the same qualified name (for example, mykeyspace.mytable) as a previously deleted table, the deleted table will no longer be restorable. If you attempt to do this from the console, a warning is displayed.
## PITR restore settings
When you restore a table using PITR, Amazon Keyspaces restores your source table's schema and data to the state based on the selected timestamp (`day:hour:minute:second`) to a new table. PITR doesn't overwrite existing tables.
In addition to the table's schema and data, PITR restores the `custom_properties` from the source table. Unlike the table's data, which is restored based on the selected timestamp between earliest restore time and current time, custom properties are always restored based on the table's settings as of the current time.
The settings of the restored table match the settings of the source table with the timestamp of when the restore was initiated. If you want to overwrite these settings during restore, you can do so using `WITH custom_properties`. Custom properties include the following settings.
+ Read/write capacity mode
+ Provisioned throughput capacity settings
+ PITR settings
If the table is in provisioned capacity mode with auto scaling enabled, the restore operation also restores the table's auto scaling settings. You can overwrite them using the `autoscaling_settings` parameter in CQL or `autoScalingSpecification` with the CLI. For more information on auto scaling settings, see [Manage throughput capacity automatically with Amazon Keyspaces auto scaling](autoscaling.md).
When you do a full table restore, all table settings for the restored table come from the current settings of the source table at the time of the restore.
For example, suppose that a table's provisioned throughput was recently lowered to 50 read capacity units and 50 write capacity units. You then restore the table's state to three weeks ago. At this time, its provisioned throughput was set to 100 read capacity units and 100 write capacity units. In this case, Amazon Keyspaces restores your table data to that point in time, but uses the current provisioned throughput settings (50 read capacity units and 50 write capacity units).
The following settings are not restored, and you must configure them manually for the new table.
+ Amazon Keyspaces change data capture (CDC) streams
+ AWS Identity and Access Management (IAM) policies
+ Amazon CloudWatch metrics and alarms
+ Tags (can be added to the CQL `RESTORE` statement using `WITH TAGS`)
## PITR restore of encrypted tables
When you restore a table using PITR, Amazon Keyspaces restores your source table's encryption settings. If the table was encrypted with an AWS owned key (default), the table is restored with the same setting automatically. If the table you want to restore was encrypted using a customer managed key, the same customer managed key needs to be accessible to Amazon Keyspaces to restore the table data.
You can change the encryption settings of the table at the time of restore. To change from an AWS owned key to a customer managed key, you need to supply a valid and accessible customer managed key at the time of restore.
If you want to change from a customer managed key to an AWS owned key, confirm that Amazon Keyspaces has access to the customer managed key of the source table to restore the table with an AWS owned key. For more information about encryption at rest settings for tables, see [Encryption at rest: How it works in Amazon Keyspaces](encryption.howitworks.md).
**Note**
If the table was deleted because Amazon Keyspaces lost access to your customer managed key, you need to ensure the customer managed key is accessible to Amazon Keyspaces before trying to restore the table. A table that was encrypted with a customer managed key can't be restored if Amazon Keyspaces doesn't have access to that key. For more information, see [Troubleshooting key access](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html) in the AWS Key Management Service Developer Guide.
## PITR restore of multi-Region tables
You can restore a multi-Region table using PITR. For the restore operation to be successful, PITR has to be enabled on all replicas of the source table and both the source and the destination table have to be replicated to the same AWS Regions.
Amazon Keyspaces restores the settings of the source table in each of the replicated Regions that are part of the keyspace. You can also override settings during the restore operation. For more information about settings that can be changed during the restore, see [PITR restore settings](#howitworks_backup_settings).
For more information about multi-Region replication, see [How multi-Region replication works in Amazon Keyspaces](multiRegion-replication_how-it-works.md).
## PITR restore of tables with user-defined types (UDTs)
You can restore a table that uses UDTs. For the restore operation to be successful, the referenced UDTs have to exist and be valid in the keyspace.
If any required UDT is missing when you attempt to restore a table, Amazon Keyspaces tries to restore the UDT schema automatically and then continues to restore the table.
If you removed and recreated the UDT, Amazon Keyspaces restores the UDT with the new schema of the UDT and rejects the request to restore the table using the original UDT schema. In this case, if you wish to restore the table with the old UDT schema, you can restore the table to a new keyspace. When you delete and recreate a UDT, even if the schema of the recreated UDT is the same as the schema of the deleted UDT, the recreated UDT is considered a new UDT. In this case, Amazon Keyspaces rejects the request to restore the table with the old UDT schema.
If the UDT is missing and Amazon Keyspaces attempts to restore the UDT, the attempt fails if you have reached the maximum number of UDTs for the account in the Region.
For more information about UDT quotas and default values, see [Quotas and default values for user-defined types (UDTs) in Amazon Keyspaces](quotas.md#quotas-udts). For more information about working with UDTs, see [User-defined types (UDTs) in Amazon Keyspaces](udts.md).
## Table restore time with PITR
The time it takes you to restore a table is based on multiple factors and isn't always correlated directly to the size of the table.
The following are some considerations for restore times.
+ You restore backups to a new table. It can take up to 20 minutes (even if the table is empty) to perform all the actions to create the new table and initiate the restore process.
+ Restore times for large tables with well-distributed data models can be several hours or longer.
+ If your source table contains data that is significantly skewed, the time to restore might increase. For example, if your table’s primary key is using the month of the year as a partition key, and all your data is from the month of December, you have skewed data.
A best practice when planning for disaster recovery is to regularly document average restore completion times and establish how these times affect your overall Recovery Time Objective.
## Amazon Keyspaces PITR and integration with AWS services
The following PITR operations are logged using AWS CloudTrail to enable continuous monitoring and auditing.
+ Create a new table with PITR enabled or disabled.
+ Enable or disable PITR on an existing table.
+ Restore an active or a deleted table.
For more information, see [Logging Amazon Keyspaces API calls with AWS CloudTrail](logging-using-cloudtrail.md).
You can perform the following PITR actions using CloudFormation.
+ Create a new table with PITR enabled or disabled.
+ Enable or disable PITR on an existing table.
For more information, see the [Cassandra Resource Type Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Cassandra.html) in the [CloudFormation User Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/).
# Use point-in-time recovery in Amazon Keyspaces
With Amazon Keyspaces (for Apache Cassandra), you can restore tables to a specific point in time using Point-in-Time Restore (PITR). PITR enables you to restore a table to a prior state within the last 35 days, providing data protection and recovery capabilities. This feature is valuable in cases such as accidental data deletion, application errors, or for testing purposes. You can quickly and efficiently recover data, minimizing downtime and data loss. The following sections guide you through the process of restoring tables using PITR in Amazon Keyspaces, ensuring data integrity and business continuity.
**Topics**
+ [Configure restore table IAM permissions for Amazon Keyspaces PITR](howitworks_restore_permissions.md)
+ [Configure PITR for a table in Amazon Keyspaces](configure_PITR.md)
+ [Turn off PITR for an Amazon Keyspaces table](disable_PITR.md)
+ [Restore a table from backup to a specified point in time in Amazon Keyspaces](restoretabletopointintime.md)
+ [Restore a deleted table using Amazon Keyspaces PITR](restoredeleted.md)
# Configure restore table IAM permissions for Amazon Keyspaces PITR
This section summarizes how to configure permissions for an AWS Identity and Access Management (IAM) principal to restore Amazon Keyspaces tables. In IAM, the AWS managed policy `AmazonKeyspacesFullAccess` includes the permissions to restore Amazon Keyspaces tables. To implement a custom policy with minimum required permissions, consider the requirements outlined in the next section.
To successfully restore a table, the IAM principal needs the following minimum permissions:
+ `cassandra:Restore` – The restore action is required for the target table to be restored.
+ `cassandra:Select` – The select action is required to read from the source table.
+ `cassandra:TagResource` – The tag action is optional, and only required if the restore operation adds tags.
This is an example of a policy that grants minimum required permissions to a user to restore tables in 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*"
]
}
]
}
```
Additional permissions to restore a table might be required based on other selected features. For example, if the source table is encrypted at rest with a customer managed key, Amazon Keyspaces must have permissions to access the customer managed key of the source table to successfully restore the table. For more information, see [PITR restore of encrypted tables](PointInTimeRecovery_HowItWorks.md#howitworks_backup_encryption).
If you are using IAM policies with [condition keys](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) to restrict incoming traffic to specific sources, you must ensure that Amazon Keyspaces has permission to perform a restore operation on your principal's behalf. You must add an `aws:ViaAWSService` condition key to your IAM policy if your policy restricts incoming traffic to any of the following:
+ VPC endpoints with `aws:SourceVpce`
+ IP ranges with `aws:SourceIp`
+ VPCs with `aws:SourceVpc`
The `aws:ViaAWSService` condition key allows access when any AWS service makes a request using the principal's credentials. For more information, see [IAM JSON policy elements: Condition key](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) in the *IAM User Guide*.
The following is an example of a policy that restricts source traffic to a specific IP address and allows Amazon Keyspaces to restore a table on the principal's behalf.
```
{
"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"
}
}
}
]
}
```
For an example policy using the `aws:ViaAWSService` global condition key, see [VPC endpoint policies and Amazon Keyspaces point-in-time recovery (PITR)](vpc-endpoints.md#VPC_PITR_restore).
# Configure PITR for a table in Amazon Keyspaces
You can configure a table in Amazon Keyspaces for backup and restore operations using PITR with the console, CQL, and the AWS CLI.
When creating a new table using CQL or the AWS CLI, you must explicitly enable PITR in the create table statement. When you create a new table using the console, PITR will be enable by default.
To learn how to restore a table, see [Restore a table from backup to a specified point in time in Amazon Keyspaces](restoretabletopointintime.md).
------
#### [ Console ]
**Configure PITR for a table using the console**
1. Sign in to the AWS Management Console, and open the Amazon Keyspaces console at [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home).
1. In the navigation pane, choose **Tables** and select the table you want to edit.
1. On the **Backups** tab, choose **Edit**.
1. In the **Edit point-in-time recovery settings** section, select **Enable Point-in-time recovery**.
1. Choose **Save changes**.
------
#### [ Cassandra Query Language (CQL) ]
**Configure PITR for a table using CQL**
1. You can manage PITR settings for tables by using the `point_in_time_recovery` custom property.
To enable PITR when you're creating a new table, you must set the status of `point_in_time_recovery` to `enabled`. You can use the following CQL command as an example.
```
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**
If no point-in-time recovery custom property is specified, point-in-time recovery is disabled by default.
1. To enable PITR for an existing table using CQL, run the following CQL command.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'enabled'}}
```
------
#### [ CLI ]
**Configure PITR for a table using the AWS CLI**
1. You can manage PITR settings for tables by using the `UpdateTable` API.
To enable PITR when you're creating a new table, you must include `point-in-time-recovery 'status=ENABLED'` in the create table command. You can use the following AWS CLI command as an example. The command has been broken into separate lines to improve readability.
```
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**
If no point-in-time recovery value is specified, point-in-time recovery is disabled by default.
1. To confirm the point-in-time recovery setting for a table, you can use the following AWS CLI command.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. To enable PITR for an existing table using the AWS CLI, run the following command.
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=ENABLED'
```
------
# Turn off PITR for an Amazon Keyspaces table
You can turn off PITR for an Amazon Keyspaces table at any time using the console, CQL, or the AWS CLI.
**Important**
Disabling PITR deletes your backup history immediately, even if you reenable PITR on the table within 35 days.
To learn how to restore a table, see [Restore a table from backup to a specified point in time in Amazon Keyspaces](restoretabletopointintime.md).
------
#### [ Console ]
**Disable PITR for a table using the console**
1. Sign in to the AWS Management Console, and open the Amazon Keyspaces console at [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home).
1. In the navigation pane, choose **Tables** and select the table you want to edit.
1. On the **Backups** tab, choose **Edit**.
1. In the **Edit point-in-time recovery settings** section, clear the **Enable Point-in-time recovery** check box.
1. Choose **Save changes**.
------
#### [ Cassandra Query Language (CQL) ]
**Disable PITR for a table using CQL**
+ To disable PITR for an existing table, run the following CQL command.
```
ALTER TABLE mykeyspace.mytable
WITH custom_properties = {'point_in_time_recovery': {'status': 'disabled'}}
```
------
#### [ CLI ]
**Disable PITR for a table using the AWS CLI**
+ To disable PITR for an existing table, run the following AWS CLI command.
```
aws keyspaces update-table --keyspace-name 'myKeyspace' --table-name 'myTable' --point-in-time-recovery 'status=DISABLED'
```
------
# Restore a table from backup to a specified point in time in Amazon Keyspaces
The following section demonstrates how to restore an existing Amazon Keyspaces table to a specified point in time.
**Note**
This procedure assumes that the table you're using has been configured with point-in-time recovery. To enable PITR for a table, see [Configure PITR for a table in Amazon Keyspaces](configure_PITR.md).
**Important**
While a restore is in progress, don't modify or delete the AWS Identity and Access Management (IAM) policies that grant the IAM principal (for example, user, group, or role) permission to perform the restore. Otherwise, unexpected behavior can result. For example, if you remove write permissions for a table while that table is being restored, the underlying `RestoreTableToPointInTime` operation can't write any of the restored data to the table.
You can modify or delete permissions only after the restore operation is complete.
------
#### [ Console ]
**Restore a table to a specified point in time using the console**
1. Sign in to the AWS Management Console, and open the Amazon Keyspaces console at [https://console.aws.amazon.com/keyspaces/home](https://console.aws.amazon.com/keyspaces/home).
1. In the navigation pane on the left side of the console, choose **Tables**.
1. In the list of tables, choose the table you want to restore.
1. On the **Backups** tab of the table, in the **Point-in-time recovery** section, choose **Restore**.
1. For the new table name, enter a new name for the restored table, for example **mytable\$1restored**.
1. To define the point in time for the restore operation, you can choose between two options:
+ Select the preconfigured **Earliest** time.
+ Select **Specify date and time** and enter the date and time you want to restore the new table to.
**Note**
You can restore to any point in time within **Earliest** time and the current time. Amazon Keyspaces restores your table data to the state based on the selected date and time (day:hour:minute:second).
1. Choose **Restore** to start the restore process.
The table that is being restored is shown with the status **Restoring**. After the restore process is finished, the status of the restored table changes to **Active**.
------
#### [ Cassandra Query Language (CQL) ]
**Restore a table to a point in time using CQL**
1. You can restore an active table to a point-in-time between `earliest_restorable_timestamp` and the current time. Current time is the default.
To confirm that point-in-time recovery is enabled for the table, query the `system_schema_mcs.tables` as shown in this example.
```
SELECT custom_properties
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable';
```
Point-in-time recovery is enabled as shown in the following sample output.
```
custom_properties
-----------------
{
...,
"point_in_time_recovery": {
"earliest_restorable_timestamp":"2020-06-30T19:19:21.175Z"
"status":"enabled"
}
}
```
1.
+ Restore the table to the current time. When you omit the `WITH restore_timestamp = ...` clause, the current timestamp is used.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
+ You can also restore to a specific point in time, defined by a `restore_timestamp` in ISO 8601 format. You can specify any point in time during the last 35 days. For example, the following command restores the table to the `EarliestRestorableDateTime`.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable
WITH restore_timestamp = '2020-06-30T19:19:21.175Z';
```
For a full syntax description, see [RESTORE TABLE](cql.ddl.table.md#cql.ddl.table.restore) in the language reference.
1. To verify that the restore of the table was successful, query the `system_schema_mcs.tables` to confirm the status of the table.
```
SELECT status
FROM system_schema_mcs.tables
WHERE keyspace_name = 'mykeyspace' AND table_name = 'mytable_restored'
```
The query shows the following output.
```
status
------
RESTORING
```
The table that is being restored is shown with the status **Restoring**. After the restore process is finished, the status of the table changes to **Active**.
------
#### [ CLI ]
**Restore a table to a point in time using the AWS CLI**
1. Create a simple table named `myTable` that has PITR enabled. The command has been broken up into separate lines for readability.
```
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. Confirm the properties of the new table and review the `earliestRestorableTimestamp` for PITR.
```
aws keyspaces get-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
The output of this command returns the following.
```
{
"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.
+ To restore a table to a point in time, specify a `restore_timestamp` in ISO 8601 format. You can chose any point in time during the last 35 days in one second intervals. For example, the following command restores the table to the `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"
```
The output of this command returns the ARN of the restored table.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored"
}
```
+ To restore the table to the current time, you can omit the `restore-timestamp` parameter.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored1'"
```
------
# Restore a deleted table using Amazon Keyspaces PITR
The following procedure shows how to restore a deleted table from backup to the time of deletion. You can do this using CQL or the AWS CLI.
**Note**
This procedure assumes that PITR was enabled on the deleted table.
------
#### [ Cassandra Query Language (CQL) ]
**Restore a deleted table using CQL**
1. To confirm that point-in-time recovery is enabled for a deleted table, query the system table. Only tables with point-in-time recovery enabled are shown.
```
SELECT custom_properties
FROM system_schema_mcs.tables_history
WHERE keyspace_name = 'mykeyspace' AND table_name = 'my_table';
```
The query shows the following output.
```
custom_properties
------------------
{
...,
"point_in_time_recovery":{
"restorable_until_time":"2020-08-04T00:48:58.381Z",
"status":"enabled"
}
}
```
1. Restore the table to the time of deletion with the following sample statement.
```
RESTORE TABLE mykeyspace.mytable_restored
FROM TABLE mykeyspace.mytable;
```
------
#### [ CLI ]
**Restore a deleted table using the AWS CLI**
1. Delete a table that you created previously that has PITR enabled. The following command is an example.
```
aws keyspaces delete-table --keyspace-name 'myKeyspace' --table-name 'myTable'
```
1. Restore the deleted table to the time of deletion with the following command.
```
aws keyspaces restore-table --source-keyspace-name 'myKeyspace' --source-table-name 'myTable' --target-keyspace-name 'myKeyspace' --target-table-name 'myTable_restored2'
```
The output of this command returns the ARN of the restored table.
```
{
"restoredTableARN": "arn:aws:cassandra:us-east-1:111122223333:/keyspace/myKeyspace/table/myTable_restored2"
}
```
------