# 使用本机备份和还原导入和导出 SQL Server 数据库
<a name="SQLServer.Procedural.Importing"></a>

Amazon RDS 支持使用完整备份文件 (.bak 文件) 对 Microsoft SQL Server 数据库进行本机备份和还原。当您使用 RDS 时，您将访问存储在 Amazon S3 中的文件，而不是使用数据库服务器上的本地文件系统。

例如，您可以从本地服务器创建完整备份，将该备份存储到 S3 上，然后将其还原到现有 Amazon RDS 数据库实例。您还可以从 RDS 进行备份，将其存储在 S3 上，然后在需要的任何位置还原它们。

本机备份和还原适用于所有 AWS 区域中的单可用区和多可用区数据库实例，包括具有只读副本的多可用区数据库实例。本机备份和还原适用于 Amazon RDS 支持的所有 Microsoft SQL Server 版本。

下图说明了支持的方案。

![\[本机备份和还原架构\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)


使用本机 .bak 文件备份和还原数据库通常是备份和还原数据库的最快方法。此外，使用本机备份和还原还提供了很多其他优势。例如，您可以执行以下操作：
+ 将数据库迁移到 Amazon RDS 或从后者迁移数据库。
+ 在 RDS for SQL Server 数据库实例之间移动数据库。
+ 迁移 .bak 文件中的数据、架构、存储过程、触发器和其他数据库代码。
+ 备份和还原单个数据库，而不是整个数据库实例。
+ 创建用于开发、测试、培训和演示的数据库副本。
+ 通过 Amazon S3 传输备份文件，为您提供一层额外保护以进行灾难恢复。
+ 创建开启了透明数据加密 (TDE) 的数据库的本机备份，并将这些备份还原到本地数据库。有关更多信息，请参阅 [SQL Server 中的透明数据加密支持](Appendix.SQLServer.Options.TDE.md)。
+ 将开启了 TDE 的本地数据库的本机备份还原到 RDS for SQL Server 数据库实例。有关更多信息，请参阅 [SQL Server 中的透明数据加密支持](Appendix.SQLServer.Options.TDE.md)。

**Contents**
+ [限制和建议](#SQLServer.Procedural.Importing.Native.Limitations)
+ [针对本机备份和还原进行设置](SQLServer.Procedural.Importing.Native.Enabling.md)
  + [为本机备份和还原手动创建 IAM 角色](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [使用本机备份和还原](SQLServer.Procedural.Importing.Native.Using.md)
  + [备份数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
    + [示例](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
  + [还原数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
    + [示例](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
  + [还原日志](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
    + [示例](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
  + [完成数据库还原](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
  + [处理部分还原的数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
    + [删除部分还原的数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
    + [部分还原的数据库的快照还原和时间点恢复行为](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
  + [取消任务](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
  + [跟踪任务的状态](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
    + [用法](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
    + [示例](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
    + [响应](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [压缩备份文件](SQLServer.Procedural.Importing.Native.Compression.md)
+ [故障排除](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [使用其他方法导入和导出 SQL Server 数据](SQLServer.Procedural.Importing.Snapshots.md)
  + [使用快照将数据导入 RDS for SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
    + [导入数据](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
      + [生成和发布脚本向导](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
      + [导入和导出向导](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
      + [批量复制](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
  + [从 RDS for SQL Server 中导出数据](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
    + [SQL Server 导入和导出向导](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
    + [SQL Server 生成和发布脚本向导与 bcp 实用工具](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [从 Linux 中使用 BCP 实用程序导入和导出数据](SQLServer.Procedural.Importing.BCP.Linux.md)
  + [先决条件](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
  + [在 Linux 上安装 SQL Server 命令行工具](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
  + [从 RDS for SQL Server 中导出数据](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
    + [基本导出语法](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
    + [导出示例](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
  + [将数据导入到 RDS for SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
    + [基本导入语法](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
    + [导入示例](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
  + [常用 BCP 选项](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
  + [最佳实践和注意事项](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
  + [排查常见 问题](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)

## 限制和建议
<a name="SQLServer.Procedural.Importing.Native.Limitations"></a>

以下是有关对本机备份和还原的使用的一些限制：
+ 您不能备份到与您的 Amazon RDS 数据库实例不同的AWS区域中的某个 Amazon S3 存储桶或从该存储桶中进行还原。
+ 如果存在同名的现有数据库，则无法还原数据库。数据库名称是唯一的。
+ 强烈建议您不要将备份从一个时区还原到另一个时区。如果您将备份从一个时区还原到另一个时区，则必须审核您的查询和应用程序以查看时区更改的影响。
+ RDS for Microsoft SQL Server 具有每个文件 5TB 的大小限制。若要在本机备份更大的数据库，则可以使用多文件备份。
+ 可以备份到 S3 的最大数据库大小取决于数据库实例上的可用内存、CPU、I/O 和网络资源。数据库越大，备份代理占用的内存就越多。
+ 不能同时对 10 个以上的备份文件执行备份或还原操作。
+ 差异备份基于上一个完整备份。要使差异备份起作用，您不能在上一个完整备份和差异备份之间拍摄快照。如果您需要差异备份，但存在手动或自动快照，请先进行另一个完整备份，然后再继续进行差异备份。
+ 其文件的 file\$1guid（唯一标识符）设置为 `NULL` 的数据库不支持差异还原和日志还原。
+ 您最多可以同时运行两个备份或还原任务。
+ 您无法在 Amazon RDS 上从 SQL Server 执行本机日志备份。
+ RDS 支持最大 64 TiB 的数据库本机还原。SQL Server Express Edition 上的数据库的本机还原限制为 10 GB。
+ 您无法在维护时段内或在 Amazon RDS 处于创建数据库快照过程中的任何时间对数据库进行本机备份。如果本机备份任务与 RDS 每日备份时段重叠，则会取消本机备份任务。
+ 在多可用区数据库实例上，您只能在本机还原在完全恢复模式下备份的数据库。
+ 不支持在事务内调用 RDS 过程进行本机备份和还原。
+ 请使用对称加密 AWS KMS key 来加密您的备份。Amazon RDS 不支持非对称 KMS 密钥。有关更多信息，请参阅 [AWS Key Management Service开发人员指南](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) 中的*创建对称加密 KMS 密钥*。
+ 本机备份文件使用“仅加密”加密模式通过指定的 KMS 密钥加密。当您还原加密的备份文件时，注意它们是使用“仅加密”加密模式加密的。
+ 您无法还原包含 FILESTREAM 文件组的数据库。
+ 当您将 `@enable_bucket_default_encryption=1` 传入备份存储过程时，Amazon S3 使用 AWS KMS（SSE-KMS）的服务器端加密可通过 S3 存储桶的默认加密配置进行支持。默认情况下，还原支持 S3 对象的服务器端加密。

  当您向存储过程提供 KMS 密钥时，任何原生备份和还原都将使用该 KMS 密钥在客户端上进行加密和解密。如果 `@enable_bucket_default_encryption=0`，AWS 使用 SSE-S3 将备份存储在 S3 存储桶中；如果 `@enable_bucket_default_encryption=1`，则使用 S3 存储桶配置的默认加密密钥。
+ 使用 S3 接入点时，无法将接入点配置为使用 RDS 内部 VPC。
+ 为了获得最高性能，我们建议您使用目录存储桶或目录存储桶的接入点（如果您所在的地区提供接入点）。

如果在创建、复制和还原备份文件时，您的数据库可处于脱机状态，建议您使用本机备份和还原将其迁移到 RDS。如果您的本地数据库不能处于脱机状态，建议您使用 AWS Database Migration Service 将您的数据库迁移到 Amazon RDS。有关更多信息，请参阅[什么是 AWS Database Migration Service？](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) 

本机备份和还原不是为了替换跨区域快照复制功能的数据恢复功能。建议您使用快照复制为 Amazon RDS 中的跨区域灾难恢复将数据库快照复制到另一AWS区域。有关更多信息，请参阅 [复制 Amazon RDS 的数据库快照](USER_CopySnapshot.md)。

# 针对本机备份和还原进行设置
<a name="SQLServer.Procedural.Importing.Native.Enabling"></a>

要设置本机备份和还原，您需要三个组件：

1. 用于存储备份文件的 Amazon S3 存储桶。

   您必须将 S3 存储桶用于备份文件，然后上传您要迁移到 RDS 的备份。如果您已有一个 Amazon S3 存储桶，则可以使用它。如果没有，则可以[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html)。或者，您可以选择在使用 `SQLSERVER_BACKUP_RESTORE` 添加 AWS 管理控制台 选项时为自己创建新的存储桶。

   有关使用 S3 的信息，请参阅 [Amazon Simple Storage Service 用户指南](https://docs.aws.amazon.com/AmazonS3/latest/userguide/)

1. 用于访问存储桶的 AWS Identity and Access Management (IAM) 角色。

   如果您已有一个 IAM 角色，则可以使用它。您可以选择在使用AWS 管理控制台添加 `SQLSERVER_BACKUP_RESTORE` 选项时为自己创建新的 IAM 角色。或者，您可以手动创建一个新的角色。

   如果您想要手动创建新的 IAM 角色，请使用下一部分中介绍的方法。如果要将信任关系和权限策略附加到现有 IAM 角色，请执行相同操作。

1. 已添加到数据库实例上选项组的 `SQLSERVER_BACKUP_RESTORE` 选项。

   要在数据库实例上启用本机备份和还原，请将 `SQLSERVER_BACKUP_RESTORE` 选项添加到数据库实例上的选项组。有关更多信息和说明，请参阅 [SQL Server 中对本机备份和还原的支持](Appendix.SQLServer.Options.BackupRestore.md)。

## 为本机备份和还原手动创建 IAM 角色
<a name="SQLServer.Procedural.Importing.Native.Enabling.IAM"></a>

如果要手动创建新的 IAM 角色以用于本机备份和还原，可以这样做。在这种情况下，您将创建一个角色，以将权限从 Amazon RDS 服务委派给 Amazon S3 存储桶。创建 IAM 角色时，您将附加信任关系和权限策略。信任关系允许 RDS 代入此角色。这些权限策略定义此角色可以执行的操作。有关创建角色的更多信息，请参阅[创建将权限委派给 AWS 服务的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。

对于本机备份和还原功能，可使用类似于本节中以下示例的信任关系和权限策略。在下面的示例中，我们使用服务委托人名称 `rds.amazonaws.com` 作为所有服务账户的别名。在其他示例中，我们指定 Amazon Resource Name (ARN) 以标识我们在信任策略中授予访问权限的其他账户、用户或角色。

我们建议在基于资源的信任关系中使用 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键，以此限制服务对特定资源的权限。这是防范[混淆代理问题](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html)最有效的方法。

您可以使用这两个全局条件上下文键并让 `aws:SourceArn` 值包含账户 ID。在这种情况下，当 `aws:SourceAccount` 值和 `aws:SourceArn` 值中的账户使用相同策略语句时，确保二者使用相同的账户 ID。
+ 如果您想对单个资源进行跨服务访问，请使用 `aws:SourceArn`。
+ 如果您想允许该账户中的任何资源与跨服务使用操作相关联，请使用 `aws:SourceAccount`。

在信任关系中，请务必使用 `aws:SourceArn` 全局条件上下文键和访问角色资源的完整 ARN。对于本机备份和还原，请确保同时包含数据库选项组和数据库实例，如以下示例所示。

**Example 与本机备份和还原的全局条件上下文键的信任关系**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "rds.amazonaws.com"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "aws:SourceArn": [
                        "arn:aws:rds:Region:0123456789:db:db_instance_identifier",
                        "arn:aws:rds:Region:0123456789:og:option_group_name"
                    ],
                    "aws:SourceAccount": "0123456789"
                }
            }
        }
    ]
}
```

以下示例使用 ARN 指定资源。有关使用 ARN 的更多信息，请参阅 [Amazon 资源名称（ARN）](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。

**Example 不带加密支持的适用于本机备份和还原的权限策略**    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement":
    [
        {
        "Effect": "Allow",
        "Action":
            [
                "s3:ListBucket",
                "s3:GetBucketLocation"
            ],
        "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
        },
        {
        "Effect": "Allow",
        "Action":
            [
                "s3:GetObjectAttributes",
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListMultipartUploadParts",
                "s3:AbortMultipartUpload"
            ],
        "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
        }
    ]
}
```

**Example 带加密支持的适用于本机备份和还原的权限策略**  
若要对备份文件进行加密，可在权限策略中包含加密密钥。有关加密密钥的更多信息，请参阅 *AWS Key Management Service 开发人员指南*中的[入门](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html)。  
您必须使用对称加密 KMS 密钥来加密您的备份。Amazon RDS 不支持非对称 KMS 密钥。有关更多信息，请参阅 [AWS Key Management Service开发人员指南](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) 中的*创建对称加密 KMS 密钥*。  
IAM 角色还必须是 KMS 密钥的密钥用户和密钥管理员，也就是说，必须在密钥策略中指定该密钥。有关更多信息，请参阅 [AWS Key Management Service开发人员指南](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) 中的*创建对称加密 KMS 密钥*。  
****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "AllowAccessToKey",
      "Effect": "Allow",
      "Action": [
        "kms:DescribeKey",
        "kms:GenerateDataKey",
        "kms:Encrypt",
        "kms:Decrypt"
      ],
      "Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
    },
    {
      "Sid": "AllowAccessToS3",
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetBucketLocation"
      ],
      "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
    },
    {
      "Sid": "GetS3Info",
      "Effect": "Allow",
      "Action": [
        "s3:GetObjectAttributes",
        "s3:GetObject",
        "s3:PutObject",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
    }
  ]
}
```

**Example 使用不支持加密的接入点进行本机备份和还原的权限策略**  
使用 S3 接入点所需的操作与 S3 存储桶相同。资源路径已更新，以匹配 S3 接入点 ARN 模式。  
接入点必须配置为使用**网络来源：互联网**，因为 RDS 不发布私有 VPC。来自 RDS 实例的 S3 流量不会经过公共互联网，因为它会经过私有 VPC。  
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket",
                "s3:GetBucketLocation"
                ],
            "Resource": [
            "arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
            "arn:aws:s3:::underlying-bucket"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObjectAttributes",
                "s3:GetObject",
                "s3:PutObject",
                "s3:ListMultipartUploadParts",
                "s3:AbortMultipartUpload"
                ],
                "Resource": [
                "arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
                    "arn:aws:s3:::underlying-bucket/*"
                    ]
                }
            ]   
}
```

**Example 使用不支持加密的目录存储桶中的接入点进行本机备份和还原的权限策略**  
目录存储桶使用的[基于会话的授权机制](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html)与通用型存储桶不同，因此本机备份还原所需的唯一权限是存储桶级别的“s3express:CreateSession”权限。要配置对象级别的访问权限，必须使用[目录存储桶的接入点](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html)。  
接入点必须配置为使用**网络来源：互联网**，因为 RDS 不发布私有 VPC。来自 RDS 实例的 S3 流量不会经过公共互联网，因为它会经过私有 VPC。  
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement":
    [
        {
        "Effect": "Allow",
        "Action": "s3express:CreateSession",
        "Resource": 
            [
                "arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
                "arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
            ]
        }
    ]
}
```

# 使用本机备份和还原
<a name="SQLServer.Procedural.Importing.Native.Using"></a>

在启用并配置本机备份和还原功能后，可以开始使用该功能。先连接到您的 Microsoft SQL Server 数据库，然后调用 Amazon RDS 存储过程来执行该操作。有关连接到数据库的说明，请参阅 [连接到 Microsoft SQL Server 数据库实例](USER_ConnectToMicrosoftSQLServerInstance.md)。

某些存储过程要求您向 Amazon S3 存储桶和文件提供 Amazon Resource Name (ARN)。您的 ARN 的格式为 `arn:aws:s3:::bucket_name/file_name.extension`。Amazon S3 不需要在 ARN 中使用账号或 AWS 区域。

如果您还提供可选 KMS 密钥，则密钥 ARN 的格式为 `arn:aws:kms:region:account-id:key/key-id`。有关更多信息，请参阅 [Amazon Resource Name (ARN) 和 AWS 服务命名空间](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。您必须使用对称加密 KMS 密钥来加密您的备份。Amazon RDS 不支持非对称 KMS 密钥。有关更多信息，请参阅 [AWS Key Management Service开发人员指南](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) 中的*创建对称加密 KMS 密钥*。

**注意**  
无论您是否使用 KMS 密钥，本机备份和还原任务都会对上传到 S3 的文件默认通过 SSE-S3 启用服务器端高级加密标准（AES）256 位加密。将 `@enable_bucket_default_encryption=1` 传入备份存储过程时，使用 S3 存储桶配置的默认加密密钥。

有关如何调用每个存储过程的说明，请参阅以下主题：
+ [备份数据库](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [还原数据库](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [还原日志](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [完成数据库还原](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [处理部分还原的数据库](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [取消任务](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [跟踪任务的状态](#SQLServer.Procedural.Importing.Native.Tracking)

## 备份数据库
<a name="SQLServer.Procedural.Importing.Native.Using.Backup"></a>

要备份数据库，请使用 `rds_backup_database` 存储过程。

**注意**  
您无法在维护时段内对数据库进行备份，也无法在 Amazon RDS 拍摄快照时对数据库进行备份。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Backup.Syntax"></a>

```
exec msdb.dbo.rds_backup_database
	@source_db_name='database_name',
	@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
	[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],	
	[@overwrite_s3_backup_file=0|1],
	[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
        [@max_transfer_size=n],
        [@buffer_count=n],
	[@type='DIFFERENTIAL|FULL'],
	[@number_of_files=n],
	[@enable_bucket_default_encryption=0|1];
```

以下参数为必需参数：
+ `@source_db_name` – 要备份的数据库的名称。
+ `@s3_arn_to_backup_to`：ARN，指示要用于备份的 Amazon S3 存储桶、接入点、目录存储桶或目录存储桶的接入点，以及备份文件的名称。

  此文件可以具有任何扩展名，但通常使用 `.bak`。请注意，接入点 ARN 的格式必须为 `arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`。

以下参数可选：
+ `@kms_master_key_arn` – 用于加密项目的对称加密 KMS 密钥的 ARN。
  + 您不能使用默认加密密钥。如果使用默认密钥，则不会备份数据库。
  +  如果未指定 KMS 密钥标识符，则不会对备份文件进行加密。有关更多信息，请参阅[加密 Amazon RDS 资源](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html)。
  + 指定 KMS 密钥时，将使用客户端加密。
  + Amazon RDS 不支持非对称 KMS 密钥。有关更多信息，请参阅 [AWS Key Management Service开发人员指南](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) 中的*创建对称加密 KMS 密钥*。
+ `@overwrite_s3_backup_file` – 指示是否覆盖现有备份文件的值。
  + `0` – 不覆盖现有文件。此值是默认值。

    如果文件已存在，则将 `@overwrite_s3_backup_file` 设置为 0 会返回错误。
  + `1` – 覆盖具有指定名称的现有文件，即使该文件不是备份文件也是如此。
+ `@type` – 备份的类型。
  + `DIFFERENTIAL` – 进行差异备份。
  + `FULL` – 进行完整备份。此值是默认值。

  差异备份基于上一个完整备份。要使差异备份起作用，您不能在上一个完整备份和差异备份之间拍摄快照。如果您需要差异备份，但快照存在，请先进行另一个完整备份，然后再继续进行差异备份。

  您可以使用以下示例 SQL 查询来查找上一个完整备份或快照：

  ```
  select top 1
  database_name
  , 	backup_start_date
  , 	backup_finish_date
  from    msdb.dbo.backupset
  where   database_name='mydatabase'
  and     type = 'D'
  order by backup_start_date desc;
  ```
+ `@number_of_files` – 备份将被划分（分块）成的文件数。最大文件数为 10。
  + 完整备份和差异备份都支持多文件备份。
  + 如果您输入值 1 或省略该参数，则会创建单个备份文件。

  请提供文件拥有的通用前缀，然后使用星号 (`*`) 为其添加后缀。星号可位于 S3 ARN 的 *file\$1name* 部分中的任意位置。星号由所生成文件中的一系列字母数字字符串替换，从 `1-of-number_of_files` 开始。

  例如，如果 S3 ARN 中的文件名为 `backup*.bak` 并且您已设置 `@number_of_files=4`，则生成的备份文件为 `backup1-of-4.bak`、`backup2-of-4.bak`、`backup3-of-4.bak` 和 `backup4-of-4.bak`。
  + 如果任意文件名已存在，并且 `@overwrite_s3_backup_file` 设置为 0，则会返回错误。
  + 在 S3 ARN 的 *file\$1name* 部分，多文件备份只能有一个星号。
  + 单文件备份可以在 S3 ARN 的 *file\$1name* 部分中包含任意数量的星号。星号不会从所生成的文件名中删除。
+ `@block_size` – 块大小（以字节为单位），指定备份操作的物理块大小。有效值为 512、1024、2048、4096、8192、16384、32768 和 65536
+ `@max_transfer_size` – 最大传输大小表示备份过程中每次 I/O 操作传输的数据量（以字节为单位）的上限。有效值是 65536 字节（64 KB）到 4194304 字节（4 MB）的倍数。
+ `@buffer_count` – 用于备份过程的 I/O 缓冲区总数。
+ `@enable_bucket_default_encryption`：一个值，指示是否使用 S3 存储桶的默认加密配置，在 S3 中进行服务器端加密。无论此设置如何，目录存储桶始终使用存储桶的默认加密配置。
  + `0` – 服务器端加密通过 SSE-S3 使用 256 位高级加密标准（AES）。
  + `1` – 服务器端加密使用 S3 存储桶配置的[默认加密](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html)。

### 示例
<a name="SQLServer.Procedural.Importing.Native.Backup.Examples"></a>

**Example 差异备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```

**Example 使用客户端加密的完整备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```

**Example 多文件备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```

**Example 多文件差异备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```

**Example 使用加密的多文件备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```

**Example 使用 S3 覆盖进行多文件备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```

**Example 使用块大小进行备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```

**Example 使用 `@max_transfer_size` 和 `@buffer_count` 进行多文件备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```

**Example 使用 @number\$1of\$1files 参数进行单文件备份**  
此示例生成一个名为 `backup*.bak` 的备份文件。  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```

**Example 使用服务器端加密的完整备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```

**Example 使用接入点进行完整备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```

**Example 使用目录存储桶的接入点进行完整备份**  

```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```

## 还原数据库
<a name="SQLServer.Procedural.Importing.Native.Using.Restore"></a>

要还原数据库，请调用 `rds_restore_database` 存储过程。还原任务完成且数据库打开后，Amazon RDS 将创建数据库的初始快照。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Restore.Syntax"></a>

```
exec msdb.dbo.rds_restore_database
	@restore_db_name='database_name',
	@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
	@with_norecovery=0|1,
	[@keep_cdc=0|1],
	[@data_file_volume='D:|H:|I:|J:'],
	[@log_file_volume='D:|H:|I:|J:'],
	[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
        [@block_size=512|1024|2048|4096|8192|16384|32768|65536],
        [@max_transfer_size=n],
        [@buffer_count=n],
	[@type='DIFFERENTIAL|FULL'];
```

以下参数为必需参数：
+ `@restore_db_name`– 要还原的数据库的名称。数据库名称是唯一的。如果存在同名的现有数据库，则无法还原数据库。
+ `@s3_arn_to_restore_from` – 指示用于还原数据库的备份文件的 Amazon S3 前缀和名称的 ARN。
  + 对于单文件备份，请提供整个文件名。
  + 对于多文件备份，请提供文件拥有的通用前缀，然后使用星号 (`*`) 为其添加后缀。
    + 如果使用目录存储桶，则由于[目录存储桶的差异](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html)，ARN 必须以 `/*` 结尾。
  + 如果 `@s3_arn_to_restore_from` 为空，则返回以下错误消息：S3 ARN prefix cannot be empty (S3 ARN 前缀不能为空)。

以下参数对于差异还原是必需的，但对于完整还原是可选的：
+ `@with_norecovery` – 用于还原操作的恢复子句。
  + 将它设置为 `0` 来使用 RECOVERY 进行还原。在这种情况下，在还原后，数据库将处于在线状态。
  + 将它设置为 `1` 来使用 NORECOVERY 进行还原。在这种情况下，在还原任务完成后，数据库将保持 RESTORING 状态。使用这种方法，您可以执行以后的差异还原。
  + 对于 DIFFERENTIAL 还原，请指定 `0` 或 `1`。
  + 对于 `FULL` 还原，此值默认为 `0`。

以下参数可选：
+ `@keep_cdc` – 表示是否在还原的数据库上保留更改数据捕获（CDC）配置。设为 `1` 可启用 KEEP\$1CDC，设为 `0` 可禁用。默认值为 `0`。
+ `@data_file_volume`：指定数据库数据文件的驱动器盘符。默认值为 `D:`。
+ `@log_file_volume`：指定数据库日志文件的驱动器盘符。默认值为 `D:`。
+ `@kms_master_key_arn` - 如果您已对备份文件进行加密，则 KMS 密钥用于解密文件。

  指定 KMS 密钥时，将使用客户端加密。
+ `@type` – 还原的类型。有效类型为 `DIFFERENTIAL` 和 `FULL`。默认值为 `FULL`。
+ `@block_size` – 块大小（以字节为单位），指定备份操作的物理块大小。有效值为 512、1024、2048、4096、8192、16384、32768 和 65536
+ `@max_transfer_size` – 最大传输大小表示备份过程中每次 I/O 操作传输的数据量（以字节为单位）的上限。有效值是 65536 字节（64 KB）到 4194304 字节（4 MB）的倍数。
+ `@buffer_count` – 用于备份过程的 I/O 缓冲区总数。

**注意**  
对于差异还原，数据库必须处于 RESTORING 状态，或者必须已存在使用 NORECOVERY 还原的任务。  
在数据库处于在线状态时，您无法还原以后的差异备份。  
您无法为已具有使用 RECOVERY 的挂起还原任务的数据库提交还原任务。  
不支持同时使用 NORECOVERY 和 KEEP\$1CDC 的完整还原。  
具有跨区域只读副本的实例并不支持所有原生还原。  
对于支持的配置，在具有只读副本的多可用区实例上还原数据库类似于在多可用区实例上还原数据库。您无需执行任何其他操作，即可在副本上还原数据库。

### 示例
<a name="SQLServer.Procedural.Importing.Native.Restore.Examples"></a>

**Example 单文件还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```

**Example 多文件还原**  
为避免还原多个文件时出错，请确保所有备份文件有相同的前缀且没有任何其他文件使用该前缀。  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```

**Example 使用 RECOVERY 的完整数据库还原**  
以下三个示例执行相同的任务，即使用 RECOVERY 进行完整还原。  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```

**Example 使用加密进行完整数据库还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```

**Example 使用块大小进行还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```

**Example 使用 @max\$1transfer\$1size 和 @buffer\$1count 进行多文件还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```

**Example 使用 NORECOVERY 进行完整数据库还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```

**Example 使用 NORECOVERY 的差异还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```

**Example 使用 RECOVERY 的差异还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```

**Example 使用 RECOVERY 的完整数据库还原（使用接入点）**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```

**Example 使用 KEEP\$1CDC 的完整数据库还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```

## 还原日志
<a name="SQLServer.Procedural.Importing.Native.Restore.Log"></a>

要还原日志，请调用 `rds_restore_log` 存储过程。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Restore.Log.Syntax"></a>

```
exec msdb.dbo.rds_restore_log 
	@restore_db_name='database_name',
	@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
	[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
	[@with_norecovery=0|1],
	[@keep_cdc=0|1],
	[@stopat='datetime'],
	[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
        [@max_transfer_size=n],
        [@buffer_count=n];
```

以下参数为必需参数：
+ `@restore_db_name` – 要还原其日志的数据库的名称。
+ `@s3_arn_to_restore_from` – 指示用于还原日志的日志文件的 Amazon S3 前缀和名称的 ARN。此文件可以具有任何扩展名，但通常使用 `.trn`。

  如果 `@s3_arn_to_restore_from` 为空，则返回以下错误消息：S3 ARN prefix cannot be empty (S3 ARN 前缀不能为空)。

以下参数可选：
+ `@keep_cdc` – 表示是否在还原的数据库上保留更改数据捕获（CDC）配置。设为 1 可启用 KEEP\$1CDC，设为 0 可禁用。默认值是 0。
+ `@kms_master_key_arn` - 如果您已对日志进行加密，则 KMS 密钥用于解密日志。
+ `@with_norecovery` – 用于还原操作的恢复子句。此值默认为 `1`。
  + 将它设置为 `0` 来使用 RECOVERY 进行还原。在这种情况下，在还原后，数据库将处于在线状态。在数据库处于在线状态时，您无法还原其他日志备份。
  + 将它设置为 `1` 来使用 NORECOVERY 进行还原。在这种情况下，在还原任务完成后，数据库将保持 RESTORING 状态。使用这种方法，您可以执行以后的日志还原。
+ `@stopat` – 指定将数据库还原到其在指定的日期和时间的状态的值（采用日期时间格式）。仅将在指定日期和时间之前写入的事务日志记录应用于数据库。

  如果未指定此参数（它为 NULL），则会还原完整的日志。
+ `@block_size` – 块大小（以字节为单位），指定备份操作的物理块大小。有效值为 512、1024、2048、4096、8192、16384、32768 和 65536
+ `@max_transfer_size` – 最大传输大小表示备份过程中每次 I/O 操作传输的数据量（以字节为单位）的上限。有效值是 65536 字节（64 KB）到 4194304 字节（4 MB）的倍数。
+ `@buffer_count` – 用于备份过程的 I/O 缓冲区总数。

**注意**  
对于日志还原，数据库必须处于 restoring 状态，或者必须已存在使用 NORECOVERY 还原的任务。  
在数据库处于在线状态时，您无法还原日志备份。  
您无法在已具有使用 RECOVERY 的挂起还原任务的数据库上提交日志还原任务。

### 示例
<a name="SQLServer.Procedural.Importing.Native.Restore.Log.Examples"></a>

**Example 日志还原**  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```

**Example 使用加密的日志还原**  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```

**Example 使用 NORECOVERY 的日志还原**  
以下两个示例执行相同的任务，即使用 NORECOVERY 进行日志还原。  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```

**Example 使用块大小进行还原**  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```

**Example 使用 RECOVERY 的日志还原**  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```

**Example 使用 STOPAT 子句的日志还原**  

```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```

**Example 使用 KEEP\$1CDC 的日志还原**  

```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```

## 完成数据库还原
<a name="SQLServer.Procedural.Importing.Native.Finish.Restore"></a>

如果数据库上的上一个还原任务是使用 `@with_norecovery=1` 执行的，则数据库现在处于 RESTORING 状态。使用 `rds_finish_restore` 存储过程打开此数据库以执行常规操作。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax"></a>

```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```

**注意**  
要使用此方法，数据库必须处于 RESTORING 状态，且没有任何挂起的还原任务。  
要完成数据库还原，请使用主登录名。或使用最近使用 NORECOVERY 还原数据库或日志的用户登录名。

## 处理部分还原的数据库
<a name="SQLServer.Procedural.Importing.Native.Partially.Restored"></a>

### 删除部分还原的数据库
<a name="SQLServer.Procedural.Importing.Native.Drop.Partially.Restored"></a>

要删除部分还原的数据库（保留为 RESTORING 状态），请使用 `rds_drop_database` 存储过程。

```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```

**注意**  
您无法为已具有挂起的还原或完成还原任务的数据库提交 DROP 数据库请求。  
要删除数据库，请使用主登录名。或使用最近使用 NORECOVERY 还原数据库或日志的用户登录名。

### 部分还原的数据库的快照还原和时间点恢复行为
<a name="SQLServer.Procedural.Importing.Native.Snapshot.Restore"></a>

在快照还原和时间点恢复期间，将从目标实例中删除源实例中的部分还原的数据库（保留为 RESTORING 状态）。

## 取消任务
<a name="SQLServer.Procedural.Importing.Native.Using.Cancel"></a>

要取消备份或还原任务，请调用 `rds_cancel_task` 存储过程。

**注意**  
您无法取消 FINISH\$1RESTORE 任务。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Cancel.Syntax"></a>

```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```

以下参数是必需参数：
+ `@task_id`– 要取消的任务的 ID。可以通过调用 `rds_task_status` 获取任务 ID。

## 跟踪任务的状态
<a name="SQLServer.Procedural.Importing.Native.Tracking"></a>

要跟踪备份和还原任务的状态，请调用 `rds_task_status` 存储过程。如果您未提供任何参数，则存储过程将返回所有任务的状态。任务的状态约每 2 分钟更新一次。任务历史记录保留 36 天。

### 用法
<a name="SQLServer.Procedural.Importing.Native.Tracking.Syntax"></a>

```
exec msdb.dbo.rds_task_status
	[@db_name='database_name'],
	[@task_id=ID_number];
```

以下参数可选：
+ `@db_name`– 要显示其任务状态的数据库的名称。
+ `@task_id`– 要显示其任务状态的任务的 ID。

### 示例
<a name="SQLServer.Procedural.Importing.Native.Tracking.Examples"></a>

**Example 列出特定任务的状态**  

```
exec msdb.dbo.rds_task_status @task_id=5;
```

**Example 列出特定数据库和任务的状态**  

```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```

**Example 列出特定数据库上的所有任务及其状态**  

```
exec msdb.dbo.rds_task_status @db_name='my_database';
```

**Example 列出当前实例上的所有任务及其状态**  

```
exec msdb.dbo.rds_task_status;
```

### 响应
<a name="SQLServer.Procedural.Importing.Native.Tracking.Response"></a>

`rds_task_status` 存储过程返回以下列。


****  

| 列 | 描述 | 
| --- | --- | 
| `task_id` |  任务的 ID。  | 
| `task_type` |  任务类型取决于输入参数，如下所示： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) 在完成以下还原任务时打开数据库后，Amazon RDS 创建数据库的初始快照： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html)  | 
| `database_name` |  与任务关联的数据库的名称。  | 
| `% complete` |  用百分比值表示的任务进度。  | 
| `duration (mins)` |  在任务上花费的时间 (以分钟为单位)。  | 
| `lifecycle` |  任务的状态。有以下可能状态： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html)  | 
| `task_info` |  有关任务的其他信息。 如果在备份或还原数据库时出错，则此列将包含有关错误的信息。有关可能的错误列表以及缓解策略，请参阅 [故障排除](SQLServer.Procedural.Importing.Native.Troubleshooting.md)。  | 
| `last_updated` |  上次更新任务状态的日期和时间。状态每隔 5% 的进度更新一次。  | 
| `created_at` | 任务的创建日期和时间。 | 
| S3\$1object\$1arn | 指示要备份或还原的文件的 Amazon S3 前缀和名称的 ARN。 | 
| `overwrite_s3_backup_file` |  调用备份任务时指定的 `@overwrite_s3_backup_file` 参数的值。有关更多信息，请参阅 [备份数据库](#SQLServer.Procedural.Importing.Native.Using.Backup)。  | 
| KMS\$1master\$1key\$1arn | 用于加密 (对于备份) 和解密 (对于还原) 的 KMS 密钥的 ARN。 | 
| filepath | 不适用于本机备份和还原任务。 | 
| overwrite\$1file | 不适用于本机备份和还原任务。 | 

# 压缩备份文件
<a name="SQLServer.Procedural.Importing.Native.Compression"></a>

要节省 Amazon S3 存储桶中的空间，您可以压缩备份文件。有关压缩备份文件的更多信息，请参阅 Microsoft 文档中的[备份压缩](https://msdn.microsoft.com/en-us/library/bb964719.aspx)。

以下数据库版本支持压缩您的备份文件：
+ Microsoft SQL Server 企业版 
+ Microsoft SQL Server 标准版 

要验证备份文件的压缩选项，请运行以下代码：

```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```

要为备份文件启用压缩，请运行以下代码：

```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```

要为备份文件禁用压缩，请运行以下代码：

```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```

# 故障排除
<a name="SQLServer.Procedural.Importing.Native.Troubleshooting"></a>

以下是您使用本地备份和还原时可能会遇到的问题。


****  

| 问题 | 故障排除建议 | 
| --- | --- | 
|  数据库备份/恢复选项尚未启用或启用中。请稍后重试。  |  请确保您已将 `SQLSERVER_BACKUP_RESTORE` 选项添加到与数据库实例关联的数据库选项组。有关更多信息，请参阅 [添加本机备份和还原选项](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add)。  | 
|  对象“*rds\$1backup\$1database*”（数据库“msdb”，架构“dbo”）上的 EXECUTE 权限遭拒绝。  |  确保在执行存储过程时使用主用户。如果您以主用户身份登录后仍遇到此错误，则可能是由于管理员用户权限不符。要重置主用户，请使用 AWS 管理控制台。请参阅[重置 Amazon RDS for SQL Server 主用户的 db\$1owner 角色成员资格](Appendix.SQLServer.CommonDBATasks.ResetPassword.md)。  | 
|  对象“*rds\$1restore\$1database*”（数据库“msdb”，架构“dbo”）上的 EXECUTE 权限遭拒绝。  |  确保在执行存储过程时使用主用户。如果您以主用户身份登录后仍遇到此错误，则可能是由于管理员用户权限不符。要重置主用户，请使用 AWS 管理控制台。请参阅[重置 Amazon RDS for SQL Server 主用户的 db\$1owner 角色成员资格](Appendix.SQLServer.CommonDBATasks.ResetPassword.md)。  | 
|  拒绝访问  | 备份或还原进程无法访问备份文件。这通常由类似于以下的问题导致： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html)  | 
|  <edition\$1name> 版本不支持带压缩的备份数据库  |  仅 Microsoft SQL Server 企业版和标准版支持压缩备份文件。 有关更多信息，请参阅“[压缩备份文件](SQLServer.Procedural.Importing.Native.Compression.md)”。  | 
|  不存在密钥 <ARN>  |  您已尝试还原一个加密备份，但未提供有效的加密密钥。检查您的加密密钥并重试。有关更多信息，请参阅“[还原数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)”。  | 
|  请使用正确的类型重新发布任务并覆盖属性  |  如果您尝试备份数据库并提供了已存在文件的名称，但将覆盖策略设置为 false，则保存操作会失败。要修复该错误，请提供不存在的文件名，或者将覆盖属性设置为 true。 有关更多信息，请参阅“[备份数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)”。 还有可能是您希望还原数据库，但意外调用了 `rds_backup_database` 存储过程。在这种情况下，请改为调用 `rds_restore_database` 存储过程。 有关更多信息，请参阅“[还原数据库](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)”。 如果您希望还原数据库并调用 `rds_restore_database` 存储过程，请确保您提供了有效的备份文件名称。 有关更多信息，请参阅“[使用本机备份和还原](SQLServer.Procedural.Importing.Native.Using.md)”。  | 
|  请指定与 RDS 实例位于同一区域的存储桶  |  您不能备份到与您的 Amazon RDS 数据库实例不同的AWS区域中的某个 Amazon S3 存储桶或从该存储桶中进行还原。您可以使用 Amazon S3 复制将备份文件复制到正确的AWS区域。 有关更多信息，请参阅 Amazon S3 文档中的[跨区域复制](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html)。  | 
|  指定的存储桶不存在  | 验证您使用正确格式为存储桶和文件提供了正确的 ARN。 有关更多信息，请参阅“[使用本机备份和还原](SQLServer.Procedural.Importing.Native.Using.md)”。  | 
|  用户 <ARN> 无权对 <ARN> 资源执行 <kms action>  |  您请求了加密操作，但未提供正确的 AWS KMS 权限。确保您具有正确的权限，否则，请添加权限。 有关更多信息，请参阅“[针对本机备份和还原进行设置](SQLServer.Procedural.Importing.Native.Enabling.md)”。  | 
|  还原”任务无法从 10 个以上的备份文件中恢复。请减少匹配的文件数量，然后重试。  |  减少您尝试从中还原的文件数。如有必要，您可以让每个文件变得更大。  | 
|  数据库“*database\$1name*”已存在。不允许存在两个仅大小写或重音不同的数据库。选择其他数据库名称。  |  如果存在同名的现有数据库，则无法还原数据库。数据库名称是唯一的。  | 

# 使用其他方法导入和导出 SQL Server 数据
<a name="SQLServer.Procedural.Importing.Snapshots"></a>

接下来，您可以找到有关使用快照将 Microsoft SQL Server 数据导入到 Amazon RDS 中的信息。还可以找到有关使用快照从运行 SQL Server 的 RDS 数据库实例中导出数据的信息。

如果您的方案支持此方法，则可使用本机备份和还原功能更轻松地将数据移入和移出 Amazon RDS。有关更多信息，请参阅[使用本机备份和还原导入和导出 SQL Server 数据库](SQLServer.Procedural.Importing.md)。

**注意**  
Amazon RDS for Microsoft SQL Server 不支持将数据导入 `msdb` 数据库。

## 使用快照将数据导入 RDS for SQL Server
<a name="SQLServer.Procedural.Importing.Procedure"></a>

**使用快照将数据导入 SQL Server 数据库实例**

1. 创建数据库实例。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。

1. 阻止应用程序访问目标数据库实例。

   如果您在导入数据时阻止应用程序访问数据库实例，数据传输速度会更快。此外，您无需担心在加载数据时会因其他应用程序无法写入到数据库实例而引起冲突。如果因出现问题而必须要回滚到之前的数据库快照，则丢失的唯一更改就是导入的数据。在解决问题后，您可以再次导入这些数据。

   有关控制数据库实例访问权限的信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。

1. 创建目标数据库快照。

   如果目标数据库已存有数据，我们建议您先为数据库创建快照，然后再导入数据。如果数据导入过程出现问题或您想要放弃更改，您可以使用此快照将数据库还原到先前的状态。有关数据库快照的信息，请参阅 [为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)。
**注意**  
获取数据库快照时，数据库的 I/O 操作会在备份进行期间暂停一会（以毫秒为单位）。

1. 禁用目标数据库的自动备份。

   禁用目标数据库实例上的自动备份将会提高导入数据时的性能，因为 Amazon RDS 在禁用自动备份后不会记录事务。但需要考虑以下问题。执行时间点恢复时需要使用自动备份。因此，在导入数据时，无法将数据库还原到特定时间点。此外，除非您选择保留先前在数据库实例上创建的所有自动备份，否则系统会将其清除。

   选择保留自动备份有助于防止意外删除数据。Amazon RDS 还会保存数据库实例属性以及每个自动备份以便进行恢复。利用此选项，可将已删除的数据库实例还原到备份保留期内的指定时间点，即使在删除它之后也是如此。由于自动备份是用于有效数据库实例的，它们将在特定备份时段结束后自动被删除。

   您也可使用先前的快照来恢复数据库，并且您创建的所有快照仍然可用。有关自动备份的信息，请参阅 [备份简介](USER_WorkingWithAutomatedBackups.md)。

1. 禁用外键约束 (如适用)。

    如果需要禁用外键约束，可以使用以下脚本。

   ```
   --Disable foreign keys on all tables
       DECLARE @table_name SYSNAME;
       DECLARE @cmd NVARCHAR(MAX);
       DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
       
       OPEN table_cursor;
       FETCH NEXT FROM table_cursor INTO @table_name;
       
       WHILE @@FETCH_STATUS = 0 BEGIN
         SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
         EXEC (@cmd);
         FETCH NEXT FROM table_cursor INTO @table_name;
       END
       
       CLOSE table_cursor;
       DEALLOCATE table_cursor;
       
       GO
   ```

1. 删除索引 (如果适用)。

1. 禁用触发器 (如果适用)。

    如果您需要禁用触发器，则可使用以下脚本执行该操作。

   ```
   --Disable triggers on all tables
       DECLARE @enable BIT = 0;
       DECLARE @trigger SYSNAME;
       DECLARE @table SYSNAME;
       DECLARE @cmd NVARCHAR(MAX);
       DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
        table_object.name table_name
       FROM sysobjects trigger_object
       JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
       WHERE trigger_object.type = 'TR';
       
       OPEN trigger_cursor;
       FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
       
       WHILE @@FETCH_STATUS = 0 BEGIN
         IF @enable = 1
            SET @cmd = 'ENABLE ';
         ELSE
            SET @cmd = 'DISABLE ';
       
         SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
         EXEC (@cmd);
         FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
       END
       
       CLOSE trigger_cursor;
       DEALLOCATE trigger_cursor;
       
       GO
   ```

1. 查询源 SQL Server 实例，获取要导入到目标数据库实例的所有登录名。

   SQL Server 将登录名和密码存储在 `master` 数据库中。由于 Amazon RDS 未授予访问 `master` 数据库的权限，因此您无法直接将登录名和密码导入目标数据库实例。您必须在源 SQL Server 实例上查询 `master` 数据库以生成数据定义语言 (DDL) 文件。此文件应包括要添加到目标数据库实例的所有登录名和密码。此文件还应包括要传输的角色成员资格和权限。

   有关查询 `master` 数据库的信息，请参阅 Microsoft 知识库中的 [Transfer logins and passwords between instances of SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances) 。

   该脚本输出是可在目标数据库实例上运行的另一个脚本。知识库文章中的脚本包含以下代码：

   ```
   p.type IN 
   ```

   在 `p.type` 出现的所有位置，改用以下代码：

   ```
   p.type = 'S' 
   ```

1. 使用[导入数据](#ImportData.SQLServer.Import)中的方法导入数据。

1. 授予应用程序访问目标数据库实例的权限。

   完成数据导入后，您可以向导入期间被阻止的应用程序授予访问数据库实例的权限。有关控制数据库实例访问权限的信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。

1. 启用目标数据库实例的自动备份。

   有关自动备份的信息，请参阅 [备份简介](USER_WorkingWithAutomatedBackups.md)。

1. 启用外键约束。

    如果您之前禁用了外键约束，现在可通过以下脚本重新启用。

   ```
   --Enable foreign keys on all tables
       DECLARE @table_name SYSNAME;
       DECLARE @cmd NVARCHAR(MAX);
       DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
       
       OPEN table_cursor;
       FETCH NEXT FROM table_cursor INTO @table_name;
       
       WHILE @@FETCH_STATUS = 0 BEGIN
         SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
         EXEC (@cmd);
         FETCH NEXT FROM table_cursor INTO @table_name;
       END
       
       CLOSE table_cursor;
       DEALLOCATE table_cursor;
   ```

1. 启用索引 (如果适用)。

1. 启用触发器 (如果适用)。

    如果您之前禁用了触发器，现在可以通过以下脚本启用触发器。

   ```
   --Enable triggers on all tables
       DECLARE @enable BIT = 1;
       DECLARE @trigger SYSNAME;
       DECLARE @table SYSNAME;
       DECLARE @cmd NVARCHAR(MAX);
       DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
        table_object.name table_name
       FROM sysobjects trigger_object
       JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
       WHERE trigger_object.type = 'TR';
       
       OPEN trigger_cursor;
       FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
       
       WHILE @@FETCH_STATUS = 0 BEGIN
         IF @enable = 1
            SET @cmd = 'ENABLE ';
         ELSE
            SET @cmd = 'DISABLE ';
       
         SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
         EXEC (@cmd);
         FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
       END
       
       CLOSE trigger_cursor;
       DEALLOCATE trigger_cursor;
   ```

### 导入数据
<a name="ImportData.SQLServer.Import"></a>

Microsoft SQL Server Management Studio 是一种包含在所有 Microsoft SQL Server 版本 (Express 版除外) 中的图像化 SQL Server 客户端。您可以从 Microsoft 上免费下载 SQL Server Management Studio Express。要找到此下载，请访问 [Microsoft 网站](https://www.microsoft.com/en-us/download)。

**注意**  
SQL Server Management Studio 应用程序只能在 Windows 环境中运行。

SQL Server Management Studio 包括能够帮助将数据导入 SQL Server 数据库实例的以下工具：
+ 生成和发布脚本向导
+ 导入和导出向导
+ 批量复制

#### 生成和发布脚本向导
<a name="ImportData.SQLServer.MgmtStudio.ScriptWizard"></a>

生成和发布脚本向导可创建一个包含数据库架构或数据本身，或兼具两者的脚本。您可以在本地 SQL Server 部署中为数据库生成脚本。然后，您可以运行该脚本以将其包含的信息传输到 Amazon RDS 数据库实例。

**注意**  
对于 1GiB 或更大的数据库，只编写数据库架构的脚本会更高效。然后，您可以使用导入和导出向导，或 SQL Server 的批量复制功能来传输数据。

有关生成和发布脚本向导的详细信息，请参阅 [Microsoft SQL Server 文档](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx)。

在此向导中，请特别注意**设置脚本选项**页面中的高级选项，确保已选中脚本需要包含的所有选项。例如，默认情况下，脚本不包含数据库触发器。

生成并保存脚本后，您可以使用 SQL Server Management Studio 连接数据库实例，然后运行脚本。

#### 导入和导出向导
<a name="ImportData.SQLServer.MgmtStudio.ImportExportWizard"></a>

导入和导出向导工具可创建一种特殊的集成服务包，您可以使用此集成服务包将数据从本地 SQL Server 数据库复制到目标数据库实例。此向导可筛选要将哪些表格甚至是表格内的哪些元组复制到目标数据库实例。

**注意**  
导入和导出向导在用于大型数据集时非常有效，但是就从本地部署中远程导出数据而言，这可能不是最快的方式。要采用更快的方式，请考虑 SQL Server 批量复制功能。

有关导入和导出向导的详细信息，请参阅 [Microsoft SQL Server 文档](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx)。

在此向导中，请在 **Choose a Destination (选择目标)** 页面上执行以下操作：
+ 对于 **Server Name (服务器名称)**，键入数据库实例的终端节点名称。
+ 对于服务器身份验证模式，请选择 **Use SQL Server Authentication**。
+ 对于 **User name (用户名)** 和 **Password (密码)**，请键入您为数据库实例创建的主用户凭证。

#### 批量复制
<a name="ImportData.SQLServer.MgmtStudio.BulkCopy"></a>

SQL Server 批量复制功能是一种将数据从源数据库复制到数据库实例的高效工具。批量复制可将指定的数据写入一个数据文件，如 ASCII 文件。然后您可以再次运行批量复制，将此文件内容写入目标数据库实例。

本部分使用了 **bcp** 实用工具，所有版本的 SQL Server 都包含此工具。有关批量导入和导出操作的详细信息，请参阅 [Microsoft SQL Server 文档](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx)。

**注意**  
使用批量复制前，您必须先将数据库架构导入目标数据库实例。本主题前面介绍的生成和发布脚本向导这一工具非常适合用于该操作。

以下命令用于连接到本地 SQL Server 实例。它在您现有 SQL Server 部署的 C:\$1 根目录中生成指定表的制表符定界文件。指定表时需使用完全限定名，文本文件的名称与复制的表相同。

```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000 
```

上述代码包含以下选项：
+ `-n` 指定，批量复制将使用待复制数据的本机数据类型。
+ `-S` 指定 *bcp* 实用工具连接到的 SQL Server 实例。
+ `-U` 指定要登录到 SQL Server 实例的账户的用户名。
+ `-P` 为 指定的用户指定密码。`-U`
+ `-b` 指定每批导入数据的行数。

**注意**  
可能有对导入情况来说很重要的其他参数。例如，您可能需要与身份值有关的 `-E` 参数。有关更多信息，请参阅 [Microsoft SQL Server 文档](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx)中的 **bcp** 实用工具的命令行语法的完整说明。

例如，假设某一数据库名为 `store`，使用了默认架构 `dbo` 且包含一个名为 `customers` 的表。密码为 `admin` 的用户账户 `insecure` 将 `customers` 表中的 10000 行复制到名为 `customers.txt` 的文件中。

```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000 
```

生成数据文件后，可以使用类似的命令将数据上传到数据库实例。事先在目标数据库实例上创建数据库和架构。然后使用 `in` 参数指定输入文件，而不是使用 `out` 指定输出文件。您需要指定数据库实例的终端节点，而不是使用 localhost 指定本地 SQL Server 实例。如果您使用的端口不是 1433 端口，也需要执行该指定操作。用户名和密码是数据库实例的主用户名和密码。语法如下所示。

```
bcp dbname.schema_name.table_name 
					in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```

为继续上述示例，我们假设主用户名是 `admin`，密码为 `insecure`。数据库实例的终端节点是 `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com`，且您使用端口 4080。命令如下所示。

```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000 
```

**注意**  
作为安全最佳实践，请指定除此处所示提示以外的密码。

## 从 RDS for SQL Server 中导出数据
<a name="SQLServer.Procedural.Exporting"></a>

您可以选择以下选项之一来从 RDS for SQL Server 数据库实例中导出数据：
+ **使用完整备份文件 (.bak) 的本机数据库备份** – 使用 .bak 文件备份数据库的过程已得到大幅优化，因此，它通常是最快的导出数据的方法。有关更多信息，请参阅“[使用本机备份和还原导入和导出 SQL Server 数据库](SQLServer.Procedural.Importing.md)”。
+ **SQL Server 导入和导出向导** – 有关更多信息，请参阅 [SQL Server 导入和导出向导](#SQLServer.Procedural.Exporting.SSIEW)。
+ **SQL Server 生成和发布脚本向导与 bcp 实用工具** – 有关更多信息，请参阅 [SQL Server 生成和发布脚本向导与 bcp 实用工具](#SQLServer.Procedural.Exporting.SSGPSW)。

### SQL Server 导入和导出向导
<a name="SQLServer.Procedural.Exporting.SSIEW"></a>

您可以使用 SQL Server 导入和导出向导将一个或多个表、视图或查询从 RDS for SQL Server 数据库实例复制到另一个数据存储。如果目标数据存储不是 SQL Server，这将是最佳选择。有关更多信息，请参阅 SQL Server 文档中的 [ SQL Server 导入和导出向导](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx)。

SQL Server 导入和导出向导是 Microsoft SQL Server Management Studio 的一部分。此图形化 SQL Server 客户端包含在所有 Microsoft SQL Server 版本（Express 版除外）中。SQL Server Management Studio 应用程序只能在 Windows 环境中运行。您可以从 Microsoft 上免费下载 SQL Server Management Studio Express。要找到此下载，请访问 [Microsoft 网站](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio)。

**使用 SQL Server 导入和导出向导来导出数据**

1. 在 SQL Server Management Studio 中，连接到 RDS for SQL Server 数据库实例。有关如何执行该操作的详细信息，请参阅[连接到 Microsoft SQL Server 数据库实例](USER_ConnectToMicrosoftSQLServerInstance.md)。

1. 在 **Object Explorer** 中，展开 **Databases (数据库)**，打开源数据库的上下文（右键单击）菜单，选择 **Tasks (任务)**，然后选择 **Export Data (导出数据)**。此时将显示向导。

1. 在 **Choose a Data Source (选择数据源)** 页面上，执行以下操作：

   1. 对于 **Data source (数据源)**，选择 **SQL Server Native Client 11.0**。

   1. 确认**服务器名称**框中显示 RDS for SQL Server 数据库实例的终端节点。

   1. 选择 **Use SQL Server Authentication (使用 SQL Server 身份验证)**。对于 **用户名** 和 **密码**，键入您的数据库实例的主用户名和密码。

   1. 确认 **Database (数据库)** 框中显示要从中导出数据的数据库。

   1. 选择**下一步**。

1. 在 **Choose a Destination (选择目标)** 页面上，执行以下操作：

   1. 对于 **Destination (目标)**，选择 **SQL Server Native Client 11.0**。
**注意**  
提供了其他目标数据源。这些包括 .NET Framework 数据提供程序、OLE DB 提供程序、SQL Server Native Client 提供程序、ADO.NET 提供程序、Microsoft Office Excel、Microsoft Office Access 以及平面文件源。如果您选择这些数据源之一作为目标，请跳过步骤 4 的其余部分。有关接下来要提供的连接信息的详细信息，请参阅 SQL Server 文档中的[选择目标](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx)。

   1. 对于 **Server name (服务器名称)**，键入目标 SQL Server 数据库实例的服务器名称。

   1. 选择适当的身份验证类型。如有必要，键入用户名和密码。

   1. 对于 **Database (数据库)**，选择目标数据库的名称，或选择 **New (新建)** 以创建一个包含已导出数据的新数据库。

      如果选择**新建**，请参阅 SQL Server 文档中的[创建数据库](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx)，以了解要提供的数据库信息。

   1. 选择**下一步**。

1. 在 **Table Copy or Query (表复制或查询)** 页面上，选择 **Copy data from one or more tables or views (从一个或多个表或视图复制数据)** 或 **Write a query to specify the data to transfer (编写查询以指定要传输的数据)**。选择**下一步**。

1. 如果您选择 **Write a query to specify the data to transfer (编写查询以指定要传输的数据)**，则将看到 **Provide a Source Query (提供源查询)** 页面。键入或贴入 SQL 查询，然后选择 **Parse (分析)** 以进行验证。在验证查询后，选择 **Next (下一步)**。

1. 在 **Select Source Tables and Views (选择源表和视图)** 页面上，执行以下操作：

   1. 选择要导出的表和视图，或确认已选择您提供的查询。

   1. 选择 **Edit Mappings (编辑映射)** 并指定数据库和列映射信息。有关详细信息，请参阅 SQL Server 文档中的[列映射](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx)。

   1. (可选) 若要查看要导出的数据的预览，请选择表、视图或查询，然后选择 **Preview**。

   1. 选择**下一步**。

1. 在 **Run Package (运行程序包)** 页面上，确认已选择 **Run immediately (立即运行)**。选择**下一步**。

1. 在 **Complete the Wizard (完成向导)** 页面上，确认数据导出详细信息是预期的详细信息。选择 **Finish (结束)**。

1. 在 **The execution was successful (执行已成功)** 页面上，单击 **Close (关闭)**。

### SQL Server 生成和发布脚本向导与 bcp 实用工具
<a name="SQLServer.Procedural.Exporting.SSGPSW"></a>

您可以使用 SQL Server 生成和发布脚本向导来为整个数据库或仅为所选对象创建脚本。可在目标 SQL Server 数据库实例上运行这些脚本以重新创建已编写脚本的对象。然后，可以使用 bcp 实用工具将选定对象的数据批量导出到目标数据库实例。若要在两个 SQL Server 数据库实例之间移动整个数据库 (包括表以外的对象) 或大量数据，这将是最佳选择。有关 bcp 命令行语法的完整说明，请参阅 Microsoft SQL Server 文档中的 [bcp 实用工具](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx)。

SQL Server 生成和发布脚本向导是 Microsoft SQL Server Management Studio 的一部分。此图形化 SQL Server 客户端包含在所有 Microsoft SQL Server 版本（Express 版除外）中。SQL Server Management Studio 应用程序只能在 Windows 环境中运行。您可以从 Microsoft 上[免费下载](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio) SQL Server Management Studio Express。

**使用 SQL Server 生成和发布脚本向导与 bcp 实用工具来导出数据**

1. 在 SQL Server Management Studio 中，连接到 RDS for SQL Server 数据库实例。有关如何执行该操作的详细信息，请参阅 [连接到 Microsoft SQL Server 数据库实例](USER_ConnectToMicrosoftSQLServerInstance.md)。

1. 在 **Object Explorer** 中，展开 **Databases (数据库)** 节点并选择要编写脚本的数据库。

1. 按照 SQL Server 文档中的[生成和发布脚本向导](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx)中的说明，创建脚本文件。

1. 在 SQL Server Management Studio 中，连接到目标 SQL Server 数据库实例。

1. 在 **Object Explorer**（对象资源管理器）中选择目标 SQL Server 数据库实例后，在 **File**（文件）菜单上选择 **Open**（打开），选择 **File**（文件），然后打开脚本文件。

1. 如果您已编写了整个数据库的脚本，请查看脚本中的 CREATE DATABASE 语句。请确保将在所需位置使用所需参数创建数据库。有关更多信息，请参阅 SQL Server 文档中的 [CREATE DATABASE](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx)。

1. 如果在脚本中创建数据库用户，请检查目标数据库实例中是否有这些用户的服务器登录名。如果没有登录名，请为这些用户创建登录名；否则，用于创建数据库用户的脚本命令将失败。有关更多信息，请参阅 SQL Server 文档中的[创建登录名](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx)。

1. 选择 SQL 编辑器菜单上的 **\$1Execute** 以运行脚本文件并创建数据库对象。完成脚本后，验证是否存在预期的所有数据库对象。

1. 使用 bcp 实用工具将数据从 RDS for SQL Server 数据库实例导出到文件。打开命令提示符并键入以下命令。

   ```
   bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
   ```

   上述代码包含以下选项：
   + *table\$1name* 是您已在目标数据库中重新创建且现在需要填充数据的其中一个表的名称。
   + *data\$1file* 是要创建的数据文件的完整路径和名称。
   + `-n` 指定，批量复制将使用待复制数据的本机数据类型。
   + `-S` 指定要从中导出数据的 SQL Server 数据库实例。
   + `-U` 指定在连接到 SQL Server 数据库实例时要使用的用户名。
   + `-P` 为 `-U` 指定的用户指定密码。

   下面显示了示例命令。

   ```
   bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
   ```

   重复此步骤，直到您获得要导出的所有表的数据文件。

1. 按照 SQL Server 文档中的[批量导入数据基本指南](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx)中的说明，准备目标数据库实例以便批量导入数据。

1. 在考虑 SQL Server 文档中的[关于批量导入和批量导出操作](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx)中讨论的性能和其他问题后，决定要使用的批量导入方法。

1. 从使用 bcp 实用工具创建的数据文件中批量导入数据。为此，请按照 SQL Server 文档中的[使用 bcp 实用工具导入和导出批量数据](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx)或[使用 BULK INSERT 或 OPENROWSET(BULK...) 导入批量数据](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx)中的说明进行操作，具体取决于您在步骤 11 中所做的决定。

# 从 Linux 中使用 BCP 实用程序导入和导出数据
<a name="SQLServer.Procedural.Importing.BCP.Linux"></a>

BCP（批量复制程序）实用程序提供了一种在 RDS for SQL Server 数据库实例与数据文件之间传输大量数据的高效方法。您可以从 Linux 环境中使用 BCP 来执行批量数据操作，这使其可用于数据迁移、ETL 处理和常规数据传输。

BCP 既支持将数据从文件导入到 SQL Server 表中，也支持将数据从 SQL Server 表导出到文件。这对于传输包括分隔文本文件在内的各种格式的结构化数据特别有效。

## 先决条件
<a name="SQLServer.Procedural.Importing.BCP.Linux.Prerequisites"></a>

在从 Linux 系统中对 RDS for SQL Server 数据库实例使用 BCP 之前，请确保您已具备以下条件：
+ 一个 Linux 环境，该环境与 RDS for SQL Server 数据库实例具有网络连接
+ 安装在 Linux 系统上的 Microsoft SQL Server 命令行工具，包括：
  + sqlcmd：SQL Server 命令行查询工具
  + bcp：批量复制程序实用程序
+ RDS for SQL Server 数据库实例的有效凭证
+ 通过安全组配置的网络访问权限，以支持通过 SQL Server 端口（通常为 1433）进行连接
+ 针对要执行的操作的相应数据库权限

## 在 Linux 上安装 SQL Server 命令行工具
<a name="SQLServer.Procedural.Importing.BCP.Linux.Installing"></a>

要从 Linux 中使用 BCP，您需要安装 Microsoft SQL Server 命令行工具。有关特定 Linux 发行版的详细安装说明，请参阅以下 Microsoft 文档：
+ [Install sqlcmd and bcp the SQL Server command-line tools on Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [bcp utility](https://docs.microsoft.com/en-us/sql/tools/bcp-utility)：BCP 实用程序的完整参考资料

安装完成后，请运行以下命令以确保工具位于 PATH 下：

```
bcp -v
sqlcmd -?
```

## 从 RDS for SQL Server 中导出数据
<a name="SQLServer.Procedural.Importing.BCP.Linux.Exporting"></a>

您可以使用 BCP 将数据从 RDS for SQL Server 数据库实例导出到 Linux 系统上的文件。这对于创建备份、执行数据分析或准备数据来进行迁移非常有用。

### 基本导出语法
<a name="SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic"></a>

使用 BCP 导出数据的基本语法是：

```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```

其中：
+ `database.schema.table`：完全限定的表名称
+ `output_file`：输出文件的路径和名称
+ `server_name`：RDS for SQL Server 端点
+ `username`：数据库用户名
+ `password`：数据库密码

### 导出示例
<a name="SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example"></a>

以下示例从 `sales` 数据库中名为 `customers` 的表导出数据：

```
bcp sales.dbo.customers out /home/user/customers.txt \
    -S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
    -U admin \
    -P mypassword \
    -c \
    -t "|" \
    -r "\n"
```

此命令：
+ 从 `customers` 表中导出数据
+ 将输出保存到 `/home/user/customers.txt`
+ 使用字符格式 (`-c`)
+ 使用竖线（\$1）作为字段分隔符 (`-t "|"`)
+ 使用换行符作为行分隔符 (`-r "\n"`)

## 将数据导入到 RDS for SQL Server
<a name="SQLServer.Procedural.Importing.BCP.Linux.Importing"></a>

您可以使用 BCP 将 Linux 系统上文件中的数据导入到 RDS for SQL Server 数据库实例。这对于数据迁移、加载测试数据或定期更新数据非常有用。

### 基本导入语法
<a name="SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic"></a>

使用 BCP 导入数据的基本语法是：

```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```

其中：
+ `database.schema.table`：完全限定的目标表名称
+ `input_file`：输入文件的路径和名称
+ `server_name`：RDS for SQL Server 端点
+ `username`：数据库用户名
+ `password`：数据库密码

### 导入示例
<a name="SQLServer.Procedural.Importing.BCP.Linux.Importing.Example"></a>

以下示例将数据从文件导入到名为 `customers` 的表中：

```
bcp sales.dbo.customers in /home/user/customers.txt \
    -S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
    -U admin \
    -P mypassword \
    -c \
    -t "|" \
    -r "\n" \
    -b 1000
```

此命令：
+ 将数据导入到 `customers` 表中
+ 读取 `/home/user/customers.txt` 中的数据
+ 使用字符格式 (`-c`)
+ 使用竖线（\$1）作为字段分隔符 (`-t "|"`)
+ 使用换行符作为行分隔符 (`-r "\n"`)
+ 以 1000 行为一批处理数据 (`-b 1000`)

## 常用 BCP 选项
<a name="SQLServer.Procedural.Importing.BCP.Linux.Options"></a>

BCP 提供了许多选项来控制数据格式和传输行为。下表介绍了常用的选项：


| 选项 | 描述 | 
| --- | --- | 
| -c | 对所有列使用字符数据类型 | 
| -n | 使用原生数据库数据类型 | 
| -t | 指定字段分隔符（默认为制表符） | 
| -r | 指定行分隔符（默认为换行符） | 
| -b | 指定批量操作的批次大小 | 
| -F | 指定要导出或导入的第一行 | 
| -L | 指定要导出或导入的最后一行 | 
| -e | 指定用于捕获被拒绝行的错误文件 | 
| -f | 指定用于对数据进行格式化的格式文件 | 
| -q | 将带引号的标识符用于对象名称 | 

## 最佳实践和注意事项
<a name="SQLServer.Procedural.Importing.BCP.Linux.BestPractices"></a>

当从 Linux 中将 BCP 与 RDS for SQL Server 结合使用时，请考虑以下最佳实践：
+ **使用批处理**：对于大型数据集，使用 `-b` 选项来分批处理数据。这可以提高性能并可实现更好的错误恢复。
+ **妥善地处理错误**：使用 `-e` 选项在单独的文件中捕获错误信息和被拒绝的行，以进行分析。
+ **选择适当的数据格式**：当源和目标都是 SQL Server 时，使用字符格式 (`-c`) 来实现跨平台兼容性，或使用原生格式 (`-n`) 来提高性能。
+ **保护您的凭证**：避免直接在命令行中放入密码。考虑使用环境变量或配置文件以及适当的权限。
+ **使用小型数据集进行测试**：在处理大量数据之前，使用较小的数据集测试 BCP 命令以验证格式和连接性。
+ **监控网络连接**：确保稳定的网络连接，特别是对于大型数据传输。考虑使用诸如 `screen` 或 `tmux` 之类的工具执行长时间运行的操作。
+ **验证数据完整性**：在传输数据后，验证行数和样本数据，以确保操作成功完成。

## 排查常见 问题
<a name="SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting"></a>

下表描述了从 Linux 中使用 BCP 时可能遇到的常见问题及其解决方案：


| 事务 | 解决方案 | 
| --- | --- | 
| 连接超时或网络错误 | 验证 Amazon RDS 端点、安全组设置和网络连接。确保可以从 Linux 系统访问 SQL Server 端口（通常为 1433）。 | 
| 身份验证失败次数 | 验证用户名和密码。确保数据库用户对您正在执行的操作具有相应的权限。 | 
| 数据格式错误 | 检查您的字段和行分隔符。确保数据格式符合 BCP 的预期。对复杂的数据结构使用格式文件。 | 
| 权限被拒绝错误 | 请确保数据库用户对目标表具有 INSERT 权限（用于导入）或 SELECT 权限（用于导出）。 | 
| 大文件处理问题 | 通过 -b 选项使用批处理。考虑将大文件拆分成较小的分块，以改善性能和错误恢复。 | 
| 字符编码问题 | 确保数据文件使用兼容的字符编码。对字符格式使用 -c 选项或指定相应的代码页。 |