DynamoDB备份与恢复 #

DynamoDB备份类型：
├── 按需备份（On-Demand Backup）
│   ├── 手动创建
│   ├── 完整备份
│   └── 长期保留
└── 时间点恢复（PITR）
    ├── 自动启用
    ├── 连续备份
    └── 35天内任意时间点恢复

aws dynamodb create-backup \
  --table-name Users \
  --backup-name users-backup-2024-01-01

const { DynamoDBClient, CreateBackupCommand } = require('@aws-sdk/client-dynamodb');

const client = new DynamoDBClient({ region: 'us-east-1' });

const response = await client.send(new CreateBackupCommand({
  TableName: 'Users',
  BackupName: 'users-backup-2024-01-01'
}));

console.log('Backup ARN:', response.BackupDetails.BackupArn);

aws dynamodb list-backups \
  --table-name Users

# 按时间范围筛选
aws dynamodb list-backups \
  --table-name Users \
  --time-range-lower-bound 2024-01-01T00:00:00Z \
  --time-range-upper-bound 2024-01-31T23:59:59Z

aws dynamodb describe-backup \
  --backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Users/backup/01234567890123

aws dynamodb delete-backup \
  --backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Users/backup/01234567890123

const { DynamoDBClient, CreateBackupCommand, ListBackupsCommand, DeleteBackupCommand } = require('@aws-sdk/client-dynamodb');

const client = new DynamoDBClient({ region: 'us-east-1' });

async function createDailyBackup(tableName) {
  const backupName = `${tableName}-backup-${new Date().toISOString().split('T')[0]}`;
  
  const response = await client.send(new CreateBackupCommand({
    TableName: tableName,
    BackupName: backupName
  }));
  
  console.log(`Created backup: ${backupName}`);
  return response.BackupDetails;
}

async function cleanupOldBackups(tableName, retentionDays = 30) {
  const cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
  
  const response = await client.send(new ListBackupsCommand({
    TableName: tableName
  }));
  
  for (const backup of response.BackupSummaries) {
    const backupDate = new Date(backup.BackupCreationDateTime);
    
    if (backupDate < cutoffDate) {
      await client.send(new DeleteBackupCommand({
        BackupArn: backup.BackupArn
      }));
      console.log(`Deleted old backup: ${backup.BackupName}`);
    }
  }
}

// 使用示例
async function backupJob() {
  const tables = ['Users', 'Orders', 'Products'];
  
  for (const table of tables) {
    await createDailyBackup(table);
    await cleanupOldBackups(table, 30);
  }
}

aws dynamodb update-continuous-backups \
  --table-name Users \
  --point-in-time-recovery-specification \
    PointInTimeRecoveryEnabled=true

const { UpdateContinuousBackupsCommand } = require('@aws-sdk/client-dynamodb');

await client.send(new UpdateContinuousBackupsCommand({
  TableName: 'Users',
  PointInTimeRecoverySpecification: {
    PointInTimeRecoveryEnabled: true
  }
}));

aws dynamodb describe-continuous-backups \
  --table-name Users

{
  "ContinuousBackupsDescription": {
    "ContinuousBackupsStatus": "ENABLED",
    "PointInTimeRecoveryDescription": {
      "PointInTimeRecoveryStatus": "ENABLED",
      "EarliestRestorableDateTime": "2024-01-01T00:00:00Z",
      "LatestRestorableDateTime": "2024-01-27T10:00:00Z"
    }
  }
}

aws dynamodb restore-table-to-point-in-time \
  --source-table-name Users \
  --target-table-name Users-Restored \
  --restore-date-time 2024-01-15T12:00:00Z

const { RestoreTableToPointInTimeCommand } = require('@aws-sdk/client-dynamodb');

await client.send(new RestoreTableToPointInTimeCommand({
  SourceTableName: 'Users',
  TargetTableName: 'Users-Restored',
  RestoreDateTime: new Date('2024-01-15T12:00:00Z')
}));

aws dynamodb restore-table-to-point-in-time \
  --source-table-name Users \
  --target-table-name Users-Restored \
  --use-latest-restorable-time

aws dynamodb restore-table-from-backup \
  --target-table-name Users-Restored \
  --backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Users/backup/01234567890123

const { RestoreTableFromBackupCommand } = require('@aws-sdk/client-dynamodb');

await client.send(new RestoreTableFromBackupCommand({
  TargetTableName: 'Users-Restored',
  BackupArn: 'arn:aws:dynamodb:us-east-1:123456789012:table/Users/backup/01234567890123'
}));

aws dynamodb restore-table-from-backup \
  --target-table-name Users-Restored \
  --backup-arn arn:aws:dynamodb:us-east-1:123456789012:table/Users/backup/01234567890123 \
  --sse-specification Enabled=true,SSEType=KMS,KMSMasterKeyId=alias/my-key \
  --billing-mode PAY_PER_REQUEST

恢复限制：
├── 恢复创建新表
├── 不能覆盖现有表
├── 恢复时间取决于表大小
├── 恢复过程中表状态为CREATING
└── 索引会自动恢复

async function afterRestore(sourceTable, restoredTable) {
  // 等待恢复完成
  await waitForTableActive(restoredTable);
  
  // 验证数据
  const sourceCount = await getItemCount(sourceTable);
  const restoredCount = await getItemCount(restoredTable);
  
  if (sourceCount !== restoredCount) {
    console.warn('Item count mismatch!');
  }
  
  // 更新应用配置
  await updateAppConfig(restoredTable);
  
  // 切换流量
  await switchTraffic(restoredTable);
}

async function waitForTableActive(tableName) {
  while (true) {
    const response = await client.send(new DescribeTableCommand({
      TableName: tableName
    }));
    
    if (response.Table.TableStatus === 'ACTIVE') {
      return;
    }
    
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

成本计算：
├── 备份存储：$0.10/GB/月
├── 无数据传输费用
└── 恢复不额外收费

成本计算：
├── PITR存储：$0.20/GB/月
├── 按表大小计费
└── 恢复不额外收费

优化建议：
├── 定期清理旧备份
├── 合理设置保留策略
├── 评估是否需要PITR
└── 监控备份存储使用

备份策略：
├── 启用PITR（所有生产表）
├── 定期按需备份
│   ├── 每日备份
│   ├── 保留30天
│   └── 重要变更前备份
└── 跨区域备份（灾难恢复）

// AWS Lambda定时备份
exports.handler = async (event) => {
  const tables = process.env.TABLES.split(',');
  const retentionDays = parseInt(process.env.RETENTION_DAYS || '30');
  
  for (const tableName of tables) {
    // 创建备份
    await createDailyBackup(tableName);
    
    // 清理旧备份
    await cleanupOldBackups(tableName, retentionDays);
  }
  
  return { status: 'success' };
};

const { DynamoDBClient, CreateBackupCommand } = require('@aws-sdk/client-dynamodb');
const { S3Client, PutObjectCommand } = require('@aws-sdk/client-s3');

async function exportToS3(tableName, bucketName) {
  // 使用DynamoDB导出到S3
  const { DynamoDBClient, ExportTableToPointInTimeCommand } = require('@aws-sdk/client-dynamodb');
  
  const client = new DynamoDBClient({ region: 'us-east-1' });
  
  await client.send(new ExportTableToPointInTimeCommand({
    TableArn: `arn:aws:dynamodb:us-east-1:123456789012:table/${tableName}`,
    S3Bucket: bucketName,
    S3Prefix: `backups/${tableName}/`,
    ExportFormat: 'DYNAMODB_JSON'
  }));
}

最佳实践：
├── 启用PITR
├── 定期测试恢复
├── 自动化备份流程
├── 监控备份状态
├── 制定恢复计划
└── 文档化备份策略

恢复最佳实践：
├── 验证恢复数据完整性
├── 在非生产环境测试
├── 记录恢复步骤
├── 定期演练
└── 监控恢复时间