";
public static void main(String[] args) throws SQLException {
final Properties properties = new Properties();
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))",
DB_SERVER_NAME, SSL_PORT, DB_SID);
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
properties.put("oracle.jdbc.J2EE13Compliant", "true");
properties.put("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
properties.put("javax.net.ssl.trustStoreType", "JKS");
properties.put("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
final Connection connection = DriverManager.getConnection(connectionString, properties);
// If no exception, that means handshake has passed, and an SSL connection can be opened
}
}
```
**重要**
在确定了数据库连接使用 SSL/TLS 并更新了应用程序信任存储之后，可以更新数据库以使用 rds-ca-rsa2048-g1 证书。有关说明，请参阅[通过修改数据库实例或集群来更新 CA 证书](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-updating)中的步骤 3。
# 对 RDS for Oracle 数据库实例使用原生网络加密
Oracle Database 提供两种通过网络加密数据的方式：原生网络加密（NNE）和传输层安全性协议（TLS）。NNE 是 Oracle 的专有安全功能，而 TLS 是行业标准。RDS for Oracle 对于所有 Oracle Database 版本均支持 NNE。
与 TLS 相比，NNE 具有以下优势：
+ 您可以使用 NNE 选项中的设置控制客户端和服务器上的 NNE：
+ `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` 和 `SQLNET.ALLOW_WEAK_CRYPTO`
+ `SQLNET.CRYPTO_CHECKSUM_CLIENT` 和 `SQLNET.CRYPTO_CHECKSUM_SERVER`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` 和 `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER`
+ `SQLNET.ENCRYPTION_CLIENT` 和 `SQLNET.ENCRYPTION_SERVER`
+ `SQLNET.ENCRYPTION_TYPES_CLIENT` 和 `SQLNET.ENCRYPTION_TYPES_SERVER`
+ 在大多数情况下，您不需要配置您的客户端或服务器。相比之下，TLS 要求您同时配置客户端和服务器。
+ 不需要证书。在 TLS 中，服务器需要证书（该证书最终会过期），而客户端要求颁发服务器证书的证书颁发机构提供可信根证书。
通过向与数据库实例关联的选项组添加 Oracle NNE 选项，可为 Oracle 数据库实例提供 NNE 加密。有关更多信息，请参阅 [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md)。
**注意**
您不能在同一个数据库实例上同时使用 NNE 和 TLS。
# 为 Amazon RDS for Oracle 配置 Kerberos 身份验证
当用户连接到 Amazon RDS for Oracle 数据库实例时，您可以使用 Kerberos 身份验证来验证用户的身份。在此配置中，您的数据库实例可以使用 Amazon Directory Service for Microsoft Active Directory（也称为 Amazon Managed Microsoft AD）。当用户对联接到信任域的 RDS for Oracle 数据库实例进行身份验证时，身份验证请求将转发至您使用 Amazon Directory Service 创建的目录。
将所有凭证保存在同一目录中可以节省您的时间和精力。您有一个集中位置用来存储和管理多个数据库实例的凭证。目录还可以改善您的整体安全配置文件。
# 区域和版本可用性
功能可用性和支持因每个数据库引擎的特定版本以及 Amazon Web Services 区域而异。有关使用 Kerberos 身份验证的 RDS for Oracle 的版本和区域可用性的更多信息，请参阅[支持 Amazon RDS 中 Kerberos 身份验证功能的区域和数据库引擎](Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.md)。
**注意**
对于 RDS for Oracle 数据库实例已弃用的数据库实例类，不支持 Kerberos 身份验证。有关更多信息，请参阅 [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
**Topics**
+ [区域和版本可用性](oracle-kerberos-setting-up.RegionVersionAvailability.md)
+ [为 Oracle 数据库实例设置 Kerberos](oracle-kerberos-setting-up.md)
+ [在域中管理数据库实例](oracle-kerberos-managing.md)
+ [使用 Kerberos 身份验证连接到 Oracle](oracle-kerberos-connecting.md)
# 为 Oracle 数据库实例设置 Kerberos
使用 Amazon Directory Service for Microsoft Active Directory（也称为 Amazon Managed Microsoft AD）为 Oracle 数据库实例设置 Kerberos 身份验证。要设置 Kerberos 身份验证，请完成以下步骤：
+ [步骤 1：使用 Amazon Managed Microsoft AD 创建目录](#oracle-kerberos.setting-up.create-directory)
+ [步骤 2：创建信任](#oracle-kerberos.setting-up.create-forest-trust)
+ [步骤 3：配置 Amazon RDS 的 IAM 权限](#oracle-kerberos.setting-up.CreateIAMRole)
+ [步骤 4：创建和配置用户](#oracle-kerberos.setting-up.create-users)
+ [步骤 5：在目录和数据库实例之间启用跨 VPC 流量](#oracle-kerberos.setting-up.vpc-peering)
+ [步骤 6：创建或修改 Oracle 数据库实例](#oracle-kerberos.setting-up.create-modify)
+ [步骤 7：创建 Kerberos 身份验证 Oracle 登录名](#oracle-kerberos.setting-up.create-logins)
+ [步骤 8：配置 Oracle 客户端](#oracle-kerberos.setting-up.configure-oracle-client)
**注意**
在设置过程中，RDS 会创建一个名为 *managed\$1service\$1user*@*example.com* 且具有 `CREATE SESSION` 权限的 Oracle 数据库用户，其中的 *example.com* 为您的域名。此用户对应于 Directory Service 在 Managed Active Directory 中创建的用户。RDS 会定期使用 Directory Service 提供的凭证登录 Oracle 数据库。之后，RDS 会立即销毁票证缓存。
## 步骤 1：使用 Amazon Managed Microsoft AD 创建目录
Amazon Directory Service 将在 Amazon 云中创建一个完全托管的 Active Directory。创建 Amazon Managed Microsoft AD 目录时，Amazon Directory Service 将代表您创建两个域控制器和域名系统 (DNS) 服务器。目录服务器在 VPC 中的不同子网中创建。这种冗余有助于确保始终可以访问目录，即使发生了故障。
创建 Amazon Managed Microsoft AD 目录时，Amazon Directory Service 代表您执行以下任务：
+ 在 VPC 中设置 Active Directory。
+ 使用用户名 Admin 和指定密码创建目录管理员账户。您可以使用此账户管理您的目录。
**注意**
请务必保存此密码。Amazon Directory Service 不会存储它。您可以重置它，但无法检索它。
+ 为目录控制器创建安全组。
在启动 Amazon Managed Microsoft AD 时，Amazon 创建一个组织单位 (OU)，其中包含目录的所有对象。此 OU 具有您在创建目录时键入的 NetBIOS 名称且位于域根目录中。此域根目录由 Amazon 拥有和管理。
使用您的 Amazon Managed Microsoft AD 目录创建的 Admin 账户对您的 OU 的最常见管理活动具有以下权限：
+ 创建、更新或删除用户
+ 将资源添加到域（如文件或打印服务器），然后为 OU 中的用户分配这些资源的权限
+ 创建额外的 OU 和容器
+ 委托授权
+ 从 Active Directory 回收站还原删除的对象
+ 在 Active Directory Web 服务上运行 AD 和 DNS Windows PowerShell 模块
Admin 账户还具有执行下列域范围活动的权限：
+ 管理 DNS 配置（添加、删除或更新记录、区域和转发器）
+ 查看 DNS 事件日志
+ 查看安全事件日志
您可以使用 Amazon Web Services 管理控制台、Amazon CLI 或 Amazon Directory Service API 创建目录。确保打开目录安全组上的相关出站端口，以便目录可以与 Oracle 数据库实例进行通信。
**使用 Amazon Managed Microsoft AD 创建目录**
1. 登录 Amazon Web Services 管理控制台，然后打开 Amazon Directory Service 控制台，网址为：[https://console.aws.amazon.com/directoryservicev2/](https://console.amazonaws.cn/directoryservicev2/)。
1. 在导航窗格中，选择 **Directories (目录)**，然后选择 **Set up Directory (设置目录)**。
1. 选择 **Amazon Managed Microsoft AD**。Amazon Managed Microsoft AD 是当前唯一可以与 Amazon RDS 一起使用的选项。
1. 输入以下信息：
**目录 DNS 名称**
目录的完全限定名称，例如 **corp.example.com**。
**目录 NetBIOS 名称**
目录的短名称，如 **CORP**。
**目录描述**
（可选）目录的描述。
**管理员密码**
目录管理员的密码。目录创建过程将使用用户名 Admin 和此密码创建一个管理员账户。
目录管理员密码不能包含单词“admin”。此密码区分大小写，且长度必须介于 8 – 64 个字符之间。至少，它还必须包含下列四种类别中三种类别的一个字符：
+ 小写字母 (a–z)
+ 大写字母 (A–Z)
+ 数字 (0–9)
+ 非字母数字字符 (\$1\$1@\$1\$1%^&\$1\$1-\$1=`\$1\$1()\$1\$1[]:;"'<>,.?/)
**确认密码**
已重新键入管理员密码。
1. 选择 **Next (下一步)**。
1. 在 **Networking (网络)** 部分中输入以下信息，然后选择 **Next (下一步)**：
**VPC**
目录的 VPC。在同一 VPC 中创建 Oracle 数据库实例。
**子网**
目录服务器的子网。两个子网必须位于不同的可用区。
1. 查看目录信息并进行必要的更改。如果信息正确，请选择 **Create directory (创建目录)**。
![\[创建过程中的目录详细信息页面\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/WinAuth2.png)
目录创建需要几分钟时间。创建成功后，**Status (状态)** 值将更改为 **Active (活动)**。
要查看有关您的目录的信息，请在目录列表中选择目录名称。请记下 **Directory ID (目录 ID)** 值，因为您在创建或修改 Oracle 数据库实例时需要此值。
![\[“目录详细信息”页面\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/WinAuth3.png)
## 步骤 2：创建信任
如果您计划仅使用 Amazon Managed Microsoft AD，请转到[步骤 3：配置 Amazon RDS 的 IAM 权限](#oracle-kerberos.setting-up.CreateIAMRole)。
要使用自行管理的 Active Directory 启用 Kerberos 身份验证，您必须在自行管理的 Active Directory 与在上一步中创建的 Amazon Managed Microsoft AD 之间创建林信任关系。信任可以是单向的，其中 Amazon Managed Microsoft AD 信任自行管理的 Active Directory。信任也可以是双向的，此时两个 Active Directory 相互信任。有关使用 Amazon Directory Service 设置林信任的更多信息，请参阅 *Amazon Directory Service 管理指南* 中的[何时创建信任关系](https://docs.amazonaws.cn/directoryservice/latest/admin-guide/ms_ad_setup_trust.html)。
## 步骤 3：配置 Amazon RDS 的 IAM 权限
要为您调用 Amazon Directory Service，Amazon RDS 需要一个使用托管式 IAM policy `AmazonRDSDirectoryServiceAccess` 的 IAM 角色。该角色允许 Amazon RDS 调用 Amazon Directory Service。
**注意**
为了让角色允许访问，Amazon Security Token Service（Amazon STS）端点必须在您的 Amazon Web Services 账户的正确 Amazon Web Services 区域中激活。Amazon STS 端点原定设置为在所有 Amazon Web Services 区域中保持活跃，您无需执行任何进一步操作即可使用它们。有关更多信息，请参阅**《IAM 用户指南》中的[在 Amazon Web Services 区域中激活和停用 Amazon STS](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#sts-regions-activate-deactivate)。
### 创建 IAM 角色
当您使用 Amazon Web Services 管理控制台创建数据库实例并且控制台用户具有 `iam:CreateRole` 权限时，控制台将自动创建 `rds-directoryservice-kerberos-access-role`。否则，您必须手动创建 IAM 角色。当手动创建 IAM 角色时，请选择 `Directory Service`，然后将 Amazon 托管式策略 `AmazonRDSDirectoryServiceAccess` 附加到该角色。
有关为服务创建 IAM 角色的更多信息，请参阅 *IAM 用户指南*中的[创建向Amazon服务委托权限的角色](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_roles_create_for-service.html)。
**注意**
用于 RDS for Microsoft SQL Server 的 Windows 身份验证 IAM 角色不能用于 RDS for Oracle。
### 手动创建 IAM 信任策略
或者，您可以创建具有所需权限的资源策略，而不是使用托管式 IAM policy `AmazonRDSDirectoryServiceAccess`。同时指定 `directoryservice.rds.amazonaws.com` 和 `rds.amazonaws.com` 作为主体。
要限制 Amazon RDS 为其他服务提供对资源的权限，我们建议在资源策略中使用 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键。防范混淆代理问题最有效的方法是使用 `aws:SourceArn` 全局条件上下文键和 Amazon RDS 资源的完整 ARN。有关更多信息，请参阅 [防范跨服务混淆代理问题](cross-service-confused-deputy-prevention.md)。
以下示例演示如何使用 Amazon RDS 中的 `aws:SourceArn` 和 `aws:SourceAccount` 全局条件上下文键来防范混淆代理问题。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
对于选择加入区域，您还必须以 `directoryservice.rds.region_name.amazonaws.com` 形式包含该区域的服务主体。例如，在非洲（开普敦）区域中，使用以下信任策略：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"directoryservice.rds.af-south-1.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:af-south-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
角色还必须具有以下 IAM policy。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ds:DescribeDirectories",
"ds:AuthorizeApplication",
"ds:UnauthorizeApplication",
"ds:GetAuthorizedApplicationDetails"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
## 步骤 4：创建和配置用户
您可使用 Active Directory 用户和计算机工具（Active Directory 域服务和 Active Directory 轻型目录服务工具之一）创建用户。在这种情况下，*用户*表示有权访问您的目录的独立个人或实体。
要在 Amazon Directory Service 目录中创建用户和组，您必须连接到属于 Amazon Directory Service 目录成员的 Windows Amazon EC2 实例。同时，您必须以具有创建用户权限的用户身份登录。有关在 Microsoft Active Directory 中创建用户的更多信息，请参阅 *Amazon Managed Microsoft AD 管理指南*中的[管理 Amazon Directory Service 中的用户和组](https://docs.amazonaws.cn/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html)。
## 步骤 5：在目录和数据库实例之间启用跨 VPC 流量
如果您打算将目录和数据库实例放在同一 VPC 中，请跳过该步骤，然后转到[步骤 6：创建或修改 Oracle 数据库实例](#oracle-kerberos.setting-up.create-modify)。
如果您计划在不同Amazon账户或 VPC 中查找目录和数据库实例，请使用 VPC 对等连接或[Amazon Transit Gateway](https://docs.amazonaws.cn/vpc/latest/tgw/what-is-transit-gateway.html) 配置跨 VPC 流量。以下过程使用 VPC 对等连接启用 VPC 之间的流量。请按照 *Amazon Virtual Private Cloud 对等连接指南*中的[什么是 VPC 对等连接？](https://docs.amazonaws.cn/vpc/latest/peering/Welcome.html)操作。
**使用 VPC 对等连接启用跨 VPC 流量**
1. 设置适合的 VPC 路由规则，以便确保网络流量可以双向流动。
1. 确保数据库实例的安全组可以从目录的安全组接收入站流量。有关更多信息，请参阅 *Amazon Managed Microsoft AD 管理指南* 中的 [Amazon Directory Service 最佳实践](https://docs.amazonaws.cn/directoryservice/latest/admin-guide/ms_ad_best_practices.html)。
1. 确保没有任何网络访问控制列表 (ACL) 规则会阻止流量。
如果该目录由不同的 Amazon 账户拥有，则您必须共享该目录。
**在 Amazon 账户之间共享目录**
1. 按照 *Amazon 管理指南*中的[教程：共享 Amazon Managed Microsoft AD 目录以实现无缝 EC2 域加入](https://docs.amazonaws.cn/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html)中的说明，开始与将要在其中创建数据库实例的 Amazon Directory Service 账户共享目录。
1. 使用数据库实例的账户登录到 Amazon Directory Service 控制台，并确保在处理之前域具有 `SHARED` 状态。
1. 使用数据库实例的账户登录 Amazon Directory Service 控制台时，请记录**目录 ID** 值。您可以使用此目录 ID 将数据库实例加入域。
## 步骤 6：创建或修改 Oracle 数据库实例
创建或修改 Oracle 数据库实例，以便与您的目录一起使用。您可以使用控制台、CLI 或 RDS API 将数据库实例与目录关联。您可以通过下列方式之一来执行该操作：
+ 使用控制台、[ create-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/create-db-instance.html) CLI 命令或 [CreateDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API 操作创建新的 Oracle 数据库实例。
有关说明，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 使用控制台、[modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) CLI 命令或 [ModifyDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API 操作修改现有 Oracle 数据库实例。
有关说明，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
+ 使用控制台、[restore-db-instance-from-db-snapshot](https://docs.amazonaws.cn/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) CLI 命令或 [RestoreDBInstanceFromDBSnapshot](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) RDS API 操作从数据库快照还原 Oracle 数据库实例。
有关说明，请参阅[还原到数据库实例](USER_RestoreFromSnapshot.md)。
+ 使用控制台、[restore-db-instance-to-point-in-time](https://docs.amazonaws.cn/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) CLI 命令或 [RestoreDBInstanceToPointInTime](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API 操作将 Oracle 数据库实例还原到某个时间点。
有关说明，请参阅[将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)。
只有 VPC 中的 Oracle 数据库实例才支持 Kerberos 身份验证。数据库实例可以与目录在同一 VPC 中或在不同 VPC 中。创建或修改数据库实例时，请执行以下操作：
+ 请提供创建目录时生成的域标识符（`d-*` 标识符）。
+ 还要提供您创建的 IAM 角色的名称。
+ 确保数据库实例安全组可以从目录安全组接收入站流量并将出站流量发送到目录。
在使用控制台创建数据库实例时，请选择 **Database authentication (数据库身份验证)** 部分中的 **Password and Kerberos authentication (密码和 Kerberos 身份验证)**。选择 **Browse Directory (浏览目录)**，然后选择目录或选择 **Create a new directory (创建新目录)**。
![\[创建数据库实例时的 Kerberos 身份验证设置\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/kerberos-authentication.png)
在使用控制台修改或还原数据库实例时，请在 **Kerberos authentication (Kerberos 身份验证)** 部分中选择目录，或选择 **Create a new directory (创建新目录)**。
![\[修改或还原数据库实例时的 Kerberos 身份验证设置\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/kerberos-auth-modify-restore.png)
使用 Amazon CLI 时，数据库实例需要以下参数才能使用您创建的目录：
+ 对于 `--domain` 参数，请使用创建目录时生成的域标识符（“d-\$1”标识符）。
+ 对于 `--domain-iam-role-name` 参数，请使用您使用托管 IAM 策略 `AmazonRDSDirectoryServiceAccess` 创建的角色。
例如，以下 CLI 命令会修改数据库实例以使用目录。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--domain d-ID \
--domain-iam-role-name role-name
```
对于：Windows
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--domain d-ID ^
--domain-iam-role-name role-name
```
**重要**
如果您修改数据库实例以启用 Kerberos 身份验证，请在进行更改之后重启数据库实例。
**注意**
*MANAGED\$1SERVICE\$1USER* 是一个服务账户，名称由 RDS 的 Directory Service 随机生成。在 Kerberos 身份验证设置期间，RDS for Oracle 会使用同一名称创建用户并为其分配 `CREATE SESSION` 权限。在外部将 Oracle 数据库用户标识为 *MANAGED\$1SERVICE\$1USER@EXAMPLE.COM*，其中 *EXAMPLE.COM* 是您的域名。RDS 会定期使用 Directory Service 提供的凭证登录 Oracle 数据库。之后，RDS 会立即销毁票证缓存。
## 步骤 7：创建 Kerberos 身份验证 Oracle 登录名
使用 Amazon RDS 主用户凭证连接到 Oracle 数据库实例，就像连接到任何其他数据库实例一样。数据库实例加入到 Amazon Managed Microsoft AD 域。这样，您可以根据从域中的 Microsoft Active Directory 用户预置 Oracle 登录名和用户。要管理数据库权限，可以授予和撤消这些登录的标准 Oracle 权限。
**要允许 Microsoft Active Directory 用户向 Oracle 验证身份**
1. 请使用 Amazon RDS 主用户凭证连接到 Oracle 数据库实例。
1. 在 Oracle 数据库中创建在外部验证身份的用户。
在以下示例中，使用您的用户名和域名替换 `KRBUSER@CORP.EXAMPLE.COM`。
```
CREATE USER "KRBUSER@CORP.EXAMPLE.COM" IDENTIFIED EXTERNALLY;
GRANT CREATE SESSION TO "KRBUSER@CORP.EXAMPLE.COM";
```
域中用户（人和应用程序）现在均可使用 Kerberos 身份验证从加入域的客户端计算机连接到 Oracle 数据库实例。
## 步骤 8：配置 Oracle 客户端
要配置 Oracle 客户端，请满足以下要求：
+ 创建一个名为 krb5.conf (Linux) 或 krb5.ini (Windows) 的配置文件，以指向域。将 Oracle 客户端配置为使用此配置文件。
+ 验证流量是否可以在 DNS 端口 53 上通过 TCP/UDP、在 Kerberos 端口（用于托管 Amazon Directory Service 的 88 和 464）上通过 TCP 以及在 LDAP 端口 389 上通过 TCP 在客户端主机和 Amazon Directory Service 之间进行流动。
+ 验证流量是否可以通过数据库端口在客户端主机和数据库实例之间流动。
以下是 Amazon Managed Microsoft AD 的示例内容。
```
[libdefaults]
default_realm = EXAMPLE.COM
[realms]
EXAMPLE.COM = {
kdc = example.com
admin_server = example.com
}
[domain_realm]
.example.com = CORP.EXAMPLE.COM
example.com = CORP.EXAMPLE.COM
```
以下是本地 Microsoft AD 的示例内容。在 krb5.conf 或 krb5.ini 文件中，将 *on-prem-ad-server-name* 替换为本地 AD 服务器的名称。
```
[libdefaults]
default_realm = ONPREM.COM
[realms]
AWSAD.COM = {
kdc = awsad.com
admin_server = awsad.com
}
ONPREM.COM = {
kdc = on-prem-ad-server-name
admin_server = on-prem-ad-server-name
}
[domain_realm]
.awsad.com = AWSAD.COM
awsad.com= AWSAD.COM
.onprem.com = ONPREM.COM
onprem.com= ONPREM.COM
```
**注意**
配置 krb5.ini 或 krb5.conf 文件后，我们建议您重启服务器。
以下是 SQL\$1Plus 配置的示例 sqlnet.ora 内容：
```
SQLNET.AUTHENTICATION_SERVICES=(KERBEROS5PRE,KERBEROS5)
SQLNET.KERBEROS5_CONF=path_to_krb5.conf_file
```
有关 SQL Developer 配置示例，请参阅 Oracle 支持网站中的[文档 1609359.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1609359.1)。
# 在域中管理数据库实例
您可以使用控制台、CLI 或 RDS API 来管理您的数据库实例及其与 Microsoft Active Directory 的关系。例如，您可以关联 Microsoft Active Directory 以启用 Kerberos 身份验证。您也可以取消 Microsoft Active Directory 的关联以禁用 Kerberos 身份验证。您也可以将由一个 Microsoft Active Directory 在外部进行身份验证的数据库实例移动到另一个 Active Directory。
例如，使用 CLI，您可以执行下列操作：
+ 要重新尝试为失败的成员启用 Kerberos 身份验证，请使用 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) CLI 命令并为 `--domain` 选项指定当前成员的目录 ID。
+ 要禁用数据库实例上的 Kerberos 身份验证，请使用 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) CLI 命令并为 `none` 选项指定 `--domain`。
+ 要将数据库实例从一个域移至另一个域，请使用 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) CLI 命令并为 `--domain` 选项指定新域的域标识符。
## 查看域成员资格的状态
在创建或修改数据库实例后，数据库实例将成为域的成员。您可以在控制台中查看数据库实例的域成员身份状态，也可以通过运行 [describe-db-instances](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-instances.html) CLI 命令来查看。数据库实例的状态可以是以下状态之一：
+ `kerberos-enabled` – 数据库实例已启用 Kerberos 身份验证。
+ `enabling-kerberos` – Amazon是在此数据库实例上启用 Kerberos 身份验证的过程。
+ `pending-enable-kerberos` – 启用 Kerberos 身份验证正在此数据库实例上等待处理。
+ `pending-maintenance-enable-kerberos` – Amazon将尝试在下一个计划的维护时段在数据库实例上启用 Kerberos 身份验证。
+ `pending-disable-kerberos` – 禁用 Kerberos 身份验证正在此数据库实例上等待处理。
+ `pending-maintenance-disable-kerberos` – Amazon将尝试在下一个计划的维护时段在数据库实例上禁用 Kerberos 身份验证。
+ `enable-kerberos-failed` – 出现一个配置问题，导致Amazon无法在数据库实例上启用 Kerberos 身份验证。在重新发出命令以修改数据库实例之前纠正配置问题。
+ `disabling-kerberos` – Amazon是在此数据库实例上启用 Kerberos 身份验证的过程。
启用 Kerberos 身份验证的请求可能因网络连接问题或不正确的 IAM 角色而失败。如果在创建或修改数据库实例时尝试启用 Kerberos 身份验证失败，请确保您使用的是正确的 IAM 角色。然后修改数据库实例以加入域。
**注意**
只有对 Amazon RDS for Oracle 进行 Kerberos 身份验证才会将流量发送到域的 DNS 服务器。所有其他 DNS 请求被视为对运行 Oracle 的数据库实例进行出站网络访问。有关 Amazon RDS for Oracle 出站网络访问的更多信息，请参阅[设置自定义 DNS 服务器](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS)。
## 强制轮换 Kerberos 密钥
私有密钥是在 Amazon Managed Microsoft AD 和 Amazon RDS for Oracle 数据库实例之间共享的。该密钥每 45 天自动轮换一次。您可以使用以下 Amazon RDS 过程强制轮换该密钥：
```
SELECT rdsadmin.rdsadmin_kerberos_auth_tasks.rotate_kerberos_keytab AS TASK_ID FROM DUAL;
```
**注意**
在只读副本配置中，只能在源数据库实例上使用该过程，而不能在只读副本上使用该过程。
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。您可以查看 bdump 文件中的持续任务的状态。bdump 文件位于 `/rdsdbdata/log/trace` 目录下。每个 bdump 文件名称格式如下。
```
dbtask-task-id.log
```
您可以通过显示任务的输出文件来查看结果。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
将 *`task-id`* 替换为由此过程返回的任务 ID。
**注意**
任务以异步方式执行。
# 使用 Kerberos 身份验证连接到 Oracle
这部分假定您已按[步骤 8：配置 Oracle 客户端](oracle-kerberos-setting-up.md#oracle-kerberos.setting-up.configure-oracle-client)中所述设置 Oracle 客户端。要使用 Kerberos 身份验证连接到 Oracle 数据库，请使用 Kerberos 身份验证类型登录。例如，在启动 Oracle SQL Developer 之后，请选择 **Kerberos 身份验证**作为身份验证类型，如下面的示例所示。
![\[在 Oracle SQL Developer 中显示新建/选择数据库连接对话框。Kerberos 身份验证复选框处于选中状态。\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/ora-kerberos-auth.png)
要通过 SQL\$1Plus 使用 Kerberos 身份验证连接到 Oracle，请执行以下操作：
1. 在命令提示符处，运行以下命令：
```
kinit username
```
将 *`username`* 替换为用户名，并在提示符下输入 Microsoft Active Directory 为用户存储的密码。
1. 打开 SQL\$1Plus，使用 Oracle 数据库实例的 DNS 名称和端口号连接。
有关在 SQL\$1Plus 中连接到 Oracle 数据库实例的更多信息，请参阅[使用 SQL\$1Plus 连接到数据库实例](USER_ConnectToOracleInstance.SQLPlus.md)。
**提示**
如果您使用的是原生 Windows 缓存，也可以在 sqlnet.ora 文件中将 `SQLNET.KERBEROS5_CC_NAME` 参数设置为 `OSMSFT://` 或 `MSLSA`，以便使用存储在 Microsoft Active Directory 中的凭证。
# 使用证书和 Oracle Wallet 配置 UTL\$1HTTP 访问
Amazon RDS 支持对 RDS for Oracle 数据库实例进行出站网络访问。要将数据库实例连接到网络，您可以使用以下 PL/SQL 软件包：
`UTL_HTTP`
此软件包从 SQL 和 PL/SQL 发出 HTTP 调用。您可以使用它通过 HTTP 访问 Internet 上的数据。有关详细信息，请参阅 Oracle 文档中的 [UTL\$1HTTP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_HTTP.html#GUID-A85D2D1F-90FC-45F1-967F-34368A23C9BB)。
`UTL_TCP`
此软件包在 PL/SQL 中提供 TCP/IP 客户端访问功能。此软件包对于使用 Internet 协议和电子邮件的 PL/SQL 应用程序很有用。有关更多信息，请参阅 Oracle 文档中的 [UTL\$1TCP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_TCP.html#GUID-348AFFE8-78B2-4217-AE73-384F46A1D292)。
`UTL_SMTP`
此软件包提供 SMTP 命令的接口，以便客户端能够向 SMTP 服务器发送电子邮件。有关详细信息，请参阅 Oracle 文档中的 [UTL\$1SMTP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_SMTP.html#GUID-F0065C52-D618-4F8A-A361-7B742D44C520)。
您可以通过完成以下任务来配置 `UTL_HTTP.REQUEST`，以便与 SSL 握手期间需要客户端身份验证证书的网站搭配使用。您还可以通过修改 Oracle Wallet 生成命令和 `DBMS_NETWORK_ACL_ADMIN.APPEND_WALLET_ACE` 过程，为 `UTL_HTTP` 访问网站配置密码身份验证。有关更多信息，请参阅 Oracle Database 文档中的 [DBMS\$1NETWORK\$1ACL\$1ADMIN](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_NETWORK_ACL_ADMIN.html)。
**注意**
您可为 `UTL_SMTP` 调整以下任务，以便通过 SSL/TLS（包括 [Amazon Simple Email Service](https://www.amazonaws.cn/ses/)）发送电子邮件。
**Topics**
+ [配置 UTL\$1HTTP 访问时的注意事项](#utl_http-considerations)
+ [步骤 1：获取网站的根证书](#website-root-certificate)
+ [步骤 2：创建 Oracle Wallet](#create-oracle-wallet)
+ [步骤 3：将 Oracle Wallet 下载到 RDS for Oracle 实例](#upload-wallet-to-instance)
+ [步骤 4：授予用户 Oracle Wallet 权限](#config-oracle-wallet-user)
+ [步骤 5：配置从数据库实例访问网站](#config-website-access)
+ [步骤 6：测试从数据库实例到网站的连接](#test_utl_http)
## 配置 UTL\$1HTTP 访问时的注意事项
在配置访问之前，请考虑以下事项：
+ 您可以将 SMTP 与 UTL\$1MAIL 选项结合使用。有关更多信息，请参阅 [Oracle UTL\$1MAIL](Oracle.Options.UTLMAIL.md)。
+ 远程主机的域名服务器 (DNS) 名称满足以下所有条件：
+ 可公开解析。
+ Amazon RDS 数据库实例的终端节点。
+ 可通过自定义 DNS 服务器解析。有关更多信息，请参阅“[设置自定义 DNS 服务器](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS)”。
+ 同一 VPC 或对等 VPC 中的 Amazon EC2 实例的私有 DNS 名称。在这种情况下，请确认该名称可通过自定义 DNS 服务器解析。或者，要使用 Amazon 提供的 DNS，您可以启用 VPC 设置中的 `enableDnsSupport` 属性，并启用对 VPC 对等连接的 DNS 解析支持。有关更多信息，请参阅 [VPC 中的 DNS 支持](https://docs.amazonaws.cn/vpc/latest/userguide/vpc-dns.html#vpc-dns-support)和[修改 VPC 对等连接](https://docs.amazonaws.cn/vpc/latest/peering/working-with-vpc-peering.html#modify-peering-connections)。
+ 若要安全地连接到远程 SSL/TLS 资源，建议创建和上传自定义 Oracle Wallet。使用与 Amazon RDS for Oracle 功能集成的 Amazon S3，您可以将 Wallet 从 Amazon S3 下载到 Oracle 数据库实例。有关 Oracle 的 Amazon S3 集成的信息，请参阅[Amazon S3 集成](oracle-s3-integration.md)。
+ 如果为每个实例配置了 Oracle SSL 选项，您可以在 SSL/TLS 终端节点上的 Oracle 数据库实例之间建立数据库连接。无需作进一步配置。有关更多信息，请参阅 [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)。
## 步骤 1：获取网站的根证书
要在 RDS for Oracle 数据库实例与网站之间建立安全连接，请添加根 CA 证书。Amazon RDS 使用根证书将网站证书签署到 Oracle Wallet。
您可以通过各种方式获取根证书。例如，您可以执行以下操作：
1. 使用 Web 服务器访问受证书保护的网站。
1. 下载用于签名的根证书。
对于 Amazon 服务，根证书通常位于 [Amazon Trust Services 存储库](https://www.amazontrust.com/repository/)中。
## 步骤 2：创建 Oracle Wallet
创建包含 Web 服务器证书和客户端身份验证证书的 Oracle Wallet。RDS Oracle 实例使用 Web 服务器证书建立与网站的安全连接。网站需要客户端证书才能对 Oracle 数据库用户进行身份验证。
您可能希望在不使用客户端证书进行身份验证的情况下配置安全连接。在这种情况下，您可以跳过以下过程中的 Java 密钥库步骤。
**创建 Oracle Wallet**
1. 将根证书和客户端证书放在一个目录中，然后更改到此目录。
1. 将 .p12 客户端证书转换为 Java 密钥库。
**注意**
如果没有使用客户端证书进行身份验证，可以跳过此步骤。
以下示例将名为 *client\$1certificate.p12* 的客户端证书转换为名为 *client\$1keystore.jks* 的 Java 密钥库。该密钥库随后会包含在 Oracle Wallet 中。密钥库密码为 *P12PASSWORD*。
```
orapki wallet pkcs12_to_jks -wallet ./client_certificate.p12 -jksKeyStoreLoc ./client_keystore.jks -jksKeyStorepwd P12PASSWORD
```
1. 为 Oracle Wallet 创建与证书目录不同的目录。
以下示例会创建 `/tmp/wallet` 目录。
```
mkdir -p /tmp/wallet
```
1. 在 Wallet 目录中创建 Oracle Wallet。
以下示例将 Oracle Wallet 密码设置为 *P12PASSWORD*，这与之前步骤中 Java 密钥库使用的密码相同。虽然使用相同的密码很方便，但没有必要这样做。`-auto_login` 参数会打开自动登录功能，无需在每次访问时指定密码。
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
```
orapki wallet create -wallet /tmp/wallet -pwd P12PASSWORD -auto_login
```
1. 将 Java 密钥库添加到 Oracle Wallet 中。
**注意**
如果没有使用客户端证书进行身份验证，可以跳过此步骤。
以下示例将密钥库 *client\$1keystore.jks* 添加到名为 */mp/wallet* 的 Oracle Wallet 中。在此示例中，您为 Java 密钥库和 Oracle Wallet 指定了相同密码。
```
orapki wallet jks_to_pkcs12 -wallet /tmp/wallet -pwd P12PASSWORD -keystore ./client_keystore.jks -jkspwd P12PASSWORD
```
1. 将目标网站的根证书添加到 Oracle Wallet。
以下示例将添加名为 *Root\$1CA.cer* 的证书。
```
orapki wallet add -wallet /tmp/wallet -trusted_cert -cert ./Root_CA.cer -pwd P12PASSWORD
```
1. 添加任何中间证书。
以下示例将添加名为 *Intermediate.cer* 的证书。根据需要多次重复此步骤，以便加载所有中间证书。
```
orapki wallet add -wallet /tmp/wallet -trusted_cert -cert ./Intermediate.cer -pwd P12PASSWORD
```
1. 确认新创建的 Oracle Wallet 具有所需证书。
```
orapki wallet display -wallet /tmp/wallet -pwd P12PASSWORD
```
## 步骤 3：将 Oracle Wallet 下载到 RDS for Oracle 实例
在此步骤中，将 Oracle Wallet 上传到 Amazon S3，然后将 Wallet 从 Amazon S3 下载到 RDS for Oracle 实例。
**将 Oracle Wallet 下载到 RDS for Oracle 数据库实例**
1. 完成 Amazon S3 与 Oracle 集成的先决条件，然后将 `S3_INTEGRATION` 选项添加到您的 Oracle 数据库实例。确保该选项的 IAM 角色具有您正在使用的 Amazon S3 存储桶的访问权限。
有关更多信息，请参阅 [Amazon S3 集成](oracle-s3-integration.md)。
1. 以主用户身份登录数据库实例，然后创建 Oracle 目录来保存 Oracle Wallet。
以下示例将创建名为 *WALLET\$1DIR* 的 Oracle 目录。
```
EXEC rdsadmin.rdsadmin_util.create_directory('WALLET_DIR');
```
有关更多信息，请参阅 [在主数据存储空间中创建和删除目录](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories)。
1. 将 Oracle Wallet 上传到 Amazon S3 存储桶。
您可以使用任何受支持的上传技术。
1. 如果要重新上传 Oracle Wallet，请删除现有 Wallet。否则，请跳到下一步。
以下示例将删除名为 *cwallet.sso* 的现有 Wallet。
```
EXEC UTL_FILE.FREMOVE ('WALLET_DIR','cwallet.sso');
```
1. 将 Oracle Wallet 从 Amazon S3 存储桶下载到 Oracle 数据库实例。
以下示例会将名为 *cwallet.sso* 的 Wallet 从名为 *my\$1s3\$1bucket* 的 Amazon S3 存储桶下载到名为 *WALLET\$1DIR* 的数据库实例目录。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'my_s3_bucket',
p_s3_prefix => 'cwallet.sso',
p_directory_name => 'WALLET_DIR')
AS TASK_ID FROM DUAL;
```
1. （可选）下载受密码保护的 Oracle Wallet。
仅在每次使用 Wallet 都需要密码时，才下载此 Wallet。以下示例将下载受密码保护的 Wallet *ewallet.p12*。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'my_s3_bucket',
p_s3_prefix => 'ewallet.p12',
p_directory_name => 'WALLET_DIR')
AS TASK_ID FROM DUAL;
```
1. 检查数据库任务的状态。
在以下示例中，将上述步骤返回的任务 ID 替换为 *dbtask-1234567890123-4567.log*。
```
SELECT TEXT FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1234567890123-4567.log'));
```
1. 检查用于存储 Oracle Wallet 的目录的内容。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'WALLET_DIR'));
```
有关更多信息，请参阅 [列出数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories)。
## 步骤 4：授予用户 Oracle Wallet 权限
您可以创建新的数据库用户或配置现有用户。无论采用哪种方法，都必须配置用户使用证书访问 Oracle Wallet，以便实现安全连接和客户端身份验证。
**授予用户 Oracle Wallet 权限**
1. 以主用户身份登录 RDS for Oracle 数据库实例。
1. 如果不想配置现有数据库用户，可以选择创建新用户。否则，请跳到下一步。
以下示例将创建名为 *my-user* 的数据库用户。
```
CREATE USER my-user IDENTIFIED BY my-user-pwd;
GRANT CONNECT TO my-user;
```
1. 授予数据库用户对包含 Oracle Wallet 的目录的权限。
以下示例将授予用户 *my-user* 对目录 *WALLET\$1DIR* 的读取访问权限。
```
GRANT READ ON DIRECTORY WALLET_DIR TO my-user;
```
1. 授予数据库用户对 `UTL_HTTP` 软件包的使用权限。
以下 PL/SQL 计划授予用户 *my-user* 对 `UTL_HTTP` 的访问权限。
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_HTTP', UPPER('my-user'));
END;
/
```
1. 授予数据库用户对 `UTL_FILE` 软件包的使用权限。
以下 PL/SQL 计划授予用户 *my-user* 对 `UTL_FILE` 的访问权限。
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_FILE', UPPER('my-user'));
END;
/
```
## 步骤 5：配置从数据库实例访问网站
在此步骤中，您将配置 Oracle 数据库用户，以便其可以使用 `UTL_HTTP`、上传的 Oracle Wallet 和客户端证书连接到目标网站。有关更多信息，请参阅 Oracle Database 文档中的[配置对 Oracle Wallet 的访问控制](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-fine-grained-access-in-pl-sql-packages-and-types.html#GUID-0BCB5925-A40F-4507-95F9-5DA4A1919EBD)。
**配置从 RDS for Oracle 数据库实例访问网站**
1. 以主用户身份登录 RDS for Oracle 数据库实例。
1. 在安全端口上为用户和目标网站创建主机访问控制条目 (ACE)。
以下示例将 *my-user* 配置为在安全端口 443 上访问 *secret.encrypted-website.com*。
```
BEGIN
DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
host => 'secret.encrypted-website.com',
lower_port => 443,
upper_port => 443,
ace => xs$ace_type(privilege_list => xs$name_list('http'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
-- If the program unit results in PLS-00201, set
-- the principal_type parameter to 2 as follows:
-- principal_type => 2));
END;
/
```
**重要**
前面的程序单元可能会导致以下错误：`PLS-00201: identifier 'XS_ACL' must be declared`。如果返回此错误，请将为 `principal_type` 分配值的行替换为以下行，然后重新运行程序单元：
```
principal_type => 2));
```
有关 PL/SQL 软件包 `XS_ACL` 中常量的更多信息，请参阅 Oracle Database 文档中的 [Real Application Security Administrator's and Developer's Guide](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbfsg/XS_ACL-package.html#GUID-A157FB28-FE23-4D30-AAEB-8224230517E7)**。
有关更多信息，请参阅 Oracle Database 文档中的[为外部网络服务配置访问控制](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-fine-grained-access-in-pl-sql-packages-and-types.html#GUID-3D5B66BC-0277-4887-9CD1-97DB44EB5213)。
1. （可选）在标准端口上为用户和目标网站创建主机访问控制条目。
如果是标准 Web 服务器端口 (80) 而不是安全端口 (443) 提供的网页，则可能需要使用标准端口。
```
BEGIN
DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
host => 'secret.encrypted-website.com',
lower_port => 80,
upper_port => 80,
ace => xs$ace_type(privilege_list => xs$name_list('http'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
-- If the program unit results in PLS-00201, set
-- the principal_type parameter to 2 as follows:
-- principal_type => 2));
END;
/
```
1. 确认存在访问控制条目。
```
SET LINESIZE 150
COLUMN HOST FORMAT A40
COLUMN ACL FORMAT A50
SELECT HOST, LOWER_PORT, UPPER_PORT, ACL
FROM DBA_NETWORK_ACLS
ORDER BY HOST;
```
1. 授予数据库用户对 `UTL_HTTP` 软件包的使用权限。
以下 PL/SQL 计划授予用户 *my-user* 对 `UTL_HTTP` 的访问权限。
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_HTTP', UPPER('my-user'));
END;
/
```
1. 确认存在相关的访问控制列表。
```
SET LINESIZE 150
COLUMN ACL FORMAT A50
COLUMN PRINCIPAL FORMAT A20
COLUMN PRIVILEGE FORMAT A10
SELECT ACL, PRINCIPAL, PRIVILEGE, IS_GRANT,
TO_CHAR(START_DATE, 'DD-MON-YYYY') AS START_DATE,
TO_CHAR(END_DATE, 'DD-MON-YYYY') AS END_DATE
FROM DBA_NETWORK_ACL_PRIVILEGES
ORDER BY ACL, PRINCIPAL, PRIVILEGE;
```
1. 授予数据库用户使用证书进行客户端身份验证和 Oracle Wallet 进行连接的权限。
**注意**
如果没有使用客户端证书进行身份验证，可以跳过此步骤。
```
DECLARE
l_wallet_path all_directories.directory_path%type;
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
DBMS_NETWORK_ACL_ADMIN.APPEND_WALLET_ACE(
wallet_path => 'file:/' || l_wallet_path,
ace => xs$ace_type(privilege_list => xs$name_list('use_client_certificates'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
END;
/
```
## 步骤 6：测试从数据库实例到网站的连接
在此步骤中，您将配置数据库用户，以便其可以使用 `UTL_HTTP`、上传的 Oracle Wallet 和客户端证书连接到网站。
**配置从 RDS for Oracle 数据库实例访问网站**
1. 以具有 `UTL_HTTP` 权限的数据库用户身份登录 RDS for Oracle 数据库实例。
1. 确认与目标网站的连接可以解析主机地址。
以下示例将从 *secret.encrypted-website.com* 获取主机地址。
```
SELECT UTL_INADDR.GET_HOST_ADDRESS(host => 'secret.encrypted-website.com')
FROM DUAL;
```
1. 测试失败连接。
以下查询失败，因为 `UTL_HTTP` 需要带有证书的 Oracle Wallet 的位置。
```
SELECT UTL_HTTP.REQUEST('secret.encrypted-website.com') FROM DUAL;
```
1. 使用 `UTL_HTTP.SET_WALLET` 并从 `DUAL` 中进行选择来测试网站访问。
```
DECLARE
l_wallet_path all_directories.directory_path%type;
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
UTL_HTTP.SET_WALLET('file:/' || l_wallet_path);
END;
/
SELECT UTL_HTTP.REQUEST('secret.encrypted-website.com') FROM DUAL;
```
1. （可选）将查询存储在变量中并使用 `EXECUTE IMMEDIATE` 来测试网络访问。
```
DECLARE
l_wallet_path all_directories.directory_path%type;
v_webpage_sql VARCHAR2(1000);
v_results VARCHAR2(32767);
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
v_webpage_sql := 'SELECT UTL_HTTP.REQUEST(''secret.encrypted-website.com'', '''', ''file:/' ||l_wallet_path||''') FROM DUAL';
DBMS_OUTPUT.PUT_LINE(v_webpage_sql);
EXECUTE IMMEDIATE v_webpage_sql INTO v_results;
DBMS_OUTPUT.PUT_LINE(v_results);
END;
/
```
1. （可选）查找 Oracle Wallet 目录的文件系统位置。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'WALLET_DIR'));
```
使用上一个命令的输出来发出 HTTP 请求。例如，如果目录为 *rdsdbdata/userdirs/01*，则运行以下查询。
```
SELECT UTL_HTTP.REQUEST('https://secret.encrypted-website.com/', '', 'file://rdsdbdata/userdirs/01')
FROM DUAL;
```
# 在 RDS for Oracle 中使用 CDB
在 Oracle 多租户架构中，容器数据库（CDB）可以包括客户创建的可插拔数据库（PDB）。有关 CDB 的更多信息，请参阅 Oracle 数据库文档中的[多租户架构简介](https://docs.oracle.com/en/database/oracle/oracle-database/19/multi/introduction-to-the-multitenant-architecture.html#GUID-267F7D12-D33F-4AC9-AA45-E9CD671B6F22)。
**Topics**
+ [RDS for Oracle CDB 概述](Oracle.Concepts.CDBs.md)
+ [配置 RDS for Oracle CDB](oracle-cdb.configuring.md)
+ [备份和还原 CDB](Oracle.Concepts.single-tenant.snapshots.md)
+ [将 RDS for Oracle 非 CDB 转换为 CDB](oracle-cdb-converting.md)
+ [将单租户配置转换为多租户配置](oracle-single-tenant-converting.md)
+ [将 RDS for Oracle 租户数据库添加到您的 CDB 实例](oracle-cdb-configuring.adding.pdb.md)
+ [修改 RDS for Oracle 租户数据库](oracle-cdb-configuring.modifying.pdb.md)
+ [从您的 CDB 中删除 RDS for Oracle 租户数据库](oracle-cdb-configuring.deleting.pdb.md)
+ [查看租户数据库详细信息](oracle-cdb-configuring.describing.pdb.md)
+ [升级 CDB](Oracle.Concepts.single-tenant.upgrades.md)
# RDS for Oracle CDB 概述
运行 Oracle Database 19c 或更高版本时，您可以将 RDS for Oracle 数据库实例创建为容器数据库（CDB）。从 Oracle Database 21c 开始，所有数据库都是 CDB。CDB 不同于非 CDB，因为 CDB 可以包含可插拔数据库（PDB），在 RDS for Oracle 中称为租户数据库。PDB 是模式和对象的可移植集合，在应用程序看来是单独的数据库。
在创建 CDB 实例时创建初始租户数据库（PDB）。在 RDS for Oracle 中，您的客户端应用程序与 PDB 交互，而不是与 CDB 交互。使用 PDB 的体验基本上与使用非 CDB 的体验相同。
**Topics**
+ [CDB 架构的多租户配置](#multi-tenant-configuration)
+ [CDB 架构的单租户配置](#Oracle.Concepts.single-tenant)
+ [CDB 的创建和转换选项](#oracle-cdb-creation-conversion)
+ [CDB 中的用户账户和权限](#Oracle.Concepts.single-tenant.users)
+ [CDB 中的参数组系列](#Oracle.Concepts.single-tenant.parameters)
+ [RDS for Oracle CDB 的限制](#Oracle.Concepts.single-tenant-limitations)
## CDB 架构的多租户配置
RDS for Oracle 支持 Oracle 多租户架构（也称为 *CDB 架构*）的多租户配置。在此配置中，您的 RDS for Oracle CDB 实例可以包含 1-30 个租户数据库，具体取决于数据库版本和任何所需的选项许可证。在 Oracle 数据库中，租户数据库是 PDB。您的数据库实例必须使用 Oracle 数据库版本 19.0.0.0.ru-2022-01.rur-2022.r1 或更高版本。
**注意**
Amazon RDS 配置之所以称为“多-租户”而不是“多租户”，是因为它是 Amazon RDS 平台的一项功能，而不仅仅是 Oracle 数据库引擎的功能。同样，RDS 术语“租户”是指 RDS 配置中的任何租户，而不仅仅是 Oracle PDB。在 RDS 文档中，未加连字号的术语“Oracle 多租户”仅指 Oracle 数据库 CDB 架构，该架构与本地部署和 RDS 部署均兼容。
您可以配置以下设置：
+ 租户数据库名称
+ 租户数据库主用户名
+ 租户数据库主密码（可选与 Secrets Manager 集成）
+ 租户数据库字符集
+ 租户数据库国家字符集
租户数据库字符集可以不同于 CDB 字符集。这同样适用于国家字符集。创建初始租户数据库后，您可以使用 RDS API 创建、修改或删除租户数据库。CDB 名称原定设置为 `RDSCDB` 且无法更改。有关更多信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)和[修改 RDS for Oracle 租户数据库](oracle-cdb-configuring.modifying.pdb.md)。
## CDB 架构的单租户配置
RDS for Oracle 支持 Oracle 多租户架构的旧配置，即单租户配置。在此配置中，RDS for Oracle CDB 实例只能包含一个租户（PDB）。之后无法创建更多 PDB。
## CDB 的创建和转换选项
Oracle Database 21c 仅支持 CDB，而 Oracle Database 19c 同时支持 CDB 和非 CDB。所有 RDS for Oracle CDB 实例都支持多租户和单租户配置。
### Oracle 数据库架构的创建、转换和升级选项
下表显示了用于创建和升级 RDS for Oracle 数据库的不同架构选项。
| 版本 | 数据库创建选项 | 架构转换选项 | 主要版本升级目标 |
| --- | --- | --- | --- |
| Oracle Database 21c | 仅限 CDB 架构 | 不适用 | 不适用 |
| Oracle Database 19c | CDB 或非 CDB 架构 | 非 CDB 至 CDB 架构（2021 年 4 月 RU 或更高版本） | Oracle Database 21c CDB |
如上表所示，在新的主要数据库版本中，您不能直接将非 CDB 升级到 CDB。但您可以将 Oracle Database 19c 非 CDB 转换为 Oracle Database 19c CDB，然后将 Oracle Database 19c CDB 升级为 Oracle Database 21c CDB。有关更多信息，请参阅 [将 RDS for Oracle 非 CDB 转换为 CDB](oracle-cdb-converting.md)。
### CDB 架构配置的转换选项
下表显示了用于转换 RDS for Oracle 数据库实例架构配置的不同选项。
| 当前架构和配置 | 转换为 CDB 架构的单租户配置 | 转换为 CDB 架构的多租户配置 | 转换为非 CDB 架构 |
| --- | --- | --- | --- |
| 非 CDB | 支持 | 支持\$1 | 不适用 |
| 使用单租户配置的 CDB | 不适用 | 支持 | 不支持 |
| 使用多租户配置的 CDB | 不支持 | 不适用 | 不支持 |
\$1 您无法在单个操作中将非 CDB 转换为多租户配置。将非 CDB 转换为 CDB 后，CDB 将处于单租户配置。然后，您可以通过另一个操作将单租户配置转换为多租户配置。
## CDB 中的用户账户和权限
在 Oracle 多租户架构中，所有用户账户都是普通用户或本地用户。CDB 普通用户是指在 CDB 根目录和每个现有和将来的 PDB 中已知单个身份和密码的数据库用户。相比之下，本地用户只存在于单个 PDB 中。
RDS 主用户是 PDB 中的本地用户账户，这是您在创建数据库实例时命名的。如果您创建新的用户账户，这些用户也将成为位于 PDB 中的本地用户。您不能使用任何用户账户创建新的 PDB 或修改现有 PDB 的状态。
`rdsadmin` 用户是普通用户账户。您可以运行此账户中存在的 RDS for Oracle 软件包，但无法以 `rdsadmin` 的身份登录。有关详细信息，请参阅 Oracle 文档中的[关于普通用户和本地用户](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-security-for-oracle-database-users.html#GUID-BBBD9904-F2F3-442B-9AFC-8ACDD9A588D8)。
对于多租户和单租户配置中的主用户，您可以使用自行管理的凭证或由 Amazon Secrets Manager 管理的凭证。在单租户配置中，您可以使用实例级 CLI 命令，例如，对于托管式主密码使用 `create-db-instance`。在多租户配置中，您可以使用租户数据库命令，例如，对于托管式主密码使用 `create-tenant-database`。有关设置 Secrets Manager 集成的更多信息，请参阅[使用 Secrets Manager 管理 RDS for Oracle 租户数据库的主用户密码](rds-secrets-manager.md#rds-secrets-manager-tenant)。
## CDB 中的参数组系列
CDB 有其自己的参数类系列和原定设置参数值。CDB 参数组系列如下所示：
+ oracle-ee-cdb-21
+ oracle-se2-cdb-21
+ oracle-ee-cdb-19
+ oracle-se2-cdb-19
## RDS for Oracle CDB 的限制
RDS for Oracle 支持本地 CDB 中提供的一部分功能。
### CDB 的限制
以下限制在 CDB 级别适用于 RDS for Oracle：
+ 您无法连接到 CDB。您始终连接到租户数据库（PDB），而不是 CDB。就像为非 CDB 指定终端节点一样，应为 PDB 指定终端节点。唯一的区别是您指定 *pdb\$1name* 作为数据库名称，其中 *pdb\$1name* 是为 PDB 选择的名称。
+ 您无法将使用多租户配置的 CDB 转换为使用单租户配置的 CDB。转换为多租户配置是单向不可逆的操作。
+ 如果您的数据库实例使用低于 19.0.0.0.ru-2022-01.rur-2022.r1 的 Oracle 数据库版本，则您无法启用或者转换为多租户配置。
+ 您不能在 CDB 中使用数据库活动流。
+ 您无法从 `CDB$ROOT` 中启用审计。您必须在每个 PDB 中单独启用审计。
### 租户数据库（PDB）限制
以下限制适用于 RDS for Oracle 多租户配置中的租户数据库：
+ 您不能将租户数据库操作推迟到维护时段。所有更改都会立即生效。
+ 您无法将租户数据库添加到使用单租户配置的 CDB。
+ 您不能在单个操作中添加或修改多个租户数据库。一次只能添加或修改一个。
+ 您不能将租户数据库名称修改为 `CDB$ROOT` 或 `PDB$SEED`。
+ 如果租户数据库是 CDB 中唯一的租户，则无法将其删除。
+ 并非所有数据库实例类类型都有足够的资源来支持 RDS for Oracle CDB 实例中的多个 PDB。PDB 数量的增加会影响较小实例类的性能和稳定性，并会增加大多数实例级操作（例如数据库升级）的时间。
+ 您不能使用 `rdsadmin.rdsadmin_util.rename_global_name` 重命名 PDB，必须改用 `modify-tenant-database` API。
+ 不能使用多个 Amazon Web Services 账户在同一 CDB 中创建 PDB。PDB 必须归托管 PDB 的数据库实例的账户所有。
+ CDB 中的所有 PDB 都使用相同的终端节点和数据库侦听器。
+ PDB 级别不支持以下操作，但 CDB 级别支持以下操作：
+ 备份和恢复
+ 数据库升级
+ 维护操作
+ PDB 级别不支持以下功能，但 CDB 级别支持以下功能：
+ 选项组（选项安装在您 CDB 实例上的所有 PDB 上）
+ 参数组（所有参数均来自与您的 CDB 实例关联的参数组）
+ 本地 CDB 架构支持但 RDS for Oracle CDB 不支持的 PDB 级操作包括以下内容：
**注意**
以下列表并非详尽内容。
+ 应用程序 PDB
+ 代理 PDB
+ 启动和停止 PDB
+ PDB 的拔出和插入
要将数据移入或移出 CDB，请使用与非 CDB 相同的方法。有关迁移数据的更多信息，请参阅[将数据导入到 Amazon RDS 上的 Oracle](Oracle.Procedural.Importing.md)。
+ PDB 级别的设置选项
PDB 将继承 CDB 选项组中的选项设置。有关设置选项的更多信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。有关最佳实践，请参阅[使用数据库参数组](CHAP_BestPractices.md#CHAP_BestPractices.DBParameterGroup)。
+ 在 PDB 中配置参数
PDB 继承 CDB 的参数设置。有关设置选项的更多信息，请参阅[向 Oracle 数据库实例添加选项](Appendix.Oracle.Options.md)。
+ 为同一 CDB 中的 PDB 配置不同的侦听器
+ Oracle 闪回功能
# 配置 RDS for Oracle CDB
配置 CDB 与配置非 CDB 类似。
**Topics**
+ [创建 RDS for Oracle CDB 实例](#Oracle.Concepts.single-tenant.creation)
+ [在 RDS for Oracle CDB 中连接到 PDB](#Oracle.Concepts.connecting.pdb)
## 创建 RDS for Oracle CDB 实例
在 RDS for Oracle 中，创建 CDB 实例与创建非 CDB 实例几乎完全相同。不同之处在于，您在创建数据库实例时选择了 Oracle 多租户架构，还选择了架构配置：多租户或单租户。如果您在创建使用多租户配置的 CDB 时创建标签，则 RDS 会将标签传播到初始租户数据库。要创建 CDB，请使用 Amazon Web Services 管理控制台、Amazon CLI 或 RDS API。
### 控制台
**创建 CDB 实例**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择要在其中创建 CDB 实例的 Amazon Web Services 区域。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择**创建数据库**。
1. 在**选择数据库创建方法**中，选择**标准创建**。
1. 在**引擎选项**下面，选择 **Oracle**。
1. 对于**数据库管理类型**，选择 **Amazon RDS**。
1. 对于**架构设置**，选择 **Oracle 多租户架构**。
1. 对于**架构配置**，请执行以下操作之一：
+ 选择**多租户配置**，继续执行下一步。
+ 选择**单租户配置**并跳至步骤 11。
1. （多租户配置）对于**租户数据库设置**，请进行以下更改：
+ 对于**租户数据库名称**，输入初始 PDB 的名称。PDB 名称必须与 CDB 名称不同，后者默认为 `RDSCDB`。
+ 对于**租户数据库主用户名**，输入 PDB 的主用户名。您不能使用租户数据库主用户名登录 CDB 本身。
+ 对于**凭证管理**，选择以下任一其它凭证管理选项：
+ **在 Amazon Secrets Manager 管理**
托管式密码适用于初始租户数据库，而不适用于实例。在**选择加密密钥**中，选择 Secrets Manager 创建的 KMS 密钥或您已创建的密钥。
**注意**
我们建议将 Amazon Secrets Manager 作为管理凭证的最安全的方法。将收取额外费用。有关更多信息，请参阅 [使用 Amazon RDS 和 Amazon Secrets Manager 管理密码](rds-secrets-manager.md)。
+ **自行管理**
要指定密码，请清除**自动生成密码**复选框（如果已选中）。在**主密码**和**确认主密码**中输入相同的密码。
+ 在**租户数据库字符集**中，为 PDB 选择一个字符集。您可以选择与 CDB 字符集不同的租户数据库字符集。
默认 PDB 字符集是 **AL32UTF8**。如果选择非默认 PDB 字符集，则创建 CDB 的速度可能会变慢。
**注意**
您无法在创建操作中指定多个租户数据库。创建 CDB 时，它有一个 PDB。您可以在单独的操作中将 PDB 添加到现有的 CDB。
1. （单租户配置）根据[数据库实例的设置](USER_CreateDBInstance.Settings.md)中列出的选项选择所需的设置：
1. 在**设置**部分中，打开**凭证设置**。然后执行以下操作：
1. 在**主用户名**中，输入 PDB 中本地用户的名称。您不能使用主用户名登录 CDB 根目录。
1. 对于**凭证管理**，选择以下任一其它凭证管理选项：
+ **在 Amazon Secrets Manager 管理**
在**选择加密密钥**中，选择 Secrets Manager 创建的 KMS 密钥或您已创建的密钥。
**注意**
我们建议将 Amazon Secrets Manager 作为管理凭证的最安全的方法。将收取额外费用。有关更多信息，请参阅 [使用 Amazon RDS 和 Amazon Secrets Manager 管理密码](rds-secrets-manager.md)。
+ **自行管理**
要指定密码，请清除**自动生成密码**复选框（如果已选中）。在**主密码**和**确认主密码**中输入相同的密码。
1. 对于其余部分，请指定数据库实例设置。有关每个设置的信息，请参阅[数据库实例的设置](https://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.Settings.html)。
1. 选择**创建数据库**。
### Amazon CLI
要使用多租户配置创建 CDB，请结合以下参数使用 [create-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/create-db-instance.html) 命令：
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine { oracle-ee-cdb | oracle-se2-cdb }`
+ `--master-username`
+ `--master-user-password` 或 `--manage-master-user-password`
+ `--multi-tenant`（对于单租户配置，不要指定 `multi-tenant` 或 `--no-multi-tenant`）
+ `--allocated-storage`
+ `--backup-retention-period`
有关每项设置的信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。
以下示例采用多租户配置创建了一个名为 *my-cdb-inst* 的 RDS for Oracle 数据库实例。如果您指定 `--no-multi-tenant` 或未指定 `--multi-tenant`，则默认 CDB 配置为单租户配置。引擎是 `oracle-ee-cdb`：一个指定 `oracle-ee` 和 `--multi-tenant` 但因错误失败的命令。初始租户数据库名为 *mypdb*。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-db-instance \
2. --engine oracle-ee-cdb \
3. --db-instance-identifier my-cdb-inst \
4. --multi-tenant \
5. --db-name mypdb \
6. --allocated-storage 250 \
7. --db-instance-class db.t3.large \
8. --master-username pdb_admin \
9. --manage-master-user-password \
10. --backup-retention-period 3
```
对于：Windows
```
1. aws rds create-db-instance ^
2. --engine oracle-ee-cdb ^
3. --db-instance-identifier my-cdb-inst ^
4. --multi-tenant ^
5. --db-name mypdb ^
6. --allocated-storage 250 ^
7. --db-instance-class db.t3.large ^
8. --master-username pdb_admin ^
9. --manage-master-user-password \ ^
10. --backup-retention-period 3
```
作为安全最佳实践，请指定除此处所示提示以外的密码。
此命令生成类似于下述信息的输出。输出中不包括数据库名称、字符集、国家/地区字符集、主用户和主用户密钥。您可以使用 CLI 命令 `describe-tenant-databases` 查看此信息。
```
1. {
2. "DBInstance": {
3. "DBInstanceIdentifier": "my-cdb-inst",
4. "DBInstanceClass": "db.t3.large",
5. "MultiTenant": true,
6. "Engine": "oracle-ee-cdb",
7. "DBResourceId": "db-ABCDEFGJIJKLMNOPQRSTUVWXYZ",
8. "DBInstanceStatus": "creating",
9. "AllocatedStorage": 250,
10. "PreferredBackupWindow": "04:59-05:29",
11. "BackupRetentionPeriod": 3,
12. "DBSecurityGroups": [],
13. "VpcSecurityGroups": [
14. {
15. "VpcSecurityGroupId": "sg-0a1bcd2e",
16. "Status": "active"
17. }
18. ],
19. "DBParameterGroups": [
20. {
21. "DBParameterGroupName": "default.oracle-ee-cdb-19",
22. "ParameterApplyStatus": "in-sync"
23. }
24. ],
25. "DBSubnetGroup": {
26. "DBSubnetGroupName": "default",
27. "DBSubnetGroupDescription": "default",
28. "VpcId": "vpc-1234567a",
29. "SubnetGroupStatus": "Complete",
30. ...
```
### RDS API
要使用 Amazon RDS API 创建数据库实例，请调用 [CreateDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) 操作。
有关每项设置的信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。
## 在 RDS for Oracle CDB 中连接到 PDB
您可以使用像 SQL\$1Plus 这样的实用程序连接到 PDB。要下载包含独立版本 SQL\$1Plus 的 Oracle 即时客户端，请参阅 [Oracle 即时客户端下载](https://www.oracle.com/database/technologies/instant-client/downloads.html)。
要将 SQL\$1Plus 连接到 PDB，您需要以下信息：
+ PDB 名称
+ 数据库用户名和密码
+ 您的数据库实例的端点
+ 端口号
有关查找上述信息的信息，请参阅[查找 RDS for Oracle 数据库实例的端点](USER_Endpoint.md)。
**Example 使用 SQL\$1Plus 连接到您的 PDB**
在以下示例中，用您的主用户替换 *master\$1user\$1name*。另外，请将端点替换为您的数据库实例，然后包含端口号和 Oracle SID。SID 值是您在创建数据库实例时指定的 PDB 的名称，而不是数据库实例标识符。
对于 Linux、macOS 或 Unix：
```
1. sqlplus 'master_user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=endpoint)(PORT=port))(CONNECT_DATA=(SID=pdb_name)))'
```
对于：Windows
```
1. sqlplus master_user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=endpoint)(PORT=port))(CONNECT_DATA=(SID=pdb_name)))
```
您应该可以看到类似于如下所示的输出内容。
```
SQL*Plus: Release 19.0.0.0.0 Production on Mon Aug 21 09:42:20 2021
```
在您输入用户的密码之后，将出现 SQL 提示。
```
SQL>
```
**注意**
较短格式连接字符串 (Easy connect 或 EZCONNECT) (如 `sqlplus username/password@LONGER-THAN-63-CHARS-RDS-ENDPOINT-HERE:1521/database-identifier`) 可能会遇到最大字符限制，不应用于连接。
# 备份和还原 CDB
您可以使用 RDS 数据库快照或 Recovery Manager（RMAN）备份和还原 CDB。
## 使用数据库快照备份和还原 CDB
数据库快照在 CDB 和非 CDB 架构中的工作原理类似。主要区别如下所示：
+ 还原 CDB 的数据库快照后，无法重命名 CDB。CDB 名为 `RDSCDB` 且无法更改。
+ 还原 CDB 的数据库快照后，无法重命名 PDB。您可以使用 [modify-tenant-database](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyTenantDatabase.html) 命令修改 PDB 名称。
+ 要在快照中查找租户数据库，请使用 CLI 命令 [describe-db-snapshot-tenant-databases](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_DescribeDBSnapshotTenantDatabases.html)。
+ 您无法直接与使用多租户架构配置的 CDB 快照中的租户数据库进行交互。如果还原数据库快照，则会还原其所有租户数据库。
+ RDS for Oracle 将租户数据库上的标签隐式复制到数据库快照中的租户数据库。还原租户数据库后，标签会显示在还原后的数据库中。
+ 如果您还原数据库快照并使用 `--tags` 参数指定新标签，则新标签将覆盖所有现有标签。
+ 如果您为带有标签的 CDB 实例拍摄数据库快照，并且您指定了 `--copy-tags-to-snapshot`，则 RDS for Oracle 会将标签从租户数据库复制到快照中的租户数据库。
有关更多信息，请参阅 [Oracle Database 注意事项](USER_RestoreFromSnapshot.md#USER_RestoreFromSnapshot.Oracle)。
## 使用 RMAN 备份和还原 CDB
要了解如何使用 RMAN 备份和还原 CDB 或个人租户数据库，请参阅[执行 Oracle 数据库实例的常见 RMAN 任务](Appendix.Oracle.CommonDBATasks.RMAN.md)。
# 将 RDS for Oracle 非 CDB 转换为 CDB
您可以使用 `modify-db-instance` 命令将 Oracle 数据库的架构从非 CDB 架构更改为 Oracle 多租户架构，也称为 *CDB 架构*。在大多数情况下，这种方法比创建新的 CDB 并导入数据更可取。转换操作会导致停机。
升级数据库引擎版本时，不能在同一操作中更改数据库架构。因此，要将 Oracle Database 19c 非 CDB 升级到 Oracle Database 21c CDB，您首先需要执行一个步骤来将非 CDB 转换为 CDB，然后再执行一个步骤来将 19c CDB 升级到 21c CDB。
非 CDB 转换操作有以下要求：
+ 必须为数据库引擎类型指定 `oracle-ee-cdb` 或 `oracle-se2-cdb`。只支持这两个值。
+ 您的数据库引擎必须使用具有 2021 年 4 月或更高版本的版本更新（RU）的 Oracle Database 19c。
该操作具有以下限制：
+ 您无法将 CDB 转换为非 CDB。您只能将非 CDB 转换为 CDB。
+ 您无法通过单次 `modify-db-instance` 调用将非 CDB 转换为多租户配置。将非 CDB 转换为 CDB 后，您的 CDB 将处于单租户配置。要将单租户配置转换为多租户配置，请再次运行 `modify-db-instance`。有关更多信息，请参阅 [将单租户配置转换为多租户配置](oracle-single-tenant-converting.md)。
+ 您无法转换启用了 Oracle Data Guard 的主数据库或副本数据库。要转换具有只读副本的非 CDB，请先删除所有只读副本。
+ 您无法在同一操作中升级数据库引擎版本，并将非 CDB 转换为 CDB。
转换非 CDB 前，请考虑以下事项：
+ 选项和参数组的注意事项与升级数据库引擎的注意事项相同。有关更多信息，请参阅 [Oracle 数据库升级注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md)。
+ 您可以在单个操作中将使用托管式主密码的现有非 CDB 实例转换为单租户实例。单租户实例继承托管式密码。
+ 如果数据库实例安装了 `OEMAGENT` 选项，则最佳实践是在转换非 CDB 之前移除此选项。在非 CDB 转换为 CDB 之后，请重新安装该选项。有关更多信息，请参阅 [适用于 Enterprise Manager Cloud Control 的 Oracle Management Agent](Oracle.Options.OEMAgent.md)。
+ 在转换过程中，RDS 将联机重做日志大小重置为默认的 128M。
## 控制台
**将非 CDB 转换为 CDB**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择数据库实例所在的 Amazon Web Services 区域。
1. 在导航窗格中，选择**数据库**，然后选择要转换为 CDB 实例的非 CDB 实例。
1. 选择 **Modify**(修改)。
1. 对于**架构设置**，选择 **Oracle 多租户架构**。转换后，您的 CDB 将处于单租户配置。
1. （可选）对于**数据库参数组**，请为您的 CDB 实例选择一个新的参数组。转换数据库实例时和升级数据库实例时，适用的参数组注意事项相同。有关更多信息，请参阅 [参数组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.PG)。
1. (可选）对于**选项组**，为 CDB 实例选择一个新的选项组。转换数据库实例时和升级数据库实例时，适用的选项组注意事项相同。有关更多信息，请参阅 [选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)。
1. （可选）对于**凭证管理**，请选择**在 Amazon Secrets Manager 中管理**或**自行管理**。有关更多信息，请参阅 [使用 Secrets Manager 管理数据库实例的主用户密码](rds-secrets-manager.md#rds-secrets-manager-db-instance)。
1. 当所有更改都达到您的要求时，选择**继续**并查看修改摘要。
1. （可选）选择**立即应用**以立即应用更改。选择此选项在某些情况下可能导致停机。有关更多信息，请参阅“[使用计划修改设置](USER_ModifyInstance.ApplyImmediately.md)”。
1. 在确认页面上，检查您的更改。如果更改正确无误，请选择**修改数据库实例**。
也可以选择 **Back (返回)** 编辑您的更改，或选择 **Cancel (取消)** 取消更改。
## Amazon CLI
要将数据库实例上的非 CDB 转换为采用单租户配置的 CDB，请在 Amazon CLI 命令 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 中将 `--engine` 设置为 `oracle-ee-cdb` 或 `oracle-se2-cdb`。有关更多信息，请参阅 [数据库实例的设置](USER_ModifyInstance.Settings.md)。
以下示例转换名为 *my-non-cdb* 的数据库实例，并指定自定义选项组和参数组。该命令还支持使用 Secrets Manager 管理密码。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier my-non-cdb \
--engine oracle-ee-cdb \
--option-group-name custom-option-group \
--db-parameter-group-name custom-parameter-group \
--manage-master-user-password
```
对于 Windows：
```
aws rds modify-db-instance ^
--db-instance-identifier my-non-cdb ^
--engine oracle-ee-cdb ^
--option-group-name custom-option-group ^
--db-parameter-group-name custom-parameter-group ^
--manage-master-user-password
```
## RDS API
要将非 CDB 转换为 CDB，请在 RDS API 操作 [ModifyDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) 中指定 `Engine`。
# 将单租户配置转换为多租户配置
您可以将 RDS for Oracle CDB 的架构从单租户配置修改为多租户配置。转换前后，您的 CDB 包含单租户数据库（PDB）。数据库实例的标签会传播到在转换期间创建的初始租户数据库。
在开始之前，请确保您的 IAM 策略有权创建租户数据库。在转换过程中，RDS for Oracle 会将以下元数据迁移到新的租户数据库：
+ 主用户名
+ 托管式主密码（如果源 CDB 与 Secrets Manager 集成）
+ 数据库名称
+ 字符集
+ 国家字符集
在转换之前，可以使用 `describe-db-instances` 命令查看上述信息。转换完成后，您可以使用 `describe-tenant-database` 命令查看信息。
从单租户到多租户的转换具有以下限制：
+ 转换为多租户配置后，您以后无法转换回单租户配置。该转换是不可逆的。
+ 您无法转换启用了 Oracle Data Guard 的主数据库或副本数据库。
+ 您无法在同一操作中升级数据库引擎版本，并转换为多租户配置。
+ 在转换过程中，您无法启用或禁用托管式主用户密码。
## 控制台
**将使用单租户配置的 CDB 转换为多租户配置**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择数据库实例所在的 Amazon Web Services 区域。
1. 在导航窗格中，选择**数据库**，然后选择要转换为 CDB 实例的非 CDB 实例。
1. 选择 **Modify**(修改)。
1. 对于**架构设置**，选择 **Oracle 多租户架构**。
1. 对于**架构配置**，请选择**多租户配置**。
1. （可选）对于**数据库参数组**，请为您的 CDB 实例选择一个新的参数组。转换数据库实例时和升级数据库实例时，适用的参数组注意事项相同。
1. (可选）对于**选项组**，为 CDB 实例选择一个新的选项组。转换数据库实例时和升级数据库实例时，适用的选项组注意事项相同。
1. 当所有更改都达到您的要求时，选择**继续**并查看修改摘要。
1. 选择**立即应用**。切换到多租户配置时需要此选项。注意，选择此选项在某些情况下可能导致停机。
1. 在确认页面上，检查您的更改。如果更改正确无误，请选择**修改数据库实例**。
也可以选择 **Back (返回)** 编辑您的更改，或选择 **Cancel (取消)** 取消更改。
## Amazon CLI
要将使用单租户配置的 CDB 转换为多租户配置，请在命令 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 中指定 Amazon CLI。
以下示例将名为 `my-st-cdb` 的数据库实例从单租户配置转换为多租户配置。`--apply-immediately` 选项是必需的。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance --region us-east-1\
--db-instance-identifier my-st-cdb \
--multi-tenant \
--apply-immediately
```
对于：Windows
```
aws rds modify-db-instance --region us-east-1 ^
--db-instance-identifier my-st-cdb ^
--multi-tenant ^
--apply-immediately
```
输出如下所示。
```
{
"DBInstance": {
"DBInstanceIdentifier": "my-st-cdb",
"DBInstanceClass": "db.r5.large",
"MultiTenant": false,
"Engine": "oracle-ee-cdb",
"DBResourceId": "db-AB1CDE2FGHIJK34LMNOPRLXTXU",
"DBInstanceStatus": "modifying",
"MasterUsername": "admin",
"DBName": "ORCL",
...
"EngineVersion": "19.0.0.0.ru-2022-01.rur-2022-01.r1",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "bring-your-own-license",
"OptionGroupMemberships": [
{
"OptionGroupName": "default:oracle-ee-cdb-19",
"Status": "in-sync"
}
],
...
"PendingModifiedValues": {
"MultiTenant": "true"
}
}
}
```
# 将 RDS for Oracle 租户数据库添加到您的 CDB 实例
在 RDS for Oracle 多租户配置中，租户数据库是 PDB。要添加租户数据库，请确保满足以下先决条件：
+ 您的 CDB 已启用多租户配置。有关更多信息，请参阅 [CDB 架构的多租户配置](Oracle.Concepts.CDBs.md#multi-tenant-configuration)。
+ 您具有创建租户数据库所需的 IAM 权限。
您可以使用 Amazon Web Services 管理控制台、Amazon CLI 或 RDS API 添加租户数据库。您不能通过单个操作添加多个租户数据库：必须一次添加一个。如果 CDB 启用了备份保留功能，则 Amazon RDS 会在数据库实例添加新的租户数据库之前和之后对其进行备份。如果 CDB 有只读副本，您只能向主数据库实例添加租户数据库；Amazon RDS 会自动在副本上创建租户数据库。还会验证复制运行状况，同时确保所有副本都可用，并且在创建租户之前，复制滞后少于 5 分钟。
## 控制台
**向数据库实例添加租户数据库**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择要在其中创建租户数据库的 Amazon Web Services 区域。
1. 在导航窗格中，选择**数据库**。
1. 选择要向其中添加租户数据库的 CDB 实例。您的数据库实例必须使用 CDB 架构的多租户配置。
1. 选择**操作**，然后选择**添加租户数据库**。
1. 对于**租户数据库设置**，请执行以下操作：
+ 对于**租户数据库名称**，输入新 PDB 的名称。
+ 对于**租户数据库主用户名**，输入您 PDB 的主用户名。
+ 选择以下任一其它凭证管理选项：
+ **在 Amazon Secrets Manager 管理**
在**选择加密密钥**中，选择 Secrets Manager 创建的 KMS 密钥或您已创建的密钥。
**注意**
我们建议将 Amazon Secrets Manager 作为管理凭证的最安全的方法。将收取额外费用。使用只读副本的实例不支持 Amazon Secrets Manager。有关更多信息，请参阅 [使用 Amazon RDS 和 Amazon Secrets Manager 管理密码](rds-secrets-manager.md)。
+ **自行管理**
要指定密码，请清除**自动生成密码**复选框（如果已选中）。在**主密码**和**确认主密码**中输入相同的密码。
+ 在**其他配置**下，在**初始数据库名称**中输入 PDB 的名称。您不能命名 CDB，它具有原定设置名称 `RDSCDB`。
+ 在**租户数据库字符集**中，为 PDB 选择一个字符集。默认值为 **AL32UTF8**。您可以选择不同于 CDB 字符集的 PDB 字符集。如果实例有只读副本，则无法使用自定义字符集创建租户。如果需要，您可以在创建只读副本之前使用自定义字符集创建租户。
+ 对于**租户数据库国家字符集**，请为 PDB 选择一个国家字符集。默认值为 **AL32UTF8**。国家字符集仅为使用 `NCHAR` 数据类型（`NCHAR`、`NVARCHAR2`、和 `NCLOB`）且不影响数据库元数据的列指定编码。
有关上述设置的更多信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。
1. 选择**添加租户**。
## Amazon CLI
要使用 Amazon CLI 将租户数据库添加到您的 CDB，请结合以下必需参数使用 [create-tenant-database](https://docs.amazonaws.cn/cli/latest/reference/rds/create-tenant-database.html) 命令：
+ `--db-instance-identifier`
+ `--tenant-db-name`
+ `--master-username`
+ `--master-user-password`
以下示例在名为 *my-cdb-inst* 的 RDS for Oracle CDB 实例中创建一个名为 *mypdb2* 的租户数据库。PDB 的字符集是 `UTF-16`。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name mypdb2 \
4. --master-username mypdb2-admin \
5. --master-user-password mypdb2-pwd \
6. --character-set-name UTF-16
```
对于：Windows
```
1. aws rds create-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name mypdb2 ^
4. --master-username mypdb2-admin ^
5. --master-user-password mypdb2-pwd ^
6. --character-set-name UTF-16
```
该输出值看上去类似于以下内容。
```
...}
"TenantDatabase" :
{
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:mypdb2",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "mypdb2",
"Status" : "creating",
"MasterUsername" : "mypdb2",
"CharacterSetName" : "UTF-16",
...
}
}...
```
# 修改 RDS for Oracle 租户数据库
您只能修改 CDB 中租户数据库的 PDB 名称和主用户密码。请注意以下要求和限制：
+ 要修改数据库实例中租户数据库的设置，租户数据库必须存在。
+ 您无法在单个操作中修改多个租户数据库。一次只能修改一个租户数据库。
+ 您不能将租户数据库的名称更改为 `CDB$ROOT` 或 `PDB$SEED`。
+ 如果您的数据库实例有只读副本，则只能修改主数据库实例上的租户。还会验证复制运行状况，同时确保副本可用，并且在修改租户之前复制滞后小于 5 分钟。
您可以使用 Amazon Web Services 管理控制台、Amazon CLI 或 RDS API 修改 PDB。
## 控制台
**修改租户数据库的 PDB 名称或主密码**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择要在其中创建租户数据库的 Amazon Web Services 区域。
1. 在导航窗格中，选择**数据库**。
1. 选择要修改其数据库名称或主用户密码的租户数据库。
1. 选择 **Modify**(修改)。
1. 对于**租户数据库设置**，请执行以下任意操作：
+ 对于**租户数据库名称**，输入新 PDB 的新名称。
+ 对于**租户数据库主密码**，输入新的密码。
1. 选择**修改租户**。
## Amazon CLI
要使用 Amazon CLI 修改租户数据库，请结合以下参数调用 [modify-tenant-database](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-tenant-database.html) 命令：
+ `--db-instance-identifier` *值*
+ `--tenant-db-name value`
+ `[--new-tenant-db-name value]`
+ `[--master-user-password value]`
以下示例在数据库实例 `my-cdb-inst` 上将租户数据库 `pdb1` 重命名为 `pdb-hr`。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds modify-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb1 \
4. --new-tenant-db-name pdb-hr
```
对于：Windows
```
1. aws rds modify-tenant-database --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb1 ^
4. --new-tenant-db-name pdb-hr
```
此命令生成类似于下述信息的输出。
```
{
"TenantDatabase" : {
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb1",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb1",
"Status" : "modifying",
"MasterUsername" : "tenant-admin-user"
"Port" : "6555",
"CharacterSetName" : "UTF-16",
"MaxAllocatedStorage" : "1000",
"ParameterGroups": [
{
"ParameterGroupName": "pdb1-params",
"ParameterApplyStatus": "in-sync"
}
],
"OptionGroupMemberships": [
{
"OptionGroupName": "pdb1-options",
"Status": "in-sync"
}
],
"PendingModifiedValues": {
"TenantDBName": "pdb-hr"
}
}
}
```
# 从您的 CDB 中删除 RDS for Oracle 租户数据库
您可以使用 Amazon Web Services 管理控制台、Amazon CLI 或 RDS API 删除租户数据库（PDB）。请考虑以下先决条件和限制：
+ 租户数据库和数据库实例必须存在。
+ 要成功删除，必须存在以下情况之一：
+ 租户数据库和数据库实例可用。
**注意**
您可以拍摄最终快照，但前提是租户数据库和数据库实例在发出 `delete-tenant-database` 命令之前处于可用状态。仅当数据库实例有只读副本时，才会在主实例上拍摄此快照。
+ 正在创建租户数据库。
+ 数据库实例正在修改租户数据库。
+ 如果数据库实例有只读副本，则这些限制适用于所有副本。
+ 您无法在单个操作中删除多个租户数据库。
+ 如果租户数据库是 CDB 中唯一的租户，则无法将其删除。
+ 您无法删除只读副本上的租户数据库，只能删除主数据库实例上的租户。还会验证复制运行状况，同时确保在删除租户之前，复制滞后小于 5 分钟。
## 控制台
**删除租户数据库**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择**数据库**，然后选择要删除的租户数据库。
1. 对于 ** Actions**，选择 **Delete**。
1. 要为数据库实例创建最终数据库快照，请选择**是否创建最终快照?**。
1. 如果选择创建最终快照，请输入**最终快照名称**。
1. 在框中输入 **delete me**。
1. 选择 **Delete**。
## Amazon CLI
要使用 Amazon CLI 删除租户数据库，请结合以下参数调用 [delete-tenant-database](https://docs.amazonaws.cn/cli/latest/reference/rds/delete-tenant-database.html) 命令：
+ `--db-instance-identifier value`
+ `--tenant-db-name value`
+ `[--skip-final-snapshot | --no-skip-final-snapshot]`
+ `[--final-snapshot-identifier value]`
以下示例从名为 *my-cdb-inst* 的 CDB 中删除名为 *pdb-test* 的租户数据库。默认情况下，该操作会创建最终快照。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds delete-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb-test \
4. --final-snapshot-identifier final-snap-pdb-test
```
对于：Windows
```
1. aws rds delete-tenant-database --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb-test ^
4. --final-snapshot-identifier final-snap-pdb-test
```
此命令生成类似于下述信息的输出。
```
{
"TenantDatabase" : {
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac456",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb-test",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb-test",
"Status" : "deleting",
"MasterUsername" : "pdb-test-admin"
"Port" : "6555",
"CharacterSetName" : "UTF-16",
"MaxAllocatedStorage" : "1000",
"ParameterGroups": [
{
"ParameterGroupName": "tenant-1-params",
"ParameterApplyStatus": "in-sync"
}
],
"OptionGroupMemberships": [
{
"OptionGroupName": "tenant-1-options",
"Status": "in-sync"
}
]
}
}
```
# 查看租户数据库详细信息
您可以像查看非 CDB 或 CDB 一样查看租户数据库的详细信息。
## 控制台
**查看有关租户数据库的详细信息**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择数据库实例所在的 Amazon Web Services 区域。
1. 在导航窗格中，选择**数据库**。
![\[查看有关 CDB 的详细信息\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/cdb-list.png)
在上图中，唯一租户数据库（PDB）显示为数据库实例的子数据库。
1. 选择租户数据库的名称。
![\[查看有关 PDB 的详细信息\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/pdb-details.png)
## Amazon CLI
要查看有关 PDB 的详细信息，请使用 Amazon CLI 命令 [describe-tenant-databases](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-tenant-databases.html)。
以下示例描述了指定区域中的所有租户数据库。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds describe-tenant-databases --region us-east-1
```
对于：Windows
```
1. aws rds describe-tenant-databases --region us-east-1
```
此命令生成类似于下述信息的输出。
```
"TenantDatabases" : [
{
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb-test",
"Status" : "available",
"MasterUsername" : "pdb-test-admin",
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac456",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb-test",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": []
},
{
"DBInstanceIdentifier" : "my-cdb-inst2",
"TenantDBName" : "pdb-dev",
"Status" : "modifying",
"MasterUsername" : "masterrdsuser"
"DbiResourceId" : "db-xyz789",
"TenantDatabaseResourceId" : "tdb-ghp890",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst2:pdb-dev",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": []
},
... other truncated data
```
以下示例描述了指定区域中数据库实例 `my-cdb-inst` 上的租户数据库。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds describe-tenant-databases --region us-east-1 \
2. --db-instance-identifier my-cdb-inst
```
对于：Windows
```
1. aws rds describe-tenant-databases --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst
```
此命令生成类似于下述信息的输出。
```
{
"TenantDatabase": {
"TenantDatabaseCreateTime": "2023-10-19T23:55:30.046Z",
"DBInstanceIdentifier": "my-cdb-inst",
"TenantDBName": "pdb-hr",
"Status": "creating",
"MasterUsername": "tenant-admin-user",
"DbiResourceId": "db-abc123",
"TenantDatabaseResourceId": "tdb-bac567",
"TenantDatabaseARN": "arn:aws:rds:us-west-2:579508833180:pdb-hr:tdb-abcdefghi1jklmno2p3qrst4uvw5xy6zabc7defghi8jklmn90op",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": [
{
"Key": "TEST",
"Value": "testValue"
}
]
}
}
```
以下示例描述了美国东部（弗吉尼亚州北部）区域中数据库实例 `my-cdb-inst` 上的租户数据库 `pdb1`。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds describe-tenant-databases --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb1
```
对于：Windows
```
1. aws rds describe-tenant-databases --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb1
```
此命令生成类似于下述信息的输出。
```
{
"TenantDatabases" : [
{
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb1"
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb1",
"Status" : "ACTIVE",
"MasterUsername" : "masterawsuser"
"Port" : "1234",
"CharacterSetName": "UTF-8",
"ParameterGroups": [
{
"ParameterGroupName": "tenant-custom-pg",
"ParameterApplyStatus": "in-sync"
}
],
{
"OptionGroupMemberships": [
{
"OptionGroupName": "tenant-custom-og",
"Status": "in-sync"
}
]
}
]
}
```
# 升级 CDB
您可以将 CDB 升级到其他 Oracle 数据库版本。例如，您可以将 Oracle Database 19c CDB 升级为 Oracle Database 21c CDB。在升级期间，您无法更改数据库架构。因此，您不能将非 CDB 升级为 CDB 或将 CDB 升级为非 CDB。
将 CDB 升级为 CDB 的过程与将非 CDB 升级为非 CDB 的过程相同。有关更多信息，请参阅 [升级 RDS for Oracle 数据库引擎](USER_UpgradeDBInstance.Oracle.md)。
# 管理您的 RDS for Oracle 数据库实例
以下是您使用 RDS for Oracle 数据库实例执行的常见管理任务。对于所有 RDS 数据库实例，有些任务是相同的。其他任务是特定于 RDS for Oracle 的。
以下任务是所有 RDS 数据库的共同任务，但 Oracle 数据库具有特殊的注意事项。例如，您可以使用 Oracle 客户端 SQL\$1Plus 和 SQL Developer 连接到 Oracle 数据库。
****
| 任务区域 | 相关文档 |
| --- | --- |
| **实例类、存储和 PIOPS** 如果您正在创建生产实例，请了解实例类、存储类型和预置 IOPS 在 Amazon RDS 中的工作原理。 | [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md) [Amazon RDS 存储类型](CHAP_Storage.md#Concepts.Storage) |
| **多可用区部署** 生产数据库实例应使用多可用区部署。多可用区部署为数据库实例提供了更高的可用性、数据持久性和容错能力。 | [配置和管理 Amazon RDS 的多可用区部署](Concepts.MultiAZ.md) |
| **Amazon VPC** 如果您的 Amazon 账户具有原定设置虚拟私有云（VPC），则自动在原定设置 VPC 中创建数据库实例。如果您的账户没有默认 VPC，并且您希望数据库实例位于 VPC 中，则必须在创建实例之前创建 VPC 和子网组。 | [在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **安全组**： 默认情况下，数据库实例使用阻止访问的防火墙。确保使用正确的 IP 地址和网络配置创建安全组来访问数据库实例。 | [使用安全组控制访问权限](Overview.RDSSecurityGroups.md) |
| **参数组** 如果数据库实例需要特定数据库参数，则在创建数据库实例前创建参数组。 | [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md) |
| **选项组** 如果数据库实例需要特定的数据库选项，则在创建数据库实例前创建选项组。 | [向 Oracle 数据库实例添加选项](Appendix.Oracle.Options.md) |
| **连接到您的数据库实例** 在创建安全组并将其与数据库实例关联后，您可以使用任何标准 SQL 客户端应用程序（如 Oracle SQL\$1Plus）连接到数据库实例。 | [连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md) |
| **备份和还原** 您可以配置数据库实例以采用自动备份或采用手动快照，然后从备份或快照还原实例。 | [备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md) |
| **监控** 您可以使用 CloudWatch Amazon RDS 指标、事件和增强监控来监控 Oracle 数据库实例。 | [在 Amazon RDS 控制台中查看指标](USER_Monitoring.md) [查看 Amazon RDS 事件](USER_ListEvents.md) |
| **日志文件** 您可以访问 Oracle 数据库实例的日志文件。 | [监控 Amazon RDS 日志文件](USER_LogAccess.md) |
您在下面可以找到 RDS Oracle 常见 DBA 任务的特定于 Amazon RDS 实施的描述。为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。此外，RDS 还限制了对需要高级权限的某些系统过程和表的访问。在许多任务中，您可以运行 `rdsadmin` 程序包，这是一个特定于 Amazon RDS 的工具，可用于管理您的数据库。
以下是运行 Oracle 的数据库实例的常见 DBA 任务：
+ [系统任务](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [数据库任务](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [日志任务](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [RMAN 任务](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Oracle 计划程序任务](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [诊断问题](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [其他任务](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
您还可以使用 Amazon RDS 过程将 Amazon S3 与 Oracle 集成在一起以及运行 OEM Management Agent 数据库任务。有关更多信息，请参阅“[Amazon S3 集成](oracle-s3-integration.md)”和“[使用 Management Agent 执行数据库任务](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks)”。
# 执行 Oracle 数据库实例的常见系统任务
下文中介绍了如何在运行 Oracle 的 Amazon RDS 数据库实例上，执行与系统相关的特定常见 DBA 任务。为了提供托管服务体验，Amazon RDS 不允许通过 shell 访问数据库实例，而仅限访问某些需要高级权限的系统过程和表。
**Topics**
+ [断开会话连接](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [终止会话](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [在会话中取消 SQL 语句](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [启用和禁用受限制的会话](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [刷新共享池](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [向 SYS 对象授予 SELECT 或 EXECUTE 权限](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [撤销 SYS 对象的 SELECT 或 EXECUTE 权限](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [管理 Oracle 数据库实例的 RDS\$1X\$1 视图](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [向非主用户授予权限](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [创建自定义函数来验证密码](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [设置自定义 DNS 服务器](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [设置和取消设置系统诊断事件](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# 断开会话连接
要终止专用服务器进程以断开当前会话连接，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.disconnect`。`disconnect` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `sid` | number | — | 是 | 会话标识符。 |
| `serial` | number | — | 是 | 会话的序列号。 |
| `method` | varchar | 'IMMEDIATE' | 否 | 有效值为 `'IMMEDIATE'` 或 `'POST_TRANSACTION'`。 |
以下示例断开一个会话。
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
要获取会话标识符和会话序列号，请查询 `V$SESSION` 视图。以下示例获取用户 `AWSUSER` 的所有会话。
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
数据库必须处于打开状态，才能使用此方法。有关断开会话连接的更多信息，请参阅 Oracle 文档中的 [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166)。
# 终止会话
要终止会话，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.kill`。`kill` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `sid` | number | — | 是 | 会话标识符。 |
| `serial` | number | — | 是 | 会话的序列号。 |
| `method` | varchar | null | 否 | 有效值为 `'IMMEDIATE'` 或 `'PROCESS'`。如果您指定 `IMMEDIATE`，其效果与运行以下语句相同： ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
如果您指定 `PROCESS`，将终止与会话关联的进程。仅当终止使用 `IMMEDIATE` 的会话失败时，才指定 `PROCESS`。 |
要获取会话标识符和会话序列号，请查询 `V$SESSION` 视图。以下示例获取用户 *AWSUSER* 的所有会话。
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
以下示例终止会话。
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
以下示例终止与会话关联的进程。
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# 在会话中取消 SQL 语句
要在会话中取消 SQL 语句，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.cancel`。
**注意**
Oracle Database 19c (19.0.0) 和 RDS for Oracle 的所有更高主要和次要版本均支持此过程。
`cancel` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `sid` | number | — | 是 | 会话标识符。 |
| `serial` | number | — | 是 | 会话的序列号。 |
| `sql_id` | varchar2 | null | 否 | SQL 语句的 SQL 标识符。 |
以下示例在会话中取消 SQL 语句。
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
要获取会话标识符、会话序列号和 SQL 语句的 SQL 标识符，请查询 `V$SESSION` 视图。以下示例获取用户 `AWSUSER` 的所有会话和 SQL 标识符。
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# 启用和禁用受限制的会话
要启用和禁用受限制的会话，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.restricted_session`。`restricted_session` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 是 | 描述 |
| --- | --- | --- | --- | --- |
| `p_enable` | 布尔值 | true | 否 | 设置为 `true` 则启用受限制的会话；设置为 `false` 则禁用受限制的会话。 |
以下示例介绍了如何启用和禁用受限制的会话。
```
/* Verify that the database is currently unrestricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
/* Enable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => true);
/* Verify that the database is now restricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
----------
RESTRICTED
/* Disable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => false);
/* Verify that the database is now unrestricted again. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
```
# 刷新共享池
要刷新共享池，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.flush_shared_pool`。`flush_shared_pool` 过程没有参数。
以下示例刷新共享池。
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## 刷新缓冲区缓存
要刷新缓冲区缓存，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.flush_buffer_cache`。`flush_buffer_cache` 过程没有参数。
以下示例刷新缓冲区缓存。
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## 刷新数据库智能闪存缓存
要刷新数据库智能闪存缓存，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.flush_flash_cache`。`flush_flash_cache` 过程没有参数。以下示例刷新数据库智能闪存缓存。
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
有关将数据库智能闪存缓存与 RDS for Oracle 结合使用的更多信息，请参阅 [在 RDS for Oracle 实例存储中存储临时数据](CHAP_Oracle.advanced-features.instance-store.md)。
# 向 SYS 对象授予 SELECT 或 EXECUTE 权限
通常，您使用可包含多个对象的角色来传输权限。要为单个对象授予权限，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.grant_sys_object`。此过程仅授予已通过角色或直接授权授予主用户的权限。
`grant_sys_object` 过程具有以下参数。
**重要**
对于所有参数值，除非您使用区分大小写的标识符创建了用户，否则请使用大写字母。例如，如果您运行 `CREATE USER myuser` 或 `CREATE USER MYUSER`，则数据字典将存储 `MYUSER`。但是，如果您在 `CREATE USER "MyUser"` 中使用双引号，则数据字典将存储 `MyUser`。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | 是 | 要授予其权限的对象的名称。对象可以是目录、函数、包、过程、序列、表或视图。对象名称的拼写必须与其在 `DBA_OBJECTS` 中出现时的拼写完全相同。由于大多数系统对象都是用大写形式定义的，因此，建议您先尝试这样做。 |
| `p_grantee` | varchar2 | — | 是 | 要向其授予权限的对象的名称。对象可以是架构或角色。 |
| `p_privilege` | varchar2 | null | 是 | — |
| `p_grant_option` | 布尔值 | false | 否 | 设置为 `true`，则使用 with grant option。 |
以下示例将名为 `V_$SESSION` 的对象的 select 权限授予名为 `USER1` 的用户。
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
以下示例使用授予选项将名为 `V_$SESSION` 的对象的 select 权限授予名为 `USER1` 的用户。
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
要能够授予针对某个对象的权限，您的账户必须具有通过使用授权选项或通过使用 `with admin option` 授予的角色直接为其授予的这些权限。在最常见的情况下，您可能希望授予已授予给 `SELECT` 角色的针对 DBA 视图的 `SELECT_CATALOG_ROLE` 权限。如果尚未使用 `with admin option` 将该角色直接授予您的用户，则您将无法转让此权限。如果您具有 DBA 权限，则可直接将该角色授予其他用户。
以下示例将 `SELECT_CATALOG_ROLE` 和 `EXECUTE_CATALOG_ROLE` 授予 `USER1`。由于使用了 `with admin option`，因此，`USER1` 现在可向已获得 `SELECT_CATALOG_ROLE` 的 SYS 对象授予访问权。
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
无需对已获得 `PUBLIC` 的对象重新授权。如果您使用 `grant_sys_object` 过程重新授予访问权，则此过程调用将成功。
# 撤销 SYS 对象的 SELECT 或 EXECUTE 权限
要撤销单个对象的特权，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.revoke_sys_object`。该过程仅撤消已通过角色或直接授权授予主账户的权限。
`revoke_sys_object` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | 是 | 要撤销其权限的对象的名称。对象可以是目录、函数、包、过程、序列、表或视图。对象名称的拼写必须与其在 `DBA_OBJECTS` 中出现时的拼写完全相同。由于大多数系统对象都是用大写形式定义的，因此，建议您先尝试这样做。 |
| `p_revokee` | varchar2 | — | 是 | 要撤销其权限的对象的名称。对象可以是架构或角色。 |
| `p_privilege` | varchar2 | null | 是 | — |
以下示例从名为 `V_$SESSION` 的用户撤销名为 `USER1` 的对象的 select 权限。
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# 管理 Oracle 数据库实例的 RDS\$1X\$1 视图
您可能需要访问 `SYS.X$` 固定表，这些表只能由 `SYS` 访问。要在符合条件的 `X$` 表上创建 `SYS.RDS_X$` 视图，请使用 `rdsadmin.rdsadmin_util` 包中的过程。您的主用户将自动获得对于 `RDS_X$` 视图的权限 `SELECT … WITH GRANT OPTION`。
`rdsadmin.rdsadmin_util` 过程适用于以下情况：
+ 从未升级过且使用以下版本的现有数据库实例：
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` 以及更高的 21c 版本
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` 以及更高的 19c 版本
+ 您创建的任何新的数据库实例
+ 您已升级的任何现有数据库实例
**重要**
在内部，`rdsadmin.rdsadmin_util` 包在 `X$` 表上创建视图。`X$` 表是内部系统对象，Oracle 数据库文档中未对此进行描述。我们建议您在非生产数据库中测试特定的视图，并且在 Oracle 支持的指导下仅在生产数据库中创建视图。
## 列出符合条件在 RDS\$1X\$1 视图中使用的 X\$1 固定表
要列出符合条件在 `RDS_X$` 视图中使用的 X\$1 表，请使用 RDS 过程 `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`。此过程不接受任何参数。以下语句列出了所有符合条件的 `X$` 表（包括示例输出）。
```
SQL> SET SERVEROUTPUT ON
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_allowed_sys_x$_views);
'X$BH'
'X$K2GTE'
'X$KCBWBPD'
'X$KCBWDS'
'X$KGLLK'
'X$KGLOB'
'X$KGLPN'
'X$KSLHOT'
'X$KSMSP'
'X$KSPPCV'
'X$KSPPI'
'X$KSPPSV'
'X$KSQEQ'
'X$KSQRS'
'X$KTUXE'
'X$KQRFP'
```
符合条件的 `X$` 表的列表可能随时间推移而变化。要确保符合条件的 `X$` 固定表的列表是最新的，请定期重新运行 `list_allowed_sys_x$_views`。
## 创建 SYS.RDS\$1X\$1 视图
要在符合条件的 `X$` 表上创建 `RDS_X$` 视图，请使用 RDS 过程 `rdsadmin.rdsadmin_util.create_sys_x$_view`。您只能为 `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` 的输出中列出的表创建视图。`create_sys_x$_view` 过程接受以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | 是 | 有效的 `X$` 表名称。此值必须是 `list_allowed_sys_x$_views` 报告的 `X$` 表之一。 |
| `p_force_creation` | 布尔值 | FALSE | 否 | 一个值，表示是否强制为 `X$` 表创建已存在的 `RDS_X$` 视图。默认情况下，如果视图已经存在，RDS 将不会创建该视图。要强制创建，请将此参数设置为 `TRUE`。 |
下面的示例基于表 `X$KGLOB` 创建 `SYS.RDS_X$KGLOB` 视图。视图名称的格式为 `RDS_X$tablename`。
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
以下数据字典查询列出视图 `SYS.RDS_X$KGLOB` 并显示其状态。您的主用户将自动获得对该视图的 `SELECT ... WITH GRANT OPTION` 权限。
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
OWNER OBJECT_NAME STATUS
------------------------------ ------------------------------ ------------------------------
SYS RDS_X$KGLOB VALID
```
**重要**
不能保证 `X$` 表在升级前后保持不变。在引擎升级期间，RDS for Oracle 会删除并重新创建 `X$` 表上的 `RDS_X$` 视图。然后它向主用户授予 `SELECT ... WITH GRANT OPTION` 权限。升级后，根据需要向数据库用户授予对相应 `RDS_X$` 视图的权限。
## 列出 SYS.RDS\$1X\$1 视图
要列出现有 `RDS_X$` 视图，请使用 RDS 过程 `rdsadmin.rdsadmin_util.list_created_sys_x$_views`。该过程仅列出由过程 `create_sys_x$_view` 创建的视图。以下示例列出了具有相应 `RDS_X$` 视图的 `X$` 表（包括示例输出）。
```
SQL> SET SERVEROUTPUT ON
SQL> COL XD_TBL_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_created_sys_x$_views);
XD_TBL_NAME STATUS
------------------------------ ------------------------------
X$BH VALID
X$K2GTE VALID
X$KCBWBPD VALID
3 rows selected.
```
## 删除 RDS\$1X\$1 视图
要删除 `SYS.RDS_X$` 视图，请使用 RDS 过程 `rdsadmin.rdsadmin_util.drop_sys_x$_view`。您只能删除 `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views` 的输出中列出的视图。`drop_sys_x$_view` 过程接受以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | 是 | 有效的 `X$` 固定表名称。此值必须是 `list_created_sys_x$_views` 报告的 `X$` 固定表之一。 |
以下示例删除了在表 `X$KGLOB` 上创建的 `RDS_X$KGLOB` 视图。
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
以下示例显示视图 `SYS.RDS_X$KGLOB` 已被删除（包括示例输出）。
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
no rows selected
```
# 向非主用户授予权限
您可以使用 `SYS` 角色向 `SELECT_CATALOG_ROLE` 架构中的多个对象授予 select 权限。`SELECT_CATALOG_ROLE` 角色向用户授予对数据字典视图的 `SELECT` 权限。以下示例向名为 `SELECT_CATALOG_ROLE` 的用户授予角色 `user1`。
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
您可以使用 `EXECUTE` 角色向 `SYS` 架构中的多个对象授予 `EXECUTE_CATALOG_ROLE` 权限。`EXECUTE_CATALOG_ROLE` 角色向用户授予对数据字典中的包和过程的 `EXECUTE` 权限。以下示例向名为 *user1* 的用户授予角色 `EXECUTE_CATALOG_ROLE`。
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
以下示例获取角色 `SELECT_CATALOG_ROLE` 和 `EXECUTE_CATALOG_ROLE` 允许的权限。
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
以下示例将创建一个名为 `user1` 的非主用户，授予 `CREATE SESSION` 权限并授予对名为 *sh.sales* 的数据库的 `SELECT` 权限。
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# 创建自定义函数来验证密码
您可以通过以下方式创建自定义密码验证函数：
+ 要使用标准验证逻辑，并将函数存储在 `SYS` 架构中，请使用 `create_verify_function` 过程。
+ 要使用自定义验证逻辑，或者避免将函数存储在 `SYS` 架构中，请使用 `create_passthrough_verify_fcn` 过程。
# create\$1verify\$1function 过程
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_password_verify.create_verify_function` 创建自定义函数来验证密码。所有版本的 RDS for Oracle 都支持 `create_verify_function` 过程。
`create_verify_function` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | 是 | 自定义函数的名称。将在 SYS 架构中为您创建此函数。为用户配置文件分配此函数。 |
| `p_min_length` | number | 8 | 否 | 要求的字符的最小数量。 |
| `p_max_length` | number | 256 | 否 | 允许的字符的最大数量。 |
| `p_min_letters` | number | 1 | 否 | 要求的字母的最小数量。 |
| `p_min_uppercase` | number | 0 | 否 | 要求的大写字母的最小数量。 |
| `p_min_lowercase` | number | 0 | 否 | 要求的小写字母的最小数量。 |
| `p_min_digits` | number | 1 | 否 | 要求的数字的最小数量。 |
| `p_min_special` | number | 0 | 否 | 要求的特殊字符的最小数量。 |
| `p_min_different_chars` | number | 3 | 否 | 旧密码和新密码之间需要的不同字符的最小数。 |
| `p_disallow_username` | 布尔值 | true | 否 | 设置为 `true` 可禁止在密码中使用用户名。 |
| `p_disallow_reverse` | 布尔值 | true | 否 | 设置为 `true` 则禁止在密码中使用反向用户名。 |
| `p_disallow_db_name` | 布尔值 | true | 否 | 设置为 `true` 则禁止在密码中使用数据库或服务器名称。 |
| `p_disallow_simple_strings` | 布尔值 | true | 否 | 设置为 `true` 则禁止将简单字符串用作密码。 |
| `p_disallow_whitespace` | 布尔值 | false | 否 | 设置为 `true` 则禁止在密码中使用空格字符。 |
| `p_disallow_at_sign` | 布尔值 | false | 否 | 设置为 `true` 以禁止在密码中使用 @ 字符。 |
可以创建多个密码验证函数。
自定义函数的名称受到一些限制。您的自定义函数不能具有与现有系统对象相同的名称。名称长度不能超过 30 个字符。另外，名称必须包括以下字符串之一：`PASSWORD`、`VERIFY`、`COMPLEXITY`、`ENFORCE` 或 `STRENGTH`。
下面的示例创建一个名为 `CUSTOM_PASSWORD_FUNCTION` 的函数。此函数要求密码具有至少 12 个字符、2 个大写字符、1 个数字和 1 个特殊字符，并且该密码禁止使用 @ 字符。
```
begin
rdsadmin.rdsadmin_password_verify.create_verify_function(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_min_length => 12,
p_min_uppercase => 2,
p_min_digits => 1,
p_min_special => 1,
p_disallow_at_sign => true);
end;
/
```
要查看验证函数的文本，请查询 `DBA_SOURCE`。以下示例获取名为 `CUSTOM_PASSWORD_FUNCTION` 的自定义密码函数的文本。
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
要将您的验证函数与用户配置文件关联，请使用 `ALTER PROFILE`。以下示例将名为 `CUSTOM_PASSWORD_FUNCTION` 的验证 PL/SQL 函数与 `DEFAULT` 用户配置文件关联。`PASSWORD_VERIFY_FUNCTION` 是 Oracle 配置文件资源名称。
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
要查看哪些用户配置文件与哪些验证函数关联，请查询 `DBA_PROFILES`。以下示例获取与名为 `CUSTOM_PASSWORD_FUNCTION` 的自定义验证函数关联的配置文件。
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION' AND LIMIT = 'CUSTOM_PASSWORD_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
```
以下示例获取所有配置文件以及与之关联的密码验证函数。
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
RDSADMIN PASSWORD_VERIFY_FUNCTION PASSWORD NULL
```
# create\$1passthrough\$1verify\$1fcn 过程
所有版本的 RDS for Oracle 都支持 `create_passthrough_verify_fcn` 过程。
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn` 创建自定义函数来验证密码。`create_passthrough_verify_fcn` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | 是 | 自定义验证函数的名称。这是在 SYS 架构中为您创建的包装函数，它不包含任何验证逻辑。为用户配置文件分配此函数。 |
| `p_target_owner` | varchar2 | — | 是 | 自定义验证函数的架构所有者。 |
| `p_target_function_name` | varchar2 | — | 是 | 包含验证逻辑的现有自定义函数的名称。您的自定义函数必须返回布尔值。如果密码有效，您的函数应返回 `true`；如果密码无效应返回 `false`。 |
以下示例创建的密码验证函数使用名为 `PASSWORD_LOGIC_EXTRA_STRONG` 的函数的逻辑。
```
begin
rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_target_owner => 'TEST_USER',
p_target_function_name => 'PASSWORD_LOGIC_EXTRA_STRONG');
end;
/
```
要将验证函数与用户配置文件关联，请使用 `alter profile`。以下示例将验证函数与 `DEFAULT` 用户配置文件关联。
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## 设置自定义 DNS 服务器
Amazon RDS 支持对运行 Oracle 的数据库实例进行出站网络访问。有关出站网络访问（包括先决条件）的更多信息，请参阅[使用证书和 Oracle Wallet 配置 UTL\$1HTTP 访问](Oracle.Concepts.ONA.md)。
Amazon RDS Oracle 支持通过客户拥有的自定义域名服务 (DNS) 服务器解析 DNS。通过自定义 DNS 服务器，您可以仅解析 Amazon RDS 数据库实例中的完全限定域名。
自定义 DNS 名称服务器设置完成后，它需要 30 分钟将更改传播到数据库实例中。将更改传播到数据库实例后，需要进行 DNS 查找的所有出站网络流量将通过端口 53 查询您的 DNS 服务器。
要为您的 Amazon RDS for Oracle 数据库实例设置自定义 DNS 服务器，请执行以下操作：
+ 在附加到 Virtual Private Cloud (VPC) 的 DHCP 选项集中，将 `domain-name-servers` 选项设置为您的 DNS 名称服务器的 IP 地址。有关更多信息，请参阅[ DHCP 选项集](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_DHCP_Options.html)。
**注意**
`domain-name-servers` 选项最多可接受四个值，但您的 Amazon RDS 数据库实例只使用第一个值。
+ 请确保您的 DNS 服务器可以解析所有查找查询，包括公有 DNS 名称、Amazon EC2 私有 DNS 名称和特定客户的 DNS 名称。如果出站网络流量中包含您的 DNS 服务器不能处理的 DNS 查找，您的 DNS 服务器必须已配置适当的上游 DNS 提供程序。
+ 请配置您的 DNS 服务器，以生成等于或小于 512 字节的用户数据报协议 (UDP) 响应。
+ 请配置您的 DNS 服务器，以生成等于或小于 1024 字节的传输控制协议 (TCP) 响应。
+ 配置您的 DNS 服务器，允许流量通过 Amazon RDS 数据库实例的端口 53 入站。如果您的 DNS 服务器在 Amazon VPC 中，此 VPC 的安全组必须包含以下入站规则：允许端口 53 上的 UDP 和 TCP 流量。如果您的 DNS 服务器不在 Amazon VPC 中，它必须具有适当的防火墙允许名单，以允许端口 53 上的 UDP 和 TCP 入站流量。
有关更多信息，请参阅[您的 VPC 的安全组](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_SecurityGroups.html)和[添加和删除规则](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules)。
+ 配置您的 Amazon RDS 数据库实例的 VPC，允许流量通过端口 53 出站。您的 VPC 安全组必须包含以下出站规则：允许端口 53 上的 UDP 和 TCP 流量。
有关更多信息，请参阅[您的 VPC 的安全组](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_SecurityGroups.html)和[添加和删除规则](https://docs.amazonaws.cn/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules)。
+ 必须正确配置 Amazon RDS 数据库实例和 DNS 服务器之间的路由路径，允许 DNS 流量。
+ 如果 Amazon RDS 数据库实例和 DNS 服务器不在同一 VPC 中，必须在它们之间设置对等连接。有关更多信息，请参阅[什么是 VPC 对等连接？](https://docs.amazonaws.cn/vpc/latest/peering/Welcome.html)
# 设置和取消设置系统诊断事件
要在会话级别设置和取消设置诊断事件，可以使用 Oracle SQL 语句 `ALTER SESSION SET EVENTS`。但是，要在系统级别设置事件，您不能使用 Oracle SQL。相反，请使用 `rdsadmin.rdsadmin_util` 软件包中的系统事件过程。以下引擎版本中提供系统事件过程：
+ 所有 Oracle Database 21c 版本
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 或更高的 Oracle Database 19c 版本
有关更多信息，请参阅《Amazon RDS for Oracle 发布说明》**中的[版本 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1)
**重要**
`rdsadmin.rdsadmin_util` 软件包内部使用 `ALTER SYSTEM SET EVENTS` 语句设置事件。Oracle 数据库文档中没有记录此 `ALTER SYSTEM` 语句。某些系统诊断事件可能会生成大量跟踪信息、引起争用或影响数据库可用性。我们建议您在非生产数据库中测试特定的诊断事件，并且在 Oracle 支持的指导下仅在生产数据库中设置事件。
## 列出允许的系统诊断事件
要列出可以设置的系统事件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.list_allowed_system_events`。此过程不接受任何参数。
以下示例列出了您可以设置的所有系统事件。
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
以下示例输出列出了事件编号及其描述。使用 Amazon RDS 过程 `set_system_event` 来设置这些事件并使用 `unset_system_event` 来取消设置它们。
```
604 - error occurred at recursive SQL level
942 - table or view does not exist
1401 - inserted value too large for column
1403 - no data found
1410 - invalid ROWID
1422 - exact fetch returns more than requested number of rows
1426 - numeric overflow
1427 - single-row subquery returns more than one row
1476 - divisor is equal to zero
1483 - invalid length for DATE or NUMBER bind variable
1489 - result of string concatenation is too long
1652 - unable to extend temp segment by in tablespace
1858 - a non-numeric character was found where a numeric was expected
4031 - unable to allocate bytes of shared memory ("","","","")
6502 - PL/SQL: numeric or value error
10027 - Specify Deadlock Trace Information to be Dumped
10046 - enable SQL statement timing
10053 - CBO Enable optimizer trace
10173 - Dynamic Sampling time-out error
10442 - enable trace of kst for ORA-01555 diagnostics
12008 - error in materialized view refresh path
12012 - error on auto execute of job
12504 - TNS:listener was not given the SERVICE_NAME in CONNECT_DATA
14400 - inserted partition key does not map to any partition
31693 - Table data object failed to load/unload and is being skipped due to error:
```
**注意**
允许的系统事件列表可能会随着时间的推移而变化。要确保您拥有最新的符合条件的活动列表，请使用 `rdsadmin.rdsadmin_util.list_allowed_system_events`。
## 设置系统诊断事件
要设置系统事件，请使用Amazon RDS过程`rdsadmin.rdsadmin_util.set_system_event`。您只能设置 `rdsadmin.rdsadmin_util.list_allowed_system_events` 输出中列出的事件。`set_system_event` 过程接受以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_event` | number | — | 是 | 系统事件编号。此值必须是 `list_allowed_system_events` 报告的事件编号之一。 |
| `p_level` | number | — | 是 | 活动级别。有关不同级别值的说明，请参阅 Oracle 数据库文档或 Oracle 支持。 |
过程 `set_system_event` 根据以下原则构造和运行所需的 `ALTER SYSTEM SET EVENTS` 语句：
+ 事件类型（`context` 或 `errorstack`）是自动确定的。
+ `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` 表单中的语句设置上下文事件。此符号等同于 `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`。
+ `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` 表单中的语句设置错误堆栈事件。此符号等同于 `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`。
以下示例将事件 942 设置为级别 3，将事件 10442 设置为级别 10。示例输出包括在内。
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(942,3);
Setting system event 942 with: alter system set events '942 errorstack (3)'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(10442,10);
Setting system event 10442 with: alter system set events '10442 level 10'
PL/SQL procedure successfully completed.
```
## 列出设置的系统诊断事件
要列出当前设置的系统事件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.list_set_system_events`。此过程仅报告 `set_system_event` 在系统级别设置的事件。
以下示例列出了活动的系统事件。
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
以下示例输出显示了事件列表、事件类型、当前设置事件的级别以及设置事件的时间。
```
942 errorstack (3) - set at 2020-11-03 11:42:27
10442 level 10 - set at 2020-11-03 11:42:41
PL/SQL procedure successfully completed.
```
## 取消设置系统诊断事件
要取消设置系统事件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.unset_system_event`。您只能取消设置 `rdsadmin.rdsadmin_util.list_allowed_system_events` 输出中列出的事件。`unset_system_event` 过程接受以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_event` | number | — | 是 | 系统事件编号。此值必须是 `list_allowed_system_events` 报告的事件编号之一。 |
以下示例取消设置事件 942 和 10442。示例输出包括在内。
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(942);
Unsetting system event 942 with: alter system set events '942 off'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(10442);
Unsetting system event 10442 with: alter system set events '10442 off'
PL/SQL procedure successfully completed.
```
# 执行 Oracle 数据库实例的常见数据库任务
下文中介绍了如何在运行 Oracle 的 Amazon RDS 数据库实例上，执行与数据库相关的特定常见 DBA 任务。为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。并且 Amazon RDS 还限制了对需要高级权限的某些系统程序和表的访问。
**Topics**
+ [更改数据库的全局名称](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [在 RDS for Oracle 中使用表空间](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [在 RDS for Oracle 中使用临时文件](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [在 RDS for Oracle 中调整表空间、数据文件和临时文件的大小](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [在 RDS for Oracle 中的存储卷之间移动数据](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [在 RDS for Oracle 中使用外部表](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# 更改数据库的全局名称
要更改数据库的全局名称，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.rename_global_name`。`rename_global_name` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | 是 | 数据库的新全局名称。 |
数据库必须处于打开状态，才能更改名称。有关更改数据库的全局名称的更多信息，请参阅 Oracle 文档中的 [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547)。
以下示例将数据库的全局名称更改为 `new_global_name`。
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# 在 RDS for Oracle 中使用表空间
可以将表空间与 RDS for Oracle 结合使用，后者是一种用于存储数据库数据的逻辑存储单元。
**重要**
如果您的数据库实例有副本，我们建议使用参数组设置而不是会话级别的更改来管理默认文件位置。对主实例中默认文件位置的会话级别更改不会自动反映在副本中。使用参数组设置可确保文件位置在主实例和副本实例间保持一致。
**Topics**
+ [在 RDS for Oracle 中指定数据库文件位置](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [在 RDS for Oracle 中创建表空间并调整其大小](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [在 RDS for Oracle 中的附加存储卷上创建表空间](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [在 RDS for Oracle 中设置默认表空间](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [在 RDS for Oracle 中设置默认临时表空间](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [在实例存储上创建临时表空间](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## 在 RDS for Oracle 中指定数据库文件位置
RDS for Oracle 使用 Oracle 管理的文件（OMF）来命名数据库文件。创建数据库文件时，数据库会根据 `DB_CREATE_FILE_DEST` 初始化参数的当前设置派生该设置。
`DB_CREATE_FILE_DEST` 初始化参数的默认值为 `/rdsdbdata/db`（对于独立数据库）和 `/rdsdbdata/db/pdb` [对于容器化（CDB/MT）架构]。如果数据库实例有附加存储卷，则可以将 `DB_CREATE_FILE_DEST` 设置为卷位置。例如，如果实例在 `/rdsdbdata/db` 上挂载了卷，则可以将 `DB_CREATE_FILE_DEST` 设置为该值。
您可以在会话级别或 Oracle 数据库实例级别修改 `DB_CREATE_FILE_DEST` 参数。
### 在实例级别修改 DB\$1CREATE\$1FILE\$1SET
要在实例级别修改该参数，请更新分配给数据库实例的参数组中的该参数并应用该参数。有关更多信息，请参阅[RDS for Oracle 初始化参数](Oracle.Concepts.FeatureSupport.Parameters.md)和[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 在会话级别修改 DB\$1CREATE\$1FILE\$1DEST
您可以通过执行 `ALTER SESSION` 语句在会话级别修改该参数。当您想要在特定位置为特定会话创建数据库文件而不影响整个实例时，这种方法非常有用。
以下示例显示了如何检查当前参数值并针对会话修改该值：
```
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata/db
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata2/db
```
## 在 RDS for Oracle 中创建表空间并调整其大小
创建表空间时，数据库会在创建时在由 `DB_CREATE_FILE_DEST` 初始化参数指定的存储卷中创建数据文件。原定设置情况下，如果未指定数据文件大小，则创建的表空间原定设置为 `AUTOEXTEND ON`，且没有最大大小。在以下示例中，表空间 *users1* 是可自动扩展的。
```
CREATE TABLESPACE users1;
```
由于这些默认设置，表空间会增大以占用所有分配的存储空间。建议您在永久表空间和临时表空间上指定适当的最大大小，并仔细监视空间使用率。
以下示例创建一个名为 *users2* 的表空间，起始大小为 1GB。由于指定了数据文件大小，但未指定 `AUTOEXTEND ON`，因此表空间不可自动扩展。
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
以下示例创建一个名为 *users3* 的表空间，起始大小为 1GB，开启了自动扩展，且最大大小为 10GB。
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
以下示例创建一个名为 *temp01* 的临时表空间。
```
CREATE TEMPORARY TABLESPACE temp01;
```
您可以使用 `ALTER TABLESPACE` 调整大文件表空间的大小。可以 KB (K)、MB (M)、GB (G) 或 TB (T) 为单位指定大小。以下示例将名为 *users\$1bf* 的大文件表空间的大小调整到 200MB。
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
以下示例向名为 *users\$1sf* 的小文件表空间添加另一个数据文件。
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## 在 RDS for Oracle 中的附加存储卷上创建表空间
要在附加存储卷上创建表空间，请将 `DB_CREATE_FILE_DEST` 参数修改为卷位置。以下示例将文件位置设置为 `/rdsdbdata2/db`。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
在以下示例中，您将在附加卷 `/rdsdbdata2/db` 上创建表空间。
```
CREATE TABLESPACE new_tablespace DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'NEW_TABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
NEW_TABLESPACE 7 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_newtable_a123b4c5_.dbf
```
要创建小文件表空间并将其数据文件分散到不同的存储卷，请在创建表空间后向表空间添加数据文件。在以下示例中，您创建了一个表空间，其中数据文件位于默认位置 `/rdsdbdata/db`。然后将默认目标设置为 `/rdsdbdata/db2`。向新创建的表空间中添加数据文件时，数据库会将该文件存储在 `/rdsdbdata/db2` 中。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata/db';
Session altered.
CREATE SMALLFILE TABLESPACE smalltbs DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
ALTER TABLESPACE smalltbs ADD DATAFILE SIZE 10G;
Tablespace altered.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
SMALLTBS 9 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_smalltbs_n564004g_.dbf
```
## 在 RDS for Oracle 中设置默认表空间
要设置默认表空间，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.alter_default_tablespace`。`alter_default_tablespace` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | 是 | 默认表空间的名称。 |
以下示例将默认表空间设置为 *users2*：
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## 在 RDS for Oracle 中设置默认临时表空间
要设置默认临时表空间，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`。`alter_default_temp_tablespace` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | 是 | 默认临时表空间的名称。 |
以下示例将默认临时表空间设置为 *temp01*。
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## 在实例存储上创建临时表空间
要在实例存储上创建临时表空间，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace`。`create_inst_store_tmp_tblspace` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | 是 | 临时表空间的名称。 |
以下示例在实例存储中创建临时表空间 *temp01*。
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**重要**
运行 `rdsadmin_util.create_inst_store_tmp_tblspace` 时，新创建的临时表空间不会自动设置为原定设置临时表空间。要将其设置为原定设置，请参阅 [在 RDS for Oracle 中设置默认临时表空间](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)。
有关更多信息，请参阅 [在 RDS for Oracle 实例存储中存储临时数据](CHAP_Oracle.advanced-features.instance-store.md)。
# 在 RDS for Oracle 中使用临时文件
## 在只读副本上向实例存储中添加临时文件
当您在主数据库实例上创建临时表空间时，只读副本不会创建临时文件。假设由于以下原因之一，只读副本上存在一个空的临时表空间：
+ 您从只读副本上的表空间中删除了一个临时文件。有关更多信息，请参阅 [删除只读副本上的临时文件](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md)。
+ 您在主数据库实例上创建了一个新的临时表空间。在这种情况下，RDS for Oracle 会将元数据同步到只读副本。
您可以将临时文件添加到空的临时表空间，并将临时文件存储在实例存储中。要在实例存储中创建临时文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.add_inst_store_tempfile`。您只能在只读副本上使用此过程。 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | 是 | 只读副本上临时表空间的名称。 |
在以下示例中，您的只读副本上存在空的临时表空间 *temp01*。运行以下命令以创建此表空间的临时文件，并将其存储在实例存储中。
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
有关更多信息，请参阅 [在 RDS for Oracle 实例存储中存储临时数据](CHAP_Oracle.advanced-features.instance-store.md)。
# 删除只读副本上的临时文件
您不能删除只读副本上的现有临时表空间。您可以将只读副本上的临时文件存储从 Amazon EBS 更改为实例存储，或者从实例存储更改为 Amazon EBS。为实现这些目标，请执行以下操作：
1. 删除只读副本上临时表空间中的当前临时文件。
1. 在不同的存储上创建新的临时文件。
要删除临时文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util. drop_replica_tempfiles`。您只能在只读副本上使用此过程。`drop_replica_tempfiles` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | 是 | 只读副本上临时表空间的名称。 |
假设一个名为 *temp01* 的临时表空间位于只读副本上的实例存储中。通过运行以下命令，删除此表空间中的所有临时文件。
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
有关更多信息，请参阅 [在 RDS for Oracle 实例存储中存储临时数据](CHAP_Oracle.advanced-features.instance-store.md)。
# 在 RDS for Oracle 中调整表空间、数据文件和临时文件的大小
原定设置情况下，在开启自动扩展的情况下创建 Oracle 表空间，并且没有最大大小。由于这些原定设置，表空间有时可能会变得过大。建议您在永久表空间和临时表空间上指定适当的最大大小，并仔细监视空间使用率。
## 调整永久表空间大小
要调整 RDS for Oracle 数据库实例中永久表空间的大小，请使用以下任何 Amazon RDS 过程：
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
`resize_datafile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | number | — | 是 | 要调整大小的数据文件的标识符。 |
| `p_size` | varchar2 | — | 是 | 数据文件的大小。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。 |
`autoextend_datafile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | number | — | 是 | 要调整大小的数据文件的标识符。 |
| `p_autoextend_state` | varchar2 | — | 是 | 自动扩展功能的状态。指定 `ON` 可自动扩展数据文件，指定 `OFF` 可关闭自动扩展功能。 |
| `p_next` | varchar2 | — | 否 | 下一个数据文件增量的大小。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。 |
| `p_maxsize` | varchar2 | — | 否 | 允许自动扩展的最大磁盘空间。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。您可以指定 `UNLIMITED` 以删除文件大小限制。 |
以下示例将数据文件 4 的大小调整为 500MB。
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
以下示例对于数据文件 4 关闭自动扩展功能。该示例还为数据文件 5 开启自动扩展功能，增量为 128MB，且没有最大大小。
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## 调整临时表空间大小
要调整 RDS for Oracle 数据库实例中临时表空间（包括只读副本）的大小，请使用以下任何 Amazon RDS 过程：
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
`resize_temp_tablespace` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | 是 | 要调整大小的临时表空间的名称。 |
| `p_size` | varchar2 | — | 是 | 表空间的大小。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。 |
`resize_tempfile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | number | — | 是 | 要调整大小的临时文件的标识符。 |
| `p_size` | varchar2 | — | 是 | 临时文件的大小。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。 |
`autoextend_tempfile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | number | — | 是 | 要调整大小的临时文件的标识符。 |
| `p_autoextend_state` | varchar2 | — | 是 | 自动扩展功能的状态。指定 `ON` 可自动扩展临时文件，指定 `OFF` 可关闭自动扩展功能。 |
| `p_next` | varchar2 | — | 否 | 下一个临时文件增量的大小。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。 |
| `p_maxsize` | varchar2 | — | 否 | 允许自动扩展的最大磁盘空间。以字节数（原定设置）、KB（K）、MB（M）或 GB（G）为单位指定大小。您可以指定 `UNLIMITED` 以删除文件大小限制。 |
以下示例将名为 `TEMP` 的临时表空间的大小调整为 4GB。
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
以下示例将基于临时文件（文件标识符为 `1`）的临时表空间大小调整为 2MB。
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
以下示例对于临时文件 1 关闭自动扩展功能。该示例还将临时文件 2 的最大自动扩展大小设置为 10GB，增量为 100MB。
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
有关 Oracle 数据库实例的只读副本的更多信息，请参阅[使用 Amazon RDS for Oracle 的只读副本](oracle-read-replicas.md)。
# 在 RDS for Oracle 中的存储卷之间移动数据
您可以在主存储卷和附加存储卷之间移动数据文件和数据库对象。在移动数据之前，请考虑以下几点：
+ 源卷和目标卷必须具有足够的可用空间。
+ 数据移动操作会消耗两个卷上的 I/O。
+ 大量数据移动可能会影响数据库性能。
+ 当您还原快照时，如果数据受到 EBS 延迟加载的影响，则在存储卷之间移动数据可能会较慢。
**Topics**
+ [在 RDS for Oracle 中的卷之间移动数据文件](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [在 RDS for Oracle 中的卷之间移动表数据和索引](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [使用附加卷管理 LOB 存储](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## 在 RDS for Oracle 中的卷之间移动数据文件
要在存储卷之间移动数据文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.move_datafile`。请注意以下要求：
+ 必须使用 Oracle 企业版才能运行 `move_datafile` 过程。
+ 您无法移动表空间 `SYSTEM` 和 `RDSADMIN`。
`move_datafile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 必需 | 描述 |
| --- | --- | --- | --- |
| `p_data_file_id` | number | 是 | 要移动的数据文件的 ID。 |
| `p_location` | varchar2 | 是 | 要将数据文件移动到的存储卷。 |
以下示例将表空间从默认卷 `rdsdbdata` 移到附加卷 `rdsdbdata2`。
```
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata/db/ORCL_A/datafile/o1_mf_mynewtab_n123abcd_.dbf
EXECUTE rdsadmin.rdsadmin_util.move_datafile( 6, 'rdsdbdata2');
PL/SQL procedure successfully completed.
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_mynewtab_n356efgh_.dbf
```
## 在 RDS for Oracle 中的卷之间移动表数据和索引
您可以通过在附加存储卷上创建表空间来优化数据库存储。然后，您可以使用标准 Oracle SQL 将表、索引和分区等对象移动到这些表空间。当数据库包含具有不同访问模式的数据时，这种方法对于性能调整非常有用。例如，您可以将频繁访问的操作数据存储在高性能存储卷上，同时将极少访问的历史数据移到成本较低的存储卷上。
在以下示例中，您在高性能卷 `rdsdbdata2` 上创建了一个新的表空间。然后，当表处于联机状态时，您可以将该表移到附加存储卷中。您还可以将索引移到相同的卷上。联机时移动表和重建索引要求使用 Oracle 企业版。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
CREATE TABLESPACE perf_tbs DATAFILE SIZE 10G;
ALTER TABLE employees
MOVE TABLESPACE perf_tbs ONLINE;
ALTER INDEX employees_idx
REBUILD ONLINE TABLESPACE perf_tbs;
```
在以下示例中，您在低成本卷上创建表空间。然后，使用联机操作将表分区移到低成本存储卷上。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE hist_tbs DATAFILE SIZE 10G;
ALTER TABLE orders
MOVE PARTITION orders_2022
TABLESPACE hist_tbs ONLINE;
```
在以下示例中，您可以查询活动会话的长时间操作。
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
您可以使用以下查询检查表空间使用情况。
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## 使用附加卷管理 LOB 存储
您的数据库可能包含具有 BLOB 或 CLOB 对象的表，这些对象会占用大量存储空间，但并不频繁访问。要优化存储，您可以将这些 LOB 段重新放置到附加存储卷上的表空间。
在以下示例中，您在一个旨在存储低访问频率数据的低成本卷上，为 LOB 数据创建一个表空间。然后创建在该卷上存储数据的表。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE lob_data DATAFILE SIZE 5G AUTOEXTEND ON NEXT 1G;
CREATE TABLE documents (
doc_id NUMBER PRIMARY KEY,
doc_date DATE,
doc_content CLOB
) TABLESPACE user_data
LOB(doc_content) STORE AS (TABLESPACE lob_data);
```
# 在 RDS for Oracle 中使用外部表
*Oracle 外部表*是具有不在数据库中数据的表。这些数据位于数据库可以访问的外部文件中。使用外部表，您可以访问数据而无需将其加载到数据库中。有关外部表的更多信息，请参阅 Oracle 文档中的[管理外部表](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507)。
使用 Amazon RDS，您可以将外部表文件存储在目录对象中。您可以创建目录对象，或者使用 Oracle 数据库中预定义的目录对象，例如 DATA\$1PUMP\$1DIR 目录。有关创建目录对象的信息，请参阅[在主数据存储空间中创建和删除目录](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories)。您可以查询 ALL\$1DIRECTORIES 视图来列出您的 Amazon RDS Oracle 数据库实例的目录对象。
**注意**
目录对象指向由实例使用的主数据存储空间 (Amazon EBS 卷)。—包括数据文件、重做日志、审核、跟踪和其他文件在内—所用的空间均计入分配的存储中。
您可以使用 [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) 包或 [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069) 包，将外部数据文件从一个 Oracle 数据库移动到另一个。外部数据文件从源数据库上的目录移至目标数据库上的指定目录中。有关使用 `DBMS_FILE_TRANSFER` 的信息，请参阅 [使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)。
移动外部数据文件之后，您可以用它来创建外部表。以下示例创建使用 USER\$1DIR1 目录中 `emp_xt_file1.txt` 文件的外部表。
```
CREATE TABLE emp_xt (
emp_id NUMBER,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
user_name VARCHAR2(20)
)
ORGANIZATION EXTERNAL (
TYPE ORACLE_LOADER
DEFAULT DIRECTORY USER_DIR1
ACCESS PARAMETERS (
RECORDS DELIMITED BY NEWLINE
FIELDS TERMINATED BY ','
MISSING FIELD VALUES ARE NULL
(emp_id,first_name,last_name,user_name)
)
LOCATION ('emp_xt_file1.txt')
)
PARALLEL
REJECT LIMIT UNLIMITED;
```
假设您要将位于 Amazon RDS Oracle 数据库实例中的数据移动到外部数据文件中。在这种情况下，您可以通过创建外部表并从数据库中的表选择数据来填充外部数据文件。例如，以下 SQL 语句通过查询数据库中的 `orders_xt` 表创建 `orders` 外部表。
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
在此示例中，数据填充到 DATA\$1PUMP\$1DIR 目录的 `orders_xt.dmp` 文件中。
# 通过检查点检验数据库
要通过检查点检验数据库，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.checkpoint`。`checkpoint` 过程没有参数。
以下示例为数据库创建检查点。
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# 设置分布式恢复
要设置分布式恢复，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.enable_distr_recovery` 和 `disable_distr_recovery`。这些过程没有参数。
以下示例启用分布式恢复。
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
以下示例禁用分布式恢复。
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# 设置数据库时区
您可以通过以下方式设置 Amazon RDS Oracle 数据库的时区：
+ `Timezone` 选项
`Timezone` 选项在主机级别更改时区，并且会影响所有日期列和值（例如 `SYSDATE`）。有关更多信息，请参阅“[Oracle 时区](Appendix.Oracle.Options.Timezone.md)”。
+ Amazon RDS 过程 `rdsadmin.rdsadmin_util.alter_db_time_zone`
`alter_db_time_zone` 步骤仅更改某些数据类型的时区，而不更改 `SYSDATE`。在 [Oracle 文档](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705)中列出了与设置时区有关的其他限制。
**注意**
您还可以为 Oracle Scheduler 设置默认时区。有关更多信息，请参阅“[设置 Oracle Scheduler 作业的时区](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone)”。
`alter_db_time_zone` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | 是 | 作为已命名的区域或与协调世界时 (UTC) 的绝对偏移量的时区。有效偏移范围介于 -12:00 到 \$114:00 之间。 |
以下示例将时区更改为 UTC 加 3 小时。
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
以下示例将时区更改为非洲/阿尔及尔时区。
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
使用 `alter_db_time_zone` 过程更改时区后，重启数据库实例以使更改生效。有关更多信息，请参阅“[重启数据库实例](USER_RebootInstance.md)”。有关升级时区的信息，请参阅 [时区注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST)。
# 使用 Automatic Workload Repository (AWR) 生成性能报告
要收集性能数据并生成报告，Oracle 建议使用 Automatic Workload Repository (AWR)。AWR 需要 Oracle Database Enterprise Edition 以及 Diagnostics and Tuning 包的许可证。要启用 AWR，请将 `CONTROL_MANAGEMENT_PACK_ACCESS` 初始化参数设置为 `DIAGNOSTIC` 或 `DIAGNOSTIC+TUNING`。
## 在 RDS 中使用 AWR 报告
要生成 AWR 报告，您可以运行脚本，例如 `awrrpt.sql`。这些脚本安装在数据库主机服务器上。在 Amazon RDS 中，您无法直接访问主机。但是，您可以从其他 Oracle 数据库安装中获取 SQL 脚本的副本。
您还可以通过在 `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL 软件包中运行过程来使用 AWR。您可以使用此软件包管理基准和快照，还可以显示 ASH 和 AWR 报告。例如，要生成文本格式的 AWR 报告，请运行 `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT` 过程。但是，您无法从Amazon Web Services 管理控制台访问这些 AWR 报告。
使用 AWR 时，我们建议使用 `rdsadmin.rdsadmin_diagnostic_util` 过程。您可以使用这些过程生成以下内容：
+ AWR 报告
+ Active Session History (ASH) 报告
+ Automatic Database Diagnostic Monitor (ADDM) 报告
+ AWR 数据的 Oracle Data Pump Export 转储文件
`rdsadmin_diagnostic_util` 过程将报告保存到数据库实例文件系统。您可以从控制台访问这些报告。您还可以使用 `rdsadmin.rds_file_util` 过程访问报告，并可以使用 S3 集成访问复制到 Amazon S3 的报告。有关更多信息，请参阅“[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)”和“[Amazon S3 集成](oracle-s3-integration.md)”。
您可在以下 Amazon RDS for Oracle 数据库引擎版本中使用 `rdsadmin_diagnostic_util` 过程：
+ 所有 Oracle Database 21c 版本
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 或更高的 Oracle Database 19c 版本
有关解释如何在复制场景中使用诊断报告的博客，请参阅[为 Amazon RDS for Oracle 只读副本生成 AWR 报告](https://www.amazonaws.cn/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/)。
## 诊断实用程序软件包的通用参数
通常，您在通过 `rdsadmin_diagnostic_util` 软件包管理 AWR 和 ADDM 时可以使用以下参数。
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
使用 rdsadmin\$1diagnostic\$1util 软件包管理 ASH 时，通常使用以下参数。
[\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## 生成 AWR 报告
要生成 AWR 报告，请使用 `rdsadmin.rdsadmin_diagnostic_util.awr_report` 过程。
以下示例生成快照范围 101–106 的 AWR 报告。输出文本文件名为 `awrrpt_101_106.txt`。您可以通过Amazon Web Services 管理控制台访问此报告。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
以下示例生成快照范围 63–65 的 HTML 报告。输出 HTML 文件名为 `awrrpt_63_65.html`。该过程将报告写入名为 `AWR_RPT_DUMP` 的非默认数据库目录。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## 将 AWR 数据提取到转储文件
要将 AWR 数据提取到转储文件中，请使用 `rdsadmin.rdsadmin_diagnostic_util.awr_extract` 过程。只能在 PDB 级别使用此功能。
以下示例提取范围 101–106 中的快照。输出转储文件名为 `awrextract_101_106.dmp`。您可以通过控制台访问此文件。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
以下示例提取范围在 63–65 中的快照。输出转储文件名为 `awrextract_63_65.dmp`。该文件存储在名为 `AWR_RPT_DUMP` 的非默认数据库目录中。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## 生成 ADDM 报告
要生成 ADDM 报告，请使用 `rdsadmin.rdsadmin_diagnostic_util.addm_report` 过程。
以下示例生成快照范围 101–106 的 ADDM 报告。输出文本文件名为 `addmrpt_101_106.txt`。您可以通过控制台访问报告。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
以下示例生成快照范围 63–65 的 ADDM 报告。输出文本文件名为 `addmrpt_63_65.txt`。该文件存储在名为 `ADDM_RPT_DUMP` 的非默认数据库目录中。
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## 生成 ASH 报告
要生成 ASH 报告，请使用 `rdsadmin.rdsadmin_diagnostic_util.ash_report` 过程。
以下示例生成一个 ASH 报告，其中包含当前时间 14 分钟前的数据。输出文件的名称使用格式 `ashrptbegin_timeend_time.txt`，其中 `begin_time` 和 `end_time` 使用格式 `YYYYMMDDHH24MISS`。您可以通过控制台访问文件。
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
以下示例生成一个 ASH 报告，其中包括从 2019 年 11 月 18 日下午 6 点 07 分到 2019 年 11 月 18 日下午 6 点 15 分的数据。输出 HTML 报告名为 `ashrpt_20190918180700_20190918181500.html`。该报告存储在名为 `AWR_RPT_DUMP` 的非默认数据库目录中。
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => TO_DATE('2019-09-18 18:07:00', 'YYYY-MM-DD HH24:MI:SS'),
end_time => TO_DATE('2019-09-18 18:15:00', 'YYYY-MM-DD HH24:MI:SS'),
report_type => 'html',
dump_directory => 'AWR_RPT_DUMP');
END;
/
```
## 从控制台或 CLI 访问 AWR 报告
要访问 AWR 报告或导出转储文件，您可以使用 Amazon Web Services 管理控制台 或 Amazon CLI。有关更多信息，请参阅 [下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)。
# 在 VPC 中调整用于数据库实例的数据库链接
要在同一 Virtual Private Cloud (VPC) 或对等 VPC 中使用与 Amazon RDS 数据库实例的 Oracle 数据库链接，这两个数据库实例之间应具有有效路由。使用 VPC 路由表和网络访问控制列表 (ACL) 验证数据库实例之间的有效路由。
每个数据库实例的安全组必须允许另一个数据库实例的传入和传出。入站和出站规则可引用同一 VPC 或对等 VPC 中的安全组。有关更多信息，请参阅[更新安全组以引用对等的 VPC 安全组](https://docs.amazonaws.cn/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups)。
如果您已使用 VPC 中的 DHCP 选项集配置自定义 DNS 服务器，则自定义 DNS 服务器必须能够解析数据库链接目标的名称。有关更多信息，请参阅“[设置自定义 DNS 服务器](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS)”。
有关将数据库链接用于 Oracle Data Pump 的更多信息，请参阅 [使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)。
# 设置数据库实例的默认版本
您可以在私有环境中重新定义称为版本的数据库对象。您可以使用基于版本的重新定义，以最少的停机来升级应用程序的数据库对象。
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.alter_default_edition` 设置 Amazon RDS Oracle 数据库实例的默认版本。
以下示例将 Amazon RDS Oracle 数据库实例的默认版本设置为 `RELEASE_V1`。
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
以下示例将 Amazon RDS Oracle 数据库实例的默认版本设置回 Oracle 默认值。
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
有关基于 Oracle 版本的重新定义的更多信息，请参阅 Oracle 文档中的[关于版本和基于版本的重新定义](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167)。
# 为 SYS.AUD\$1 表启用审核
要在数据库审核跟踪表 `SYS.AUD$` 上启用审核，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table`。唯一受支持的审核属性为 `ALL`。您无法审核或不审核单个语句或操作。
运行以下版本的 Oracle 数据库实例支持启用审核：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
`audit_all_sys_aud_table` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_by_access` | 布尔值 | true | 否 | 设置为 `true` 以审核 `BY ACCESS`。设置为 `false` 以审核 `BY SESSION`。 |
以下查询返回数据库的 `SYS.AUD$` 的当前审核配置。
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
以下命令启用 `ALL` `SYS.AUD$` 上的 `BY ACCESS` 的审核。
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table;
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => true);
```
以下命令启用 `ALL` `SYS.AUD$` 上的 `BY SESSION` 的审核。
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
有关更多信息，请参阅 Oracle 文档中的 [AUDIT（传统审核）](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/AUDIT-Traditional-Auditing.html#GUID-ADF45B07-547A-4096-8144-50241FA2D8DD)。
# 为 SYS.AUD\$1 表禁用审核
要在数据库审核跟踪表 `SYS.AUD$` 上禁用审核，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table`。此过程不需要任何参数。
以下查询返回数据库的 `SYS.AUD$` 的当前审核配置：
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
以下命令禁用 `ALL` 上的 `SYS.AUD$` 的审计。
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
有关更多信息，请参阅 Oracle 文档中的 [NOAUDIT（传统审核）](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/NOAUDIT-Traditional-Auditing.html#GUID-9D8EAF18-4AB3-4C04-8BF7-37BD0E15434D)。
# 清理中断的在线索引构建
要清理失败的在线索引构建，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_dbms_repair.online_index_clean`。
`online_index_clean` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | 否 | 索引的对象 ID。通常，您可以使用 ORA-08104 错误文本中的对象 ID。 |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | 否 | 指定 `rdsadmin.rdsadmin_dbms_repair.lock_wait`（默认值），尝试锁定底层对象，在锁定失败时重试，直至达到内部限制。 指定 `rdsadmin.rdsadmin_dbms_repair.lock_nowait`，尝试锁定底层对象，但在锁定失败时不重试。 |
下面的示例清理失败的在线索引构建：
```
declare
is_clean boolean;
begin
is_clean := rdsadmin.rdsadmin_dbms_repair.online_index_clean(
object_id => 1234567890,
wait_for_lock => rdsadmin.rdsadmin_dbms_repair.lock_nowait
);
end;
/
```
有关更多信息，请参阅 Oracle 文档中的 [ONLINE\$1INDEX\$1CLEAN 函数](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555)。
# 跳过损坏的数据块
要在索引和表扫描期间跳过损坏的数据块，请使用 `rdsadmin.rdsadmin_dbms_repair` 程序包。
下面的过程封装了 `sys.dbms_repair.admin_table` 过程的功能，并且不带任何参数：
+ `rdsadmin.rdsadmin_dbms_repair.create_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table`
下面的过程采用与其 Oracle 数据库 `DBMS_REPAIR` 程序包中的对应项相同的参数。
+ `rdsadmin.rdsadmin_dbms_repair.check_object`
+ `rdsadmin.rdsadmin_dbms_repair.dump_orphan_keys`
+ `rdsadmin.rdsadmin_dbms_repair.fix_corrupt_blocks`
+ `rdsadmin.rdsadmin_dbms_repair.rebuild_freelists`
+ `rdsadmin.rdsadmin_dbms_repair.segment_fix_status`
+ `rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks`
有关处理数据库损坏的更多信息，请参阅 Oracle 文档中的 [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948)。
**Example 响应损坏的数据块**
此示例显示了响应损坏的数据块的基本工作流程。您的步骤将取决于数据块损坏的位置和性质。
在尝试修复损坏的数据块之前，请仔细查看 [DBMS\$1RECH](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) 文档。
**在索引和表扫描期间跳过损坏的数据块**
1. 如果还没有修复表，则运行以下程序来创建修复表。
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. 运行以下程序以检查现有记录，适当时清除它们。
```
SELECT COUNT(*) FROM SYS.REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.ORPHAN_KEY_TABLE;
SELECT COUNT(*) FROM SYS.DBA_REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.DBA_ORPHAN_KEY_TABLE;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table;
```
1. 运行以下程序检查损坏的数据块。
```
SET SERVEROUTPUT ON
DECLARE v_num_corrupt INT;
BEGIN
v_num_corrupt := 0;
rdsadmin.rdsadmin_dbms_repair.check_object (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
corrupt_count => v_num_corrupt
);
dbms_output.put_line('number corrupt: '||to_char(v_num_corrupt));
END;
/
COL CORRUPT_DESCRIPTION FORMAT a30
COL REPAIR_DESCRIPTION FORMAT a30
SELECT OBJECT_NAME, BLOCK_ID, CORRUPT_TYPE, MARKED_CORRUPT,
CORRUPT_DESCRIPTION, REPAIR_DESCRIPTION
FROM SYS.REPAIR_TABLE;
SELECT SKIP_CORRUPT
FROM DBA_TABLES
WHERE OWNER = '&corruptionOwner'
AND TABLE_NAME = '&corruptionTable';
```
1. 使用 `skip_corrupt_blocks` 过程为受影响的表启用或禁用损坏跳过。根据具体情况，您可能还需要将数据提取到新表，然后删除包含损坏的数据块的表。
运行以下程序为受影响的表启用损坏跳过。
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.skip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
运行以下程序禁用损坏跳过。
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.noskip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
1. 完成所有修复工作后，运行以下过程删除修复表。
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## 清除回收站
删除表时，Oracle 数据库不会立即清除其存储空间。数据库将重命名表，并将其与所有关联的对象放在回收站中。清除回收站将删除这些项目并释放其存储空间。
要清除整个回收站，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.purge_dba_recyclebin`。但是，此过程无法清除回收站中的 `SYS` 和 `RDSADMIN` 对象。如果您需要清除这些对象，请联系 Amazon Support。
以下示例清除整个回收站。
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# 为全部编写设置原定设置显示值
要更改 Amazon RDS Oracle 实例上全部编写的原定设置显示值，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val`。请注意，您使用 `DBMS_REDACT` PL/SQL 包创建了一个编写策略，如 Oracle 数据库文档中所述。`dbms_redact_upd_full_rdct_val` 过程为受现有策略影响的不同数据类型指定要显示的字符。
`dbms_redact_upd_full_rdct_val` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_number_val` | 数字 | Null | 否 | 修改 `NUMBER` 数据类型的列的原定设置值。 |
| `p_binfloat_val` | binary\$1float | Null | 否 | 修改 `BINARY_FLOAT` 数据类型的列的原定设置值。 |
| `p_bindouble_val` | binary\$1double | Null | 否 | 修改 `BINARY_DOUBLE` 数据类型的列的原定设置值。 |
| `p_char_val` | char | Null | 否 | 修改 `CHAR` 数据类型的列的原定设置值。 |
| `p_varchar_val` | varchar2 | Null | 否 | 修改 `VARCHAR2` 数据类型的列的原定设置值。 |
| `p_nchar_val` | nchar | Null | 否 | 修改 `NCHAR` 数据类型的列的原定设置值。 |
| `p_nvarchar_val` | nvarchar2 | Null | 否 | 修改 `NVARCHAR2` 数据类型的列的原定设置值。 |
| `p_date_val` | date | Null | 否 | 修改 `DATE` 数据类型的列的原定设置值。 |
| `p_ts_val` | timestamp | Null | 否 | 修改 `TIMESTAMP` 数据类型的列的原定设置值。 |
| `p_tswtz_val` | timestamp with time zone | Null | 否 | 修改 `TIMESTAMP WITH TIME ZONE` 数据类型的列的原定设置值。 |
| `p_blob_val` | blob | Null | 否 | 修改 `BLOB` 数据类型的列的原定设置值。 |
| `p_clob_val` | clob | Null | 否 | 修改 `CLOB` 数据类型的列的原定设置值。 |
| `p_nclob_val` | nclob | Null | 否 | 修改 `NCLOB` 数据类型的列的原定设置值。 |
以下示例将 `CHAR` 数据类型的原定设置编写值更改为 \$1：
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
以下示例更改 `NUMBER`、`DATE` 和 `CHAR` 数据类型的原定设置编写值：
```
BEGIN
rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(
p_number_val=>1,
p_date_val=>to_date('1900-01-01','YYYY-MM-DD'),
p_varchar_val=>'X');
END;
/
```
使用 `dbms_redact_upd_full_rdct_val` 过程更改全部编写的原定设置值后，请重启数据库实例以使更改生效。有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
# 执行 Oracle 数据库实例的常见日志相关任务
下文中介绍了如何在运行 Oracle 的 Amazon RDS 数据库实例上，执行与日志记录相关的特定常见 DBA 任务。为了提供托管服务体验，Amazon RDS 不允许通过 shell 访问数据库实例，而仅限访问某些需要高级权限的系统过程和表。
有关更多信息，请参阅“[Amazon RDS for Oracle 数据库日志文件](USER_LogAccess.Concepts.Oracle.md)”。
**Topics**
+ [设置强制日志记录](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [设置补充日志记录](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [切换联机日志文件](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [添加联机重做日志](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [删除联机重做日志](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [调整联机重做日志的大小](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [保留存档重做日志](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [访问在线和存档的重做日志](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [从 Amazon S3 下载存档的重做日志](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## 设置强制日志记录
在强制日志记录模式下，Oracle 记录对数据库进行的所有更改，但在临时表空间和临时段中进行的更改除外 (忽略 `NOLOGGING` 子句)。有关更多信息，请参阅 Oracle 文档中的[指定“强制日志记录”模式](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096)。
要设置强制日志记录，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.force_logging`。`force_logging` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 是 | 描述 |
| --- | --- | --- | --- | --- |
| `p_enable` | 布尔值 | true | 否 | 设置为 `true`，数据库为强制日志记录模式；设置为 `false` 则取消数据库的强制日志记录模式。 |
以下示例将数据库置于强制日志记录模式下。
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## 设置补充日志记录
如果启用补充日志记录，则 LogMiner 将具有支持链接行和集群表的必要信息。有关更多信息，请参阅 Oracle 文档中的[补充日志记录](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582)。
Oracle 数据库在默认情况下不启用补充日志记录。要启用和禁用补充日志记录，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.alter_supplemental_logging`。有关 Amazon RDS 如何管理 Oracle 数据库实例的存档重做日志的保留期的更多信息，请参阅 [保留存档重做日志](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)。
`alter_supplemental_logging` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | 是 | 如果为 `'ADD'`，则添加补充日志记录；如果为 `'DROP'`，则删除补充日志记录。 |
| `p_type` | varchar2 | null | 否 | 补充日志记录的类型。有效值为 `'ALL'`、`'FOREIGN KEY'`、`'PRIMARY KEY'`、`'UNIQUE'` 或 `PROCEDURAL`。 |
以下示例启用补充日志记录。
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
以下示例为所有具有固定长度的最大大小列启用补充日志记录。
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
以下示例为主键列启用补充日志记录。
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## 切换联机日志文件
要切换日志文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.switch_logfile`。`switch_logfile` 过程没有参数。
以下示例切换日志文件。
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## 添加联机重做日志
运行 Oracle 的 Amazon RDS 数据库实例从四个联机重做日志 (每个日志的大小为 128 MB) 开始。要添加其他重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.add_logfile`。
`add_logfile` 过程具有以下参数。
**注意**
这些参数是互斥的。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `bytes` | positive | null | 否 | 日志文件的大小 (以字节为单位)。 仅当日志大小小于 2147483648 字节（2 GiB）时才使用此参数。否则，RDS 会发出错误。对于大于此字节值的日志大小，请改用 `p_size` 参数。 |
| `p_size` | varchar2 | — | 是 | 日志文件的大小，单位为 KB（K）、MB（M）或 GB（G）。 |
以下命令将添加一个 100MB 日志文件。
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## 删除联机重做日志
要删除重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.drop_logfile`。`drop_logfile` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `grp` | positive | — | 是 | 日志的组编号。 |
以下示例删除组编号为 3 的日志。
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
您只能删除具有未使用或不活动状态的日志。以下示例获取日志的状态。
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# 调整联机重做日志的大小
运行 Oracle 的 Amazon RDS 数据库实例从四个联机重做日志 (每个日志的大小为 128 MB) 开始。以下示例说明如何使用 Amazon RDS 过程将每个日志的大小从 128 MB 调整到 512 MB。
```
/* Query V$LOG to see the logs. */
/* You start with 4 logs of 128 MB each. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
/* Add four new logs that are each 512 MB */
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
/* Query V$LOG to see the logs. */
/* Now there are 8 logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Drop each inactive log using the group number. */
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 1);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 4);
/* Query V$LOG to see the logs. */
/* Now there are 5 logs. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 CURRENT
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Switch logs so that group 2 is no longer current. */
EXEC rdsadmin.rdsadmin_util.switch_logfile;
/* Query V$LOG to see the logs. */
/* Now one of the new logs is current. */
SQL>SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 ACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* If the status of log 2 is still "ACTIVE", issue a checkpoint to clear it to "INACTIVE". */
EXEC rdsadmin.rdsadmin_util.checkpoint;
/* Query V$LOG to see the logs. */
/* Now the final original log is inactive. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 INACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
# Drop the final inactive log.
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 2);
/* Query V$LOG to see the logs. */
/* Now there are four 512 MB logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
```
# 保留存档重做日志
您可以在数据库实例上本地保留存档的重做日志，以用于 Oracle LogMiner（`DBMS_LOGMNR`）这类产品。保留重做日志后，您可以使用 LogMiner 分析日子。有关更多信息，请参阅 Oracle 文档中的[使用 LogMiner 分析重做日志文件](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm)。
要保留存档的重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.set_configuration`。如果您在 Oracle Data Guard 中的主实例上使用此过程，则 RDS 会更改主实例和打开只读副本的存档日志保留设置，但不会更改已挂载副本上的设置。RDS 会短时间保留已挂载副本的最新存档重做日志。RDS 会自动删除下载到已挂载副本的较旧日志。
`set_configuration` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | 是 | 要更新的配置的名称。要更改已存档的重做日志的保留时间，请将名称设置为 `archivelog retention hours`。 |
| `value` | varchar | — | 是 | 该配置的值。设置日志要保留的小时数的值。 |
以下示例保留 24 小时的重做日志。
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**注意**
要使更改生效，必须执行提交操作。
要查看存档的重做日志为数据库实例保留多长时间，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.show_configuration`。
以下示例显示日志保留时间。
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
输出显示 `archivelog retention hours` 的当前设置。以下输出显示存档的重做日志保留 48 小时。
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
由于存档的重做日志保留在数据库实例中，因此，请确保数据库实例已为保留的日志分配足量的存储空间。要确定数据库实例上在最近 X 小时内使用的空间量，可以运行以下查询（将 X 替换为小时数）。
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
仅在数据库实例的备份保留期大于零时，RDS for Oracle 才会生成存档的重做日志。默认情况下，备份保留期大于零。
当存档的日志保留期过期时，RDS for Oracle 将从数据库实例中删除归档的重做日志。为支持将数据库实例还原到某个时间点，Amazon RDS 会根据备份保留期在数据库实例之外保留存档的重做日志。要修改备份保留期，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
**注意**
在一些情况下，您可以在 Linux 上使用 JDBC 下载存档重做日志并体验长延迟时间和连接重置。在此类情况下，您的 Java 客户端上的默认随机数字生成器设置可能会引发问题。我们建议您将 JDBC 驱动程序设置为使用非阻塞的随机数字生成器。
# 访问在线和存档的重做日志
您可能需要访问在线和存档重做日志文件，以供 GoldenGate、Attunity、Informatica 等外部工具进行挖掘。要访问这些文件，请执行以下操作：
1. 创建目录对象，对物理文件路径提供只读访问权限。
使用 `rdsadmin.rdsadmin_master_util.create_archivelog_dir` 和 `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`。
1. 使用 PL/SQL 读取文件。
您可以使用 PL/SQL 读取文件。有关从目录对象读取文件的更多信息，请参阅 [列出数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) 和 [读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
以下版本支持访问事务日志：
+ Oracle Database 21c
+ Oracle Database 19c
以下代码用于创建目录，为您的在线和存档重做日志文件提供只读访问权限。
**重要**
此代码还会撤销 `DROP ANY DIRECTORY` 权限。
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
以下代码会删掉在线和存档重做日志文件的目录。
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
以下代码用于授予和撤销 `DROP ANY DIRECTORY` 权限。
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# 从 Amazon S3 下载存档的重做日志
您可以使用 `rdsadmin.rdsadmin_archive_log_download` 软件包在数据库实例上下载存档的重做日志。如果存档的重做日志不再存在于数据库实例上，您可能需要从 Amazon S3 重新下载它们。然后，您可以挖掘日志或使用日志恢复或复制数据库。
**注意**
您无法在只读副本实例上下载存档的重做日志。
## 下载归档的重做日志：基本步骤
归档的重做日志的可用性取决于以下保留策略：
+ 备份保留策略 – Amazon S3 提供了此策略内的日志。此策略之外的日志将被删除。
+ 归档的日志保留策略 – 此策略内的日志在数据库实例上可用。此策略之外的日志将被删除。
如果日志不在您的实例上，但受到备份保留期的保护，请使用 `rdsadmin.rdsadmin_archive_log_download` 以重新下载。RDS for Oracle 会将日志保存到数据库实例的 `/rdsdbdata/log/arch` 目录。
**从 Amazon S3 下载归档的重做日志**
1. 配置您的保留期，以确保您下载的归档重做日志在您需要的时间内得到保留。请确保 `COMMIT` 您的更改。
RDS 根据归档日志保留策略保留您下载的日志，从下载日志之时开始。要了解如何设置保留策略，请参阅[保留存档重做日志](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)。
1. 最多等待 5 分钟，使归档的日志保留策略更改生效。
1. 使用 `rdsadmin.rdsadmin_archive_log_download` 从 Amazon S3 下载归档的重做日志。
有关更多信息，请参阅“[下载单个归档的重做日志](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log)”和“[下载一系列归档的重做日志](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series)”。
**注意**
RDS 在下载之前会自动检查可用的存储空间。如果请求的日志占用大量空间，您将收到警报。
1. 确认日志已成功从 Amazon S3 下载。
您可以查看 bdump 文件中的下载任务的状态。bdump 文件的路径名称为 `/rdsdbdata/log/trace/dbtask-task-id.log`。在前面的下载步骤中，您可以运行 `SELECT` 语句，该语句可返回 `VARCHAR2` 数据类型中的任务 ID。有关更多信息，请参阅[监控文件传输的状态](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status)中的类似示例。
## 下载单个归档的重做日志
要将单个归档的重做日志下载到 `/rdsdbdata/log/arch` 目录中，请使用 `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`。此过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `seqnum` | number | — | 是 | 归档的重做日志的序列号。 |
以下示例展示的是下载序列号为 20 的日志。
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## 下载一系列归档的重做日志
要将一系列归档的重做日志下载到 `/rdsdbdata/log/arch` 目录中，请使用 `download_logs_in_seqnum_range`。每个请求的下载限制为 300 个日志。`download_logs_in_seqnum_range` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `start_seq` | number | — | 是 | 系列的起始序列号。 |
| `end_seq` | number | — | 是 | 系列的结束序列号。 |
以下示例展示的是下载序列号为 50 至 100 的日志。
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# 执行 Oracle 数据库实例的常见 RMAN 任务
在下一节中，您可以了解如何在运行 Oracle 的 Amazon RDS 数据库实例上执行 Oracle Recovery Manager (RMAN) DBA 任务。为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。并且它还限制了对需要高级权限的某些系统程序和表的访问。
使用 Amazon RDS 包 `rdsadmin.rdsadmin_rman_util` 执行 Amazon RDS for Oracle 数据库到磁盘的 RMAN 备份。`rdsadmin.rdsadmin_rman_util` 包支持完整和增量数据库文件备份、表空间备份和归档重做日志备份。
在 RMAN 备份完成后，您可以从 Amazon RDS for Oracle 数据库实例主机复制备份文件。您可能出于还原到非 RDS 主机目的或出于长期存储备份目的而执行此操作。例如，您可以将备份文件复制到 Amazon S3 存储桶。有关更多信息，请参阅使用 [Amazon S3 集成](oracle-s3-integration.md)。
RMAN 备份的备份文件保留在 Amazon RDS 数据库实例主机上，直到您手动删除它们。您可以使用 `UTL_FILE.FREMOVE` Oracle 过程从目录中删除文件。有关更多信息，请参阅 Oracle 数据库文档中的 [FREMOVE 过程](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924)。
您不能使用 RMAN 还原 RDS for Oracle 数据库实例。但是，您可以使用 RMAN 将备份还原到本地或 Amazon EC2 实例。有关更多信息，请参阅博客文章[将 Amazon RDS for Oracle 实例还原到自行管理的实例](https://www.amazonaws.cn/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/)。
**注意**
要备份和还原到另一个 Amazon RDS for Oracle 数据库实例，您可以继续使用 Amazon RDS 备份和还原特征。有关更多信息，请参阅 [备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)。
**Topics**
+ [RMAN 备份的先决条件](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [在 RDS for Oracle 中验证数据库文件](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [启用和禁用数据块更改跟踪](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [反复检查存档重做日志](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [备份归档的重做日志文件](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [执行完整数据库备份](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [执行租户数据库的完整备份](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [执行增量数据库备份](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [执行租户数据库的增量备份](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [备份表空间](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [备份控制文件](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [执行块介质恢复](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# RMAN 备份的先决条件
在使用 `rdsadmin.rdsadmin_rman_util` 包备份数据库之前，请确保满足以下先决条件：
+ 确保您的 RDS for Oracle 数据库处于 `ARCHIVELOG` 模式。要启用此模式，请将备份保留期设置为非零值。
+ 在备份归档重做日志或执行包括归档重做日志的完整或增量备份时，以及在备份数据库时，请确保将重做日志保留期设置为非零值。需要归档重做日志才能在恢复期间保持数据库文件的一致性。有关更多信息，请参阅 [保留存档重做日志](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)。
+ 确保您的数据库实例有足够的可用空间来保存备份。备份数据库时，请将 Oracle 目录对象指定为过程调用中的一个参数。RMAN 将文件放在指定的目录中。您可以使用默认目录（如 `DATA_PUMP_DIR`），或创建新目录。有关更多信息，请参阅 [在主数据存储空间中创建和删除目录](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories)。
您可以使用 CloudWatch 指标 `FreeStorageSpace` 监控 RDS for Oracle 实例中的当前可用空间。尽管 RMAN 仅备份格式化的数据块并支持压缩，但我们建议您的可用空间超过数据库的当前大小。
# RMAN 过程的常见参数
您可以使用 Amazon RDS 包 `rdsadmin.rdsadmin_rman_util` 中的过程来通过 RMAN 执行任务。有几个参数是包中的过程通用的。该包具有以下常见参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | 有效的数据库目录名称。 | — | 是 | 包含备份文件的目录的名称。 |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | 否 | 包括在备份文件名中的唯一字符串。 限制为 30 个字符。 |
| `p_owner` | varchar2 | `p_directory_name` 中指定的目录的有效拥有者。 | — | 是 | 包含备份文件的目录的拥有者。 |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | 否 | 可用于区分备份的字符串，以便指示备份的目的或用法，例如每日备份、每周备份或增量级备份。 限制为 30 个字符。此标签不区分大小写。无论输入标签时使用的大小写如何，标签始终以大写形式存储。 标签不一定是唯一的，因此多个备份可以使用相同的标签。 如果未指定标签，则 RMAN 会使用 `TAGYYYYMMDDTHHMMSS` 格式自动分配默认标签，其中 *YYYY* 表示年份、*MM* 表示月份、*DD* 表示某天，*HH* 表示小时（采用 24 小时格式）、*MM* 表示分钟、*SS* 表示秒。日期和时间表示 RMAN 开始备份的时间。 例如，如果备份开始于 2019 年 9 月 27 日 21:45:17，则收到的标签可能为 `TAG20190927T214517`。 以下 Amazon RDS for Oracle 数据库引擎版本支持 `p_tag` 参数： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | 布尔值 | `TRUE`, `FALSE` | `FALSE` | 否 | 指定 `TRUE` 以启用基本备份压缩。 指定 `FALSE` 以禁用基本备份压缩。 |
| `p_include_archive_logs` | 布尔值 | `TRUE`, `FALSE` | `FALSE` | 否 | 指定 `TRUE` 以在备份中包括存档重做日志。 指定 `FALSE` 以从备份中排除存档重做日志。 如果您在备份中包括存档重做日志，请使用 `rdsadmin.rdsadmin_util.set_configuration` 过程将保留设置为一小时或更长时间。另外，就在要运行备份之前调用 `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` 过程。否则，由于缺少已被 Amazon RDS 管理过程删除的存档重做日志文件，备份可能会失败。 |
| `p_include_controlfile` | 布尔值 | `TRUE`, `FALSE` | `FALSE` | 否 | 指定 `TRUE` 以在备份中包括控制文件。 指定 `FALSE` 以从备份中排除控制文件。 |
| `p_optimize` | 布尔值 | `TRUE`, `FALSE` | `TRUE` | 否 | 指定 `TRUE` 以启用备份优化（如果包括存档重做日志）以减小备份大小。 指定 `FALSE` 以禁用备份优化。 |
| `p_parallel` | number | 对于 Oracle Database 企业版 (EE)，为介于 `1` 和 `254` 之间的有效整数。 `1`对于其他 Oracle Database 版本为 。 | `1` | 否 | 通道数。 |
| `p_rman_to_dbms_output` | 布尔值 | `TRUE`, `FALSE` | `FALSE` | 否 | 为 `TRUE` 时，在 `DBMS_OUTPUT` 目录中的文件之外，RMAN 输出还发送到 `BDUMP` 包。在 SQL\$1Plus 中，使用 `SET SERVEROUTPUT ON` 查看输出。 为 `FALSE` 时，RMAN 输出只发送到 `BDUMP` 目录中的文件。 |
| `p_section_size_mb` | number | 有效的整数 | `NULL` | 否 | 扇区大小，以兆字节 (MB) 为单位。 通过将每个文件拆分为指定扇区大小来并行验证。 为 `NULL` 时将忽略参数。 |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | 否 | 检测损坏的程度。 指定 `'PHYSICAL'` 检查物理损坏。物理损坏的例子包括数据块在标头和脚注中不匹配。 指定 `'PHYSICAL+LOGICAL'` 在物理损坏之外，还检查逻辑不一致的情况。逻辑损坏的例子包括数据块损坏。 |
# 在 RDS for Oracle 中验证数据库文件
您可以使用 Amazon RDS 包 `rdsadmin.rdsadmin_rman_util` 验证 Amazon RDS for Oracle 数据库文件，例如数据文件、表空间、控制文件以及服务器参数文件（SPFILE）。
有关 RMAN 验证的更多信息，请参阅[验证数据库文件和备份](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063)以及 Oracle 文档中的 [VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162)。
**Topics**
+ [验证数据库](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [验证租户数据库](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [验证表空间](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [验证控制文件](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [验证 SPFILE](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [验证 Oracle 数据文件](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## 验证数据库
要验证 RDS for Oracle 中的 Oracle 数据库使用的所有相关文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_database`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。
以下示例使用参数的默认值来验证数据库。
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
以下示例使用参数的指定值来验证数据库。
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_database(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
当 `p_rman_to_dbms_output` 参数设置为 `FALSE` 时，RMAN 输出写入到 `BDUMP` 目录中的文件。
要查看 `BDUMP` 目录中的文件，请运行以下 `SELECT` 语句。
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
要查看 `BDUMP` 目录中文件的内容，请运行以下 `SELECT` 语句。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
将文件名替换为您要查看的文件的名称。
## 验证租户数据库
要验证容器数据库（CDB）中租户数据库的数据文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_tenant`。
该过程仅适用于当前租户数据库，并使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。以下数据库引擎版本支持此过程：
+ Oracle Database 21c（21.0.0）CDB
+ Oracle Database 19c（19.0.0）CDB
以下示例使用参数的默认值来验证当前的租户数据库。
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
以下示例使用参数的指定值来验证当前的租户数据库。
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tenant(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
当 `p_rman_to_dbms_output` 参数设置为 `FALSE` 时，RMAN 输出写入到 `BDUMP` 目录中的文件。
要查看 `BDUMP` 目录中的文件，请运行以下 `SELECT` 语句。
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
要查看 `BDUMP` 目录中文件的内容，请运行以下 `SELECT` 语句。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
将文件名替换为您要查看的文件的名称。
## 验证表空间
要验证与表空间关联的文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_tablespace`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | 有效的空间表名称 | — | 是 | 表空间的名称。 |
## 验证控制文件
要仅验证 Amazon RDS Oracle 数据库实例使用的控制文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
## 验证 SPFILE
要仅验证 Amazon RDS Oracle 数据库实例使用的服务器参数文件 (SPFILE)，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_spfile`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。
## 验证 Oracle 数据文件
要验证数据文件，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.validate_datafile`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | 有效的数据文件 ID 编号或包含完整路径的有效数据文件名称 | — | 是 | 数据文件 ID 编号（来自 `v$datafile.file#`）或包含路径的完整数据文件名（来自 `v$datafile.name`）。 |
| `p_from_block` | number | 有效的整数 | `NULL` | 否 | 在数据文件中开始验证的块的编号。当这为 `NULL` 时，将使用 `1`。 |
| `p_to_block` | number | 有效的整数 | `NULL` | 否 | 在数据文件中结束验证的块的编号。当这为 `NULL` 时，将使用数据文件中的最大块。 |
# 启用和禁用数据块更改跟踪
数据库更改跟踪记录更改了跟踪文件中的数据块。此技术可以提高 RMAN 增量备份的性能。有关详细信息，请参阅 Oracle 数据库文档中的[使用数据块更改跟踪来提高增量备份性能](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A)。
只读副本不支持 RMAN 特征。但是，作为高可用性策略的一部分，您可以选择使用过程 `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking` 在只读副本中启用数据块跟踪。如果您将此只读副本提升为源数据库实例，则会为新的源实例启用数据块更改跟踪。因此，您的实例可以受益于快速的增量备份。
以下数据库引擎版本仅在企业版中支持数据块更改跟踪过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
**注意**
在单租户 CDB 中，以下操作有效，但没有客户可见的机制可以检测操作的当前状态。另请参阅 [RDS for Oracle CDB 的限制](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations)。
要为数据库实例启用数据块更改跟踪，您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`。要禁用数据块更改跟踪，请使用 `disable_block_change_tracking`。这些过程不需要任何参数。
要确定是否为您的数据库实例启用了块更改跟踪，请运行以下查询。
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
以下示例为数据库实例启用块更改跟踪。
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
以下示例为数据库实例禁用块更改跟踪。
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# 反复检查存档重做日志
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` 反复检查存档重做日志。
您可以使用此过程反复检查控制文件中注册的存档重做日志并可以选择删除过期的日志记录。当 RMAN 进行备份时，它会在控制文件中创建一条记录。随着时间的推移，这些记录会增加控制文件的大小。我们建议您定期删除过期的记录。
**注意**
标准 Amazon RDS 备份不使用 RMAN，因此不会在控制文件中创建记录。
该过程使用 RMAN 任务的常见参数 `p_rman_to_dbms_output`。
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | 布尔值 | `TRUE`, `FALSE` | `TRUE` | 否 | 当为 `TRUE` 时，从控制文件中删除过期的存档重做日志记录。 当为 `FALSE` 时，保留控制文件中过期的存档重做日志记录。 |
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
以下示例将控制文件中存档的重做日志记录标记为已过期，但不删除这些记录。
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
以下示例从控制文件中删除过期的存档重做日志记录。
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# 备份归档的重做日志文件
您可以使用 Amazon RDS 包 `rdsadmin.rdsadmin_rman_util` 备份 Amazon RDS Oracle 数据库实例的存档重做日志。
以下 Amazon RDS for Oracle 数据库引擎版本支持备份存档重做日志的过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
**Topics**
+ [备份所有存档重做日志](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [备份日期范围中的存档重做日志](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [备份 SCN 范围中的存档重做日志](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [备份序列号范围中的存档重做日志](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## 备份所有存档重做日志
要备份 Amazon RDS Oracle 数据库实例的所有存档重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
以下示例备份数据库实例的所有存档重做日志。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_all(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## 备份日期范围中的存档重做日志
要指定日期范围以备份 Amazon RDS Oracle 数据库实例的特定存档重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`。日期范围指定要备份哪些存档重做日志。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | 介于磁盘上存在的存档重做日志的 `start_date` 和 `next_date` 之间的日期。该值必须小于或等于为 `p_to_date` 指定的值。 | — | 是 | 存档日志备份的起始日期。 |
| `p_to_date` | date | 介于磁盘上存在的存档重做日志的 `start_date` 和 `next_date` 之间的日期。该值必须大于或等于为 `p_from_date` 指定的值。 | — | 是 | 存档日志备份的结束日期。 |
以下示例备份数据库实例的日期范围中的存档重做日志。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_date(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_date => '03/01/2019 00:00:00',
p_to_date => '03/02/2019 00:00:00',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## 备份 SCN 范围中的存档重做日志
要指定系统更改号 (SCN) 范围以备份 Amazon RDS Oracle 数据库实例的特定存档重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`。SCN 范围指定要备份哪些存档重做日志。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | number | 磁盘上存在的存档重做日志的 SCN。该值必须小于或等于为 `p_to_scn` 指定的值。 | — | 是 | 存档日志备份的起始 SCN。 |
| `p_to_scn` | number | 磁盘上存在的存档重做日志的 SCN。该值必须大于或等于为 `p_from_scn` 指定的值。 | — | 是 | 存档日志备份的结束 SCN。 |
以下示例备份数据库实例的 SCN 范围中的存档重做日志。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_scn(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_scn => 1533835,
p_to_scn => 1892447,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## 备份序列号范围中的存档重做日志
要指定序列号范围以备份 Amazon RDS Oracle 数据库实例的特定存档重做日志，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`。序列号范围指定要备份哪些存档重做日志。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | number | 磁盘上存在的存档重做日志的序列号。该值必须小于或等于为 `p_to_sequence` 指定的值。 | — | 是 | 存档日志备份的起始序列号。 |
| `p_to_sequence` | number | 磁盘上存在的存档重做日志的序列号。该值必须大于或等于为 `p_from_sequence` 指定的值。 | — | 是 | 存档日志备份的结束序列号。 |
以下示例备份数据库实例的序列号范围中的存档重做日志。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_sequence => 11160,
p_to_sequence => 11160,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 执行完整数据库备份
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_database_full` 执行备份中包括的所有数据块文件的备份。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
以下示例使用参数的指定值来执行数据库实例的完整备份。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 执行租户数据库的完整备份
您可以执行在容器数据库（CDB）中包括租户数据库的所有数据块的备份。适用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_tenant_full`。该过程仅适用于当前数据库备份，并使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。
以下 RDS for Oracle 数据库引擎版本支持 `rdsadmin_rman_util.backup_tenant_full` 过程：
+ Oracle Database 21c（21.0.0）CDB
+ Oracle Database 19c（19.0.0）CDB
以下示例使用参数的指定值来执行当前租户数据库的完整备份。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_TENANT_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 执行增量数据库备份
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_database_incremental` 执行数据库实例的增量备份。
有关增量备份的更多信息，请参阅 Oracle 文档中的[增量备份](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH)。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_level` | number | `0`, `1` | `0` | 否 | 指定 `0` 以启用完整增量备份。 指定 `1` 以启用非累积增量备份。 |
以下示例使用参数的指定值来执行数据库实例的增量备份。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 执行租户数据库的增量备份
您可以执行 CDB 中当前租户数据库的增量备份。适用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`。
有关增量备份的更多信息，请参阅 Oracle 数据库文档中的[增量备份](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH)。
该过程仅适用于当前租户数据库，并使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c（21.0.0）CDB
+ Oracle Database 19c（19.0.0）CDB
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_level` | number | `0`, `1` | `0` | 否 | 指定 `0` 以启用完整增量备份。 指定 `1` 以启用非累积增量备份。 |
以下示例使用参数的指定值来执行当前租户数据库的增量备份。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 备份表空间
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_tablespace` 备份表空间。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
此过程还使用以下其他参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | 有效的空间表名称。 | — | 是 | 要备份的表空间的名称。 |
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
以下示例使用参数的指定值来执行表空间备份。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tablespace(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tablespace_name => 'MYTABLESPACE',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MYTABLESPACE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 备份控制文件
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.backup_current_controlfile` 备份控制文件。
该过程使用 RMAN 任务的以下常见参数：
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
有关更多信息，请参阅“[RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)”。
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
以下示例使用参数的指定值来备份控制文件。
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_current_controlfile(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tag => 'CONTROL_FILE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# 执行块介质恢复
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_rman_util.recover_datafile_block` 恢复各个数据块，即块介质恢复。您可以使用此重载过程来恢复单个数据块或一系列数据块。
该过程使用 RMAN 任务的以下常见参数：
+ `p_rman_to_dbms_output`
有关更多信息，请参阅 [RMAN 过程的常见参数](Appendix.Oracle.CommonDBATasks.CommonParameters.md)。
此过程使用以下其它参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 说明 |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | 有效的数据文件 ID 号。 | — | 是 | 包含损坏块的数据文件。通过以下任一方式指定数据文件： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | 有效的整数。 | — | 是 | 要恢复的单个块的数量。 以下参数是互斥的： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | 有效的整数。 | — | 是 | 要恢复的一系列块中的第一个块编号。 以下参数是互斥的： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | 有效的整数。 | — | 是 | 要恢复的一系列块中的最后一个块编号。 以下参数是互斥的： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
以下 Amazon RDS for Oracle 数据库引擎版本支持此过程：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
以下示例恢复数据文件 5 中的块 100。
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
以下示例将数据文件 5 中的块 100 恢复为 150。
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_from_block => 100,
p_to_block => 150,
p_rman_to_dbms_output => TRUE);
END;
/
```
# 执行 Oracle 数据库实例的常见计划任务
某些 `SYS` 拥有的计划程序作业可能会影响正常的数据库操作。在这种情况下，Oracle 支持人员建议您修改计划。如果您需要启用或禁用 `SYS` 作业，请先在测试环境中测试对计划作业的操作，然后再在生产环境中实施它。要执行 `SYS` 拥有的 Oracle 计划程序作业的任务，请使用 Amazon RDS 包 `rdsadmin.rdsadmin_dbms_scheduler`。
下表所示的 Amazon RDS for Oracle 数据库引擎版本支持 `rdsadmin.rdsadmin_dbms_scheduler` 过程。使用此软件包时，您可以指定表中列出的 `SYS` 作业。
| 数据库版本 | 默认启用的作业 | 默认禁用的作业 |
| --- | --- | --- |
| Oracle Database 19c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
RSE$CLEAN_RECOVERABLE_SCRIPT
SM$CLEAN_AUTO_SPLIT_MERGE
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
XMLDB_NFS_CLEANUP_JOB
|
| Oracle Database 21c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
ORA$_ATSK_AUTOSTS
XMLDB_NFS_CLEANUP_JOB
|
## Oracle 计划程序过程的常见参数
要使用 Oracle 计划程序执行任务，请使用 Amazon RDS 包 `rdsadmin.rdsadmin_dbms_scheduler` 中的过程。有几个参数是包中的过程通用的。该包具有以下常见参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | [执行 Oracle 数据库实例的常见计划任务](#Appendix.Oracle.CommonDBATasks.Scheduler) 的表中列出的步骤 | — | 是 | 要修改的作业的名称。 |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | 是 | 要修改的属性。 要修改作业的重复间隔，请指定 `'REPEAT_INTERVAL'`。 要修改作业的计划名称，请指定 `'SCHEDULE_NAME'`。 |
| `value` | varchar2 | 有效的计划间隔或计划名称，具体取决于使用的属性。 | – | 是 | 新的属性值。 |
## 修改 DBMS\$1SCHEDULER 作业
要修改 Oracle Scheduler 的某些组件，使用 Oracle 过程 `dbms_scheduler.set_attribute`。有关更多信息，请参阅 Oracle 文档中的 [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) 和 [SET\$1ATTRIBUTE 过程](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399)。
在使用 Amazon RDS 数据库实例时，在对象名称前面加上架构名称 `SYS`。以下示例设置星期一窗口对象的资源计划属性。
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## 修改自动任务维护时段
Amazon RDS for Oracle 实例使用维护时段的默认设置创建。自动维护任务（如优化程序统计信息收集）在这些窗口中运行。默认情况下，维护时段会打开 Oracle 数据库资源管理器。
要修改时段，请使用 `DBMS_SCHEDULER` 程序包。出于以下原因，您可能需要修改维护时段设置：
+ 您希望维护作业在不同的时间运行，具有不同的设置，或根本不运行。例如，可能需要修改时段持续时间，或更改重复时间和间隔。
+ 您希望避免在维护期间启用资源管理器造成性能影响。例如，如果指定了默认维护计划，并且在数据库处于加载状态时打开维护时段，则可能会看到等待事件，例如 `resmgr:cpu quantum`。此等待事件与数据库资源管理器相关。您有以下选项：
+ 确保您的数据库实例的非高峰时段处于活动状态。
+ 禁用默认维护计划，方法是将 `resource_plan` 属性设置为空字符串。
+ 在参数组中将 `resource_manager_plan` 参数设置为 `FORCE:`。如果您的实例使用企业版，则此设置将阻止激活数据库资源管理器计划。
**修改维护时段设置**
1. 使用 Oracle SQL 客户端 Connect 到数据库。
1. 查询调度程序时段的当前配置。
以下示例查询 `MONDAY_WINDOW` 的配置。
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
以下输出显示该时段正在使用默认值。
```
ENABLED RESOURCE_PLAN DURATION REPEAT_INTERVAL
--------------- ------------------------------ ---------------- ------------------------------
TRUE DEFAULT_MAINTENANCE_PLAN +000 04:00:00 freq=daily;byday=MON;byhour=22
;byminute=0; bysecond=0
```
1. 使用 `DBMS_SCHEDULER` 程序包修改时段。
以下示例将资源计划设置为 null，以便资源管理器不会在维护时段期间运行。
```
BEGIN
-- disable the window to make changes
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
-- specify the empty string to use no plan
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'RESOURCE_PLAN', value=>'');
-- re-enable the window
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
以下示例将时段的最大持续时段设置为 2 小时。
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'DURATION', value=>'0 2:00:00');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
以下示例将重复间隔设置为每个星期一上午 10 点。
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'REPEAT_INTERVAL', value=>'freq=daily;byday=MON;byhour=10;byminute=0;bysecond=0');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
## 设置 Oracle Scheduler 作业的时区
要修改 Oracle Scheduler 的时区，您可以使用 Oracle 过程 `dbms_scheduler.set_scheduler_attribute`。有关 `dbms_scheduler` 程序包的更多信息，请参阅 Oracle 文档中的 [DBMS\$1SCHEDULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) 和 [SET\$1SCHEDULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907)。
**修改当前时区设置**
1. 使用客户端（例如 SQL Developer）连接到数据库。有关更多信息，请参阅“[使用 Oracle SQL Developer 连接到数据库实例](USER_ConnectToOracleInstance.SQLDeveloper.md)”。
1. 按如下所示设置默认时区，并将时区替换为 `time_zone_name`。
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
在以下示例中，您将时区更改为亚洲/上海。
首先查询当前时区，如下所示。
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
输出显示当前时区为 ETC/UTC。
```
VALUE
-------
Etc/UTC
```
然后，将时区设置为亚洲/上海。
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
有关更改系统时区的更多信息，请参阅 [Oracle 时区](Appendix.Oracle.Options.Timezone.md)。
## 关闭 SYS 拥有的 Oracle 计划程序任务
要禁用 SYS 用户拥有的 Oracle 计划程序任务，请使用 `rdsadmin.rdsadmin_dbms_scheduler.disable` 过程。
该过程在 Oracle 计划程序任务中使用 `name` 常见参数。有关更多信息，请参阅“[Oracle 计划程序过程的常见参数](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters)”。
以下示例禁用 `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle 计划程序作业。
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## 开启 SYS 拥有的 Oracle 计划程序任务
要开启 SYS 拥有的 Oracle 计划程序任务，请使用 `rdsadmin.rdsadmin_dbms_scheduler.enable` 过程。
该过程在 Oracle 计划程序任务中使用 `name` 常见参数。有关更多信息，请参阅“[Oracle 计划程序过程的常见参数](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters)”。
以下示例启用 `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle 计划程序作业。
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## 修改 CALENDAR 类型的任务的 Oracle 计划程序重复间隔
要修改重复间隔以修改 SYS 拥有的 `CALENDAR` 类型的 Oracle 计划程序作业，请使用 `rdsadmin.rdsadmin_dbms_scheduler.disable` 过程。
该过程在 Oracle 计划程序任务中使用以下常见参数：
+ `name`
+ `attribute`
+ `value`
有关更多信息，请参阅“[Oracle 计划程序过程的常见参数](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters)”。
以下示例修改 `SYS.CLEANUP_ONLINE_IND_BUILD` Oracle 计划程序作业的重复间隔。
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute(
name => 'SYS.CLEANUP_ONLINE_IND_BUILD',
attribute => 'repeat_interval',
value => 'freq=daily;byday=FRI,SAT;byhour=20;byminute=0;bysecond=0');
END;
/
```
## 修改 NAMED 类型的任务的 Oracle 计划程序重复间隔
某些 Oracle 计划程序作业使用计划名称而不是间隔。对于此类型的作业，您必须在主用户架构中创建新的命名计划。请使用标准 Oracle `sys.dbms_scheduler.create_schedule` 过程执行该操作。此外，还要使用 `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` 将新的命名计划分配给作业。
该过程在 Oracle 计划程序任务中使用以下常见参数：
+ `name`
+ `attribute`
+ `value`
有关更多信息，请参阅“[Oracle 计划程序过程的常见参数](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters)”。
以下示例修改 `SYS.BSLN_MAINTAIN_STATS_JOB` Oracle 计划程序作业的重复间隔。
```
BEGIN
DBMS_SCHEDULER.CREATE_SCHEDULE (
schedule_name => 'rds_master_user.new_schedule',
start_date => SYSTIMESTAMP,
repeat_interval => 'freq=daily;byday=MON,TUE,WED,THU,FRI;byhour=0;byminute=0;bysecond=0',
end_date => NULL,
comments => 'Repeats daily forever');
END;
/
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute (
name => 'SYS.BSLN_MAINTAIN_STATS_JOB',
attribute => 'schedule_name',
value => 'rds_master_user.new_schedule');
END;
/
```
## 在创建 Oracle 计划程序任务时关闭自动提交
当 `DBMS_SCHEDULER.CREATE_JOB` 创建 Oracle 计划程序任务时，它会立即创建任务并提交更改。要执行以下操作，可能需要将 Oracle 计划程序任务的创建合并到用户事务中：
+ 回滚用户事务时，回滚 Oracle 计划程序任务。
+ 提交主用户事务时，创建 Oracle 计划程序任务。
可以使用过程 `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` 开启此行为。此过程不需要任何参数。您可以在以下 RDS for Oracle 版本中使用此过程：
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 及更高版本
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 及更高版本
以下示例关闭 Oracle 计划程序的自动提交，创建 Oracle 计划程序任务，然后回滚事务。由于自动提交已关闭，因此数据库还会回滚 Oracle 计划程序任务的创建。
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag;
DBMS_SCHEDULER.CREATE_JOB(job_name => 'EMPTY_JOB',
job_type => 'PLSQL_BLOCK',
job_action => 'begin null; end;',
auto_drop => false);
ROLLBACK;
END;
/
PL/SQL procedure successfully completed.
SELECT * FROM DBA_SCHEDULER_JOBS WHERE JOB_NAME='EMPTY_JOB';
no rows selected
```
# 诊断 RDS for Oracle 数据库实例的问题
Oracle 数据库包括一个故障诊断基础设施，可用于调查数据库问题。在 Oracle 术语中，*问题* 是严重错误，如代码错误或数据损坏。*事件* 是指问题的发生。如果同一错误发生三次，则基础设施会显示此问题的三个事件。有关更多信息，请参阅 Oracle 数据库文档中的[诊断和解决问题](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) 。
自动诊断存储库命令解释器 (ADRCI) 实用程序是用于管理诊断数据的 Oracle 命令行工具。例如，您可以使用此工具调查问题并打包诊断数据。*事件包* 包括引用特定问题的一个或所有事件的诊断数据。您可以将事件包（作为 .zip 文件实现）上传到 Oracle 支持部门。
为了提供托管服务体验，Amazon RDS 未向 Shell 提供对于 ADRCI 的访问权限。要为 RDS for Oracle 实例执行诊断任务，请使用 Amazon RDS 程序包 `rdsadmin.rdsadmin_adrci_util`。
通过使用 `rdsadmin_adrci_util` 中的函数，您可以列出和打包问题和事件，还可以显示跟踪文件。所有函数都返回一个任务 ID。此 ID 构成包含 ADRCI 输出的日志文件名称的一部分，如 `dbtask-task_id.log` 中所示。日志文件位于 BDUMP 目录中。您可以按照[下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)中描述的过程下载日志文件。
## 诊断过程的常见参数
要执行诊断任务，请使用 Amazon RDS 程序包 `rdsadmin.rdsadmin_adrci_util` 中的函数。该包具有以下常见参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | number | 有效的事件 ID 或 Null | Null | 否 | 如果值为 Null，函数将显示所有事件。如果值不为 Null 并且表示有效的事件 ID，则函数将显示指定的事件。 |
| `problem_id` | number | 有效的问题 ID 或 Null | Null | 否 | 如果值为 Null，则函数显示所有问题。如果该值不为 Null 并表示有效的问题 ID，则函数将显示指定的问题。 |
| `last` | number | 大于 0 或 Null 的有效整数 | Null | 否 | 如果值为 Null，则函数最多显示 50 个项目。如果值不为 Null，则函数显示指定的数字。 |
## 列出事件
要列出 Oracle 的诊断事件，请使用 Amazon RDS 函数 `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`。您可以在基本模式或详细模式下列出事件。默认情况下，函数会列出 50 个最近的事件。
此函数使用以下常见参数：
+ `incident_id`
+ `problem_id`
+ `last`
如果您指定 `incident_id` 和 `problem_id`，则 `incident_id` 覆盖 `problem_id`。有关更多信息，请参阅 [诊断过程的常见参数](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters)。
此函数使用以下附加参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `detail` | 布尔值 | TRUE 或者 FALSE | `FALSE` | 否 | 如果为 `TRUE`，函数将以详细模式列出事件。如果为 `FALSE`，函数将以基本模式列出事件。 |
要列出所有事件，请不带任何参数查询 `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` 函数。查询将返回任务 ID。
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
或者，不带任何参数调用 `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` 函数，并将输出存储在 SQL 客户端变量中。您可以在其他语句中使用该变量。
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
要读取日志文件，请调用 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file`。提供任务 ID 作为文件名的一部分。下面的输出显示三个事件：53523、53522 和 53521。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:11:46.193 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:11:46.256 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
----------- ----------------------------------------------------------- ----------------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
53522 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 2020-05-29 20:15:15.247000 +00:00
53521 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:11:46.256 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:11:46.256 UTC [INFO ] The task finished successfully.
14 rows selected.
```
要列出特定事件，请使用 `incident_id` 参数指定事件 ID。在以下示例中，您只查询日志文件以搜索事件 53523。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents(incident_id=>53523);
PL/SQL procedure successfully completed.
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------
2020-05-29 21:15:25.358 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:15:25.426 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
-------------------- ----------------------------------------------------------- ---------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
1 rows fetched
2020-05-29 21:15:25.427 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:15:25.427 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## 列出问题
要列出 Oracle 的诊断问题，请使用 Amazon RDS 函数 `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`。
默认情况下，函数列出 50 个最近的问题。
此函数使用公用参数 `problem_id` 和 `last`。有关更多信息，请参阅 [诊断过程的常见参数](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters)。
要获取所有问题的任务 ID，请不带任何参数调用 `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` 函数，并将输出存储在 SQL 客户端变量中。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
要读取日志文件，请调用 `rdsadmin.rds_file_util.read_text_file` 函数，同时提供任务 ID 作为文件名的一部分。在以下输出中，日志文件显示三个问题：1、2 和 3。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
----------------------------------------------------------------------------------------------------------------------
2020-05-29 21:18:50.764 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:18:50.829 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
2 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 53523 2020-05-29 20:15:20.928000 +00:00
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 53521 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:18:50.829 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:18:50.829 UTC [INFO ] The task finished successfully.
14 rows selected.
```
在下面的示例中，您只列出问题 3。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
要读取问题 3 的日志文件，请调用 `rdsadmin.rds_file_util.read_text_file`。提供任务 ID 作为文件名的一部分。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------
2020-05-29 21:19:42.533 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:19:42.599 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 rows fetched
2020-05-29 21:19:42.599 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:19:42.599 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## 创建事件包
您可以使用 Amazon RDS 函数创建事件包 `rdsadmin.rdsadmin_adrci_util.create_adrci_package`。输出是一个 .zip 文件，您可以将其提供给 Oracle 支持部门。
此函数使用以下常见参数：
+ `problem_id`
+ `incident_id`
确保指定前面的参数之一。如果指定了两个参数，则 `incident_id` 覆盖 `problem_id`。有关更多信息，请参阅“[诊断过程的常见参数](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters)”。
要为特定事件创建包，请使用 `rdsadmin.rdsadmin_adrci_util.create_adrci_package` 参数调用 Amazon RDS 函数 `incident_id`。以下示例为事件 53523 创建一个包。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
要读取日志文件，请调用 `rdsadmin.rds_file_util.read_text_file`。您可以将任务 ID 作为文件名的一部分提供。输出显示您生成了事件包 `ORA700EVE_20200529212043_COM_1.zip`。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
--------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:20:43.031 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:20:47.641 UTC [INFO ] Generated package 1 in file /rdsdbdata/log/trace/ORA700EVE_20200529212043_COM_1.zip, mode complete
2020-05-29 21:20:47.642 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:20:47.642 UTC [INFO ] The task finished successfully.
```
要打包特定问题的诊断数据，请使用 `problem_id` 参数指定其 ID。在以下示例中，您仅打包问题 3 的数据。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
要读取任务输出，请调用 `rdsadmin.rds_file_util.read_text_file`，同时提供任务 ID 作为文件名的一部分。输出显示您生成了事件包 `ORA700EVE_20200529212111_COM_1.zip`。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:21:11.050 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:21:15.646 UTC [INFO ] Generated package 2 in file /rdsdbdata/log/trace/ORA700EVE_20200529212111_COM_1.zip, mode complete
2020-05-29 21:21:15.646 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:21:15.646 UTC [INFO ] The task finished successfully.
```
还可以下载日志文件。有关更多信息，请参阅 [下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)。
## 显示跟踪文件
您可以使用 Amazon RDS 函数 `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` 列出跟踪目录下的跟踪文件以及当前 ADR 主目录下的所有事件目录。还可以显示跟踪文件和事件跟踪文件的内容。
此函数使用以下参数。
****
| 参数名称 | 数据类型 | 有效值 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | 有效的跟踪文件名 | Null | 否 | 如果值为 Null，函数将显示所有跟踪文件。如果不为 Null，则函数显示指定的文件。 |
要显示跟踪文件，请调用 Amazon RDS 函数 `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile`。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
要列出跟踪文件名，请调用 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file`，同时提供任务 ID 作为文件名的一部分。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE TEXT LIKE '%/alert_%';
TEXT
---------------------------------------------------------------
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-28
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-27
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-26
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-25
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-24
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-23
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-22
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-21
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log
9 rows selected.
```
在以下示例中，您将为 `alert_ORCL.log` 生成输出。
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile('diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log');
PL/SQL procedure successfully completed.
```
要读取日志文件，请调用 `rdsadmin.rds_file_util.read_text_file`。提供任务 ID 作为文件名的一部分。输出显示 alert\$1ORCL.log 的前 10 行。
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE ROWNUM <= 10;
TEXT
-----------------------------------------------------------------------------------------
2020-05-29 21:24:02.083 UTC [INFO ] The trace files are being displayed.
2020-05-29 21:24:02.128 UTC [INFO ] Thu May 28 23:59:10 2020
Thread 1 advanced to log sequence 2048 (LGWR switch)
Current log# 3 seq# 2048 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_3_hbl2p8xs_.log
Thu May 28 23:59:10 2020
Archived Log entry 2037 added for thread 1 sequence 2047 ID 0x5d62ce43 dest 1:
Fri May 29 00:04:10 2020
Thread 1 advanced to log sequence 2049 (LGWR switch)
Current log# 4 seq# 2049 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_4_hbl2qgmh_.log
Fri May 29 00:04:10 2020
10 rows selected.
```
还可以下载日志文件。有关更多信息，请参阅 [下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)。
# 执行 Oracle 数据库实例的其他任务
下文中介绍了如何在运行 Oracle 的 Amazon RDS 数据库实例上执行其他 DBA 任务。为了提供托管服务体验，Amazon RDS 不允许通过 shell 访问数据库实例，而仅限访问某些需要高级权限的系统过程和表。
**Topics**
+ [在主数据存储空间中创建和删除目录](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [列出数据库实例目录中的文件](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [读取数据库实例目录中的文件](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [访问 Opatch 文件](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [管理顾问任务](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [传输表空间](rdsadmin_transport_util.md)
## 在主数据存储空间中创建和删除目录
要创建目录，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.create_directory`。您可以创建最多 10000 个目录 (全部位于主数据存储空间中)。要删除目录，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.drop_directory`。
`create_directory` 和 `drop_directory` 过程具有以下必需参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | 是 | 目录的名称。 |
以下示例创建一个名为 `PRODUCT_DESCRIPTIONS` 的新目录。
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
数据字典以大写形式存储目录名称。您可以通过查询 `DBA_DIRECTORIES` 列出目录。系统将自动选择实际主机路径名称。以下示例获取名为 `PRODUCT_DESCRIPTIONS` 的目录的目录路径：
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
数据库实例的主用户名在新目录中拥有读取和写入权限，可以向其他用户授予访问权限。`EXECUTE` 权限不可用于数据库实例上的目录。目录在您的主数据存储空间中创建，将占用空间和 I/O 带宽。
以下示例删除名为 `PRODUCT_DESCRIPTIONS` 的目录。
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**注意**
还可以使用 Oracle SQL 命令 `DROP DIRECTORY` 删除目录。
删除目录不会删除其内容。由于 `rdsadmin.rdsadmin_util.create_directory` 过程可重用路径名称，因此，删除的目录中的文件会显示在新创建的目录中。在您删除目录之前，我们建议您使用 `UTL_FILE.FREMOVE` 从目录中删除文件。有关更多信息，请参阅 Oracle 文档中的 [FREMOVE 过程](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924)。
## 列出数据库实例目录中的文件
要列出目录中的文件，请使用 Amazon RDS 过程 `rdsadmin.rds_file_util.listdir`。Oracle 副本不支持此过程。`listdir` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | 是 | 要列出的目录的名称。 |
以下示例将目录 `PRODUCT_DESCRIPTIONS` 的读/写权限授予用户 `rdsadmin`，然后列出此目录中的文件。
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## 读取数据库实例目录中的文件
要读取文本文件，请使用 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file`。`read_text_file` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | 是 | 包含文件的目录的名称。 |
| `p_filename` | varchar2 | — | 是 | 要读取的文件的名称。 |
以下示例在 `rice.txt` 目录中创建 `PRODUCT_DESCRIPTIONS` 文件。
```
declare
fh sys.utl_file.file_type;
begin
fh := utl_file.fopen(location=>'PRODUCT_DESCRIPTIONS', filename=>'rice.txt', open_mode=>'w');
utl_file.put(file=>fh, buffer=>'AnyCompany brown rice, 15 lbs');
utl_file.fclose(file=>fh);
end;
/
```
以下示例读取目录 `rice.txt` 中的文件 `PRODUCT_DESCRIPTIONS`。
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## 访问 Opatch 文件
Opatch 是一个 Oracle 实用程序，可用于将修补程序应用和回滚到 Oracle 软件。用于确定哪些修补程序已应用于数据库的 Oracle 机制是 `opatch lsinventory` 命令。为了向自带许可 (BYOL) 客户打开服务请求，Oracle 支持部门会请求 `lsinventory` 文件，有时还请求由 Opatch 生成的 `lsinventory_detail` 文件。
为提供托管服务体验，Amazon RDS 未提供对 Opatch 的 Shell 访问权限。相反，`lsinventory-dbv.txt` 包含与当前引擎版本相关的修补程序信息。当您执行次要或主要升级时，Amazon RDS 会在应用补丁后的一小时内更新 `lsinventory-dbv.txt`。要验证应用的补丁，请参阅`lsinventory-dbv.txt`。该操作类似于运行 `opatch lsinventory` 命令。
**注意**
本节中的示例假定 BDUMP 目录名为 `BDUMP`。在只读副本上，BDUMP 目录名称不同。要了解如何通过对只读副本查询 `V$DATABASE.DB_UNIQUE_NAME` 来获取 BDUMP 名称，请参阅[列出文件](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest)。
清单文件使用 Amazon RDS 命名约定 `lsinventory-dbv.txt` 和 `lsinventory_detail-dbv.txt`，其中 *dbv* 是数据库版本的全名。`lsinventory-dbv.txt` 文件在所有数据库版本上均可用。对应的 `lsinventory_detail-dbv.txt` 在 19.0.0.0、ru-2020-01.rur-2020-01.r1 或更高版本上可用。
例如，如果您的数据库版本为 19.0.0.0.ru-2021-07.rur-2021-07.r1，则您的清单文件具有以下名称。
```
lsinventory-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
lsinventory_detail-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
```
确保下载与当前版本的数据库引擎匹配的文件。
### 控制台
**使用控制台下载清单文件**
1. 通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择要查看其日志文件的数据库实例的名称。
1. 选择 **Logs & events (日志和事件)** 选项卡。
1. 向下滚动到**日志**部分。
1. 在**日志**部分中，搜索 `lsinventory`。
1. 选择要访问的文件，然后选择**下载**。
### SQL
要在 SQL 客户端中读取 `lsinventory-dbv.txt`，您可以使用 `SELECT` 语句。对于此技术，请使用以下任一 `rdsadmin` 函数：`rdsadmin.rds_file_util.read_text_file` 或 `rdsadmin.tracefile_listing`。
在下面的示例查询中，将 *dbv* 替换为您的 Oracle 数据库版本。例如，您的数据库版本可能是 19.0.0.0.ru-2020-04.rur-2020-04.r1。
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
要在 SQL 客户端中读取 `lsinventory-dbv.txt`，您可以编写 PL/SQL 程序。此程序使用 `utl_file` 读取文件，并使用 `dbms_output` 打印文件。这些是 Oracle 提供的程序包。
在下面的示例程序中，将 *dbv* 替换为您的 Oracle 数据库版本。例如，您的数据库版本可能是 19.0.0.0.ru-2020-04.rur-2020-04.r1。
```
SET SERVEROUTPUT ON
DECLARE
v_file SYS.UTL_FILE.FILE_TYPE;
v_line VARCHAR2(1000);
v_oracle_home_type VARCHAR2(1000);
c_directory VARCHAR2(30) := 'BDUMP';
c_output_file VARCHAR2(30) := 'lsinventory-dbv.txt';
BEGIN
v_file := SYS.UTL_FILE.FOPEN(c_directory, c_output_file, 'r');
LOOP
BEGIN
SYS.UTL_FILE.GET_LINE(v_file, v_line,1000);
DBMS_OUTPUT.PUT_LINE(v_line);
EXCEPTION
WHEN no_data_found THEN
EXIT;
END;
END LOOP;
END;
/
```
或者，查询 `rdsadmin.tracefile_listing`，并将输出后台打印到一个文件。以下示例将输出后台打印到 `/tmp/tracefile.txt`。
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## 管理顾问任务
Oracle 数据库中包含许多顾问。每个顾问都支持自动化任务和手动任务。您可以使用 `rdsadmin.rdsadmin_util` 程序包中的过程来管理一些顾问任务。
以下引擎版本中提供了顾问任务过程：
+ Oracle Database 21c (21.0.0)
+ 版本 19.0.0.0.ru-2021-01.rur-2021-01.r1 及更高 Oracle Database 19c 版本
有关更多信息，请参阅《Amazon RDS for Oracle 发布说明》中的[版本 19.0.0.0.ru-2021-01.rur-2021-01.r1](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2021-01.rur-2021-01.r1)**。
**Topics**
+ [设置顾问任务参数](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [禁用 AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [重新启用 AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### 设置顾问任务参数
要为某些顾问任务设置参数，请使用 Amazon RDS 程序 `rdsadmin.rdsadmin_util.advisor_task_set_parameter`。`advisor_task_set_parameter` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | 是 | 要更改其参数的顾问任务的名称。有效值有： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | 是 | 任务参数的名称。要查找顾问任务的有效参数，请运行以下查询。将 *p\$1task\$1name* 替换为 `p_task_name` 的有效值： COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
| `p_value` | varchar2 | — | 是 | 任务参数的值。要查找任务参数的有效值，请运行以下查询。将 *p\$1task\$1name* 替换为 `p_task_name` 的有效值： COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
对于 `ACCEPT_PLANS`，以下 PL/SQL 程序可将 `FALSE` 设置为 `SYS_AUTO_SPM_EVOLVE_TASK`。SQL Plan Management 自动化任务可验证计划并生成其调查结果的报告，但不会自动发展计划。您可以使用报告来识别新的 SQL 计划基准并手动接受它们。
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
对于 `EXECUTION_DAYS_TO_EXPIRE`，以下 PL/SQL 程序可将 `10` 设置为 `AUTO_STATS_ADVISOR_TASK`。预定义的任务 `AUTO_STATS_ADVISOR_TASK` 每天在维护时段自动运行一次。该示例将任务执行的保留周期设置为 10 天。
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'AUTO_STATS_ADVISOR_TASK',
p_parameter => 'EXECUTION_DAYS_TO_EXPIRE',
p_value => '10');
END;
```
### 禁用 AUTO\$1STATS\$1ADVISOR\$1TASK
要禁用 `AUTO_STATS_ADVISOR_TASK`，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.advisor_task_drop`。`advisor_task_drop` 过程接受以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | 是 | 要禁用的顾问任务的名称。唯一有效值为 `AUTO_STATS_ADVISOR_TASK`。 |
以下命令可删除 `AUTO_STATS_ADVISOR_TASK`。
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
您可以使用 `rdsadmin.rdsadmin_util.dbms_stats_init` 重新启用 `AUTO_STATS_ADVISOR_TASK`。
### 重新启用 AUTO\$1STATS\$1ADVISOR\$1TASK
要重新启用 `AUTO_STATS_ADVISOR_TASK`，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.dbms_stats_init`。`dbms_stats_init` 过程不需要任何参数。
以下命令可重新启用 `AUTO_STATS_ADVISOR_TASK`。
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# 传输表空间
使用 Amazon RDS 包 `rdsadmin.rdsadmin_transport_util` 将一组表空间从本地 Oracle 数据库复制到 RDS for Oracle 数据库实例。在物理层，可传输的表空间功能以递增方式将源数据文件和元数据文件复制到您的目标实例。您可以使用 Amazon EFS 或 Amazon S3 传输文件。有关更多信息，请参阅 [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)。
**Topics**
+ [将传输的表空间导入到您的数据库实例](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [将可传输的表空间元数据导入到数据库实例中](rdsadmin_transport_util_import_xtts_metadata.md)
+ [列出表空间导入后的孤立文件](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [表空间导入后的孤立数据文件](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# 将传输的表空间导入到您的数据库实例
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 还原您之前从源数据库实例导出的表空间。在传输阶段中，您将备份只读表空间，导出 Data Pump 元数据，将这些文件传输到目标数据库实例，然后导入表空间。有关更多信息，请参阅 [阶段 4：传输表空间](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase)。
## 语法
```
FUNCTION import_xtts_tablespaces(
p_tablespace_list IN CLOB,
p_directory_name IN VARCHAR2,
p_platform_id IN NUMBER DEFAULT 13,
p_parallel IN INTEGER DEFAULT 0) RETURN VARCHAR2;
```
## 参数
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | 是 | 要导入的表空间列表。 |
| `p_directory_name` | `VARCHAR2` | — | 是 | 包含表空间备份的目录。 |
| `p_platform_id` | `NUMBER` | `13` | 否 | 提供与在备份阶段中指定的平台 ID 相匹配的平台 ID。要查找平台的列表，请查询 `V$TRANSPORTABLE_PLATFORM`。原定设置平台是 Linux x86 64 位，以 little endian 格式表示。 |
| `p_parallel` | `INTEGER` | `0` | 否 | 并行度。原定设置情况下，并行度处于禁用状态。 |
## 示例
以下示例从 *DATA\$1PUMP\$1DIR* 目录中导入表空间 *TBS1*、*TBS2* 和 *TBS3*。源平台是基于 AIX 的系统（64 位），其平台 ID 为 `6`。您可以通过查询 `V$TRANSPORTABLE_PLATFORM` 查找平台 ID。
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
# 将可传输的表空间元数据导入到数据库实例中
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` 将可传输的表空间元数据导入您的 RDS for Oracle 数据库实例。在操作期间，元数据导入的状态显示在表 `rdsadmin.rds_xtts_operation_info` 中。有关更多信息，请参阅 [步骤 5：在目标数据库实例上导入表空间元数据](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp)。
## 语法
```
PROCEDURE import_xtts_metadata(
p_datapump_metadata_file IN SYS.DBA_DATA_FILES.FILE_NAME%TYPE,
p_directory_name IN VARCHAR2,
p_exclude_stats IN BOOLEAN DEFAULT FALSE,
p_remap_tablespace_list IN CLOB DEFAULT NULL,
p_remap_user_list IN CLOB DEFAULT NULL);
```
## 参数
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | 是 | 包含可传输表空间的元数据的 Oracle Data Pump 文件的名称。 |
| `p_directory_name` | `VARCHAR2` | — | 是 | 包含 Data Pump 文件的目录。 |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | 否 | 指示是否排除统计数据的标志。 |
| `p_remap_tablespace_list` | `CLOB` | NULL | 否 | 要在元数据导入期间重新映射的表空间列表。采用格式 `from_tbs:to_tbs`。例如，指定 `users:user_data`。 |
| `p_remap_user_list` | `CLOB` | NULL | 否 | 要在元数据导入期间重新映射的用户架构列表。采用格式 `from_schema_name:to_schema_name`。例如，指定 `hr:human_resources`。 |
## 示例
该示例从文件 *xttdump.dmp* 导入表空间元数据，该文件位于目录 *DATA\$1PUMP\$1DIR* 中。
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# 列出表空间导入后的孤立文件
使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程列出表空间导入后孤立的数据文件。确定数据文件后，可以通过调用 `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` 将其删除。
## 语法
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## 示例
以下示例运行过程 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`。输出显示了两个孤立的数据文件。
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# 表空间导入后的孤立数据文件
使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程删除表空间导入后孤立的数据文件。运行此命令会在 `BDUMP` 目录中生成一个使用名称格式 `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` 的日志文件。使用过程 `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` 找出孤立的文件。您可以通过调用过程 `rdsadmin.rds_file_util.read_text_file` 来读取日志文件。有关更多信息，请参阅 [第 6 阶段：清理剩余文件](oracle-migrating-tts.md#oracle-migrating-tts.cleanup)。
## 语法
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## 参数
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | 是 | 包含孤立数据文件的目录。 |
## 示例
以下示例删除了 *DATA\$1PUMP\$1DIR* 中的孤立数据文件。
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
以下示例读取了由上一个命令生成的日志文件。
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
# 在 RDS for Oracle 中使用存储
每个 RDS for Oracle 实例都有一个主存储卷。要增加存储容量，最多可以将三个附加存储卷连接到数据库实例。根据您的工作负载要求，对于每个卷在 gp3 和 io2 存储之间进行选择。例如，您可以将经常访问的数据放在 io2 卷上，而将历史数据放在 gp3 卷上。
使用附加存储卷可实现以下优势：
+ **增强的容量**：通过连接最多三个附加存储卷，将每个数据库实例的总存储量扩展到多达 256 TiB。
+ **灵活的存储配置和性能优化**：混合不同的存储类型（gp3 和 io2），以根据您的数据访问模式优化成本和性能。将高性能 io2 存储上频繁访问的数据与经济实惠的 gp3 存储上的归档数据分开。
+ **根据需要扩展和减少存储容量**：在需要附加存储空间时连接卷（例如在数据迁移期间），之后删除该卷。通过这种方式，您可以扩展和减少数据库实例的总存储空间。
+ **联机数据移动**：使用 Oracle 数据库的内置功能，无需停机即可在卷之间移动数据。
**注意**
您可以移除附加存储卷，但不能移除主卷。
**Topics**
+ [将附加存储卷与 RDS for Oracle 结合使用的注意事项](#User_Oracle_AdditionalStorage.considerations)
+ [将附加存储卷与 RDS for Oracle 结合使用的限制](#User_Oracle_AdditionalStorage.limitations)
+ [在 RDS for Oracle 中对附加存储卷执行数据库管理操作](#User_Oracle_AdditionalStorage.DBManagement)
+ [使用 RDS for Oracle 添加、移除或修改存储卷](User_Oracle_AdditionalStorage.ModifyStorageVolumes.md)
+ [在 RDS for Oracle 中使用附加存储卷备份和还原数据](User_Oracle_AdditionalStorage.BackupRestore.md)
+ [RDS for Oracle 中附加存储卷的使用案例](User_Oracle_AdditionalStorage.UseCases.md)
## 将附加存储卷与 RDS for Oracle 结合使用的注意事项
将附加存储卷与 RDS for Oracle 结合使用时，请考虑以下事项：
+ 您最多可以为每个实例添加 3 个附加存储卷。
+ 附加存储卷必须使用以下卷名称：
+ rdsdbdata2
+ rdsdbdata3
+ rdsdbdata4
+ 您只能添加通用型 SSD（gp3）和预调配 IOPS SSD（io2）存储类型。
+ 在应用程序继续运行的同时，您可以使用 Oracle 的联机重新放置功能在卷之间移动数据。
+ 当您通过修改数据库实例来创建附加存储卷时，无论计划修改设置如何，RDS 都会立即创建存储卷。添加存储卷是一项联机操作，不会影响数据库性能。请参阅[使用计划修改设置](USER_ModifyInstance.ApplyImmediately.md)。
要获得最佳性能，请在使用附加存储卷时检查以下各项：
+ 数据移动规划
+ 在非高峰时段安排大型移动
+ 将大型操作分成较小的分块
+ 在移动过程中监控系统资源
+ 资源管理
+ 在两个卷上保留足够的可用空间
+ 使用 AWR 或 Statspack 监控 I/O 模式
+ 监视是否发生存储空间已满的情形
+ 最佳实践
+ 尽可能使用联机数据文件重新放置操作
+ 维护适当的索引
+ 定期监控空间使用情况
将附加存储卷与副本结合使用时：
+ 当您为具有附加存储卷的数据库实例创建 RDS for Oracle 副本时，RDS 会自动在副本上配置附加存储卷。但是，在主数据库实例的存储卷中所做的任何后续修改都不会自动应用于副本。
+ 在跨卷管理数据文件位置时，我们建议使用参数组设置而不是会话级别更改，以确保主实例和副本实例之间的行为一致。
## 将附加存储卷与 RDS for Oracle 结合使用的限制
以下限制适用于将附加存储卷与 RDS for Oracle 结合使用：
+ 您无法向内存低于 64 GiB 的实例类型添加存储卷，因为它们没有足够的内存来支持大型存储卷。
+ 对于附加存储卷，最小存储大小为 200 GiB。数据库实例的主存储卷应等于或大于 200 GiB，才能连接附加存储卷。数据库实例在所有卷上的最大存储大小总计为 256 TiB。
+ 具有附加存储卷的数据库实例不支持以下功能：
+ 跨区域自动备份
+ 存储自动扩缩（用于附加存储卷）
+ 跨账户快照复制
+ 公有快照
+ 您无法删除主存储卷 (`rdsdbdata`)，但只要其它附加存储卷为空，就可以删除这些附加存储卷。
+ 您无法将联机重做日志、归档的重做日志和控制文件存储在其它存储卷中。这些文件只能存储在主存储卷 (`rdsdbdata`) 中。
## 在 RDS for Oracle 中对附加存储卷执行数据库管理操作
在 RDS for Oracle 中使用附加存储卷时，您可以执行数据库管理操作，例如创建表空间或在存储卷之间移动数据。有关对附加存储卷执行数据库管理操作的更多信息，请参阅以下各节：
+ [在 RDS for Oracle 中指定数据库文件位置](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [在 RDS for Oracle 中创建表空间并调整其大小](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [在 RDS for Oracle 中的卷之间移动数据文件](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
# 使用 RDS for Oracle 添加、移除或修改存储卷
您可以使用 Amazon Web Services 管理控制台或 Amazon CLI 添加、修改和移除附加存储卷。所有操作都使用带 `additional-storage-volumes` 参数的 `modify-db-instance` 命令。
**重要**
添加或移除附加存储卷会触发一个备份待处理操作，并进入中断时段。备份工作流程完成后，中断时段将结束。
## 添加存储卷
除了主存储卷之外，您最多可以添加三个存储卷。要向 RDS for Oracle 实例添加新的存储卷，请使用带 `additional-storage-volumes` 参数的 `modify-db-instance` 命令。
以下代码段添加了一个新的 5000 GiB 通用型 SSD（gp3）卷，预调配 IOPS 为 4000，名称为 `rdsdbdata3`。
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata3",
"StorageType":"gp3",
"AllocatedStorage":5000
"IOPS":4000}
]' \
--apply-immediately
```
## 修改存储卷
您可以修改附加存储卷的存储类型、分配的存储卷、IOPS 以及存储吞吐量设置。以下代码段修改 `rdsdbdata2` 卷的 IOPS 设置。
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"IOPS":8000}
]' \
--apply-immediately
```
**注意**
一旦将附加存储卷添加到实例，您就无法减少该存储卷的存储分配。
## 移除存储卷
当不再需要时，您可以从 RDS for Oracle 数据库实例中移除附加存储卷。在移除卷之前，请确保已将所有数据库文件从该卷中移出，并且没有数据库对象引用该卷。验证卷状态是否为 `Not-in-use`。您可以移除附加存储卷，但不能移除主存储卷。
**警告**
在移除附加存储卷之前，请确保该卷上未存储任何数据库文件。移除包含活动数据库文件的卷会导致数据库损坏。
以下示例移除 `rdsdbdata4` 卷。
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"SetForDelete":true}
]' \
--apply-immediately
```
# 在 RDS for Oracle 中使用附加存储卷备份和还原数据
您可以使用自动备份，并通过附加存储卷使用数据库实例创建数据库快照。所有备份操作都包括主卷和附加存储卷。您也可以通过附加存储卷对数据库实例使用时间点故障恢复。还原数据库时，可以添加存储卷。也可以修改现有卷的存储设置。从快照还原数据库时，不能删除附加存储卷。
**Topics**
+ [创建手动快照](#User_Oracle_AdditionalStorage.BackupRestore.ManualSnapshots)
+ [还原手动快照](#User_Oracle_AdditionalStorage.BackupRestore.RestoreSnapshots)
+ [时间点故障恢复](#User_Oracle_AdditionalStorage.BackupRestore.PitR)
## 创建手动快照
以下示例使用附加存储卷创建数据库的手动快照：
```
aws rds create-db-snapshot \
--db-instance-identifier my-oracle-asv-instance \
--db-snapshot-identifier my-snapshot
```
## 还原手动快照
从快照还原时，您可以添加新的附加存储卷，或修改现有卷的 IOPS 或吞吐量设置。以下示例从快照还原数据库实例，并修改 `rdsdbdata2` 卷的 IOPS 设置：
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier my-restored-instance \
--db-snapshot-identifier my-snapshot \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"IOPS":5000
}
]'
```
## 时间点故障恢复
在时间点故障恢复（PITR）期间，您可以使用自定义配置添加新的附加存储卷。以下示例执行 PITR 并为 `rdsdbdata2` 卷添加一个新的 5000 GiB 通用型 SSD（gp3），IOPS 为 5000，存储吞吐量为 200 MB/s：
```
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-identifier my-source-instancemy-source-instance \
--target-db-instance my-pitr-instance\
--use-latest-restorable-time \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"StorageType":"gp3",
"AllocatedStorage":5000,
"IOPS":5000,
"StorageThroughput":200
}
]'
```
# RDS for Oracle 中附加存储卷的使用案例
附加存储卷支持各种数据库管理方案。以下各节介绍了常见的使用案例和实施方法。
**Topics**
+ [将存储容量扩展到 64 TiB 以上](#User_Oracle_AdditionalStorage.UseCases.Extendingstoragecapacity)
+ [在单独的卷上对频繁和不频繁访问的数据进行存储分层](#User_Oracle_AdditionalStorage.UseCases.Storagetiering)
+ [用于数据加载和卸载的临时存储](#User_Oracle_AdditionalStorage.UseCases.Temporarystorage)
+ [将 Oracle 可传输表空间与附加存储卷结合使用](#User_Oracle_AdditionalStorage.UseCases.TransportableTablespaces)
## 将存储容量扩展到 64 TiB 以上
当主存储卷接近 64 TiB 限制但数据库中需要更多存储空间时，您可以使用附加存储卷。您可以使用 `modify-db-instance` 命令将附加存储卷连接到数据库实例，每个存储卷最多 64 TiB。连接附加存储卷后，您可以在附加存储卷上创建表空间，并使用标准 Oracle SQL 将表、索引和分区等对象移动到这些表空间。有关更多信息，请参阅 [在 RDS for Oracle 中对附加存储卷执行数据库管理操作](User_Oracle_AdditionalStorage.md#User_Oracle_AdditionalStorage.DBManagement)。
## 在单独的卷上对频繁和不频繁访问的数据进行存储分层
您可以通过在卷之间配置不同的存储类型，使用附加存储卷来优化成本和性能。例如，您可以使用高性能预调配 IOPS SSD 存储（io2）卷来存储频繁访问的数据，而将历史数据存储在经济实惠的通用型（gp3）存储卷上。您可以使用标准 Oracle 命令将特定的数据库对象（表、索引和分区）移动到这些表空间。有关更多信息，请参阅 [在 RDS for Oracle 中对附加存储卷执行数据库管理操作](User_Oracle_AdditionalStorage.md#User_Oracle_AdditionalStorage.DBManagement)。
## 用于数据加载和卸载的临时存储
您可以按照以下步骤，使用附加存储卷作为大型数据加载或导出的临时存储：
+ 使用以下命令在附加存储卷上创建一个目录：
```
BEGIN
rdsadmin.rdsadmin_util.create_directory(
p_directory_name => 'DATA_PUMP_DIR2',
p_database_volume_name => 'rdsdbdata2');
END;
/
```
+ 创建目录后，按照[使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)中所述的步骤将数据导出并导入到新目录。
+ 操作完成后，移除文件，并可以选择删除该卷以节省存储成本。只有当附加存储卷为空时，您才能移除该存储卷。
## 将 Oracle 可传输表空间与附加存储卷结合使用
您可以通过 Oracle 可传输表空间，使用附加存储卷将数据文件移动到附加存储卷中，步骤如下：
+ 在使用附加存储卷将可传输表空间导入到目标数据库之前，先在会话级别设置 `db_create_file_dest` 参数。
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
VAR x CLOB;
BEGIN
:x := rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
p_tablespace_list => 'TBTEST1',
p_directory_name => 'XTTS_DIR_DATA2',
p_platform_id => 13);
END;
/
PRINT :x;
```
+ 检查可传输表空间导入状态：
```
ALTER SESSION SET nls_date_format = 'DD.MM.YYYY HH24:MI:SS';
COL xtts_operation_start_utc FORMAT A30
COL xtts_operation_end_utc FORMAT A30
COL xtts_operation_state FORMAT A30
COL xtts_operation_type FORMAT A30
SELECT xtts_operation_start_utc, xtts_operation_type, xtts_operation_state
FROM rdsadmin.rds_xtts_operation_info;
```
+ 可传输表空间导入完成后，导入可传输表空间元数据。
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata(
p_datapump_metadata_file => 'xttdump.dmp',
p_directory_name => 'XTTS_DIR_DATA2');
END;
/
```
# 配置高级 RDS for Oracle 功能
RDS for Oracle 支持各种高级功能，包括大页、实例存储和扩展数据类型。
**Topics**
+ [在 RDS for Oracle 实例存储中存储临时数据](CHAP_Oracle.advanced-features.instance-store.md)
+ [为 RDS for Oracle 实例开启大页](Oracle.Concepts.HugePages.md)
+ [在 RDS for Oracle 中开启扩展数据类型](Oracle.Concepts.ExtendedDataTypes.md)
# 在 RDS for Oracle 实例存储中存储临时数据
在支持的 RDS for Oracle 数据库实例上，为临时表空间和数据库智能闪存缓存（闪存缓存）使用实例存储。
**Topics**
+ [RDS for Oracle 实例存储的概述](#CHAP_Oracle.advanced-features.instance-store.overview)
+ [开启 RDS for Oracle 实例存储](#CHAP_Oracle.advanced-features.instance-store.Enable)
+ [配置 RDS for Oracle 实例存储](CHAP_Oracle.advanced-features.instance-store.configuring.md)
+ [在 Oracle 只读副本上使用实例存储](CHAP_Oracle.advanced-features.instance-store.replicas.md)
+ [在实例存储和 Amazon EBS 上配置临时表空间组](CHAP_Oracle.advanced-features.instance-store.temp-ebs.md)
+ [删除 RDS for Oracle 实例存储](#CHAP_Oracle.advanced-features.instance-store.Disable)
## RDS for Oracle 实例存储的概述
*实例存储*为 RDS for Oracle 数据库实例提供临时性块级存储。您可以使用实例存储来临时存储经常变化的信息。
实例存储基于物理附加到主机的非易失性存储规范（NVMe）设备。此存储针对低延迟、随机 I/O 性能和连续读取吞吐量进行了优化。
实例存储的大小因数据库实例类型而异。有关实例存储的更多信息，请参阅《适用于 Linux 实例的 Amazon Elastic Compute Cloud 用户指南》**中的 [Amazon EC2 实例存储](https://docs.amazonaws.cn/AWSEC2/latest/UserGuide/InstanceStorage.html)。
**Topics**
+ [RDS for Oracle 实例存储中的数据类型](#CHAP_Oracle.advanced-features.instance-store.overview.uses)
+ [RDS for Oracle 实例存储的优点](#CHAP_Oracle.advanced-features.instance-store.overview.benefits)
+ [RDS for Oracle 实例存储支持的实例类](#CHAP_Oracle.advanced-features.instance-store.overview.instance-classes)
+ [RDS for Oracle 实例存储支持的引擎版本](#CHAP_Oracle.advanced-features.instance-store.overview.db-versions)
+ [RDS for Oracle 实例存储支持的 Amazon Web Services 区域](#CHAP_Oracle.advanced-features.instance-store.overview.regions)
+ [RDS for Oracle 实例存储的成本](#CHAP_Oracle.advanced-features.instance-store.overview.cost)
### RDS for Oracle 实例存储中的数据类型
您可以将以下类型的 RDS for Oracle 临时数据放入实例存储中：
临时表空间
Oracle 数据库使用临时表空间来存储不适合放入内存中的中间查询结果。较大的查询会生成大量的中间数据，这些数据需要进行临时缓存，但不需要持久保留。尤其是，临时表空间可用于排序、哈希聚合和联接。如果您的 RDS for Oracle 数据库实例使用企业版或标准版 2，则可以将临时表空间放在实例存储中。
闪存缓存
闪存缓存可提高传统路径中单块随机读取的性能。最佳做法是调整缓存的大小以容纳大部分活动的数据集。如果 RDS for Oracle 数据库实例使用企业版，则可以将闪存缓存放在实例存储中。
原定设置情况下，将实例存储配置用于临时表空间而非闪存缓存。您无法将 Oracle 数据文件和数据库日志文件放在实例存储中。
### RDS for Oracle 实例存储的优点
您可以考虑使用实例存储来存储可以承受丢失的临时文件和缓存。如果您想提高数据库性能，或者，如果增加的工作负载导致 Amazon EBS 存储出现性能问题，请考虑扩展到支持实例存储的实例类。
通过将临时表空间和闪存缓存放在实例存储上，您可以获得以下优势：
+ 降低读取延迟
+ 提高吞吐量
+ 减少了 Amazon EBS 卷上的负载
+ 由于减少了 Amazon EBS 负载，因此降低了存储和快照成本
+ 减少了预调配高 IOPS 的需要，可能会降低您的总体成本
通过将临时表空间放在实例存储上，您可以立即提高使用临时空间的查询的性能。当您将闪存缓存放在实例存储上时，缓存块读取的延迟通常比 Amazon EBS 读取的延迟要低得多。闪存缓存需要“预热”，然后才能提供性能优势。缓存会自行预热，因为当块从数据库缓冲区缓存中过期时，数据库会将块写入闪存缓存。
**注意**
在某些情况下，闪存缓存会因为缓存管理而导致性能开销。在生产环境中启用闪存缓存之前，我们建议您分析工作负载并在测试环境中测试缓存。
### RDS for Oracle 实例存储支持的实例类
Amazon RDS 对于以下数据库实例类支持实例存储：
+ db.m5d
+ db.m6id
+ db.r5d
+ db.r6id
+ db.x2idn
+ db.x2iedn
RDS for Oracle 仅对于 BYOL 许可模式支持上述数据库实例类。有关更多信息，请参阅[支持的 RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md#Oracle.Concepts.InstanceClasses.Supported)和[EE 和 SE2 自带许可（BYOL）](Oracle.Concepts.Licensing.md#Oracle.Concepts.Licensing.BYOL)。
要查看受支持的数据库实例类型的总实例存储量，请在 Amazon CLI 中运行以下命令。
**Example**
```
aws ec2 describe-instance-types \
--filters "Name=instance-type,Values=*5d.*large*,*6id.*large*" \
--query "InstanceTypes[?contains(InstanceType,'m5d')||contains(InstanceType,'r5d')||contains(InstanceType,'m6id')||contains(InstanceType,'r6id')][InstanceType, InstanceStorageInfo.TotalSizeInGB]" \
--output table
```
前面的命令返回实例存储的原始设备大小。RDS for Oracle 使用此空间的一小部分进行配置。实例存储中可用于临时表空间或闪存缓存的空间稍小。
### RDS for Oracle 实例存储支持的引擎版本
以下 RDS for Oracle 数据库引擎版本支持实例存储：
+ 21.0.0.0.ru-2022-01.rur-2022-01.r1 或更高的 Oracle Database 21c 版本
+ 19.0.0.0.ru-2021-10.rur-2021-10.r1 或更高的 Oracle Database 19c 版本
### RDS for Oracle 实例存储支持的 Amazon Web Services 区域
在支持其中一种或多种实例类型的所有 Amazon Web Services 区域中均可使用实例存储。有关 db.m5d 和 db.r5d 实例类的更多信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。有关 Amazon RDS for Oracle 支持的实例类的更多信息，请参阅 [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
### RDS for Oracle 实例存储的成本
实例存储的成本计入已开启实例存储的实例的成本中。对 RDS for Oracle 数据库实例启用实例存储不会产生额外费用。有关已开启实例存储的实例的更多信息，请参阅 [RDS for Oracle 实例存储支持的实例类](#CHAP_Oracle.advanced-features.instance-store.overview.instance-classes)。
## 开启 RDS for Oracle 实例存储
要为 RDS for Oracle 临时数据开启实例存储，请执行下列操作之一：
+ 使用支持的实例类创建 RDS for Oracle 数据库实例。有关更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 修改现有 RDS for Oracle 数据库实例以使用支持的实例类。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# 配置 RDS for Oracle 实例存储
原定设置情况下，100% 的实例存储空间分配给临时表空间。要将实例存储配置为向闪存缓存和临时表空间分配空间，请在实例的参数组中设置以下参数：
**db\$1flash\$1cache\$1size=\$1DBInstanceStore\$1\$10,2,4,6,8,10\$1/10\$1**
此参数指定为闪存缓存分配的存储空间量。此参数仅对 Oracle Database 企业版有效。默认值为 `{DBInstanceStore*0/10}`。如果您为 `db_flash_cache_size` 设置非零值，则 RDS for Oracle 实例将在您重新启动实例后启用闪存缓存。
**rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$1\$10,2,4,6,8,10\$1/10\$1**
此参数指定为临时表空间分配的存储空间量。默认值为 `{DBInstanceStore*10/10}`。对于 Oracle Database 企业版，此参数是可修改的，而对于标准版 2 为只读的。如果您为 `rds.instance_store_temp_size` 设置非零值，Amazon RDS 将在实例存储中为临时表空间分配空间。
您可以为不使用实例存储的数据库实例设置 `db_flash_cache_size` 和 `rds.instance_store_temp_size` 参数。在这种情况下，这两个设置的计算结果均为 `0`，这会关闭该功能。在这种情况下，您可以为不同的实例大小和不使用实例存储的实例使用相同的参数组。如果您修改这些参数，则确保重启关联的实例，以使更改生效。
如果您为临时表空间分配空间，Amazon RDS 不会自动创建临时表空间。要了解如何在实例存储上创建临时表空间，请参阅 [在实例存储上创建临时表空间](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)。
上述参数的组合值不得超过 10/10 或 100%。下表说明了有效和无效的参数设置。
| db\$1flash\$1cache\$1size 设置 | rds.instance\$1store\$1temp\$1size 设置 | 说明 |
| --- | --- | --- |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$10/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$110/10\$1 | 这是适用于所有 Oracle Database 版本的有效配置。Amazon RDS 将 100% 的实例存储空间分配给临时表空间。这是默认模式。 |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$110/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$10/10\$1 | 这是仅适用于 Oracle Database 企业版的有效配置。Amazon RDS 将 100% 的实例存储空间分配给闪存缓存。 |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$12/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$18/10\$1 | 这是仅适用于 Oracle Database 企业版的有效配置。Amazon RDS 将 20% 的实例存储空间分配给闪存缓存，而将 80% 的实例存储空间分配给临时表空间。 |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$16/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$14/10\$1 | 这是仅适用于 Oracle Database 企业版的有效配置。Amazon RDS 将 60% 的实例存储空间分配给闪存缓存，而将 40% 的实例存储空间分配给临时表空间。 |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$12/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$14/10\$1 | 这是仅适用于 Oracle Database 企业版的有效配置。Amazon RDS 将 20% 的实例存储空间分配给闪存缓存，而将 40% 的实例存储空间分配给临时表空间。 |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$18/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$18/10\$1 | 这是无效的配置，因为实例存储空间的总百分比超过 100%。在这种情况下，Amazon RDS 会使此尝试失败。 |
## 更改数据库实例类型时的注意事项
如果您更改数据库实例类型，则这可能会影响实例存储上闪存缓存或临时表空间的配置。考虑以下修改及其影响：
**您可以纵向扩展或缩减支持实例存储的数据库实例。**
以下各值根据实例存储的新大小成比例增加或减少：
+ 闪存缓存的新大小。
+ 分配给驻留在实例存储中的临时表空间的空间。
例如，db.m5d.4xlarge 实例上的设置 `db_flash_cache_size={DBInstanceStore*6/10}` 提供了大约 340GB 的闪存缓存空间。如果您将实例类型纵向扩展到 db.m5d.8xlarge，则闪存缓存空间将增加到大约 680GB。
**您将不使用实例存储的数据库实例修改为确实使用实例存储的实例。**
如果将 `db_flash_cache_size` 设置为大于 `0` 的值，则配置闪存缓存。如果将 `rds.instance_store_temp_size` 设置为大于 `0` 的值，则会分配实例存储空间供临时表空间使用。RDS for Oracle 不会自动将临时文件移动到实例存储。有关使用分配的空间的信息，请参阅 [在实例存储上创建临时表空间](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store) 或 [在只读副本上向实例存储中添加临时文件](Appendix.Oracle.CommonDBATasks.using-tempfiles.md#Appendix.Oracle.CommonDBATasks.adding-tempfile-replica)。
**您将使用实例存储的数据库实例修改为不使用实例存储的实例。**
在这种情况下，RDS for Oracle 会删除闪存缓存。RDS 在 Amazon EBS 卷上重新创建当前位于实例存储中的临时文件。新临时文件的最大大小是 `rds.instance_store_temp_size` 参数以前的大小。
# 在 Oracle 只读副本上使用实例存储
只读副本在实例存储上支持闪存缓存和临时表空间。虽然闪存缓存的工作方式与在主数据库实例上的工作方式相同，但请注意对于临时表空间的以下区别：
+ 您无法在只读副本上创建临时表空间。如果您在主实例上创建新的临时表空间，则 RDS for Oracle 会在没有临时文件的情况下复制表空间信息。要添加新的临时文件，请使用下列任一方法：
+ 适用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.add_inst_store_tempfile`。RDS for Oracle 在只读副本上的实例存储中创建一个临时文件，并将其添加到指定的临时表空间中。
+ 运行 `ALTER TABLESPACE … ADD TEMPFILE` 命令。RDS for Oracle 将临时文件放在 Amazon EBS 存储上。
**注意**
主数据库实例和只读副本上的临时文件大小和存储类型可能不同。
+ 您只能在主数据库实例上管理原定设置临时表空间设置。RDS for Oracle 会将该设置复制到所有只读副本。
+ 您只能在主数据库实例上配置临时表空间组。RDS for Oracle 会将该设置复制到所有只读副本。
# 在实例存储和 Amazon EBS 上配置临时表空间组
您可以将临时表空间组配置为包括实例存储和 Amazon EBS 上的临时表空间。当您想要的临时存储空间超过 `rds.instance_store_temp_size` 的最大设置所允许的空间时，此方法很有用。
当您在实例存储和 Amazon EBS 上配置临时表空间组时，这两个表空间的性能特征显著不同。Oracle 数据库根据内部算法，选择表空间来处理查询。因此，类似查询的性能可能会有所不同。
通常，您在实例存储中创建临时表空间，如下所示：
1. 在实例存储中创建临时表空间。
1. 将新的表空间设置为数据库原定设置临时表空间。
如果实例存储中的表空间大小不足，则可以按如下方式创建额外的临时存储：
1. 将实例存储中的临时表空间分配给临时表空间组。
1. 如果临时表空间不存在，请在 Amazon EBS 中创建一个新的临时表空间。
1. 将 Amazon EBS 中的临时表空间分配给包含实例存储表空间的同一个表空间组。
1. 将表空间组设置为原定设置临时表空间。
以下示例假设实例存储中临时表空间的大小不符合您的应用程序要求。该示例在实例存储中创建临时表空间 `temp_in_inst_store`，将其分配给表空间组 `temp_group`，将名为 `temp_in_ebs` 的现有 Amazon EBS 表空间添加到该组中，并将该组设置为原定设置临时表空间。
```
SQL> EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace('temp_in_inst_store');
PL/SQL procedure successfully completed.
SQL> ALTER TABLESPACE temp_in_inst_store TABLESPACE GROUP temp_group;
Tablespace altered.
SQL> ALTER TABLESPACE temp_in_ebs TABLESPACE GROUP temp_group;
Tablespace altered.
SQL> EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace('temp_group');
PL/SQL procedure successfully completed.
SQL> SELECT * FROM DBA_TABLESPACE_GROUPS;
GROUP_NAME TABLESPACE_NAME
------------------------------ ------------------------------
TEMP_GROUP TEMP_IN_EBS
TEMP_GROUP TEMP_IN_INST_STORE
SQL> SELECT PROPERTY_VALUE FROM DATABASE_PROPERTIES WHERE PROPERTY_NAME='DEFAULT_TEMP_TABLESPACE';
PROPERTY_VALUE
--------------
TEMP_GROUP
```
## 删除 RDS for Oracle 实例存储
要删除实例存储，请修改 RDS for Oracle 数据库实例以使用不支持实例存储的实例类型，如 db.m5 或 db.r5。
# 为 RDS for Oracle 实例开启大页
Amazon RDS for Oracle 支持 Linux 内核大页，提高了数据库扩展能力。大页会导致页表变小，花在内存管理上的 CPU 时间也减少，从而提高大数据库实例的性能。有关更多信息，请参阅 Oracle 文档中的[巨页概述](https://docs.oracle.com/database/121/UNXAR/appi_vlm.htm#UNXAR400)。
您可以将大页与所有支持的 RDS for Oracle 版本和修订版一起使用。
`use_large_pages` 参数控制是否为数据库实例开启大页。该参数的可能设置包括 `ONLY`、`FALSE` 和 `{DBInstanceClassHugePagesDefault}`。在 Oracle 的默认数据库参数组中，`use_large_pages` 参数设置为 `{DBInstanceClassHugePagesDefault}`。
要控制是否自动为数据库实例开启大页，您可以在参数组中使用 `DBInstanceClassHugePagesDefault` 公式变量。该值如下所示确定：
+ 对于下表中提及的数据库实例类别，`DBInstanceClassHugePagesDefault` 默认情况下计算结果始终为 `FALSE`，而 `use_large_pages` 的计算结果为 `FALSE`。如果数据库实例类至少具有 14GiB 内存，您可为这些数据库实例类手动开启大页。
+ 对于未在下表中提及的数据库实例类别，如果数据库实例类别内存小于 14 GiB，则 `DBInstanceClassHugePagesDefault` 的计算结果始终为 `FALSE`。此外，`use_large_pages` 计算结果为 `FALSE`。
+ 对于未在下表中提及的数据库实例类别，如果实例类别内存至少为 14 GiB 且小于 100 GiB，则 `DBInstanceClassHugePagesDefault` 默认情况下计算结果为 `TRUE`。此外，`use_large_pages` 计算结果为 `ONLY`。您可以通过将 `use_large_pages` 设置为 `FALSE`，手动关闭大页。
+ 对于未在下表中提及的数据库实例类别，如果实例类内存至少为 100 GiB，则 `DBInstanceClassHugePagesDefault` 的计算结果始终为 `TRUE`。此外，`use_large_pages` 的计算结果为 `ONLY`，并且不能禁用大页。
原定设置情况下，不为以下数据库实例类开启大页。
****
| 数据库实例类系列 | 原定设置情况下未开启大页的数据库实例类 |
| --- | --- |
| db.m5 | db.m5.large |
| db.m4 | db.m4.large，db.m4.xlarge，db.m4.2xlarge，db.m4.4xlarge，db.m4.10xlarge |
| db.t3 | db.t3.micro，db.t3.small，db.t3.medium，db.t3.large |
有关数据库实例类的更多信息，请参阅[数据库实例类的硬件规格](Concepts.DBInstanceClass.Summary.md)。
要为新的或现有的数据库实例手动开启大页，请将 `use_large_pages` 参数设置为 `ONLY`。大页不能与 Oracle 自动内存管理 (AMM) 一起使用。如果将 `use_large_pages` 参数设置为 `ONLY`，则还必须将 `memory_target` 和 `memory_max_target` 都设置为 `0`。有关为数据库实例设置数据库参数的更多信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
您也可以设置 `sga_target`、`sga_max_size` 和 `pga_aggregate_target` 参数。当设置系统全局区域 (SGA) 和程序全局区域 (PGA) 内存参数时，请将这些值加在一起。从可用实例内存 (`DBInstanceClassMemory`) 中减去此计算得到的总计值，可确定大页分配后的可用内存。必须保留至少 2 GiB 可用内存或总可用实例内存的 10% (取两者中较小的值)。
配置参数之后，必须重启数据库实例才能使更改生效。有关更多信息，请参阅“[重启数据库实例](USER_RebootInstance.md)”。
**注意**
Oracle 数据库实例会推迟对与 SGA 相关的初始化参数的更改，直到您重启实例而不进行故障转移。在 Amazon RDS 控制台中，选择**重启**，但*不要* 选择**通过故障转移重启**。在 Amazon CLI 中，调用带 `reboot-db-instance` 参数的 `--no-force-failover` 命令。在故障转移期间或导致实例重启的其他维护操作期间，数据库实例不会处理与 SGA 相关的参数。
针对大页，以下示例参数配置手动启用大页。您应根据自己的需要设置这些值。
```
1. memory_target = 0
2. memory_max_target = 0
3. pga_aggregate_target = {DBInstanceClassMemory*1/8}
4. sga_target = {DBInstanceClassMemory*3/4}
5. sga_max_size = {DBInstanceClassMemory*3/4}
6. use_large_pages = ONLY
```
假设在参数组中设置以下参数值。
```
1. memory_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
2. memory_max_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
3. pga_aggregate_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*1/8}, 0)
4. sga_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
5. sga_max_size = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
6. use_large_pages = {DBInstanceClassHugePagesDefault}
```
参数组由内存小于 100 GiB 的 db.r4 数据库实例类使用。如果使用这些参数设置并将 `use_large_pages` 设置为 `{DBInstanceClassHugePagesDefault}`，则为 db.r4 实例开启大页。
请考虑在参数组中设置了以下参数值的另一个示例。
```
1. memory_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
2. memory_max_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
3. pga_aggregate_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*1/8}, 0)
4. sga_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
5. sga_max_size = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
6. use_large_pages = FALSE
```
该参数组由内存小于 100 GiB 的 db.r4 数据库实例类和 db.r5 数据库实例类使用。如果使用这些参数设置，将在 db.r4 和 db.r5 实例上关闭大页。
**注意**
如果该参数组由具有至少 100 GiB 内存的 db.r4 数据库实例类或 db.r5 数据库实例类使用，则将覆盖 `FALSE` 的 `use_large_pages` 设置并将其设置为 `ONLY`。在这种情况下，将发送有关覆盖的客户通知。
当大页在数据库实例上处于活动状态后，您可以启用增强监控以查看大页信息。有关更多信息，请参阅 [使用增强监控来监控操作系统指标](USER_Monitoring.OS.md)。
# 在 RDS for Oracle 中开启扩展数据类型
Amazon RDS for Oracle 支持扩展数据类型。对于扩展数据类型，`VARCHAR2`、`NVARCHAR2` 和 `RAW` 数据类型的最大大小为 32767 字节。要使用扩展数据类型，请将 `MAX_STRING_SIZE` 参数设置为 `EXTENDED`。有关更多信息，请参阅 Oracle 文档中的[扩展数据类型](https://docs.oracle.com/database/121/SQLRF/sql_elements001.htm#SQLRF55623)。
如果您不希望使用扩展数据类型，请将 `MAX_STRING_SIZE` 参数设置为 `STANDARD`（默认值）。在这种情况下，`VARCHAR2` 和 `NVARCHAR2` 数据类型的大小限制为 4,000 字节，RAW 数据类型的大小限制为 2,000 字节。
您可以在新的或现有的数据库实例上开启扩展数据类型。对于新的数据库实例，在开启扩展数据类型时，数据库实例的创建时间通常较长。对于现有的数据库实例，数据库实例在转换过程中不可用。
## 扩展数据类型的注意事项
为数据库实例启用扩展数据类型时，请考虑以下几点：
+ 在为新的或现有的数据库实例开启扩展数据类型时，必须重启实例才能使更改生效。
+ 在开启扩展数据类型之后，无法将数据库实例改回为使用数据类型的标准大小。如果将 `MAX_STRING_SIZE` 参数重新设置为 `STANDARD`，则会导致 `incompatible-parameters` 状态。
+ 在还原使用扩展数据类型的数据库实例时，您必须指定一个参数组并将 `MAX_STRING_SIZE` 参数设置为 `EXTENDED`。在还原期间，如果指定默认参数组或任何其他参数组并将 `MAX_STRING_SIZE` 设置为 `STANDARD`，则会导致 `incompatible-parameters` 状态。
+ 如果由于 `incompatible-parameters` 设置而导致数据库实例状态为 `MAX_STRING_SIZE`，数据库实例将保持不可用状态，直到您将 `MAX_STRING_SIZE` 参数设置为 `EXTENDED` 并重新引导数据库实例。
## 为新数据库实例开启扩展数据类型
当您创建将 `MAX_STRING_SIZE` 设置为 `EXTENDED` 的数据库实例时，该实例将显示 `MAX_STRING_SIZE` 设置为默认 `STANDARD`。重启实例以启用更改。
**为新数据库实例开启扩展数据类型**
1. 在参数组中将 `MAX_STRING_SIZE` 参数设置为 `EXTENDED`。
要设置该参数，您可以创建新的参数组或修改现有的参数组。
有关更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 创建新的 RDS for Oracle 数据库实例。
有关更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
1. 将其 `MAX_STRING_SIZE` 设置为 `EXTENDED` 的参数组与数据库实例相关联。
有关更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
1. 重新引导数据库实例以使参数更改生效。
有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
## 为现有数据库实例开启扩展数据类型
在修改数据库实例以开启扩展数据类型时，RDS 将转换数据库中的数据以使用扩展的大小。参数更改后，下次重启数据库时会发生转换和停机。数据库实例在转换期间不可用。
转换数据所需的时间取决于数据库实例类、数据库大小和最后一个数据库快照的时间。为减少停机时间，请考虑就在重启前拍摄快照。这缩短了转换工作流程期间执行的备份的时间。
**注意**
在开启扩展数据类型后，您无法在转换期间执行时间点还原以还原到某个时间。您可以还原到紧靠转换前或转换后的时间。
**为现有数据库实例开启扩展数据类型**
1. 拍摄数据库的快照。
如果在数据库中具有无效的对象，Amazon RDS 将尝试重新编译这些对象。如果 Amazon RDS 无法重新编译无效的对象，转换为扩展数据类型可能会失败。如果在转换过程中出现问题，您可以使用快照还原数据库。请始终在转换之前检查无效的对象，并修复或删除这些无效的对象。对于生产数据库，我们建议先在数据库实例的副本上测试转换过程。
有关更多信息，请参阅“[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)”。
1. 在参数组中将 `MAX_STRING_SIZE` 参数设置为 `EXTENDED`。
要设置该参数，您可以创建新的参数组或修改现有的参数组。
有关更多信息，请参阅“[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)”。
1. 修改数据库实例以将其与 `MAX_STRING_SIZE` 设置为 `EXTENDED` 的参数组相关联。
有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
1. 重新引导数据库实例以使参数更改生效。
有关更多信息，请参阅“[重启数据库实例](USER_RebootInstance.md)”。
# 将数据导入到 Amazon RDS 上的 Oracle
将数据导入 Amazon RDS for Oracle 数据库实例的方式取决于以下各项：
+ 您拥有的数据量
+ 数据库中的数据库对象的数量
+ 数据库中的各种数据库对象
例如，您可以根据需要使用以下工具：
+ Oracle SQL Developer – 导入一个简单的、大小为 20MB 的数据库。
+ Oracle Data Pump – 导入复杂的数据库，或大小为数百 MB 甚至 TB 级的数据库。例如，您可以将表空间从本地数据库传输到 RDS for Oracle 数据库实例。您可以使用 Amazon S3 或 Amazon EFS 来传输数据文件和元数据。有关更多信息，请参阅 [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)、[Amazon EFS 集成](oracle-efs-integration.md) 和 [Amazon S3 集成](oracle-s3-integration.md)。
+ Amazon Database Migration Service（Amazon DMS）– 无需停机即可迁移数据库。有关 Amazon DMS 的更多信息，请参阅 [Amazon Database Migration Service 是什么](https://docs.amazonaws.cn/dms/latest/userguide/Welcome.html)和博文 [Migrating Oracle databases with near-zero downtime using Amazon DMS](https://www.amazonaws.cn/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/)。
**重要**
在使用前述的迁移技术之前，我们建议您对数据库进行备份。要导入数据，您可以通过创建快照来备份您的 RDS for Oracle 数据库实例。稍后，您可以还原快照。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
对于许多数据库引擎，将继续进行持续复制，直到您已准备好切换到目标数据库。您可以使用 Amazon DMS 从同一数据库引擎或其他引擎迁移到 RDS for Oracle。如果您从其他数据库引擎进行迁移，可以使用 Amazon Schema Conversion Tool 迁移 Amazon DMS 未迁移的架构对象。
**Topics**
+ [使用 Oracle SQL Developer 导入](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)
+ [使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)
+ [使用 Oracle Export/Import 进行导入](Oracle.Procedural.Importing.ExportImport.md)
+ [使用 Oracle SQL\$1Loader 进行导入](Oracle.Procedural.Importing.SQLLoader.md)
+ [使用 Oracle 实体化视图进行迁移](Oracle.Procedural.Importing.Materialized.md)
# 使用 Oracle SQL Developer 导入
Oracle SQL Developer 是 Oracle 发布的一种免费的图形化 Java 工具。SQL Developer 为用户提供了选项，可在两个 Oracle 数据库之间迁移数据，或将数据从其他数据库（如 MySQL）迁移到 Oracle 数据库。此工具最适合用于迁移小型数据库。
您可以将此工具安装到台式计算机 (Windows、Linux 或 Mac) 或服务器上。安装 SQL Developer 后，您可以使用该工具连接至源数据库和目标数据库。可使用“工具”菜单上的**数据库复制**命令将数据复制到 RDS for Oracle 数据库实例。
要下载 SQL Developer，请转到 [ http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer)。
建议您在开始迁移数据前先阅读 Oracle SQL Developer 产品文档。Oracle 还提供关于如何从其他数据库 (包括 MySQL 和 SQL Server) 中迁移数据的文档。有关更多信息，请参阅 Oracle 文档中的 [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration)。
# 使用 Oracle 可传输表空间进行迁移
您可以使用 Oracle 可传输表空间功能，将一组表空间从本地 Oracle 数据库复制到 RDS for Oracle 数据库实例。在物理层，您可以使用 Amazon EFS 或 Amazon S3 将源数据文件和元数据文件传输到目标数据库实例。可传输表空间功能使用 `rdsadmin.rdsadmin_transport_util` 软件包。有关此软件包的语法和语义，请参阅[传输表空间](rdsadmin_transport_util.md)。
有关阐述如何传输表空间的博客文章，请参阅 [Migrate Oracle Databases to Amazon using transportable tablespace](https://www.amazonaws.cn/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/)，以及 [Amazon RDS for Oracle Transportable Tablespaces using RMAN](https://www.amazonaws.cn/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/)。
**Topics**
+ [Oracle 可传输表空间概述](#oracle-migrating-tts.overview)
+ [第 1 阶段：设置源主机](#oracle-migrating-tts.setup-phase)
+ [第 2 阶段：准备完整的表空间备份](#oracle-migrating-tts.initial-br-phase)
+ [第 3 阶段：制作和传输增量备份](#oracle-migrating-tts.roll-forward-phase)
+ [阶段 4：传输表空间](#oracle-migrating-tts.final-br-phase)
+ [第 5 阶段：验证传输的表空间](#oracle-migrating-tts.validate)
+ [第 6 阶段：清理剩余文件](#oracle-migrating-tts.cleanup)
## Oracle 可传输表空间概述
可传输的表空间集由正在传输的表空间集的数据文件和包含表空间元数据的导出转储文件组成。在诸如可传输表空间之类的物理迁移解决方案中，您可以传输物理文件：数据文件、配置文件和 Data Pump 转储文件。
**Topics**
+ [可传输表空间的优缺点](#oracle-migrating-tts.overview.benefits)
+ [可传输表空间的限制](#oracle-migrating-tts.limitations)
+ [可传输表空间的先决条件](#oracle-migrating-tts.requirements)
### 可传输表空间的优缺点
当您需要以最少的停机时间将一个或多个大型表空间迁移到 RDS 时，建议您使用可传输的表空间。与逻辑迁移相比，可传输的表空间具有以下优势：
+ 停机时间低于大多数其他 Oracle 迁移解决方案。
+ 由于可传输表空间功能仅复制物理文件，因此，它避免了在逻辑迁移中可能发生的数据完整性错误和逻辑损坏。
+ 不需要额外的许可证。
+ 您可以跨不同的平台和字节顺序类型迁移一组表空间，例如，从 Oracle Solaris 平台迁移到 Linux。但是，不支持在 Windows 服务器之间传输表空间。
**注意**
Linux 经过充分测试并得到支持。并非所有 UNIX 版本都经过测试。
如果您使用可传输的表空间，则可以使用 Amazon S3 或 Amazon EFS 传输数据：
+ 使用 EFS 时，您的备份在导入期间将保留在 EFS 文件系统中。之后，您可以删除这些文件。在此技术中，您无需为数据库实例预调配 EBS 存储。出于这个原因，我们建议使用 Amazon EFS 而不是 S3。有关更多信息，请参阅 [Amazon EFS 集成](oracle-efs-integration.md)。
+ 使用 S3 时，您可以将 RMAN 备份下载到附加到数据库实例的 EBS 存储。在导入期间，文件将保留在您的 EBS 存储中。导入后，您可以释放此空间，该空间仍保持分配给您的数据库实例。
可传输表空间的主要缺点是您需要相对较高级的 Oracle 数据库知识。有关更多信息，请参见《Oracle 数据库管理员指南》**中的[在数据库之间传输表空间](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB)。
### 可传输表空间的限制
当您在 RDS for Oracle 中使用可传输表空间时，将适用 Oracle 数据库对此功能的限制。有关更多信息，请参见《Oracle 数据库管理员指南》**中的[可传输表空间的限制]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787)和[传输数据的一般限制](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173)。请注意 RDS for Oracle 中可传输表空间的以下其他限制：
+ 源数据库或目标数据库都不能使用标准版 2（SE2）。仅支持企业版。
+ 您不能使用 Oracle Database 11g 数据库作为源。RMAN 跨平台可传输表空间功能依赖于 RMAN 传输机制，而 Oracle Database 11g 不支持该机制。
+ 您无法使用可传输的表空间从 RDS for Oracle 数据库实例迁移数据。您只能使用可传输的表空间将数据迁移到 RDS for Oracle 数据库实例。
+ 不支持 Windows 操作系统。
+ 您无法将表空间传输到较低版本级别的数据库中。目标数据库的版本级别必须与源数据库相同或更高。例如，您无法将表空间从 Oracle Database 21c 传输到 Oracle Database 19c。
+ 您无法传输诸如 `SYSTEM` 和 `SYSAUX` 之类的管理表空间。
+ 您无法传输非数据对象，例如 PL/SQL 软件包、Java 类、视图、触发器、序列、用户、角色和临时表。要传输非数据对象，请手动创建它们或使用 Data Pump 元数据导出和导入。有关更多信息，请参阅 [My Oracle Support Note 1454872.1](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html)。
+ 您无法传输已加密或使用加密列的表空间。
+ 如果您使用 Amazon S3 传输文件，则支持的最大文件大小为 5TiB。
+ 如果源数据库使用诸如 Spatial 等 Oracle 选项，则除非在目标数据库上配置了相同的选项，否则无法传输表空间。
+ 在 Oracle 副本配置中，您无法将表空间传输到 RDS for Oracle 数据库实例。解决方法是，您可以删除所有副本，传输表空间，然后重新创建副本。
### 可传输表空间的先决条件
开始之前，完成以下任务：
+ 查看 My Oracle Support 的以下文档中描述的可传输表空间的要求：
+ [使用跨平台增量备份减少可传输表空间停机时间（文档 ID 2471245.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1)
+ [可传输表空间（TTS）局限性和限制：详细信息、参考和适用的版本（文档 ID 1454872.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1)
+ [可传输表空间（TTS）的主要注意事项 -- 常见疑问和问题（文档 ID 1166564.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1)
+ 计划字节顺序转换。如果您指定源平台 ID，则 RDS for Oracle 会自动转换字节顺序。要了解如何查找平台 ID，请参阅 [Data Guard 对同一 Data Guard 配置中异构主备用服务器和物理备用服务器的支持（文档 ID 413484.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)。
+ 确保在目标数据库实例上启用了可传输表空间功能。只有在运行以下查询时没有出现 `ORA-20304` 错误的情况下，才会启用该功能：
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
如果未启用可传输表空间功能，请重启您的数据库实例。有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
+ 确保源和目标数据库中的时区文件相同。
+ 确保源数据库和目标数据库上的数据库字符集满足以下任一要求：
+ 字符集是相同的。
+ 字符集是兼容的。有关兼容性要求的列表，请参阅 Oracle 数据库文档中的 [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173)。
+ 如果您计划使用 Amazon S3 传输文件，请执行以下操作：
+ 确保 Amazon S3 桶可用于文件传输，并且 Amazon S3 桶与数据库实例处于相同的 Amazon 区域中。有关说明，请参阅 *Amazon Simple Storage Service 入门指南* 中的[创建存储桶](https://docs.amazonaws.cn/AmazonS3/latest/userguide/CreatingABucket.html)。
+ 按照[为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md)中的说明为 Amazon RDS 集成准备 Amazon S3 桶。
+ 如果您计划使用 Amazon EFS 传输文件，请确保已按照[Amazon EFS 集成](oracle-efs-integration.md)中的说明配置 EFS。
+ 我们强烈建议您在目标数据库实例中开启自动备份。由于[元数据导入步骤](#oracle-migrating-tts.transport.import-dmp)可能会失败，因此，必须能够将数据库实例还原到其导入前的状态，从而避免需要再次备份、传输和导入表空间。
## 第 1 阶段：设置源主机
在此步骤中，您将复制 My Oracle Support 提供的传输表空间脚本，并设置必要的配置文件。在以下步骤中，*源主机*正在运行包含要传输到*目标实例*的表空间的数据库。
**设置您的源主机**
1. 以 Oracle 主目录的所有者身份登录到您的源主机。
1. 确保 `ORACLE_HOME` 和 `ORACLE_SID` 环境变量指向您的源数据库。
1. 以管理员身份登录数据库，并验证时区版本、数据库字符集和国家/地区字符集是否与目标数据库中相同。
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. 按照 [Oracle 支持说明 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) 中所述，设置可传输表空间实用程序。
安装包括在源主机上编辑 `xtt.properties` 文件。以下示例 `xtt.properties` 文件指定 `/dsk1/backups` 目录中三个表空间的备份。这些是您打算传输到目标数据库实例的表空间。它还指定源平台 ID 以自动转换字节顺序。
**注意**
有关有效的平台 ID，请参阅 [Data Guard 对同一 Data Guard 配置中异构主备用服务器和物理备用服务器的支持（文档 ID 413484.1）](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)。
```
#linux system
platformid=13
#list of tablespaces to transport
tablespaces=TBS1,TBS2,TBS3
#location where backup will be generated
src_scratch_location=/dsk1/backups
#RMAN command for performing backup
usermantransport=1
```
## 第 2 阶段：准备完整的表空间备份
在此阶段中，您将首次备份表空间，将备份传输到目标主机，然后使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 将其还原。此阶段完成后，初始表空间备份将驻留在您的目标数据库实例上，并且可以使用增量备份进行更新。
**Topics**
+ [步骤 1：备份源主机上的表空间](#oracle-migrating-tts.backup-full)
+ [步骤 2：将备份文件传输到您的目标数据库实例](#oracle-migrating-tts.transfer-full)
+ [步骤 3：在目标数据库实例上导入表空间](#oracle-migrating-tts.initial-tts-import)
### 步骤 1：备份源主机上的表空间
在此步骤中，您将使用 `xttdriver.pl` 脚本对表空间进行完整备份。`xttdriver.pl` 的输出存储在 `TMPDIR` 环境变量中。
**备份您的表空间**
1. 如果您的表空间处于只读模式，请以具有 `ALTER TABLESPACE` 权限的用户身份登录到源数据库，并将表空间置于读/写模式。否则，请跳到下一步。
以下示例将 `tbs1`、`tbs2` 和 `tbs3` 置于读/写模式。
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. 使用 `xttdriver.pl` 脚本备份您的表空间。或者，您可以指定 `--debug` 以在调试模式下运行脚本。
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### 步骤 2：将备份文件传输到您的目标数据库实例
在此步骤中，将备份和配置文件从临时位置复制到目标数据库实例。请选择以下选项之一：
+ 如果源主机和目标主机共享 Amazon EFS 文件系统，请使用操作系统实用程序（例如 `cp`）将您的备份文件和 `res.txt` 文件从临时位置复制到共享目录。然后跳至 [步骤 3：在目标数据库实例上导入表空间](#oracle-migrating-tts.initial-tts-import)。
+ 如果您需要将备份暂存到 Amazon S3 桶，请完成以下步骤。
![\[使用 Amazon S3 或 Amazon EFS 传输文件。\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### 步骤 2.2：将备份上传到 Amazon S3 桶
将您的备份和 `res.txt` 文件从临时目录上传到您的 Amazon S3 桶。有关更多信息，请参阅《Amazon Simple Storage Service 开发人员指南》**中的[上传对象](https://docs.amazonaws.cn/AmazonS3/latest/userguide/upload-objects.html)。
#### 步骤 2.3：将备份从 Amazon S3 桶下载到目标数据库实例
在此步骤中，您将使用过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份下载到您的 RDS for Oracle 数据库实例。
**从您的 Amazon S3 桶下载备份**
1. 启动 SQL\$1Plus 或 Oracle SQL Developer，并登录到 RDS for Oracle 数据库实例。
1. 使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份从 Amazon S3 桶下载到您的目标数据库实例。以下示例将所有文件从名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶下载到 `DATA_PUMP_DIR` 目录中。
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'res.txt');
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例](oracle-s3-integration.using.md#oracle-s3-integration.using.download)。
### 步骤 3：在目标数据库实例上导入表空间
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 将表空间还原到目标数据库实例。此过程会自动将数据文件转换为正确的字节顺序格式。
如果您从 Linux 以外的平台导入，请在调用 `p_platform_id` 时使用参数 `import_xtts_tablespaces` 指定源平台。确保您指定的平台 ID 与 [步骤 2：在源主机上导出表空间元数据](#oracle-migrating-tts.transport.export) 中 `xtt.properties` 文件中指定的平台 ID 匹配。
**在目标数据库实例上导入表空间**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标 RDS for Oracle 数据库实例。
1. 运行过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`，同时指定要导入的表空间和包含备份的目录。
以下示例从 *DATA\$1PUMP\$1DIR* 目录中导入表空间 *TBS1*、*TBS2* 和 *TBS3*。源平台是基于 AIX 的系统（64 位），其平台 ID 为 `6`。您可以通过查询 `V$TRANSPORTABLE_PLATFORM` 查找平台 ID。
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
1. （可选）通过查询表 `rdsadmin.rds_xtts_operation_info` 来监控进度。`xtts_operation_state` 列显示值 `EXECUTING`、`COMPLETED` 或 `FAILED`。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**注意**
对于长时间运行的操作，也可以查询 `V$SESSION_LONGOPS`、`V$RMAN_STATUS` 和 `V$RMAN_OUTPUT`。
1. 使用上一步中的任务 ID 查看已完成的导入的日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
在继续下一步之前，请确保导入成功。
## 第 3 阶段：制作和传输增量备份
在此阶段，您需要在源数据库处于活动状态时定期制作和传输增量备份。此技术减小了最终表空间备份的大小。如果您进行多个增量备份，则必须先在最后一个增量备份之后复制 `res.txt` 文件，然后才能将其应用到目标实例。
步骤与[第 2 阶段：准备完整的表空间备份](#oracle-migrating-tts.initial-br-phase)中的步骤相同，不同之处为导入步骤是可选的。
## 阶段 4：传输表空间
在此阶段，您将备份只读表空间并导出 Data Pump 元数据，将这些文件传输到目标主机，然后导入表空间和元数据。
**Topics**
+ [步骤 1：备份只读表空间](#oracle-migrating-tts.final-backup)
+ [步骤 2：在源主机上导出表空间元数据](#oracle-migrating-tts.transport.export)
+ [步骤 3：（仅限 Amazon S3）将备份和导出文件传输到您的目标数据库实例](#oracle-migrating-tts.transport)
+ [步骤 4：在目标数据库实例上导入表空间](#oracle-migrating-tts.restore-full)
+ [步骤 5：在目标数据库实例上导入表空间元数据](#oracle-migrating-tts.transport.import-dmp)
### 步骤 1：备份只读表空间
此步骤与[步骤 1：备份源主机上的表空间](#oracle-migrating-tts.backup-full)相同，但有一个关键区别：在最后一次备份表空间之前，您将表空间置于只读模式。
以下示例将 `tbs1`、`tbs2`、和 `tbs3` 置于只读模式。
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### 步骤 2：在源主机上导出表空间元数据
通过在源主机上运行 `expdb` 实用程序来导出表空间元数据。以下示例将表空间 *TBS1*、*TBS2* 和 *TBS3* 导出到目录 *DATA\$1PUMP\$1DIR* 中的转储文件 *xttdump.dmp*。
```
expdp username/pwd \
dumpfile=xttdump.dmp \
directory=DATA_PUMP_DIR \
statistics=NONE \
transport_tablespaces=TBS1,TBS2,TBS3 \
transport_full_check=y \
logfile=tts_export.log
```
如果 *DATA\$1PUMP\$1DIR* 是 Amazon EFS 中的共享目录，请跳至[步骤 4：在目标数据库实例上导入表空间](#oracle-migrating-tts.restore-full)。
### 步骤 3：（仅限 Amazon S3）将备份和导出文件传输到您的目标数据库实例
如果您使用 Amazon S3 暂存表空间备份和 Data Pump 导出文件，请完成以下步骤。
#### 步骤 3.1：将备份和转储文件从源主机上传到您的 Amazon S3 桶
将您的备份和转储文件从源主机上传到 Amazon S3 桶。有关更多信息，请参阅《Amazon Simple Storage Service 开发人员指南》**中的[上传对象](https://docs.amazonaws.cn/AmazonS3/latest/userguide/upload-objects.html)。
#### 步骤 3.2：将备份和转储文件从 Amazon S3 桶下载到目标数据库实例
在此步骤中，您将使用过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 将备份和转储文件下载到您的 RDS for Oracle 数据库实例。按照 [步骤 2.3：将备份从 Amazon S3 桶下载到目标数据库实例](#oracle-migrating-tts.download-full) 中的步骤操作。
### 步骤 4：在目标数据库实例上导入表空间
使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` 还原表空间。有关此过程的语法和语义，请参阅[将传输的表空间导入到您的数据库实例](rdsadmin_transport_util_import_xtts_tablespaces.md)
**重要**
完成最终表空间导入后，下一步是[导入 Oracle Data Pump 元数据](#oracle-migrating-tts.transport.export)。如果导入失败，请务必将数据库实例恢复到失败前的状态。因此，建议您按照[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)中的说明创建数据库实例的数据库快照。快照将包含所有导入的表空间，因此，如果导入失败，则无需重复备份和导入过程。
如果您的目标数据库实例已开启自动备份，并且 Amazon RDS 在您导入元数据之前未检测到已启动有效的快照，则 RDS 会尝试创建快照。根据您的实例活动，此快照可能会成功，也可能不成功。如果未检测到有效的快照或无法启动快照，则元数据导入将退出并显示错误。
**在目标数据库实例上导入表空间**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标 RDS for Oracle 数据库实例。
1. 运行过程 `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`，同时指定要导入的表空间和包含备份的目录。
以下示例从 *DATA\$1PUMP\$1DIR* 目录中导入表空间 *TBS1*、*TBS2* 和 *TBS3*。
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. （可选）通过查询表 `rdsadmin.rds_xtts_operation_info` 来监控进度。`xtts_operation_state` 列显示值 `EXECUTING`、`COMPLETED` 或 `FAILED`。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**注意**
对于长时间运行的操作，也可以查询 `V$SESSION_LONGOPS`、`V$RMAN_STATUS` 和 `V$RMAN_OUTPUT`。
1. 使用上一步中的任务 ID 查看已完成的导入的日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
在继续下一步之前，请确保导入成功。
1. 按照[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)中的说明制作手动数据库快照。
### 步骤 5：在目标数据库实例上导入表空间元数据
在此步骤中，使用过程 `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` 将可传输的表空间元数据导入您的 RDS for Oracle 数据库实例。有关此过程的语法和语义，请参阅[将可传输的表空间元数据导入到数据库实例中](rdsadmin_transport_util_import_xtts_metadata.md)。在操作期间，导入的状态显示在表 `rdsadmin.rds_xtts_operation_info` 中。
**重要**
在导入元数据之前，我们强烈建议您确认在导入表空间后已成功创建数据库快照。如果导入步骤失败，请还原数据库实例，解决导入错误，然后再次尝试导入。
**将 Data Pump 元数据导入您的 RDS for Oracle 数据库实例**
1. 启动 Oracle SQL 客户端，并以主用户身份登录到目标数据库实例。
1. 在传输的表空间中创建拥有模式的用户（如果这些用户尚不存在）。
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. 导入元数据，同时指定转储文件的名称及其目录位置。
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. （可选）查询可传输的表空间历史记录表以查看元数据导入的状态。
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
操作完成后，您的表空间将处于只读模式。
1. （可选）查看日志文件。
以下示例列出了 BDUMP 目录的内容，然后查询导入日志。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'BDUMP'));
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-import_xtts_metadata-2023-05-22.01-52-35.560858000.log'));
```
## 第 5 阶段：验证传输的表空间
在此可选步骤中，使用过程 `rdsadmin.rdsadmin_rman_util.validate_tablespace` 验证传输的表空间，然后将表空间置于读/写模式。
**验证传输的数据**
1. 启动 SQL\$1Plus 或 SQL Developer，并以主用户身份登录到目标数据库实例。
1. 使用过程 `rdsadmin.rdsadmin_rman_util.validate_tablespace` 验证表空间。
```
SET SERVEROUTPUT ON
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS1',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS2',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS3',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
END;
/
```
1. 将表空间置于读/写模式。
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## 第 6 阶段：清理剩余文件
在此可选步骤中，您将删除所有不需要的文件。使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程列出表空间导入后孤立的数据文件，然后使用 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` 过程删除它们。有关这些过程的语法和语义，请参阅[列出表空间导入后的孤立文件](rdsadmin_transport_util_list_xtts_orphan_files.md)和[表空间导入后的孤立数据文件](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)。
**清理剩余文件**
1. 按如下方式删除 *DATA\$1PUMP\$1DIR* 中的旧备份：
1. 通过运行 `rdsadmin.rdsadmin_file_util.listdir` 列出备份文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. 通过调用 `UTL_FILE.FREMOVE` 逐一删除备份。
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. 如果您导入了表空间，但没有为这些表空间导入元数据，则可以按如下方式删除孤立的数据文件：
1. 列出需要删除的孤立数据文件。以下示例运行过程 `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`。
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
1. 通过运行过程 `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` 删除孤立文件。
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
清理操作会在 `BDUMP` 目录中生成一个使用名称格式 `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` 的日志文件。
1. 读取上一步中生成的日志文件。以下示例读取日志 `rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log`。
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
1. 如果您导入了表空间并为这些表空间导入了元数据，但遇到了兼容性错误或其他 Oracle Data Pump 问题，请按如下方式清理部分传输的数据文件：
1. 通过查询 `DBA_TABLESPACES` 列出包含部分传输的数据文件的表空间。
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. 删除表空间和部分传输的数据文件。
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# 使用 Oracle Data Pump 导入
Oracle Data Pump 是一个实用程序，可让您将 Oracle 数据导出到转储文件并将其导入到另一个 Oracle 数据库。长期来看，它最终会取代 Oracle Export/Import 实用程序。Oracle Data Pump 是将大量数据从 Oracle 数据库迁移到 Amazon RDS 数据库实例的建议方法。
本节中的示例展示了将数据导入 Oracle 数据库的一种方法，但 Oracle Data Pump 支持其他方法。有关更多信息，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A)。
本节中的示例使用 `DBMS_DATAPUMP` 包。您可以使用 Oracle Data Pump 命令行实用程序 `impdp` 和 `expdp` 完成相同的任务。您可以在远程主机上安装这些实用程序以作为 Oracle 客户端安装的一部分，包括 Oracle 即时客户端。有关更多信息，请参阅[如何使用 Oracle Instant Client 为我的 Amazon RDS for Oracle 数据库实例运行 Data Pump 导入或导出？](https://www.amazonaws.cn/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/)
**Topics**
+ [Oracle Data Pump 概述](#Oracle.Procedural.Importing.DataPump.Overview)
+ [使用 Oracle Data Pump 和 Amazon S3 存储桶导入数据](#Oracle.Procedural.Importing.DataPump.S3)
+ [使用 Oracle Data Pump 和数据库链接导入数据](#Oracle.Procedural.Importing.DataPump.DBLink)
## Oracle Data Pump 概述
Oracle Data Pump 由以下组件组成：
+ 命令行客户端 `expdp` 和 `impdp`
+ `DBMS_DATAPUMP` PL/SQL 程序包
+ `DBMS_METADATA` PL/SQL 程序包
您可以将 Oracle Data Pump 用于以下场景：
+ 将数据从 Oracle 数据库（可以是本地或在 Amazon EC2 实例上）导入到 RDS for Oracle 数据库实例。
+ 将数据从 RDS for Oracle 数据库实例导入到 Oracle 数据库（可以是本地或在 Amazon EC2 实例上）。
+ 在 RDS for Oracle 数据库实例之间导入数据，例如将数据从 EC2-Classic 迁移到 VPC。
要下载 Oracle Data Pump 实用工具，请参阅 Oracle Technology Network 网站上的 [Oracle 数据库软件下载](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html)。有关在 Oracle Database 的版本之间进行迁移时的兼容性注意事项，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68)。
### Oracle Data Pump 工作流
通常，您在以下阶段使用 Oracle Data Pump：
1. 将数据导出到源数据库上的转储文件。
1. 将转储文件上载到目标 RDS for Oracle 数据库实例。您可以使用 Amazon S3 桶或使用两个数据库之间的数据库链接进行传输。
1. 将数据从转储文件中导入到 RDS for Oracle 数据库实例。
### Oracle Data Pump 最佳实践
当您使用 Oracle Data Pump 将数据导入到 RDS for Oracle 实例时，我们建议使用以下最佳实践：
+ 在 `schema` 或 `table` 模式中执行导入，以便导入特定架构和对象。
+ 将您导入的架构限制为您的应用程序所需的架构。
+ 请勿在 `full` 模式下导入，也不要导入系统维护的组件的架构。
因为 RDS for Oracle 不允许 `SYS` 或 `SYSDBA` 管理用户进行访问，所以，这些操作可能会损坏 Oracle 数据词典并影响数据库的稳定性。
+ 加载大量数据时，请执行以下操作：
1. 将转储文件转移到目标 RDS for Oracle 数据库实例。
1. 为您的数据库实例拍摄快照。
1. 测试导入以验证导入是否成功。
如果数据库组件失效，则您可以删除数据库实例并通过数据库快照重新创建它。还原的数据库实例包括当您拍摄数据库快照时暂存在数据库实例上的任何转储文件。
+ 请勿导入使用 Oracle Data Pump 导出参数 `TRANSPORT_TABLESPACES`、`TRANSPORTABLE`、或 `TRANSPORT_FULL_CHECK` 创建的转储文件。RDS for Oracle 数据库实例不支持导入这些转储文件。
+ 不要导入包含 Oracle 计划程序对象的转储文件 `SYS`、`SYSTEM`、`RDSADMIN`、`RDSSEC` 和 `RDS_DATAGUARD`，以及属于以下类别的文件：
+ 作业
+ 计划
+ Schedules
+ 链
+ 规则
+ 评估背景
+ 规则集
RDS for Oracle 数据库实例不支持导入这些转储文件。
+ 要排除不受支持的 Oracle 计划程序对象，请在 Data Pump 导出期间使用其他指令。如果您使用 `DBMS_DATAPUMP`，则可以在 `METADATA_FILTER` 之前添加额外的 `DBMS_METADATA.START_JOB`：
```
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
```
如果使用 `expdp`，请创建包含以下示例中所示的 `exclude` 指令的参数文件。然后，将 `PARFILE=parameter_file` 与您的 `expdp` 命令一起使用。
```
exclude=procobj:"IN
(SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)"
```
## 使用 Oracle Data Pump 和 Amazon S3 存储桶导入数据
以下导入过程使用 Oracle Data Pump 和 Amazon S3 存储桶。步骤如下所示：
1. 使用 Oracle [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) 程序包导出源数据库上的数据。
1. 将转储文件置于 Amazon S3 桶中。
1. 将转储文件从 Amazon S3 桶下载到目标 RDS for Oracle 数据库实例上的 `DATA_PUMP_DIR` 目录。
1. 使用 `DBMS_DATAPUMP` 程序包，将数据从复制的转储文件导入到 RDS for Oracle 数据库实例。
**Topics**
+ [使用 Oracle Data Pump 和 Amazon S3 桶导入数据的要求](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [步骤 1：在 RDS for Oracle 目标数据库实例上向数据库用户授予权限](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [步骤 2：使用 DBMS\$1DATAPUMP 将数据导出到转储文件中](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [步骤 3：将转储文件上传到 Amazon S3 存储桶。](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [步骤 4：将转储文件从 Amazon S3 桶下载到目标数据库实例](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [步骤 5：使用 DBMS\$1DATAPUMP 将转储文件导入到目标数据库实例](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [步骤 6：清除](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### 使用 Oracle Data Pump 和 Amazon S3 桶导入数据的要求
此过程有以下要求：
+ 确保 Amazon S3 桶可用于文件传输，并且 Amazon S3 桶与数据库实例处于相同的 Amazon Web Services 区域中。有关说明，请参阅 *Amazon Simple Storage Service 入门指南* 中的[创建存储桶](https://docs.amazonaws.cn/AmazonS3/latest/userguide/CreatingABucket.html)。
+ 您上传到 Amazon S3 存储桶的对象不得超过 5 TB。有关在 Amazon S3 中使用对象的更多信息，请参阅 [Amazon Simple Storage Service 用户指南](https://docs.amazonaws.cn/AmazonS3/latest/dev/UsingObjects.html)。
**注意**
如果要转储超过 5 TB 的文件，则可以使用并行选项来运行 Oracle Data Pump 导出。此操作会将数据分散到多个转储文件中，以便不会超过单个文件的 5 TB 限制。
+ 您必须按照 [为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md) 中的说明为 Amazon RDS 集成准备 Amazon S3 存储桶。
+ 您必须确保有足够的存储空间来存储源实例和目标数据库实例上的转储文件。
**注意**
此过程将转储文件导入到 `DATA_PUMP_DIR` 目录（所有 Oracle 数据库实例上的预配置目录）中。此目录位于您的数据文件所在的存储卷上。当您导入转储文件时，现有 Oracle 文件使用更多空间。因此，您应该确保您的数据库实例可适应这个额外的空间使用。导入的转储文件不会自动从 `DATA_PUMP_DIR` 目录中删除或清除。要删除导入的转储文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
### 步骤 1：在 RDS for Oracle 目标数据库实例上向数据库用户授予权限
在此步骤中，您将创建您计划向其中导入数据的架构，并向用户授予必要的权限。
**在 RDS for Oracle 目标实例上创建用户并授予必要的权限**
1. 使用 SQL\$1Plus 或 Oracle SQL Developer，作为主用户登录到将向其中导入数据的 RDS for Oracle 数据库实例。有关连接到数据库实例的信息，请参阅[连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 在导入数据之前，创建所需的表空间。有关更多信息，请参阅 [在 RDS for Oracle 中创建表空间并调整其大小](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)。
1. 如果要向其中导入数据的用户账户不存在，请创建用户账户并授予必需的权限和角色。如果您打算将数据导入到多个用户架构，请创建各个用户账户并向其授予所需的权限和角色。
例如，以下 SQL 语句创建新的用户并授予所需权限和角色，以将数据导入到此用户拥有的架构中。将 `schema_1` 替换为此步骤中和下列步骤中架构的名称。
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
前面的语句向新用户授予 `CREATE SESSION` 权限和 `RESOURCE` 角色。根据导入的数据库对象，您可能需要其他权限和角色。
### 步骤 2：使用 DBMS\$1DATAPUMP 将数据导出到转储文件中
要创建转储文件，请使用 `DBMS_DATAPUMP` 程序包。
**将 Oracle 数据导出到转储文件**
1. 使用 SQL Plus 或 Oracle SQL Developer，以管理用户身份连接到源 RDS for Oracle 数据库实例。如果源数据库是 RDS for Oracle 数据库实例，请使用 Amazon RDS 主用户身份进行连接。
1. 通过调用 `DBMS_DATAPUMP` 过程导出数据。
以下脚本将 `SCHEMA_1` 架构导出到 `DATA_PUMP_DIR` 目录中名为 `sample.dmp` 的转储文件中。将 `SCHEMA_1` 替换为要导出的架构的名称。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT',
job_mode => 'SCHEMA',
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_exp.log',
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
Data Pump 异步启动任务。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。
1. （可选）通过调用 `rdsadmin.rds_file_util.read_text_file` 过程查看导出日志的内容。有关更多信息，请参阅 [读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
### 步骤 3：将转储文件上传到 Amazon S3 存储桶。
使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` 将转储文件复制到 Amazon S3 存储桶中。以下示例将 `DATA_PUMP_DIR` 目录中的所有文件上传到名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶中。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 RDS for Oracle 数据库实例上传到 Amazon S3 存储桶](oracle-s3-integration.using.md#oracle-s3-integration.using.upload)。
### 步骤 4：将转储文件从 Amazon S3 桶下载到目标数据库实例
使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 执行此步骤。将文件下载到目录时，如果目录中已存在同名文件，则过程 `download_from_s3` 将跳过下载。要从下载目录中删除文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
**下载转储文件**
1. 启动 SQL\$1Plus 或 Oracle Developer 并以主用户身份登录 Amazon RDS 目标 Oracle 数据库实例
1. 使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3` 下载转储文件。
以下示例将所有文件从名为 `amzn-s3-demo-bucket` 的 Amazon S3 桶下载到 `DATA_PUMP_DIR` 目录中。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。有关更多信息，请参阅 [将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例](oracle-s3-integration.using.md#oracle-s3-integration.using.download)。
### 步骤 5：使用 DBMS\$1DATAPUMP 将转储文件导入到目标数据库实例
使用 `DBMS_DATAPUMP` 将架构导入到 RDS for Oracle 数据库实例。可能需要额外的选项（例如 `METADATA_REMAP`）。
**将数据导入到目标数据库实例**
1. 启动 SQL\$1Plus 或 SQL Developer 并以主用户身份登录 RDS for Oracle 数据库实例。
1. 通过调用 `DBMS_DATAPUMP` 过程导入数据。
下面的示例将 *SCHEMA\$11* 数据从 `sample_copied.dmp` 导入到目标数据库实例。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导入日志的内容。有关更多信息，请参阅 [读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
1. 通过列出目标数据库实例上的架构表来验证数据导入。
例如，以下查询将返回 `SCHEMA_1` 的表数量。
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### 步骤 6：清除
导入数据后，可以删除不想保留的文件。
**删除不需要的文件**
1. 启动 SQL\$1Plus 或 SQL Developer 并以主用户身份登录 RDS for Oracle 数据库实例。
1. 使用以下命令列出 `DATA_PUMP_DIR` 中的文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. 要删除 `DATA_PUMP_DIR` 中不再需要的文件，请使用以下命令。
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
例如，以下命令删除名为 `sample_copied.dmp` 的文件
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## 使用 Oracle Data Pump 和数据库链接导入数据
以下导入过程使用 Oracle Data Pump 和 Oracle [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html) 包。步骤如下所示：
1. 连接到源 Oracle 数据库，此数据库可以是本地数据库、Amazon EC2 实例 或 RDS for Oracle 数据库实例。
1. 使用 [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html) 程序包导出数据。
1. 使用 `DBMS_FILE_TRANSFER.PUT_FILE` 将转储文件从 Oracle 数据库复制到通过数据库链接连接到的目标 RDS for Oracle 数据库实例上的 `DATA_PUMP_DIR` 目录中。
1. 使用 ` DBMS_DATAPUMP` 程序包，将数据从复制的转储文件导入到 RDS for Oracle 数据库实例。
使用 Oracle 数据转储和 `DBMS_FILE_TRANSFER` 包的导入过程具有以下步骤。
**Topics**
+ [使用 Oracle Data Pump 和数据库链接导入数据的要求](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [步骤 1：在 RDS for Oracle 目标数据库实例上向用户授予权限](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [步骤 2：向用户授予源数据库权限](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [步骤 3：使用 DBMS\$1DATAPUMP 创建转储文件](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [步骤 4：创建目标数据库实例的数据库链接](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [步骤 5：使用 DBMS\$1FILE\$1TRANSFER 将导出的转储文件复制到目标数据库实例](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [步骤 6：使用 DBMS\$1DATAPUMP 将数据文件导入到目标数据库实例](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [步骤 7：清除](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### 使用 Oracle Data Pump 和数据库链接导入数据的要求
此过程有以下要求：
+ 您必须对 `DBMS_FILE_TRANSFER` 和 `DBMS_DATAPUMP` 包具有执行权限。
+ 您必须对源数据库实例上的 `DATA_PUMP_DIR` 目录具有写入权限。
+ 您必须确保有足够的存储空间来存储源实例和目标数据库实例上的转储文件。
**注意**
此过程将转储文件导入到 `DATA_PUMP_DIR` 目录（所有 Oracle 数据库实例上的预配置目录）中。此目录位于您的数据文件所在的存储卷上。当您导入转储文件时，现有 Oracle 文件使用更多空间。因此，您应该确保您的数据库实例可适应这个额外的空间使用。导入的转储文件不会自动从 `DATA_PUMP_DIR` 目录中删除或清除。要删除导入的转储文件，请使用 Oracle 网站上的 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
### 步骤 1：在 RDS for Oracle 目标数据库实例上向用户授予权限
要向用户授予对 RDS for Oracle 目标数据库实例的权限，请执行以下步骤：
1. 使用 SQL Plus 或 Oracle SQL Developer 连接到要向其中导入数据的 RDS for Oracle 数据库实例。以 Amazon RDS 主用户的身份连接。有关连接到数据库实例的信息，请参阅[连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 在导入数据之前，创建所需的表空间。有关更多信息，请参阅“[在 RDS for Oracle 中创建表空间并调整其大小](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)”。
1. 如果要导入数据的用户账户不存在，请创建用户账户并授予必需的权限和角色。如果您打算将数据导入到多个用户架构，请创建各个用户账户并向其授予所需的权限和角色。
例如，以下命令创建名为 *schema\$11* 的新用户，并向此用户授予所需权限和角色，以将数据导入到用户架构中。
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
前一个示例为新用户授予 `CREATE SESSION` 权限和 `RESOURCE` 角色。根据导入的数据库对象，可能需要其他权限和角色。
**注意**
将 `schema_1` 替换为此步骤中和下列步骤中架构的名称。
### 步骤 2：向用户授予源数据库权限
使用 SQL\$1Plus 或 Oracle SQL Developer 连接到包含要导入的数据的 RDS for Oracle 数据库实例。如有必要，可创建用户账户并授予必要权限。
**注意**
如果源数据库是 Amazon RDS 实例，则可以跳过此步骤。使用您的 Amazon RDS 主用户账户来执行导出。
以下命令创建新用户并授予必要权限。
```
CREATE USER export_user IDENTIFIED BY my-password;
GRANT CREATE SESSION, CREATE TABLE, CREATE DATABASE LINK TO export_user;
ALTER USER export_user QUOTA 100M ON users;
GRANT READ, WRITE ON DIRECTORY data_pump_dir TO export_user;
GRANT SELECT_CATALOG_ROLE TO export_user;
GRANT EXECUTE ON DBMS_DATAPUMP TO export_user;
GRANT EXECUTE ON DBMS_FILE_TRANSFER TO export_user;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
### 步骤 3：使用 DBMS\$1DATAPUMP 创建转储文件
要创建转储文件，请执行以下操作：
1. 使用 SQL\$1Plus 或 Oracle SQL Developer，以管理用户或在步骤 2 中创建的用户身份连接到源 Oracle 实例。如果源数据库是 Amazon RDS for Oracle 数据库实例，请使用 Amazon RDS 主用户身份连接。
1. 使用 Oracle Data Pump 实用程序创建转储文件。
以下脚本在 `DATA_PUMP_DIR` 目录中创建一个名为 *sample.dmp* 的转储文件。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT' ,
job_mode => 'SCHEMA' ,
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample_exp.log' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl ,
'SCHEMA_EXPR' ,
'IN (''SCHEMA_1'')'
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导出日志的内容。有关更多信息，请参阅“[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)”。
### 步骤 4：创建目标数据库实例的数据库链接
在源数据库实例和目标数据库实例之间创建数据库链接。您的本地 Oracle 实例必须具有至数据库实例的网络连接，然后才能创建数据库链接以及传输导出转储文件。
执行此步骤，使用与上一步中相同的用户账户连接。
如果您将在同一 VPC 或对等 VPC 中的两个数据库实例之间创建数据库链接，则这两个数据库实例之间应具有有效路由。每个数据库实例的安全组必须允许另一个数据库实例的传入和传出。安全组入站和出站规则可引用同一 VPC 或对等 VPC 中的安全组。有关更多信息，请参阅“[在 VPC 中调整用于数据库实例的数据库链接](Appendix.Oracle.CommonDBATasks.DBLinks.md)”。
以下命令创建名为 `to_rds` 的数据库链接，连接到位于目标数据库实例中的 Amazon RDS 主用户。
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### 步骤 5：使用 DBMS\$1FILE\$1TRANSFER 将导出的转储文件复制到目标数据库实例
使用 `DBMS_FILE_TRANSFER` 将转储文件从源数据库实例复制到目标数据库实例。以下脚本将名为 sample.dmp 的转储文件从源实例复制到名为 *to\$1rds* 的目标数据库链接（已在上一步中创建）。
```
BEGIN
DBMS_FILE_TRANSFER.PUT_FILE(
source_directory_object => 'DATA_PUMP_DIR',
source_file_name => 'sample.dmp',
destination_directory_object => 'DATA_PUMP_DIR',
destination_file_name => 'sample_copied.dmp',
destination_database => 'to_rds' );
END;
/
```
### 步骤 6：使用 DBMS\$1DATAPUMP 将数据文件导入到目标数据库实例
在数据库实例中使用 Oracle Data Pump 导入架构。可能需要额外选项（例如，METADATA\$1REMAP）。
使用 Amazon RDS 主用户账户连接到数据库实例来执行导入。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**注意**
数据抽取任务将异步开始。有关监控 Data Pump 作业的信息，请参阅 Oracle 文档中的[监控作业状态](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7)。您可以使用 `rdsadmin.rds_file_util.read_text_file` 过程查看导入日志的内容。有关更多信息，请参阅“[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)”。
您可以通过查看数据库实例上用户的表来验证数据导入。例如，以下查询将返回 `schema_1` 的表数量。
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### 步骤 7：清除
导入数据后，可以删除不想保留的文件。您可以使用以下命令列出 `DATA_PUMP_DIR` 中的文件。
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
要删除 `DATA_PUMP_DIR` 中不再需要的文件，请使用以下命令。
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
例如，以下命令删除名为 `"sample_copied.dmp"` 的文件
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# 使用 Oracle Export/Import 进行导入
在以下情况下，您可以考虑使用 Oracle Export/Import 实用程序进行迁移：
+ 您的数据量很小。
+ 不需要二进制浮点数和双精度等数据类型。
导入过程会创建必要的模式对象。因此，无需事先运行脚本来创建对象。
安装 Oracle 导出和导入实用程序的最简单方法是安装 Oracle Instant Client。要下载该软件，请前往 [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html)。有关文档，请参阅《Oracle 数据库实用程序》**手册中的[适用于 SQL\$1Loader、导出和导入的 Instant Client](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965)。
**导出表，然后导入它们**
1. 使用 `exp` 命令将表从源数据库中导出。
以下命令导出名为 `tab1`、`tab2` 以及 `tab3` 的表。转储文件为 `exp_file.dmp`。
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
导出会创建一个二进制转储文件，其中包含指定表的架构和数据。
1. 使用 `imp` 命令将架构和数据导入目标数据库。
以下命令从转储文件 `exp_file.dmp` 中导入表 `tab1`、`tab2` 和 `tab3`。
```
imp cust_dba@targetdb FROMUSER=cust_schema TOUSER=cust_schema \
TABLES=(tab1,tab2,tab3) FILE=exp_file.dmp LOG=imp_file.log
```
“导出”和“导入”具有其他可能更适合您的要求的变体。有关完整详细信息，请参阅 Oracle Database 文档。
# 使用 Oracle SQL\$1Loader 进行导入
您可以考虑将 Oracle SQL\$1Loader 用于对象数量有限的大型数据库。由于从源数据库导出并加载到目标数据库的过程特定于架构，因此，下面的示例创建示例模式对象，从源导出，然后将数据加载到目标数据库。
安装 Oracle SQL\$1Loader 的最简单方法是安装 Oracle Instant Client。要下载该软件，请前往 [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html)。有关文档，请参阅《Oracle 数据库实用程序》**手册中的[适用于 SQL\$1Loader、导出和导入的 Instant Client](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965)。
**使用 Oracle SQL\$1Loader 导入数据**
1. 使用以下 SQL 语句创建示例源表。
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. 在目标 RDS for Oracle 数据库实例上，创建用于加载数据的目标表。子句 `WHERE 1=2` 可确保复制 `ALL_OBJECTS` 的结构，但不复制任何行。
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. 将数据从源数据库导出到文本文件。以下示例使用 SQL\$1Plus。对于数据，您可能需要生成用于执行数据库中所有对象导出操作的脚本。
```
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY/MM/DD HH24:MI:SS'
SET LINESIZE 800 HEADING OFF FEEDBACK OFF ARRAY 5000 PAGESIZE 0
SPOOL customer_0.out
SET MARKUP HTML PREFORMAT ON
SET COLSEP ','
SELECT id, owner, object_name, created
FROM customer_0;
SPOOL OFF
```
1. 创建一个控制文件来描述数据。您可能需要编写脚本来执行此步骤。
```
cat << EOF > sqlldr_1.ctl
load data
infile customer_0.out
into table customer_1
APPEND
fields terminated by "," optionally enclosed by '"'
(
id POSITION(01:10) INTEGER EXTERNAL,
owner POSITION(12:41) CHAR,
object_name POSITION(43:72) CHAR,
created POSITION(74:92) date "YYYY/MM/DD HH24:MI:SS"
)
```
如果需要，将上述代码生成的文件复制到某一暂存区域，如 Amazon EC2 实例。
1. 通过适用于目标数据库的用户名和密码，使用 SQL\$1Loader 导入数据。
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# 使用 Oracle 实体化视图进行迁移
要高效率地迁移大型数据集，您可以使用 Oracle 实体化视图复制功能。通过复制，您可以使目标表与源表保持同步。这样，如果需要，您可以稍后切换到 Amazon RDS。
在可以使用实体化视图进行迁移之前，请确保满足以下要求：
+ 配置从目标数据库到源数据库的访问权限。在以下示例中，在源数据库上启用了访问规则，以允许 RDS for Oracle 目标数据库通过 SQL\$1Net 与源数据库连接。
+ 创建从 RDS for Oracle 数据库实例到源数据库的数据库链接。
**使用实体化视图迁移数据**
1. 在源实例和 RDS for Oracle 目标实例上，创建可以使用同一密码进行身份验证的用户账户。下面的示例创建了一个名为 `dblink_user` 的用户。
```
CREATE USER dblink_user IDENTIFIED BY my-password
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp;
GRANT CREATE SESSION TO dblink_user;
GRANT SELECT ANY TABLE TO dblink_user;
GRANT SELECT ANY DICTIONARY TO dblink_user;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 使用新创建的用户创建从 RDS for Oracle 目标实例到源实例的数据库链接。
```
CREATE DATABASE LINK remote_site
CONNECT TO dblink_user IDENTIFIED BY my-password
USING '(description=(address=(protocol=tcp) (host=my-host)
(port=my-listener-port)) (connect_data=(sid=my-source-db-sid)))';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 测试链接：
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. 使用主键和源实例上的具体化视图日志创建示例表。
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
ALTER TABLE customer_0 ADD CONSTRAINT pk_customer_0 PRIMARY KEY (id) USING INDEX;
CREATE MATERIALIZED VIEW LOG ON customer_0;
```
1. 在目标 RDS for Oracle 数据库实例上，创建实体化视图。
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. 在目标 RDS for Oracle 实例上，刷新实体化视图。
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. 删除实体化视图并包括 `PRESERVE TABLE` 子句，以便保留实体化视图容器表及其内容。
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
保留的表拥有与已删除具体化视图相同的名称。
# 使用 Amazon RDS for Oracle 的只读副本
要在 Oracle 数据库实例之间配置复制，您可以创建副本数据库。有关 Amazon RDS 只读副本的概览，请参阅 [Amazon RDS 只读副本概述概述](USER_ReadRepl.md#USER_ReadRepl.Overview)。有关 Oracle 副本和其他数据库引擎之间的差异摘要，请参阅 [数据库引擎的只读副本之间的差异](USER_ReadRepl.Overview.Differences.md)。
**Topics**
+ [RDS for Oracle 副本概述](oracle-read-replicas.overview.md)
+ [RDS for Oracle 副本的要求和注意事项](oracle-read-replicas.limitations.md)
+ [为创建 Oracle 副本做准备](oracle-read-replicas.Configuration.md)
+ [在装载模式下创建 RDS for Oracle 副本](oracle-read-replicas.creating-in-mounted-mode.md)
+ [修改 RDS for Oracle 副本模式](oracle-read-replicas.changing-replica-mode.md)
+ [使用 RDS for Oracle 副本备份](oracle-read-replicas.backups.md)
+ [执行 Oracle Data Guard 切换](oracle-replication-switchover.md)
+ [排查 RDS for Oracle 副本的问题](oracle-read-replicas.troubleshooting.md)
+ [使用 RDS for Oracle 重做日志传输压缩](oracle-read-replicas.redo-transport-compression.md)
# RDS for Oracle 副本概述
*Oracle 副本*数据库是主数据库的物理副本。只读模式下的 Oracle 副本称为*只读副本*。装载模式下的 Oracle 副本称为*装载副本*。Oracle 数据库不允许在副本中进行写入操作，但是您可以升级副本以使其可写。提升的只读副本拥有提出提升请求时的已复制数据。
以下视频提供了 RDS for Oracle 灾难恢复的有用概述。
[](http://www.youtube.com/watch?v=-XpzhIevwVg)
有关更多信息，请参阅博文 [Managed disaster recovery with Amazon RDS for Oracle cross-Region automated backups - Part 1](https://www.amazonaws.cn/blogs/database/managed-disaster-recovery-with-amazon-rds-for-oracle-cross-region-automated-backups-part-1/) 和 [Managed disaster recovery with Amazon RDS for Oracle cross-Region automated backups - Part 2](https://www.amazonaws.cn/blogs/database/part-2-managed-disaster-recovery-with-amazon-rds-for-oracle-xrab/)。
**Topics**
+ [只读和装载副本](#oracle-read-replicas.overview.modes)
+ [CDB 的只读副本](#oracle-read-replicas.overview.data-guard)
+ [归档重做日志保留](#oracle-read-replicas.overview.log-retention)
+ [Oracle 复制过程中的中断](#oracle-read-replicas.overview.outages)
## 只读和装载副本
创建或修改 Oracle 副本时，可以将其置于以下任一模式：
Read-only
这是默认值。Active Data Guard 会将源数据库中的更改传输并应用到所有只读副本数据库。
您可以从一个源数据库实例创建最多 5 个只读副本。有关适用于所有数据库引擎的只读副本的一般信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。有关 Oracle Data Guard 的信息，请参阅 Oracle 文档中的 [Oracle Data Guard 概念和管理](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/oracle-data-guard-concepts.html#GUID-F78703FB-BD74-4F20-9971-8B37ACC40A65)。
挂载模式
在这种情况下，复制使用 Oracle Data Guard，但副本数据库不接受用户连接。装载副本的主要用途是跨区域灾难恢复。
装载的副本无法为只读工作负载提供服务。不论存档日志的保留策略为何，装载副本都会在应用存档重做日志文件后删除这些文件。
您可以为同一源数据库实例同时创建装载和只读数据库副本。您可以将只读副本更改为装载模式，或将装载副本更改为只读模式。在两种情况下，Oracle 数据库都会保留存档日志保留设置。
## CDB 的只读副本
RDS for Oracle 同时在单租户和多租户配置中对于 Oracle Database 19c 和 21c CDB 支持 Data Guard 只读副本。您可以在 CDB 中创建、管理和提升只读副本，就像在非 CDB 中一样。还支持已装载的副本。您可以获得以下好处：
+ 托管式灾难恢复、高可用性和对副本的只读访问
+ 能够在不同的 Amazon Web Services 区域中创建只读副本。
+ 与现有 RDS 只读副本 API 集成：[CreateDBInstanceReadReplica](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html)、[PromoteReadReplica](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_PromoteReadReplica.html) 和 [SwitchoverReadReplica](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html)
要使用此功能，您需要有关副本和主数据库实例的有效 Data Guard 许可证和 Oracle 数据库企业版许可证。没有与使用 CDB 架构相关的额外费用。您只需为数据库实例付费。
有关 CDB 架构的单租户配置和多租户配置的更多信息，请参阅[RDS for Oracle CDB 概述](Oracle.Concepts.CDBs.md)。
## 归档重做日志保留
如果主数据库实例没有跨区域只读副本，则 Amazon RDS for Oracle 会在源数据库实例上至少保留两个小时的存档重做日志。无论在 `rdsadmin.rdsadmin_util.set_configuration` 中 `archivelog retention hours` 的设置为何，都是这种情况。
两小时之后或在传递归档日志保留小时数设置之后，RDS 会从源数据库实例中清除日志，以时间较长者为准。传递归档日志保留小时数设置之后，仅当日志已成功应用到数据库时，RDS 才会从只读副本清除日志。
在某些情况下，主数据库实例可能具有一个或多个跨区域只读副本。如果是这样，则 Amazon RDS for Oracle 将保留源数据库实例上的事务日志，直到将它们传输并应用到所有跨区域只读副本为止。有关 `rdsadmin.rdsadmin_util.set_configuration` 的信息，请参阅[保留归档重做日志](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)。
## Oracle 复制过程中的中断
当您创建只读副本时，Amazon RDS 会制作源数据库实例的数据库快照，然后开始复制。数据库快照操作开始时，源数据库实例会经历非常短暂的 I/O 暂停。这种 I/O 暂停通常持续大约一秒时间。如果源数据库实例为多可用区部署，则可避免 I/O 暂停，因为在这种情况下，会从辅助数据库实例制作数据库快照。
数据库快照变成 Oracle 副本。Amazon RDS 为源数据库和副本设置必要的参数和权限，而不会中断服务。同样，如果删除副本，也不会发生中断。
# RDS for Oracle 副本的要求和注意事项
在创建 Oracle 副本之前，请先熟悉以下要求和注意事项。
**Topics**
+ [RDS for Oracle 副本的版本和许可要求](#oracle-read-replicas.limitations.versions-and-licenses)
+ [RDS for Oracle 副本的选项组限制](#oracle-read-replicas.limitations.options)
+ [RDS for Oracle 的备份和还原注意事项](#oracle-read-replicas.limitations.backups)
+ [RDS for Oracle 副本的 Oracle Data Guard 要求和限制](#oracle-read-replicas.data-guard.requirements)
+ [RDS for Oracle 副本的多租户配置限制](#oracle-read-replicas.limitations.multitenant)
+ [RDS for Oracle 副本的其他注意事项](#oracle-read-replicas.limitations.miscellaneous)
## RDS for Oracle 副本的版本和许可要求
在创建 RDS for Oracle 副本之前，请考虑以下事项：
+ 如果副本处于只读模式，请确保您拥有 Active Data Guard 许可证。如果将副本置于装载模式，则不需要 Active Data Guard 许可证。只有 Oracle 数据库引擎支持装载副本。
+ Oracle 副本仅受 Oracle Enterprise Edition（EE）支持。
+ 仅使用运行 Oracle Database 19c 的非 CDB 实例创建的数据库实例支持非 CDB 的 Oracle 副本。
+ Oracle 副本仅适用于在具有两个或更多 vCPU 的数据库实例类上运行的数据库实例。源数据库实例不能使用 db.t3.small 实例类。
+ 源数据库实例及其所有副本的 Oracle 数据库引擎版本必须相同。无论副本的维护时段为何时，Amazon RDS 都会在升级源数据库实例后立即升级副本。对于跨区域副本的主要版本升级，Amazon RDS 会自动执行以下操作：
+ 为目标版本生成选项组。
+ 将所有选项和选项设置从原始选项组复制到新选项组。
+ 将升级后的跨区域副本与新选项组关联。
有关升级数据库引擎版本的更多信息，请参阅[升级 RDS for Oracle 数据库引擎](USER_UpgradeDBInstance.Oracle.md)。
## RDS for Oracle 副本的选项组限制
使用 RDS for Oracle 副本的选项组时，请考虑以下事项：
+ 当源和副本位于同一 Amazon 区域时，您不能使用与源数据库实例选项组不同的副本选项组。
对源选项组或源选项组成员资格做出的修改会传播到 Oracle 副本。不管副本的维护时段是什么，这些更改在应用到源数据库实例后，都会立即应用到副本。有关选项组的更多信息，请参阅 [使用选项组](USER_WorkingWithOptionGroups.md)。
+ 您无法从自动为 RDS for Oracle 跨区域副本创建的专用选项组中删除该副本。
+ 您无法将 RDS for Oracle 跨区域副本的专用选项组添加到其他数据库实例。
+ 您无法从 RDS for Oracle 跨区域副本的专用选项组中添加或移除非复制选项，但以下选项除外：
+ `NATIVE_NETWORK_ENCRYPTION`
+ `OEM`
+ `OEM_AGENT`
+ `SSL`
要将其他选项添加到 RDS for Oracle 跨区域副本，请将它们添加到源数据库实例的选项组中。选项还会安装在源数据库实例的所有副本上。对于许可选项，请确保副本具有足够的许可证。
提升 RDS for Oracle 跨区域副本时，提升后的副本的行为将与其他 Oracle 数据库实例的行为相同，包括其选项的管理。您可以通过删除副本的源数据库实例来显式或隐式提升副本。
有关选项组的更多信息，请参阅 [使用选项组](USER_WorkingWithOptionGroups.md)。
+ 您无法向 RDS for Oracle 跨区域副本添加 `EFS_INTEGRATION` 选项。
## RDS for Oracle 的备份和还原注意事项
在创建 RDS for Oracle 副本之前，请考虑以下事项：
+ 要创建 RDS for Oracle 副本的快照或开启自动备份，请确保手动设置备份保留期。原定设置情况下，自动备份处于开启状态。
+ 还原副本备份时，将还原到数据库时间，而不是进行备份的时间。数据库时间指备份中数据的最新应用的事务时间。差异很大，因为副本可能会落后于主数据库数分钟或数小时。
要查找差异，请使用 `describe-db-snapshots` 命令。比较 `snapshotDatabaseTime`（这是副本备份的数据库时间）与 `OriginalSnapshotCreateTime` 字段（这是主数据库上最新应用的事务）。
## RDS for Oracle 副本的 Oracle Data Guard 要求和限制
在创建 RDS for Oracle 副本之前，请注意以下要求和限制：
+ 如果您的主数据库实例使用多租户架构的单租户或多租户配置，请考虑以下几点：
+ 您必须将 Oracle Database 19c 或更高版本与企业版一起使用。
+ 您的主 CDB 实例必须位于 `ACTIVE` 生命周期。
+ 您不能将非 CDB 主实例转换为 CDB 实例，也不能在同一操作中转换其副本。而是应删除非 CDB 副本，将主数据库实例转换为 CDB，然后创建新的副本。
+ 确保主数据库实例上的登录触发器允许 `RDS_DATAGUARD` 用户以及 `AUTHENTICATED_IDENTITY` 值为 `RDS_DATAGUARD` 或 `rdsdb` 的任何用户进行访问。此外，触发器不得为 `RDS_DATAGUARD` 用户设置当前架构。
+ 为了避免阻止来自 Data Guard 代理进程的连接，请不要启用受限会话。有关受限会话的更多信息，请参阅 [启用和禁用受限制的会话](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)。
## RDS for Oracle 副本的多租户配置限制
在 RDS for Oracle 副本上使用多租户配置时，请注意以下限制：
+ 您只能在主数据库实例上创建、删除或修改租户数据库。这些更改会自动传播到副本。
+ 无法使用自定义字符集创建 RDS for Oracle 主实例、源或副本上的租户数据库。如果您需要自定义字符集，请在为数据库实例创建只读副本之前创建租户数据库。
## RDS for Oracle 副本的其他注意事项
在创建 RDS for Oracle 副本之前，请考虑以下事项：
+ 当您为具有附加存储卷的数据库实例创建 RDS for Oracle 副本时，RDS 会自动在副本上配置附加存储卷。但是，在主数据库实例的存储卷中所做的任何后续修改都不会自动应用于副本。
+ 如果您在主数据库实例中添加附加存储卷，RDS 不会自动向副本添加附加存储卷。您需要修改副本才能添加附加存储卷。
+ 如果您修改主数据库实例中的存储卷配置，例如存储大小和 IOPS，则 RDS 不会自动修改副本中的存储卷。您需要修改副本才能更新存储卷配置。
+ 在跨卷管理数据文件位置时，请注意，在主实例上所做的更改不会自动同步到副本。
+ 对于只读副本：您可以使用参数组设置来控制默认文件位置，也可以在创建文件后手动移动文件。
+ 对于挂载的副本：手动更改主数据库中数据文件位置要求重新创建挂载的副本以反映这些更改。为避免这种情况，我们建议使用参数组设置来管理默认文件位置。
+ 如果您的数据库实例是一个或多个跨区域副本的源，该源数据库将会保留其归档重做日志文件，直到在所有跨区域副本上应用这些日志文件为止。存档重做日志可能会导致存储消耗增加。
+ 为避免 RDS 自动化发生中断，系统触发器必须允许特定用户登录主数据库和副本数据库。[系统触发器](https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/plsql-triggers.html#GUID-FE23FCE8-DE36-41EF-80A9-6B4B49E80E5B)包括 DDL、登录和数据库角色触发器。我们建议您向触发器添加代码，来排除以下示例代码中列出的用户：
```
-- Determine who the user is
SELECT SYS_CONTEXT('USERENV','AUTHENTICATED_IDENTITY') INTO CURRENT_USER FROM DUAL;
-- The following users should always be able to login to either the Primary or Replica
IF CURRENT_USER IN ('master_user', 'SYS', 'SYSTEM', 'RDS_DATAGUARD', 'rdsdb') THEN
RETURN;
END IF;
```
+ 只读副本支持块更改跟踪，但装载副本不支持。您可以将装载副本更改为只读副本，然后启用块更改跟踪。有关更多信息，请参阅 [启用和禁用数据块更改跟踪](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)。
+ 当源数据库使用 Secrets Manager 管理主用户凭证时，您无法创建 Oracle 只读副本。
# 为创建 Oracle 副本做准备
在开始使用副本之前，请执行以下任务。
**Topics**
+ [启用自动备份](#oracle-read-replicas.configuration.autobackups)
+ [启用强制日志记录模式](#oracle-read-replicas.configuration.force-logging)
+ [更改日志记录配置](#oracle-read-replicas.configuration.logging-config)
+ [设置 MAX\$1STRING\$1SIZE 参数](#oracle-read-replicas.configuration.string-size)
+ [规划计算和存储资源](#oracle-read-replicas.configuration.planning-resources)
## 启用自动备份
您必须在数据库实例上启用自动备份，然后其才能充当源数据库实例。要了解如何执行此过程，请参阅[启用自动备份](USER_WorkingWithAutomatedBackups.Enabling.md)。
## 启用强制日志记录模式
建议您启用强制日志记录模式。在强制日志记录模式下，即使将 `NOLOGGING` 与数据定义语言 (DDL) 语句一起使用，Oracle 数据库也会写入重做记录。
**启用强制日志记录模式**
1. 使用 SQL Developer 等客户端工具登录 Oracle 数据库。
1. 通过运行以下过程启用强制日志记录模式。
```
exec rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
有关此过程的更多信息，请参阅 [设置强制日志记录](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.SettingForceLogging)。
## 更改日志记录配置
对于 *n* 个大小为 *m* 的联机重做日志，RDS 会在主数据库实例和所有副本上自动创建 *n* \$11 个大小为 *m* 的备用日志。每当您在主服务器上更改日志记录配置时，更改都会自动传播到副本。
如果您更改日志记录配置，请考虑以下指南：
+ 我们建议您在将数据库实例设为副本源之前完成更改。RDS for Oracle 还支持在实例成为源后对其进行更新。
+ 在更改主数据库实例上的日志记录配置之前，请检查每个副本是否有足够的存储来容纳新的配置。
您可以使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.add_logfile` 和 `rdsadmin.rdsadmin_util.drop_logfile` 修改数据库实例的日志记录配置。有关更多信息，请参阅[添加联机重做日志](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.RedoLogs)和[删除联机重做日志](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)。
## 设置 MAX\$1STRING\$1SIZE 参数
创建 Oracle 副本之前，请确保源数据库实例和副本上的 `MAX_STRING_SIZE` 参数的设置相同。您可以通过将它们与相同的参数组关联来实现。如果您为源和副本使用不同的参数组，则可以将 `MAX_STRING_SIZE` 设置为相同值。有关设置该参数的更多信息，请参阅[为新数据库实例开启扩展数据类型](Oracle.Concepts.ExtendedDataTypes.md#Oracle.Concepts.ExtendedDataTypes.CreateDBInstance)。
## 规划计算和存储资源
确保源数据库实例及其副本在计算和存储容量方面具有适当的大小，以适合其运行负载。如果副本达到计算、网络或存储资源容量，则副本会停止接收或应用来自其源实例的更改。Amazon RDS for Oracle 不会通过干预来缓解源数据库实例及其副本之间的高副本滞后。您可以单独修改某个副本的存储和 CPU 资源，而不影响其源及其他副本。
# 在装载模式下创建 RDS for Oracle 副本
默认情况下，Oracle 副本是只读的。要在装载模式下创建副本，请使用控制台、Amazon CLI、或 RDS API。
## 控制台
**从源 Oracle 数据库实例创建装载副本**
1. 登录Amazon Web Services 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择要作为装载副本源的 Oracle 数据库实例。
1. 对于**操作**，选择**创建副本**。
1. 对于**副本模式**，选择**装载**。
1. 选择要使用的设置。对于**数据库实例标识符**，输入该只读副本的名称。根据需要，调整其他设置。
1. 对于**区域**，选择将启动装载副本的区域。
1. 选择您的实例大小和存储类型。我们建议您为只读副本使用与源数据库实例相同的数据库实例类和存储类型。
1. 对于**多可用区部署**，选择**创建备用实例**以便在另一个可用区中创建副本的备用来支持装载副本的故障转移。创建您的装载副本作为多可用区数据库实例与源数据库是否为多可用区数据库实例无关。
1. 选择要使用的其他设置。
1. 选择**创建副本**。
在**数据库**页面中，装载副本具有角色“副本”。
## Amazon CLI
要在装载模式下创建 Oracle 副本，请在 `--replica-mode` 命令 [create-db-instance-read-replica](https://docs.amazonaws.cn/cli/latest/reference/rds/create-db-instance-read-replica.html) 中将 `mounted` 设为 Amazon CLI。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds create-db-instance-read-replica \
--db-instance-identifier myreadreplica \
--source-db-instance-identifier mydbinstance \
--replica-mode mounted
```
对于 Windows：
```
aws rds create-db-instance-read-replica ^
--db-instance-identifier myreadreplica ^
--source-db-instance-identifier mydbinstance ^
--replica-mode mounted
```
要将只读副本更改为装载状态，请在 `--replica-mode` 命令 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 中将 `mounted` 设为 Amazon CLI。要将挂载副本置于只读模式，请将 `--replica-mode` 设为 `open-read-only`。
## RDS API
要在装载模式下创建 Oracle 副本，请在 RDS API 操作 [CreateDBInstanceReadReplica](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html) 中指定 `ReplicaMode=mounted`。
# 修改 RDS for Oracle 副本模式
要更改现有副本的副本模式，请使用 控制台、Amazon CLI 或 RDS API。当您更改为装载模式时，副本将断开所有活动连接。当您更改为只读模式时，Amazon RDS 会初始化 Active Data Guard。
更改操作可能需要几分钟才能完成。在操作过程中，数据库实例状态会更改为**正在修改**。有关状态更改的更多信息，请参阅[查看 Amazon RDS数据库实例状态](accessing-monitoring.md#Overview.DBInstance.Status)。
## 控制台
**将 Oracle 副本的副本模式从装载更改为只读**
1. 登录Amazon Web Services 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择装载副本数据库。
1. 选择**修改**。
1. 对于**副本模式**，选择 **只读**。
1. 选择要使更改的其他设置：
1. 选择 **Continue (继续)**。
1. 对于**修改计划**，选择**立即应用**。
1. 选择**修改数据库实例**。
## Amazon CLI
要将只读副本更改为装载模式，请在 `--replica-mode` 命令 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html)中将 `mounted` 设为 Amazon CLI。要将装载副本更改为只读模式，请将 `--replica-mode` 设为 `open-read-only`。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier myreadreplica \
--replica-mode mode
```
对于 Windows：
```
aws rds modify-db-instance ^
--db-instance-identifier myreadreplica ^
--replica-mode mode
```
## RDS API
要将只读副本更改为装载模式，请在 [ModifyDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html) 中设置 `ReplicaMode=mounted`。要将装载副本更改为只读模式，请设置 `ReplicaMode=read-only`。
# 使用 RDS for Oracle 副本备份
您可以创建和还原 RDS for Oracle 副本的备份。同时支持自动备份和手动快照。有关更多信息，请参阅[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)。以下各节描述了管理主实例的备份与管理 RDS for Oracle 副本的备份之间的主要区别。
## 开启 RDS for Oracle 副本备份
Oracle 副本在原定设置情况下开启自动备份。您可以将备份保留期设置为非零正值来开启自动备份。
### 控制台
**立即启用自动备份**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择**数据库**，然后选择要修改的数据库实例或多可用区数据库集群。
1. 选择 **Modify**(修改)。
1. 对于**备份保留期**，请选择非零正值，例如三天。
1. 选择 **Continue (继续)**。
1. 选择**立即应用**。
1. 选择**修改数据库实例**或**修改集群**以保存更改并启用自动备份。
### Amazon CLI
要启用自动备份，请使用 Amazon CLI [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 或 [modify-db-cluster](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-cluster.html) 命令。
包括以下参数：
+ `--db-instance-identifier`（或 `--db-cluster-identifier` 用于可用区数据库集群）
+ `--backup-retention-period`
+ `--apply-immediately` 或者 `--no-apply-immediately`
在以下示例中，启用了自动备份并将备份保留期设置为三天。更改将立即应用。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier my_db_instance \
--backup-retention-period 3 \
--apply-immediately
```
对于 Windows：
```
aws rds modify-db-instance ^
--db-instance-identifier my_db_instance ^
--backup-retention-period 3 ^
--apply-immediately
```
### RDS API
要启用自动备份，请使用 RDS API [ModifyDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) 或 [ModifyDBCluster](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) 操作以及以下必需参数：
+ `DBInstanceIdentifier` 或 `DBClusterIdentifier`
+ `BackupRetentionPeriod`
## 还原 RDS for Oracle 副本备份
您可以还原 Oracle 副本备份，就像还原主实例的备份一样。有关更多信息，请参阅下列内容：
+ [还原到数据库实例](USER_RestoreFromSnapshot.md)
+ [将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)
还原副本备份时的主要注意事项是确定要还原到的时间点。数据库时间指备份中数据的最新应用的事务时间。还原副本备份时，将还原到数据库时间，而不是备份完成的时间。差异很大，因为 RDS for Oracle 副本可能会落后于主数据库几分钟或几小时。因此，副本备份的数据库时间以及还原到的时间点可能比备份创建时间早得多。
要查找数据库时间和创建时间之间的差异，请使用 `describe-db-snapshots` 命令。比较 `SnapshotDatabaseTime`（这是副本备份的数据库时间）与 `OriginalSnapshotCreateTime` 字段（这是主数据库上最新应用的事务）。以下示例显示了两个时间之间的差异：
```
aws rds describe-db-snapshots \
--db-instance-identifier my-oracle-replica
--db-snapshot-identifier my-replica-snapshot
{
"DBSnapshots": [
{
"DBSnapshotIdentifier": "my-replica-snapshot",
"DBInstanceIdentifier": "my-oracle-replica",
"SnapshotDatabaseTime": "2022-07-26T17:49:44Z",
...
"OriginalSnapshotCreateTime": "2021-07-26T19:49:44Z"
}
]
}
```
# 执行 Oracle Data Guard 切换
*切换*是主数据库和备用数据库之间的角色反转。在切换期间，原始主数据库转换为备用角色，而原始备用数据库转换为主角色。
在 Oracle Data Guard 环境中，主数据库支持一个或多个备用数据库。您可以执行从主数据库到备用数据库的基于切换的托管式角色转换。*切换*是主数据库和备用数据库之间的角色反转。在切换期间，原始主数据库转换为备用角色，而原始备用数据库转换为主角色。
**Topics**
+ [Oracle Data Guard 切换概述](#oracle-replication-switchover.overview)
+ [Oracle Data Guard 切换的要求](oracle-switchover.preparing.md)
+ [启动 Oracle Data Guard 切换](oracle-switchover.initiating.md)
+ [监控 Oracle Data Guard 切换](oracle-switchover.monitoring.md)
## Oracle Data Guard 切换概述
Amazon RDS 支持 Oracle Database 副本的完全托管式、基于切换的角色转换。您只能启动到已挂载或以只读方式打开的备用数据库的切换。
副本可以位于单独的 Amazon Web Services 区域中，也可以位于单个区域的不同可用区（AZ）中。支持所有 Amazon Web Services 区域。
![\[切换备用实例，使其成为主数据库实例\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/read-replica-switchover.png)
切换与只读副本提升不同。在切换过程中，源和副本数据库实例会更改角色。在提升过程中，只读副本会成为源数据库实例，但源数据库实例不会成为副本。有关更多信息，请参阅 [将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)。
**Topics**
+ [Oracle Data Guard 切换的优势](#oracle-replication-switchover.overview.benefits)
+ [支持的 Oracle 数据库版本](#oracle-replication-switchover.overview.engine-support)
+ [Oracle Data Guard 切换的成本](#oracle-replication-switchover.overview.cost)
+ [Oracle Data Guard 切换的工作原理](#oracle-replication-switchover.overview.how-it-works)
### Oracle Data Guard 切换的优势
就像 RDS for Oracle 只读副本一样，托管式切换依赖于 Oracle Data Guard。该操作旨在实现零数据丢失。Amazon RDS 可自动执行切换的以下各个方面：
+ 反转主数据库和指定备用数据库的角色，将新的备用数据库置于与原始备用数据库相同的状态（已挂载或只读）
+ 确保数据一致性
+ 在转换后维护您的复制配置
+ 支持重复性反转，允许您的新备用数据库恢复其原来的主角色
### 支持的 Oracle 数据库版本
Oracle Database 19c 及更高版本支持 Oracle Data Guard 切换。
### Oracle Data Guard 切换的成本
Oracle Data Guard 切换功能不会产生额外费用。Oracle Database 企业版支持挂载模式下的备用数据库。要以只读模式打开备用数据库，您需要 Oracle Active Data Guard 选项。
### Oracle Data Guard 切换的工作原理
Oracle Data Guard 切换是一项完全托管式操作。您可以通过发出 CLI 命令 `switchover-read-replica` 启动备用数据库的切换。然后，Amazon RDS 修改您的复制配置中的主角色和备用角色。
*原始备用角色*和*原始主角色*是切换前存在的角色。*新备用角色*和*新主角色*是切换后存在的角色。*旁观者副本*是一个副本数据库，它在 Oracle Data Guard 环境中用作备用数据库，但不切换角色。
**Topics**
+ [Oracle Data Guard 切换的各个阶段](#oracle-replication-switchover.overview.how-it-works.during-switchover)
+ [Oracle Data Guard 切换之后](#oracle-replication-switchover.overview.how-it-works.after-switchover)
#### Oracle Data Guard 切换的各个阶段
要执行切换，Amazon RDS 必须执行以下步骤：
1. 阻止原始主数据库上的新事务。在切换期间，Amazon RDS 会中断您的 Oracle Data Guard 配置中所有数据库的复制。在切换期间，原始主数据库无法处理写入请求。
1. 将未应用的事务发送到原始备用数据库，并应用它们。
1. 以只读或挂载模式重新启动新的备用数据库。该模式取决于切换前原始备用数据库的打开状态。
1. 以读/写模式打开新的主数据库。
#### Oracle Data Guard 切换之后
Amazon RDS 切换主数据库和备用数据库的角色。您负责重新连接应用程序并执行任何其他所需的配置。
**Topics**
+ [成功标准](#oracle-replication-switchover.overview.how-it-works.after-switchover.success)
+ [与新的主数据库的连接](#oracle-replication-switchover.overview.how-it-works.after-switchover.connection)
+ [新的主数据库的配置](#oracle-replication-switchover.overview.how-it-works.after-switchover.success.configuration)
##### 成功标准
当原始备用数据库执行以下操作时，Oracle Data Guard 切换获得成功：
+ 转换到其作为新的主数据库的角色
+ 完成其重新配置
为了限制停机时间，新的主数据库会尽快变为活动状态。由于 Amazon RDS 异步配置旁观者副本，因此这些副本可能会在原始主数据库之后变为活动状态。
##### 与新的主数据库的连接
切换后，Amazon RDS 不会将您当前的数据库连接传播到新的主数据库。在 Oracle Data Guard 切换完成后，将您的应用程序重新连接到新的主数据库。
##### 新的主数据库的配置
为了切换到新的主数据库，Amazon RDS 将原始备用数据库的模式更改为打开。角色的更改是对数据库的唯一更改。Amazon RDS 未设置多可用区复制等功能。
如果您使用不同的选项切换到跨区域副本，则新的主数据库会保留自己的选项。Amazon RDS 不会迁移原始主数据库上的选项。如果原始主数据库具有 SSL、NNE、OEM 和 OEM\$1AGENT 等选项，则 Amazon RDS 不会将它们传播到新的主数据库。
# Oracle Data Guard 切换的要求
在启动 Oracle Data Guard 切换之前，请确保您的复制环境满足以下要求：
+ 原始备用数据库已挂载或以只读方式打开。
+ 在原始备用数据库上启用自动备份。
+ 原始主数据库和原始备用数据库处于 `available` 状态。
+ 原始主数据库和原始备用数据库没有任何待处理的维护操作处于以下状态：`required`、`next window` 或 `in progress`。处于这些状态的操作会阻止切换。要了解如何检查待处理的维护更新的状态，请参阅[查看待处理维护更新](USER_UpgradeDBInstance.Maintenance.md#USER_UpgradeDBInstance.Maintenance.Viewing)。
处于 `available` 状态的待处理维护操作不会阻止切换。RDS for Oracle 经常发布处于状态 `available` 的操作系统（OS）更新。这些待处理的操作系统更新不会阻止切换，除非您将它们安排在下一个维护时段，这会使它们处于 `next window` 状态。
**注意**
如果您希望推迟计划的维护操作以便执行切换，请在 RDS 控制台中选择**操作**，然后选择**推迟升级**。您还可以通过应用待处理的维护操作或将维护时段移至切换之前的间隔，来防止系统阻止切换。有关更多信息，请参阅 re:Post 文章 [How to remove RDS pending maintenance items](https://repost.aws/questions/QUV3dBjmVVRnmVV1pAlzjx1w/how-to-remove-rds-pending-maintenance-item)。
+ 原始备用数据库处于复制状态。
+ 当主数据库或备用数据库当前处于切换生命周期时，您不要尝试启动切换。如果在切换后正在重新配置副本数据库，Amazon RDS 会阻止您启动另一次切换。
**注意**
*旁观者副本*是 Oracle Data Guard 配置中的副本，它不是切换的目标。在切换期间，旁观者副本可以处于任何状态。
+ 原始备用数据库的配置与原始主数据库所需的配置尽可能接近。假设原始主数据库和原始备用数据库具有不同选项的场景。切换完成后，Amazon RDS 不会自动将新的主数据库重新配置为具有与原始主数据库相同的选项。
+ 在启动切换之前，您需要配置所需的多可用区部署。Amazon RDS 不将多可用区作为切换的一部分进行管理。多可用区部署保持原样。
假设 db\$1maz 是多可用区部署中的主数据库，而 db\$1saz 是单可用区副本。您启动从 db\$1maz 到 db\$1saz 的切换。之后，db\$1maz 是多可用区副本数据库，而 db\$1saz 是单可用区主数据库。新的主数据库现在不受多可用区部署的保护。
+ 在为跨区域切换做准备时，主数据库不使用与复制配置之外的数据库实例相同的选项组。要成功进行跨区域切换，当前主数据库及其只读副本必须是仅有的使用当前主数据库的选项组的数据库实例。否则，Amazon RDS 会阻止切换。
# 启动 Oracle Data Guard 切换
您可以将 RDS for Oracle 只读副本切换为主角色，并将以前的主数据库实例切换为副本角色。
## 控制台
**将 Oracle 只读副本切换为主数据库角色**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在 Amazon RDS 控制台中，选择**数据库**。
随后会显示**数据库**窗格。每个只读副本在**角色**列中显示**副本**。
1. 选择要切换为主角色的只读副本。
1. 对于 **Actions**（操作），选择 **Switch over replica**（切换副本）。
1. 选择 **I acknowledge**（我确认）。然后选择 **Switch over replica**（切换副本）。
1. 在 **Databases**（数据库）页面，监控切换的进度。
![\[监控 Oracle Data Guard 切换的进度。\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-switchover-progress.png)
切换完成后，切换目标的角色将从 **Replica**（副本）更改为 **Source**（源）。
![\[源数据库和副本数据库会更改角色。\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-switchover-complete.png)
## Amazon CLI
要将 Oracle 副本切换为主数据库角色，请使用 Amazon CLI [https://docs.amazonaws.cn/cli/latest/reference/rds/switchover-read-replica.html](https://docs.amazonaws.cn/cli/latest/reference/rds/switchover-read-replica.html) 命令。以下示例使名为 *replica-to-be-made-primary* 的 Oracle 副本成为新的主数据库。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds switchover-read-replica \
--db-instance-identifier replica-to-be-made-primary
```
对于 Windows：
```
aws rds switchover-read-replica ^
--db-instance-identifier replica-to-be-made-primary
```
## RDS API
要将 Oracle 副本切换为主数据库角色，请使用所需参数 `DBInstanceIdentifier` 调用 Amazon RDS API [https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html) 操作。此参数指定要承担主数据库角色的 Oracle 副本的名称。
# 监控 Oracle Data Guard 切换
要检查实例的运行状况，请使用 Amazon CLI 命令 `describe-db-instances`。以下命令检查数据库实例 *orcl2* 的状态。该数据库在切换之前是备用数据库，但在切换之后是新的主数据库。
```
aws rds describe-db-instances \
--db-instance-identifier orcl2
```
要确认切换成功完成，请查询 `V$DATABASE.OPEN_MODE`。检查新的主数据库的值是否为 `READ WRITE`。
```
SELECT OPEN_MODE FROM V$DATABASE;
```
要查找与切换相关的事件，请使用 Amazon CLI 命令 `describe-events`。以下示例查找有关 *orcl2* 实例的事件。
```
aws rds describe-events \
--source-identifier orcl2 \
--source-type db-instance
```
# 排查 RDS for Oracle 副本的问题
本节介绍了可能出现的复制问题和解决方案。
**Topics**
+ [监控 Oracle 复制滞后](#oracle-read-replicas.troubleshooting.lag)
+ [对添加或修改触发器后 Oracle 复制失败进行故障排查](#oracle-read-replicas.troubleshooting.triggers)
## 监控 Oracle 复制滞后
要监控 Amazon CloudWatch 中的复制滞后，请查看 Amazon RDS `ReplicaLag` 指标。有关复制滞后时间的信息，请参阅[监控只读复制](USER_ReadRepl.Monitoring.md)和[Amazon RDS 的 Amazon CloudWatch 指标](rds-metrics.md)。
对于只读副本，如果滞后时间太长，请查询以下视图：
+ `V$ARCHIVED_LOG` – 显示哪些提交已应用到只读副本。
+ `V$DATAGUARD_STATS` – 显示组成 `ReplicaLag` 指标的各个组成部分的详细分解。
+ `V$DATAGUARD_STATUS` – 显示 Oracle 内部复制过程的日志输出。
对于挂载的副本，如果滞后时间太长，您将无法查询 `V$` 视图。而是执行以下操作：
+ 检查 CloudWatch 中的 `ReplicaLag` 指标。
+ 在控制台中检查副本的提示日志文件。查找恢复消息中的错误。这些消息包括日志序列号，您可以将其与主序列号进行比较。有关更多信息，请参阅 [Amazon RDS for Oracle 数据库日志文件](USER_LogAccess.Concepts.Oracle.md)。
## 对添加或修改触发器后 Oracle 复制失败进行故障排查
如果添加或修改任何触发器，并且之后复制失败，可能是触发器的问题。确保触发器将 RDS 进行复制所需的以下用户账户排除在外：
+ 具有管理员权限的用户账户
+ `SYS`
+ `SYSTEM`
+ `RDS_DATAGUARD`
+ `rdsdb`
有关更多信息，请参阅 [RDS for Oracle 副本的其他注意事项](oracle-read-replicas.limitations.md#oracle-read-replicas.limitations.miscellaneous)。
# 使用 RDS for Oracle 重做日志传输压缩
使用 RDS for Oracle 重做传输压缩来提高主数据库实例和备用副本之间的复制性能。这在网络带宽有限或高延迟连接的环境中特别有用。
## 获取重做传输压缩许可证
重做传输压缩是 [Oracle 高级压缩](//www.oracle.com/database/advanced-compression/)选项的一部分。要使用重做传输压缩，您需要获得 Oracle 高级压缩选项的有效许可证。有关许可信息，请联系您的 Oracle 代表。
## 配置重做传输压缩
要配置重做传输压缩，可以使用 `rds.replica.redo_compression` 参数。此参数适用于 Oracle 版本 19c 和 21c。
`rds.replica.redo_compression` 参数接受以下值：
+ `DISABLE` – 用于禁用重做传输压缩的默认值。
+ `ENABLE` – 用于通过默认算法 [ZLIB](https://zlib.net/) 启用重做传输压缩的值。
+ `ZLIB` – 用于使用 ZLIB 算法明确启用重做传输压缩的值，该算法提供了良好的压缩比。
+ `LZO` – 用于使用 [LZO](https://www.oberhumer.com/opensource/lzo/) 算法明确启用重做传输压缩的值，该算法可优化压缩速度，尤其是在解压缩期间。
## 重做传输压缩的性能注意事项
压缩和解压缩操作会消耗主实例和备用实例上的 CPU 资源。如果您使用重做传输压缩，请考虑实例资源使用情况和网络状况。
## 重做传输压缩的相关主题
有关配置重做传输压缩的更多信息，请参阅以下资源：
+ [Amazon RDS 数据库实例的数据库参数组](USER_WorkingWithDBInstanceParamGroups.md)
+ Oracle 数据库 19c 发行说明中的 [RedoCompression](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html#GUID-5E6DDFD0-6196-48EB-94AF-21A1AFBB7DE1)
# 向 Oracle 数据库实例添加选项
在 Amazon RDS 中，选项是额外的功能。您可在下面找到可以添加到运行 Oracle 数据库引擎的 Amazon RDS 实例的选项描述。
**Topics**
+ [Oracle DB 选项概述](Appendix.Oracle.Options.overview.md)
+ [Amazon S3 集成](oracle-s3-integration.md)
+ [Oracle Application Express (APEX)](Appendix.Oracle.Options.APEX.md)
+ [Amazon EFS 集成](oracle-efs-integration.md)
+ [Oracle Java 虚拟机](oracle-options-java.md)
+ [Oracle Enterprise Manager](Oracle.Options.OEM.md)
+ [Oracle Label Security](Oracle.Options.OLS.md)
+ [Oracle Locator](Oracle.Options.Locator.md)
+ [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md)
+ [Oracle OLAP](Oracle.Options.OLAP.md)
+ [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)
+ [Oracle Spatial](Oracle.Options.Spatial.md)
+ [Oracle SQLT](Oracle.Options.SQLT.md)
+ [Oracle Statspack](Appendix.Oracle.Options.Statspack.md)
+ [Oracle 时区](Appendix.Oracle.Options.Timezone.md)
+ [Oracle 时区文件自动升级](Appendix.Oracle.Options.Timezone-file-autoupgrade.md)
+ [Oracle 透明数据加密](Appendix.Oracle.Options.AdvSecurity.md)
+ [Oracle UTL\$1MAIL](Oracle.Options.UTLMAIL.md)
+ [Oracle XML DB](Appendix.Oracle.Options.XMLDB.md)
# Oracle DB 选项概述
要为 Oracle 数据库启用选项，可将它们添加到选项组中，然后将选项组关联到数据库实例。有关更多信息，请参阅 [使用选项组](USER_WorkingWithOptionGroups.md)。
**Topics**
+ [“Oracle 数据库”选项摘要](#Appendix.Oracle.Options.summary)
+ [不同版本支持的选项](#Appendix.Oracle.Options.editions)
+ [特定选项的内存要求](#Appendix.Oracle.Options.memory)
## “Oracle 数据库”选项摘要
对于 Oracle 数据库实例，您可以添加以下选项。
****
| 选项 | 选项 ID |
| --- | --- |
| [Amazon S3 集成](oracle-s3-integration.md) | `S3_INTEGRATION` |
| [Oracle Application Express (APEX)](Appendix.Oracle.Options.APEX.md) | `APEX` `APEX-DEV` |
| [Oracle Enterprise Manager](Oracle.Options.OEM.md) | `OEM` `OEM_AGENT` |
| [Oracle Java 虚拟机](oracle-options-java.md) | `JVM` |
| [Oracle Label Security](Oracle.Options.OLS.md) | `OLS` |
| [Oracle Locator](Oracle.Options.Locator.md) | `LOCATOR` |
| [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md) | `NATIVE_NETWORK_ENCRYPTION` |
| [Oracle OLAP](Oracle.Options.OLAP.md) | `OLAP` |
| [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md) | `SSL` |
| [Oracle Spatial](Oracle.Options.Spatial.md) | `SPATIAL` |
| [Oracle SQLT](Oracle.Options.SQLT.md) | `SQLT` |
| [Oracle Statspack](Appendix.Oracle.Options.Statspack.md) | `STATSPACK` |
| [Oracle 时区](Appendix.Oracle.Options.Timezone.md) | `Timezone` |
| [Oracle 时区文件自动升级](Appendix.Oracle.Options.Timezone-file-autoupgrade.md) | `TIMEZONE_FILE_AUTOUPGRADE` |
| [Oracle 透明数据加密](Appendix.Oracle.Options.AdvSecurity.md) | `TDE` |
| [Oracle UTL\$1MAIL](Oracle.Options.UTLMAIL.md) | `UTL_MAIL` |
| [Oracle XML DB](Appendix.Oracle.Options.XMLDB.md) | `XMLDB` |
## 不同版本支持的选项
如果不支持该选项，RDS for Oracle 会阻止您将该选项添加到版本中。要了解不同 Oracle 数据库版本中支持哪些 RDS 选项，请使用命令 `aws rds describe-option-group-options`。以下示例列出 Oracle Database 19c 企业版支持的选项。
```
aws rds describe-option-group-options \
--engine-name oracle-ee \
--major-engine-version 19
```
有关更多信息，请参阅 *Amazon CLI 命令引用*中的 [describe-option-group-options](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-option-group-options.html)。
## 特定选项的内存要求
某些选项需要额外的内存才能在数据库实例上运行。例如，Oracle Enterprise Manager Database Control 使用约 300 MB 的 RAM。如果为小数据库实例启用该选项，则可能会遇到内存限制导致的性能问题。您可以调整 Oracle 参数，以便数据库需要更少的 RAM。或者，您也可以扩展到更大的数据库实例。
# Amazon S3 集成
您可以在 RDS for Oracle 数据库实例和 Amazon S3 存储桶之间传输文件。您可以使用 Amazon S3 与 Oracle Database 集成的功能，例如 Oracle Data Pump。例如，您可以将 Data Pump 文件从 Amazon S3 下载到 RDS for Oracle 数据库实例。有关更多信息，请参阅 [将数据导入到 Amazon RDS 上的 Oracle](Oracle.Procedural.Importing.md)。
**注意**
数据库实例和 Amazon S3 存储桶必须位于同一 Amazon Web Services 区域。
**Topics**
+ [为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限](oracle-s3-integration.preparing.md)
+ [添加 Amazon S3 集成选项](oracle-s3-integration.preparing.option-group.md)
+ [在 Amazon RDS for Oracle 和 Amazon S3 存储桶之间传输文件](oracle-s3-integration.using.md)
+ [排查 Amazon S3 集成问题](#oracle-s3-integration.troubleshooting)
+ [删除 Amazon S3 集成选项](oracle-s3-integration.removing.md)
# 为与 Amazon S3 集成的 RDS for Oracle 配置 IAM 权限
若要让 RDS for Oracle 与 Amazon S3 集成，您的数据库实例必须可以访问 Amazon S3 存储桶。数据库实例使用的 Amazon VPC 不需要提供 Amazon S3 终端节点的访问权限。
RDS for Oracle 支持在一个账户中的数据库实例与另一个账户中的 Amazon S3 存储桶之间传输文件。如果需要其他步骤，将在以下各节中说明这些步骤。
**Topics**
+ [步骤 1：为 Amazon RDS 角色创建 IAM 策略](#oracle-s3-integration.preparing.policy)
+ [步骤 2：（可选）为 Amazon S3 存储桶创建 IAM 策略](#oracle-s3-integration.preparing.policy-bucket)
+ [步骤 3：为您的数据库实例创建 IAM 角色并附加策略](#oracle-s3-integration.preparing.role)
+ [步骤 4：将您的 IAM 角色与 RDS for Oracle 数据库实例关联](#oracle-s3-integration.preparing.instance)
## 步骤 1：为 Amazon RDS 角色创建 IAM 策略
在此步骤中，您将创建一个 Amazon Identity and Access Management（IAM）策略，该策略具有在 Amazon S3 存储桶和 RDS 数据库实例之间传输文件所需的权限。此步骤假定您已创建了 S3 桶。
创建策略前，请记下以下信息：
+ 存储桶的 Amazon 资源名称（ARN）。
+ 您的 Amazon KMS 密钥的 ARN，如果您的存储桶使用 SSE-KMS 或 SSE-S3 加密
**注意**
RDS for Oracle 数据库实例无法访问使用 SSE-C 加密的 Amazon S3 桶。
有关更多信息，请参阅《Amazon Simple Storage Service 用户指南》**中的[使用服务器端加密保护数据](https://docs.amazonaws.cn/AmazonS3/latest/userguide/serv-side-encryption.html)。
### 控制台
**创建 IAM policy 以允许 Amazon RDS 访问 Amazon S3 桶**
1. 打开 [IAM 管理控制台](https://console.amazonaws.cn/iam/home?#home)。
1. 在 **Access management (访问管理)** 下，选择 **Policies (策略)**。
1. 选择**创建策略**。
1. 在** Visual editor (可视化编辑器)** 选项卡上，选择 **Choose a service (选择服务)**，然后选择 **S3**。
1. 对于 **Actions (操作)**，选择 **Expand all (全部展开)**，然后选择将文件从 Amazon S3 存储桶传输到 Amazon RDS 所需的存储桶权限和对象权限。例如，执行以下操作：
+ 展开 **List (列表)**，然后选择 **ListBucket**。
+ 展开 **Read (读取)**，然后选择 **GetObject**。
+ 展开**写入**，然后选择 **PutObject**、**DeleteObject**、**AbortMultipartUpload** 和 **ListMultipartUploadParts**。在将大型文件（100 MB 或更大）上传到 Amazon S3 时，需要分段上传权限。
+ 展开 **Permissions management**（权限管理），然后选择**PutObjectAcl**。如果您计划将文件上传到其他账户拥有的存储桶，并且此账户需要完全控制存储桶内容，则需要此权限。
*对象权限*是 Amazon S3 中的对象操作的权限。您必须为存储桶中的对象而不是存储桶本身授予这些权限。有关更多信息，请参阅[对象操作权限](https://docs.amazonaws.cn/AmazonS3/latest/userguide/using-with-s3-actions.html#using-with-s3-actions-related-to-objects)。
1. 选择**资源**，然后执行以下操作：
1. 选择**特定**。
1. 对于**桶**，选择**添加 ARN**。输入桶 ARN。桶名称会自动填入。然后，选择 **Add (添加)**。
1. 如果显示了**对象**资源，请选择**添加 ARN** 以手动添加资源，或者选择**任意**。
**注意**
您可以将 **Amazon Resource Name (ARN)** 设置为更具体的 ARN 值，以允许 Amazon RDS 仅访问 Amazon S3 存储桶中的特定文件或文件夹。有关如何为 Amazon S3 定义访问策略的更多信息，请参阅[管理您的 Amazon S3 资源的访问权限](https://docs.amazonaws.cn/AmazonS3/latest/userguide/s3-access-control.html)。
1. （可选）选择 **Add additional permissions (添加其他权限)**，向策略中添加资源。例如，执行以下操作：
1. 如果您的存储桶使用自定义 KMS 密钥加密，请为该服务选择 **KMS**。
1. 对于**手动操作**，请选择以下选项：
+ **Encrypt**
+ **重新加密起点**和**重新加密终点**
+ **Decrypt**
+ **DescribeKey**
+ **GenerateDataKey**
1. 对于**资源**，选择**特定**。
1. 对于**密钥**，选择**添加 ARN**。输入自定义密钥的 ARN 作为资源，然后选择**添加**。
有关更多信息，请参阅 *Amazon Simple Storage Service 用户指南*中的[使用在 Amazon Key Management Service (SSE-KMS) 中存储 KMS 密钥的服务器端加密保护数据](https://docs.amazonaws.cn/AmazonS3/latest/userguide/UsingKMSEncryption.html)。
1. 如果想要 Amazon RDS 访问其他存储桶，请为这些存储桶添加 ARN。您也可以根据需要授予访问 Amazon S3 中所有存储桶和对象的权限。
1. 选择 **Next: Tags (下一步: 标签)**，然后选择 **Next: Review (下一步: 审核)**。
1. 对于** Name (名称)**，请为您的 IAM 策略输入名称，例如 `rds-s3-integration-policy`。在创建 IAM 角色与您的数据库实例关联时，需要使用此名称。您也可以添加可选的 **Description (描述)** 值。
1. 选择**创建策略**。
### Amazon CLI
创建向 Amazon RDS 授予对 Amazon S3 存储桶的访问权限的 Amazon Identity and Access Management（IAM）策略。创建策略后，请记下策略的 ARN。后续步骤需要该 ARN。
根据所需的访问类型，在策略中包括适合的操作：
+ `GetObject` – 从 Amazon S3 存储桶向 Amazon RDS 传输文件所必需的。
+ `ListBucket` – 从 Amazon S3 存储桶向 Amazon RDS 传输文件所必需的。
+ `PutObject` – 从 Amazon RDS 向 Amazon S3 存储桶传输文件所必需的。
+ `AbortMultipartUpload`：当将大型文件（100 MB 或更大）从 Amazon RDS 传输到 Amazon S3 存储桶时，进行分段上传所需。
+ `ListMultipartUploadParts`：当将大型文件（100 MB 或更大）从 Amazon RDS 传输到 Amazon S3 存储桶时，进行分段上传所需。
以下 Amazon CLI 命令使用这些选项创建一个名为 `rds-s3-integration-policy` 的 IAM 策略。该策略授予对名为 `amzn-s3-demo-bucket` 的存储桶的访问权限。
**Example**
对于 Linux、macOS 或 Unix：
```
aws iam create-policy \
--policy-name rds-s3-integration-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
以下示例包含自定义 KMS 密钥的权限。
```
aws iam create-policy \
--policy-name rds-s3-integration-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"kms:Decrypt",
"kms:Encrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey",
"kms:DescribeKey",
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:::your-kms-arn"
]
}
]
}'
```
对于：Windows
```
aws iam create-policy ^
--policy-name rds-s3-integration-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
以下示例包含自定义 KMS 密钥的权限。
```
aws iam create-policy ^
--policy-name rds-s3-integration-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"kms:Decrypt",
"kms:Encrypt",
"kms:ReEncrypt",
"kms:GenerateDataKey",
"kms:DescribeKey",
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:::your-kms-arn"
]
}
]
}'
```
## 步骤 2：（可选）为 Amazon S3 存储桶创建 IAM 策略
只有在以下情况下才需要此步骤：
+ 您计划从一个账户（账户 A）将文件上传到 Amazon S3 存储桶，然后从另一个账户（账户 B）访问它们。
+ 账户 B 拥有该存储桶。
+ 账户 B 需要完全控制加载到存储桶中的对象。
如果上述条件不适用于您，请跳至[步骤 3：为您的数据库实例创建 IAM 角色并附加策略](#oracle-s3-integration.preparing.role)。
要创建存储桶策略，请确保您具备以下各项：
+ 账户 A 的账户 ID
+ 账户 A 的用户名
+ 账户 B 中 Amazon S3 存储桶的 ARN 值
### 控制台
**创建或编辑存储桶策略**
1. 登录到 Amazon Web Services 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.amazonaws.cn/s3/)。
1. 在 **Buckets (存储桶)** 列表中，请选择要为其创建或编辑存储桶策略的存储桶的名称。
1. 选择**权限**。
1. 在 **Bucket policy (存储桶策略)** 下，请选择 **Edit (编辑)**。这将打开编辑存储桶策略页面。
1. 在**编辑存储桶策略**页面上，探索《Amazon S3 用户指南》**中的**策略示例**，选择**策略生成器**自动生成策略，或者在**策略**部分编辑 JSON。
如果选择 **Policy generator**（策略生成器）则 Amazon 策略生成器将在新的窗口中打开。
1. 在 **Amazon 策略生成器**页面，在 **Select Type of Policy**（选择策略类型）中，请选择 **S3 存储桶Policy**（S3 存储桶策略）。
1. 通过在提供的字段中输入信息来添加语句，然后选择 **Add Statement**（添加语句）。对所有您想添加的语句重复执行此操作。有关这些字段的更多信息，请参阅 *IAM 用户指南*中的 [IAM JSON 策略元素参考](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_elements.html)。
**注意**
为方便起见，**Edit bucket policy**（编辑存储桶策略）页面会在 **Policy**（策略）文本字段上方显示当前存储桶的 **Bucket ARN **（Amazon 资源名称）。您可以复制此 ARN，以便在 **Amazon 策略生成器**页面上的语句中使用。
1. 添加完语句后，请选择**生成策略**。
1. 复制生成的策略文本，请选择 **Close**（关闭），然后返回到 Amazon S3 控制台中的 **Edit bucket policy**（编辑存储桶策略）页面。
1. 在 **Policy**（策略）框中，编辑现有策略或从策略生成器粘贴存储桶策略。确保在保存策略之前解决安全警告、错误、一般警告和建议。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/account-A-user"
},
"Action": [
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket",
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
}
]
}
```
------
1. 请选择 **Save changes**（保存更改），此操作将让您返回到存储桶权限页面。
## 步骤 3：为您的数据库实例创建 IAM 角色并附加策略
此步骤假定您已在[步骤 1：为 Amazon RDS 角色创建 IAM 策略](#oracle-s3-integration.preparing.policy)中创建了 IAM 策略。在此步骤中，您将为 RDS for Oracle 数据库实例创建一个角色，然后将策略附加到该角色。
### 控制台
**创建 IAM 角色以允许 Amazon RDS 访问 Amazon S3 桶**
1. 打开 [IAM 管理控制台](https://console.amazonaws.cn/iam/home?#home)。
1. 在导航窗格中，选择**角色**。
1. 选择**创建角色**。
1. 选择 **Amazon 服务**。
1. 对于**其他 Amazon 服务的使用案例：**，选择 **RDS**，然后选择 **RDS – 向数据库添加角色**。然后选择**下一步**。
1. 对于**权限策略**下面的**搜索**，请输入您在[步骤 1：为 Amazon RDS 角色创建 IAM 策略](#oracle-s3-integration.preparing.policy)中创建的 IAM policy 的名称，然后当策略在列表中显示时选择该策略。然后选择**下一步**。
1. 对于**角色名称**，输入 IAM 角色的名称，例如 `rds-s3-integration-role`。您也可以添加可选的**描述**值。
1. 选择**创建角色**。
### Amazon CLI
**创建一个角色并向该角色附加策略**
1. 创建一个让 Amazon RDS 可代表您访问 Amazon S3 存储桶的 IAM 角色。
我们建议在基于资源的信任关系中使用 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键，以此限制服务对特定资源的权限。这是防范[混淆代理问题](https://docs.amazonaws.cn/IAM/latest/UserGuide/confused-deputy.html)最有效的方法。
您可以使用这两个全局条件上下文键并让 `aws:SourceArn` 值包含账户 ID。在这种情况下，当 `aws:SourceAccount` 值和 `aws:SourceArn` 值中的账户使用相同策略语句时，确保二者使用相同的账户 ID。
+ 如果您想对单个资源进行跨服务访问，请使用 `aws:SourceArn`。
+ 如果您想允许该账户中的任何资源与跨服务使用操作相关联，请使用 `aws:SourceAccount`。
在信任关系中，请务必使用 `aws:SourceArn` 全局条件上下文键和访问角色资源的完整 Amazon Resource Name (ARN)。
以下 Amazon CLI 命令会创建名为 `rds-s3-integration-role` 的角色来实现此目的。
**Example**
对于 Linux、macOS 或 Unix：
```
aws iam create-role \
--role-name rds-s3-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "my_account_ID",
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
对于：Windows
```
aws iam create-role ^
--role-name rds-s3-integration-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "my_account_ID",
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
有关更多信息，请参阅 *IAM 用户指南* 中的[创建向 IAM 用户委派权限的角色](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_roles_create_for-user.html)。
1. 创建角色之后，记下该角色的 ARN。后续步骤需要该 ARN。
1. 将您创建的策略附在您创建的角色上。
以下 Amazon CLI 命令将策略附加到名为 `rds-s3-integration-role` 的角色。
**Example**
对于 Linux、macOS 或 Unix：
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-integration-role
```
对于：Windows
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-integration-role
```
将 `your-policy-arn` 替换为您在上一步中记下的策略 ARN。
## 步骤 4：将您的 IAM 角色与 RDS for Oracle 数据库实例关联
配置进行 Amazon S3 集成的权限的最后一步是将您的 IAM 角色与数据库实例相关联。请注意以下要求：
+ 您必须具有访问 IAM 角色的权限，并向此角色附加所需的 Amazon S3 权限策略。
+ 您一次只能将一个 IAM 角色与 RDS for Oracle 数据库实例关联。
+ 数据库实例必须处于**可用**状态。
### 控制台
**将您的 IAM 角色与 RDS for Oracle 数据库实例关联**
1. 登录Amazon Web Services 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 从导航窗格中选择 **Databases (数据库)**。
1. 选择 RDS for Oracle 数据库实例名称以显示其详细信息。
1. 在 **Connectivity & security**（连接性和安全性）选项卡上，向下滚动到页面底部的 **Manage IAM roles**（管理 IAM 角色）部分。
1. 对于**向此实例添加 IAM 角色**，选择您在[步骤 3：为您的数据库实例创建 IAM 角色并附加策略](#oracle-s3-integration.preparing.role)中创建的角色。
1. 对于 **Feature (功能)**，选择 **S3\$1INTEGRATION**。
![\[添加 S3_INTEGRATION 角色\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/ora-s3-integration-role.png)
1. 选择 **Add role (添加角色)**。
### Amazon CLI
以下 Amazon CLI 命令将角色添加到名为 `mydbinstance` 的 Oracle 数据库实例。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds add-role-to-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
对于：Windows
```
aws rds add-role-to-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
将 `your-role-arn` 替换为您在上一步中记下的角色 ARN。必须为 `S3_INTEGRATION` 选项指定 `--feature-name`。
# 添加 Amazon S3 集成选项
要将 Amazon RDS for Oracle 与 Amazon S3 集成，您的数据库实例必须与包括 `S3_INTEGRATION` 选项的选项组关联。
## 控制台
**为 Amazon S3 集成配置选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `S3_INTEGRATION` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `S3_INTEGRATION` 选项添加到该选项组。
有关向选项组添加选项的信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 创建新的 RDS for Oracle 数据库实例并将选项组与其关联，或者修改要将选项组与其关联的 RDS for Oracle 数据库实例。
有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
有关修改 数据库实例的信息，请参阅。[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)
## Amazon CLI
**为 Amazon S3 集成配置选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `S3_INTEGRATION` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `S3_INTEGRATION` 选项添加到该选项组。
例如，以下 Amazon CLI 命令将 `S3_INTEGRATION` 选项添加到名为 **myoptiongroup** 的选项组。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name myoptiongroup \
--options OptionName=S3_INTEGRATION,OptionVersion=1.0
```
对于 Windows：
```
aws rds add-option-to-option-group ^
--option-group-name myoptiongroup ^
--options OptionName=S3_INTEGRATION,OptionVersion=1.0
```
1. 创建新的 RDS for Oracle 数据库实例并将选项组与其关联，或者修改要将选项组与其关联的 RDS for Oracle 数据库实例。
有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
有关修改 RDS for Oracle 数据库实例的信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# 在 Amazon RDS for Oracle 和 Amazon S3 存储桶之间传输文件
要在 RDS for Oracle 数据库实例和 Amazon S3 桶之间传输文件，您可以使用 Amazon RDS 软件包 `rdsadmin_s3_tasks`。您可以在上传文件时使用 GZIP 压缩文件，并在下载时解压缩它们。
**Topics**
+ [文件传输功能的要求和限制](#oracle-s3-integration.using.reqs)
+ [将文件从 RDS for Oracle 数据库实例上传到 Amazon S3 存储桶](#oracle-s3-integration.using.upload)
+ [将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例](#oracle-s3-integration.using.download)
+ [监控文件传输的状态](#oracle-s3-integration.using.task-status)
## 文件传输功能的要求和限制
在您的数据库实例和 Amazon S3 存储桶之间传输文件之前，请注意以下事项：
+ `rdsadmin_s3_tasks` 软件包传输位于单个目录中的文件。您不能在传输中包括子目录。
+ Amazon S3 存储桶中的最大对象大小为 5 TB。
+ `rdsadmin_s3_tasks` 创建的任务以异步方式运行。
+ 您可以从 Data Pump 目录（例如 `DATA_PUMP_DIR`）或用户创建的任何目录上传文件。您不能从 Oracle 后台进程使用的目录（例如 `adump`、`bdump` 或 `trace` 目录）上传文件。
+ 对于 `download_from_s3`，每次过程调用的下载限制为 2000 个文件。如果您需要从 Amazon S3 下载超过 2000 个文件，请将您的下载分成多个单独的操作，每个过程调用不超过 2000 个文件。
+ 如果您的下载文件夹中存在文件，并且您尝试下载同名的文件，`download_from_s3` 将跳过下载。要从下载目录中移除文件，请使用 PL/SQL 过程 [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF)。
## 将文件从 RDS for Oracle 数据库实例上传到 Amazon S3 存储桶
要将文件从数据库实例上传到 Amazon S3 存储桶，请使用 `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` 过程。例如，您可以上传 Oracle Recovery Manager（RMAN）备份文件或 Oracle Data Pump 文件。有关使用对象的更多信息，请参阅 [Amazon Simple Storage Service 用户指南](https://docs.amazonaws.cn/AmazonS3/latest/dev/UsingObjects.html)。有关执行 RMAN 备份的更多信息，请参阅 [执行 Oracle 数据库实例的常见 RMAN 任务](Appendix.Oracle.CommonDBATasks.RMAN.md)。
`rdsadmin.rdsadmin_s3_tasks.upload_to_s3` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_bucket_name` | VARCHAR2 | – | 必需 | 要将文件上传到其中的 Amazon S3 存储桶的名称。 |
| `p_directory_name` | VARCHAR2 | – | 必需 | 要从其中上传文件的 Oracle 目录对象的名称。该目录可以是用户创建的任何目录对象或 Data Pump 目录，例如 `DATA_PUMP_DIR`。您不能从后台进程使用的目录（例如 `adump`、`bdump` 和 `trace`）上传文件。 您只可以从指定目录上传文件。您不能上传指定目录的子目录中的文件。 |
| `p_s3_prefix` | VARCHAR2 | – | 必需 | 待上传文件的 Amazon S3 文件名前缀。如果前缀为空，则将所有文件上传到指定 Amazon S3 存储桶的最顶层，且不为文件名添加前缀。 例如，如果前缀为 `folder_1/oradb`，则文件上传到 `folder_1`。在这个例子中，`oradb` 前缀添加到每个文件。 |
| `p_prefix` | VARCHAR2 | – | 必需 | 一个文件名前缀，文件名必须与其匹配才会上传。如果前缀为空，则将所有文件上传到指定目录。 |
| `p_compression_level` | NUMBER | `0` | optional | GZIP 压缩级别。有效值范围为 `0` 至 `9`： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/oracle-s3-integration.using.html) |
| `p_bucket_owner_full_control` | VARCHAR2 | – | 可选 | 存储桶的访问控制设置。有效值仅为 null 和 `FULL_CONTROL`。仅当您从一个账户（账户 A）将文件上传到另一账户（账户 B）拥有的存储桶，并且账户 B 需要完全控制这些文件时，才需要此设置。 |
`rdsadmin.rdsadmin_s3_tasks.upload_to_s3` 过程的返回值是任务 ID。
下面的示例将 `DATA_PUMP_DIR` 目录中的所有文件上传到名为 *amzn-s3-demo-bucket* 的 Amazon S3 存储桶。文件不会被压缩。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
下面的示例将 `db` 目录中前缀为 `DATA_PUMP_DIR` 的所有文件上传到名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶。Amazon RDS 将最高级别的 GZIP 压缩应用于这些文件。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => 'db',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR',
p_compression_level => 9)
AS TASK_ID FROM DUAL;
```
下面的示例将 `DATA_PUMP_DIR` 目录中的所有文件上传到名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶。文件上传到 `dbfiles` 文件夹。在此示例中，GZIP 压缩级别为 *1*，这是速度最快的压缩级别。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => 'dbfiles/',
p_directory_name => 'DATA_PUMP_DIR',
p_compression_level => 1)
AS TASK_ID FROM DUAL;
```
下面的示例将 `DATA_PUMP_DIR` 目录中的所有文件上传到名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶。文件上传到 `dbfiles` 文件夹，且 `ora` 添加到每个文件名的开头。不应用压缩。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => 'dbfiles/ora',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
以下示例假定该命令在账户 A 中运行，但账户 B 需要完全控制存储桶内容。命令 `rdsadmin_s3_tasks.upload_to_s3` 将 `s3bucketOwnedByAccountB` 目录中的所有文件传输到名为 `DATA_PUMP_DIR` 的存储桶。访问控制设置为 `FULL_CONTROL`，以便账户 B 可以访问存储桶中的文件。GZIP 压缩级别为 *6*，它可平衡速度和文件大小。
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 's3bucketOwnedByAccountB',
p_prefix => '',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR',
p_bucket_owner_full_control => 'FULL_CONTROL',
p_compression_level => 6)
AS TASK_ID FROM DUAL;
```
在每个示例中，`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。
您可以通过显示任务的输出文件来查看结果。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
将 *`task-id`* 替换为由此过程返回的任务 ID。
**注意**
任务以异步方式执行。
## 将文件从 Amazon S3 存储桶下载到 Oracle 数据库实例
要将文件从 Amazon S3 桶下载到 RDS for Oracle 实例，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_s3_tasks.download_from_s3`。
`download_from_s3` 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_bucket_name` | VARCHAR2 | – | 必需 | 要从中下载文件的 Amazon S3 存储桶的名称。 |
| `p_directory_name` | VARCHAR2 | – | 必需 | 要将文件下载到其中的 Oracle 目录对象的名称。该目录可以是用户创建的任何目录对象或 Data Pump 目录，例如 `DATA_PUMP_DIR`。 |
| `p_error_on_zero_downloads` | VARCHAR2 | FALSE | 可选 | 一个标志，用于确定当 Amazon S3 桶中没有与前缀匹配的对象时，任务是否引发错误。如果此参数未设置或设置为 FALSE（原定设置），则任务会输出一条消息，指出未找到任何对象，但不会引发异常或失败。如果此参数为 TRUE，则任务会引发异常并失败。 可能无法通过匹配测试的前缀规范的示例包括前缀中的空格（如在 `' import/test9.log'` 中）和大小写不匹配（如在 `test9.log` 和 `test9.LOG` 中）。 |
| `p_s3_prefix` | VARCHAR2 | – | 必需 | 一个文件名前缀，文件名必须与其匹配才会下载。使用空前缀将下载指定 Amazon S3 存储桶中的所有顶级文件，但不包括存储桶中文件夹内的文件。 该过程仅从匹配前缀的第一级文件夹下载 Amazon S3 对象。匹配指定前缀的嵌套目录结构不会下载。 例如，假定 Amazon S3 存储桶拥有文件夹结构 `folder_1/folder_2/folder_3`。您可以指定 `'folder_1/folder_2/'` 前缀。在这种情况下，只会下载 `folder_2` 中的文件，不会下载 `folder_1` 或 `folder_3` 中的文件。 如果您改为指定 `'folder_1/folder_2'` 前缀，则将下载 `folder_1` 中与 `'folder_2'` 前缀匹配的所有文件，不下载 `folder_2` 中的文件。 |
| `p_decompression_format` | VARCHAR2 | – | 可选 | 解压缩格式。不解压缩时有效值为 `NONE`；解压缩时有效值为 `GZIP`。 |
`rdsadmin.rdsadmin_s3_tasks.download_from_s3` 过程的返回值是任务 ID。
下面的示例将名为 `amzn-s3-demo-bucket` 的 Amazon S3 桶中的所有文件下载到 `DATA_PUMP_DIR` 目录。这些文件没有被压缩，因此不会应用解压缩。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
下面的示例将名为 `db` 的 Amazon S3 存储桶中前缀为 `amzn-s3-demo-bucket` 的所有文件下载到 `DATA_PUMP_DIR` 目录。这些文件是用 GZIP 压缩的，因此将应用解压缩。参数 `p_error_on_zero_downloads` 开启前缀错误检查，因此，如果前缀与桶中的任何文件都不匹配，则任务会引发异常并失败。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'db',
p_directory_name => 'DATA_PUMP_DIR',
p_decompression_format => 'GZIP',
p_error_on_zero_downloads => 'TRUE')
AS TASK_ID FROM DUAL;
```
下面的示例将名为 `myfolder/` 的 Amazon S3 存储桶中的 `amzn-s3-demo-bucket` 文件夹中的所有文件下载到 `DATA_PUMP_DIR` 目录。使用 `p_s3_prefix` 参数来指定 Amazon S3 文件夹。上传的文件使用 GZIP 压缩，但在下载期间不会解压缩。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'myfolder/',
p_directory_name => 'DATA_PUMP_DIR',
p_decompression_format => 'NONE')
AS TASK_ID FROM DUAL;
```
以下示例会将名为 `amzn-s3-demo-bucket` 的 Amazon S3 存储桶中的所有文件 `mydumpfile.dmp` 下载到 `DATA_PUMP_DIR` 目录。不应用解压缩。
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'mydumpfile.dmp',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
在每个示例中，`SELECT` 语句返回 `VARCHAR2` 数据类型的任务 ID。
您可以通过显示任务的输出文件来查看结果。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
将 *`task-id`* 替换为由此过程返回的任务 ID。
**注意**
任务以异步方式执行。
您可以使用 `UTL_FILE.FREMOVE` Oracle 过程从目录中删除文件。有关更多信息，请参阅 Oracle 文档中的 [FREMOVE 过程](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924)。
## 监控文件传输的状态
文件传输任务开始和结束时会发布 Amazon RDS 事件。事件消息包含文件传输的任务 ID。有关查看事件的信息，请参阅 [查看 Amazon RDS 事件](USER_ListEvents.md)。
您可以查看 bdump 文件中的持续任务的状态。bdump 文件位于 `/rdsdbdata/log/trace` 目录下。每个 bdump 文件名称格式如下。
```
dbtask-task-id.log
```
将 `task-id` 替换为您想要监控的任务的 ID。
**注意**
任务以异步方式执行。
您可以使用 `rdsadmin.rds_file_util.read_text_file` 存储过程查看 bdump 文件的内容。例如，以下查询将返回 `dbtask-1234567890123-1234.log` bdump 文件的内容。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1234567890123-1234.log'));
```
以下示例显示传输失败的日志文件。
```
TASK_ID
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1234567890123-1234
TEXT
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2023-04-17 18:21:33.993 UTC [INFO ] File #1: Uploading the file /rdsdbdata/datapump/A123B4CDEF567890G1234567890H1234/sample.dmp to Amazon S3 with bucket name amzn-s3-demo-bucket and key sample.dmp.
2023-04-17 18:21:34.188 UTC [ERROR] RDS doesn't have permission to write to Amazon S3 bucket name amzn-s3-demo-bucket and key sample.dmp.
2023-04-17 18:21:34.189 UTC [INFO ] The task failed.
```
## 排查 Amazon S3 集成问题
有关问题排查提示，请参阅 Amazon re:Post 文章[如何排查将 Amazon RDS for Oracle 与 Amazon S3 集成时出现的问题？](https://repost.aws/en/knowledge-center/rds-oracle-s3-integration)。
# 删除 Amazon S3 集成选项
您可以从数据库实例中删除 Amazon S3 集成选项。
要从数据库实例中删除 Amazon S3 集成选项，请执行下列操作之一：
+ 要从多个数据库实例中删除 Amazon S3 集成选项，请从数据库实例所属的选项组中删除 `S3_INTEGRATION` 选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅 [从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)。
+ 要从单个数据库实例中删除 Amazon S3 集成选项，请修改该实例，并指定不包含 `S3_INTEGRATION` 选项的另一个选项组。您可以指定默认（空）选项组，或指定其他自定义选项组。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# Oracle Application Express (APEX)
Amazon RDS 通过使用 `APEX` 和 `APEX-DEV` 选项支持 Oracle Application Express (APEX)。您可以将 Oracle APEX 部署为运行时环境或基于 Web 的应用程序的完整开发环境。使用 Oracle APEX，您可完全在 Web 浏览器内构建应用程序。有关更多信息，请参阅 Oracle 文档中的 [Oracle Application Express](https://apex.oracle.com/)。
**Topics**
+ [Oracle APEX 组件](#Appendix.Oracle.Options.APEX.components)
+ [要求和限制](Appendix.Oracle.Options.APEX.Requirements.md)
+ [设置 Oracle APEX 和 Oracle Rest Data Services（ORDS）](Appendix.Oracle.Options.APEX.settingUp.md)
+ [配置 Oracle Rest Data Services（ORDS）](Appendix.Oracle.Options.APEX.ORDSConf.md)
+ [升级和移除 Oracle APEX](Appendix.Oracle.Options.APEX.UpgradeandRemove.md)
## Oracle APEX 组件
Oracle APEX 包含以下主要组件：
+ 存储 Oracle APEX 应用程序和组件元数据的*存储库*。该存储库包含安装在 Amazon RDS 数据库实例内的表、索引和其他对象。
+ 管理与 Oracle APEX 客户端的 HTTP 通信的*侦听器*。侦听器位于单独的主机上，例如 Amazon EC2 实例、公司的本地服务器或您的台式计算机。该侦听器接受来自 Web 浏览器的传入连接并将这些连接转发至 Amazon RDS 数据库实例进行处理，然后将来自存储库的结果发送回浏览器。
RDS for Oracle 支持以下类型的侦听器：
+ 对于 Oracle APEX 版本 5.0 和更高版本，请使用 Oracle REST Data Services（ORDS）19.1 和更高版本。建议您使用支持的最新版本 Oracle APEX 和 ORDS。本文档仅出于向后兼容的目的介绍旧版本。
+ 对于 Oracle APEX 版本 4.1.1，可以使用 Oracle APEX Listener 版本 1.1.4。
+ 您可以使用 Oracle HTTP Server 和`mod_plsql`侦听器。
**注意**
Amazon RDS 不支持将嵌入式 PL/SQL 网关作为 Oracle APEX 侦听器的 Oracle XML DB HTTP 服务器。对于在 Internet 上运行的应用程序而言，Oracle 一般不建议使用嵌入 PL/SQL 网关。
有关这些侦听器类型的更多信息，请参阅 Oracle 文档中的[关于选择 Web 侦听器](https://docs.oracle.com/database/apex-5.1/HTMIG/choosing-web-listener.htm#HTMIG29321)。
将 `APEX` 或 `APEX-DEV` 选项添加到 RDS for Oracle 数据库实例时，Amazon RDS 仅安装 Oracle APEX 存储库。将您的侦听器安装在单独的主机上。
# 要求和限制
以下主题列出了 Oracle APEX 和 ORDS 的要求和限制。
## Oracle APEX 版本要求
`APEX` 选项将数据库实例类中的存储用于数据库实例。下面是支持的 Oracle APEX 版本和大致的存储要求。
****
| Oracle APEX 版本 | 存储需求 | 支持的 Oracle 数据库版本 | 备注 |
| --- | --- | --- | --- |
| Oracle APEX 版本 24.2.v1 | 114 MiB | 全部 | 此版本包括补丁 37885097：PSE BUNDLE FOR APEX 24.2（PSES ON TOP OF 24.2.0）、PATCH\$1VERSION 4。 |
| Oracle APEX 版本 24.1.v1 | 112 MiB | 全部 | 此版本包括补丁 36695709：PSE BUNDLE FOR APEX 24.1（PSES ON TOP OF 24.1.0）、PATCH\$1VERSION 3。如果您需要在 EC2 实例上安装完全相同的 APEX 映像版本，请下载补丁 37544819：24.1.3 PSE BUNDLE FOR APEX 24.1（PSES ON TOP OF 24.1.0）。 |
| Oracle APEX 版本 23.2.v1 | 110 MiB | 全部 | 此版本包括补丁 35895964：PSE BUNDLE FOR APEX 23.2（PSES ON TOP OF 23.2.0）、PATCH\$1VERSION 6。如果您需要在 EC2 实例上安装完全相同的 APEX 映像版本，请下载补丁 37593125：23.2.6 PSE BUNDLE FOR APEX 23.2（PSES ON TOP OF 23.2.0）。 |
| Oracle APEX 版本 23.1.v1 | 106 MiB | 全部 | 此版本包括补丁 35283657：PSE BUNDLE FOR APEX 23.1（PSES ON TOP OF 23.1.0）、PATCH\$1VERSION 2。 |
| Oracle APEX 版本 22.2.v1 | 106MiB | 全部 | 此版本包括补丁 34628174：PSE BUNDLE FOR APEX 22.2（PSES ON TOP OF 22.2.0）、PATCH\$1VERSION 4。 |
| Oracle APEX 版本 22.1.v1 | 124MiB | 全部 | 此版本包括补丁 34020981：PSE BUNDLE FOR APEX 22.1（PSES ON TOP OF 22.1.0）、PATCH\$1VERSION 6。 |
| Oracle APEX 版本 21.2.v1 | 125 MiB | 全部 | 此版本包括补丁 33420059：PSE BUNDLE FOR APEX 21.2（PSES ON TOP OF 21.2.0）、PATCH\$1VERSION 8。 |
| Oracle APEX 版本 21.1.v1 | 125 MiB | 全部 | 此版本包括补丁 32598392：PSE BUNDLE FOR APEX 21.1、PATCH\$1VERSION 3。 |
| Oracle APEX 版本 20.2.v1 | 148 MiB | 全部，但 Oracle Database 21c 除外 | 此版本包括补丁 32006852：PSE BUNDLE FOR APEX 20.2、PATCH\$1VERSION 2020.11.12。您可以通过运行以下查询来查看补丁编号和日期： SELECT PATCH_VERSION, PATCH_NUMBER
FROM APEX_PATCHES;
|
| Oracle APEX 版本 20.1.v1 | 173 MiB | 全部，但 Oracle Database 21c 除外 | 此版本包括补丁 30990551：PSE BUNDLE FOR APEX 20.1、PATCH\$1VERSION 2020.07.15。 |
| Oracle APEX 版本 19.2.v1 | 149 MiB | 全部，但 Oracle Database 21c 除外 | |
| Oracle APEX 版本 19.1.v1 | 148 MiB | 全部，但 Oracle Database 21c 除外 | |
有关可下载的 Oracle APEX .zip 文件，请参阅 Oracle 网站上的 [Oracle APEX Prior Release Archives](https://www.oracle.com/tools/downloads/apex-all-archives-downloads.html)。
## Oracle APEX 和 ORDS 的先决条件
请注意使用 Oracle APEX 和 ORDS 的以下先决条件：
+ 系统必须使用 Java 运行时环境（JRE）。
+ 您的 Oracle 客户端安装必须包括以下内容：
+ 用于执行管理任务的 SQL\$1Plus 或 SQL Developer
+ 用于配置与 RDS for Oracle 数据库实例的连接的 Oracle Net Services
## Oracle APEX 限制
您无法修改 `APEX_version` 用户账户，该账户由 Amazon RDS 管理。因此，您不能对该用户应用数据库配置文件或强制执行密码规则。`APEX_version` 的配置文件和密码设置由 Oracle 和 Amazon 预定义，旨在满足 Amazon RDS 的安全要求。
# 设置 Oracle APEX 和 Oracle Rest Data Services（ORDS）
以下主题列出了设置 Oracle APEX 和 ORDS 所需的步骤
**Topics**
+ [将 APEX 和 APEX-DEV 选项添加到数据库实例](#Appendix.Oracle.Options.APEX.Add)
+ [解锁数据库实例上的公有用户账户](#Appendix.Oracle.Options.APEX.PublicUser)
+ [为 Oracle APEX 配置 RESTful 服务](#Appendix.Oracle.Options.APEX.ConfigureRESTful)
+ [准备好在单独的主机上安装 ORDS](#Appendix.Oracle.Options.APEX.ORDS.ords-setup)
+ [设置 Oracle APEX Listener](#Appendix.Oracle.Options.APEX.Listener)
## 将 APEX 和 APEX-DEV 选项添加到数据库实例
要将 `APEX` 和 `APEX-DEV` 选项添加到 RDS for Oracle 数据库实例，请执行以下操作：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 `APEX` 和 `APEX-DEV` 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果添加 `APEX` 和 `APEX-DEV` 选项，则在数据库实例自动重新启动时会出现短暂中断。
**注意**
安装 `APEX` 选项时，`APEX_MAIL` 可用。`APEX_MAIL` 包的执行权限授予 `PUBLIC`，因此您不需要 APEX 管理账户即可使用它。
**将 APEX 和 APEX-DEV 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于 **Engine**，请选择要使用的 Oracle 版本。所有版本均支持 `APEX` 和 `APEX-DEV` 选项。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将选项添加到该选项组。如果您只希望部署 Oracle APEX 运行时环境，则仅添加 `APEX` 选项。要部署完整开发环境，则同时添加 `APEX` 和 `APEX-DEV` 选项。
对于**版本**，选择要使用的 Oracle APEX 版本。
**重要**
如果向已经附加到一个或多个数据库实例的现有选项组添加 `APEX` 或 `APEX-DEV` 选项，则会发生短暂中断。在此中断期间，将自动重新启动所有数据库实例。
有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。如果您将 `APEX` 和 `APEX-DEV` 选项添加到现有数据库实例，则在数据库实例自动重新启动时会出现短暂中断。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## 解锁数据库实例上的公有用户账户
在数据库实例上安装 `APEX` 或 `APEX-DEV` 选项后，请确保执行以下操作：
1. 更改 `APEX_PUBLIC_USER` 账户的密码。
1. 解锁此账户。
您可以使用 Oracle SQL\$1Plus 命令行实用程序执行该操作。以主用户身份连接到数据库实例，并发出以下命令。使用所选密码替换 `new_password`。
```
1. ALTER USER APEX_PUBLIC_USER IDENTIFIED BY new_password;
2. ALTER USER APEX_PUBLIC_USER ACCOUNT UNLOCK;
```
## 为 Oracle APEX 配置 RESTful 服务
要在 Oracle APEX 中配置 RESTful 服务（对 Oracle APEX 4.1.1.V1 不需要），请使用 SQL\$1Plus 以主用户的身份连接到数据库实例。执行此操作后，运行 `rdsadmin.rdsadmin_run_apex_rest_config` 存储过程。当您运行该存储过程时，请为以下用户提供密码：
+ `APEX_LISTENER`
+ `APEX_REST_PUBLIC_USER`
该存储过程运行 `apex_rest_config.sql` 脚本，从而为这些用户创建新的数据库账户。
**注意**
Oracle APEX 版本 4.1.1.v1 无需配置。仅对于此 Oracle APEX 版本，您不需要运行该存储过程。
以下命令运行该存储过程。
```
1. EXEC rdsadmin.rdsadmin_run_apex_rest_config('apex_listener_password', 'apex_rest_public_user_password');
```
## 准备好在单独的主机上安装 ORDS
将 ORDS 安装在单独的主机上，例如 Amazon EC2 实例、公司的本地服务器或您的台式计算机。本节中的示例假设您的主机运行 Linux 且名为 `myapexhost.example.com`。
在安装 ORDS 之前，您需要创建非特权操作系统用户，然后下载并解压缩 Oracle APEX 安装文件。
**为安装 ORDS 做准备**
1. 以 `myapexhost.example.com` 身份登录到 `root`。
1. 创建一个非特权操作系统用户以控制侦听器安装。以下命令会创建一个名为 *apexuser* 的新用户。
```
useradd -d /home/apexuser apexuser
```
以下命令会为新用户分配密码。
```
passwd apexuser;
```
1. 以 `apexuser` 身份登录 `myapexhost.example.com`，并从 Oracle 将 Oracle APEX 安装文件下载到您的 `/home/apexuser` 目录：
+ [http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html](http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html)
+ [Oracle Application Express 早期版本存档](http://www.oracle.com/technetwork/developer-tools/apex/downloads/all-archives-099381.html)
1. 在 `/home/apexuser` 目录中解压缩该文件。
```
unzip apex_version.zip
```
在解压缩该文件后，`apex` 目录中会有一个 `/home/apexuser` 目录。
1. 在您仍以 `myapexhost.example.com` 身份登录 `apexuser` 时，从 Oracle 网站将 Oracle REST Data Services 文件下载到您的 `/home/apexuser` 目录：[http://www.oracle.com/technetwork/developer-tools/apex-listener/downloads/index.html](http://www.oracle.com/technetwork/developer-tools/apex-listener/downloads/index.html)
## 设置 Oracle APEX Listener
**注意**
Oracle APEX Listener 已被弃用。
Amazon RDS for Oracle 继续支持 Oracle APEX 版本 4.1.1 和 Oracle APEX Listener 版本 1.1.4。建议您使用支持的最新版本 Oracle APEX 和 ORDS。
将 Oracle APEX Listener 安装到独立的主机上，例如 Amazon EC2 实例、您公司的本地服务器或您的台式计算机上。假设您的主机名称为 `myapexhost.example.com` 且运行 Linux。
### 为安装 Oracle APEX Listener 做准备
在安装 Oracle APEX Listener 之前，您需要创建非特权操作系统用户，然后下载并解压缩 Oracle APEX 安装文件。
**为安装 Oracle APEX Listener 做准备**
1. 以 `myapexhost.example.com` 身份登录到 `root`。
1. 创建一个非特权操作系统用户以控制侦听器安装。以下命令会创建一个名为 *apexuser* 的新用户。
```
useradd -d /home/apexuser apexuser
```
以下命令会为新用户分配密码。
```
passwd apexuser;
```
1. 以 `apexuser` 身份登录 `myapexhost.example.com`，并从 Oracle 将 Oracle APEX 安装文件下载到您的 `/home/apexuser` 目录：
+ [http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html](http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html)
+ [Oracle Application Express 早期版本存档](http://www.oracle.com/technetwork/developer-tools/apex/downloads/all-archives-099381.html)
1. 在 `/home/apexuser` 目录中解压缩该文件。
```
unzip apex_.zip
```
在解压缩该文件后，`apex` 目录中会有一个 `/home/apexuser` 目录。
1. 当您仍以 `myapexhost.example.com` 身份登录 `apexuser` 时，从 Oracle 网站将 Oracle APEX Listener 文件下载到您的 `/home/apexuser` 目录。
#### 安装和配置 Oracle APEX Listener
在使用 Oracle APEX 之前，您需要下载 `apex.war` 文件，使用 Java 安装 Oracle APEX Listener，然后启动侦听器。
**安装和配置 Oracle APEX Listener**
1. 创建一个基于 Oracle APEX Listener 的新目录并打开侦听器文件。
运行以下代码：
```
mkdir /home/apexuser/apexlistener
cd /home/apexuser/apexlistener
unzip ../apex_listener.version.zip
```
1. 运行以下代码。
```
java -Dapex.home=./apex -Dapex.images=/home/apexuser/apex/images -Dapex.erase -jar ./apex.war
```
1. 输入该程序提示的以下信息：
+ APEX Listener Administrator 用户名。默认值为 *adminlistener*。
+ APEX Listener Administrator 密码。
+ APEX Listener Manager 用户名。默认值为 *managerlistener*。
+ APEX Listener Administrator 密码。
该程序将输出完成配置所需的 URL，如下所示。
```
INFO: Please complete configuration at: http://localhost:8080/apex/listenerConfigure
Database is not yet configured
```
1. 让 Oracle APEX Listener 保持运行，以便您可以使用 Oracle Application Express。完成此配置过程后，可在后台运行侦听器。
1. 从 Web 浏览器中转到 Oracle APEX Listener 程序提供的 URL。显示 Oracle Application Express Listener 管理窗口。输入以下信息：
+ **用户名** – `APEX_PUBLIC_USER`
+ **密码** – *APEX\$1PUBLIC\$1USER* 的密码。这是您先前配置 Oracle APEX 存储库时指定的密码。有关更多信息，请参阅 [解锁数据库实例上的公有用户账户](#Appendix.Oracle.Options.APEX.PublicUser)。
+ **连接类型** – 基本
+ **主机名** – 您的 Amazon RDS 数据库实例的端点，例如 `mydb.f9rbfa893tft.us-east-1.rds.amazonaws.com`。
+ **端口** – 1521
+ **SID** – Amazon RDS 实例上的数据库名称，例如，`mydb`。
1. 选择 **Apply**。此时会显示 Oracle APEX 管理窗口。
1. 为 Oracle APEX `admin` 用户设置密码。为此，请使用 SQL\$1Plus 以主用户身份连接到数据库实例，然后运行以下命令。
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
使用主用户名替换 `master`。在 `apxchpwd.sql` 脚本提示您时，输入新的 `admin` 密码。
1. 返回浏览器中的 Oracle APEX 管理窗口，然后选择**管理**。接下来选择 **Application Express Internal Administration**。在提示您输入凭证时，请输入以下信息：
+ **用户名** – `admin`
+ **密码** – 使用 `apxchpwd.sql` 脚本设置的密码
选择 **Login**，然后设置 `admin` 用户的新密码。
您的侦听器现在已可以使用。
# 配置 Oracle Rest Data Services（ORDS）
以下主题列出了 ORDS 21 和 22 的配置选项：
**Topics**
+ [安装并配置 ORDS 21 及更低版本](#Appendix.Oracle.Options.APEX.ORDS)
+ [安装和配置 ORDS 22 及更高版本](#Appendix.Oracle.Options.APEX.ORDS22)
## 安装并配置 ORDS 21 及更低版本
现在一切就绪，可以安装和配置用于 Oracle APEX 的 Oracle Rest Data Services (ORDS) 了。对于 Oracle APEX 版本 5.0 及更高版本，请使用 ORDS 版本 19.1 到 21。要了解如何安装 ORDS 22 及更高版本，请参阅[安装和配置 ORDS 22 及更高版本](#Appendix.Oracle.Options.APEX.ORDS22)。
将侦听器安装在单独的主机上，例如 Amazon EC2 实例、公司的本地服务器或您的台式计算机。对于本节中的示例，我们假定您的主机的名称为 `myapexhost.example.com`，并且您的主机运行的是 Linux。
**安装并配置 ORDS 21 及更低版本以与 Oracle APEX 结合使用**
1. 转至 [Oracle REST Data Services](https://www.oracle.com/database/technologies/appdev/rest-data-services-downloads-212.html)，查看自述文件。确保安装了所需的 Java 版本。
1. 为 ORDS 安装创建一个新目录。
```
mkdir /home/apexuser/ORDS
cd /home/apexuser/ORDS
```
1. 从 [Oracle REST data services](https://www.oracle.com/database/technologies/appdev/rest-data-services-downloads-212.html) 下载文件 `ords.version.number.zip`。
1. 将该文件解压缩到 `/home/apexuser/ORDS` 目录中。
1. 如果要将 ORDS 安装到多租户数据库中，请将如下命令行添加到文件 `/home/apexuser/ORDS/params/ords_params.properties`：
```
pdb.disable.lockdown=false
```
1. 为主用户授予所需的权限以安装 ORDS。
在安装 Oracle APEX 的选项后，为主用户提供所需的权限以安装 ORDS 架构。您可以连接到数据库并运行以下命令以完成该操作。将 `MASTER_USER` 替换为主用户的大写名称。
**重要**
输入用户名时，除非您使用区分大小写的标识符创建了用户，否则请使用大写字母。例如，如果您运行 `CREATE USER myuser` 或 `CREATE USER MYUSER`，则数据字典将存储 `MYUSER`。但是，如果您在 `CREATE USER "MyUser"` 中使用双引号，则数据字典将存储 `MyUser`。有关更多信息，请参阅“[向 SYS 对象授予 SELECT 或 EXECUTE 权限](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)”。
```
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_ROLE_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONS_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONSTRAINTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_PROCEDURES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TABLES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_VIEWS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPIUTL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SESSION', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_UTILITY', 'MASTER_USER', 'EXECUTE', true);
```
**注意**
这些命令适用于 ORDS 版本 19.1 和更高版本。
1. 使用下载的 ords.war 文件安装 ORDS 架构。
```
java -jar ords.war install advanced
```
程序会提示您输入以下信息。括号中为默认值。有关更多信息，请参阅 Oracle 文档中的 [Oracle REST Data Services 简介](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/20.2/aelig/installing-REST-data-services.html#GUID-6F7B4E61-B730-4E73-80B8-F53299123730)。
+ 输入用于存储配置数据的位置：
输入 */apexuser/ORDS*。这是 ORDS 配置文件的位置。
+ 指定要使用的数据库连接类型。输入 [1] 基本 [2] TNS [3] 自定义 URL [1] 的编号：
选择所需的连接类型。
+ 输入数据库服务器 [localhost] 的名称：*DB\$1instance\$1endpoint*
选择默认值或输入正确的值。
+ 输入数据库侦听器端口 [1521]：*DB\$1instance\$1port*
选择默认值或输入正确的值。
+ 输入 1 以指定数据库服务名称，或输入 2 以指定数据库 SID [1]：
选择 `2` 以指定数据库 SID。
+ 数据库 SID [xe]
选择默认值或输入正确的值。
+ 如果要验证/安装 Oracle REST Data Services 架构，请输入 1，或输入 2 以跳过此步骤 [1]：
选择 `1`。此步骤将创建名为 ORDS\$1PUB\$1USER 的 Oracle REST Data Services 代理用户。
+ 输入 ORDS\$1PUBLIC\$1USER 的数据库密码：
输入密码，然后确认。
+ 要求使用管理员权限登录以验证 Oracle REST Data Services 架构。
输入管理员用户名：*master\$1user*
输入 *master\$1user* 的数据库密码：*master\$1user\$1password*
确认该密码：*master\$1user\$1password*
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
+ 输入 ORDS\$1METADATA [SYSAUX] 的默认表空间。
输入 ORDS\$1METADATA [TEMP] 的临时表空间。
输入 ORDS\$1PUBLIC\$1USER [USERS] 的默认表空间。
输入 ORDS\$1PUBLIC\$1USER [TEMP] 的临时表空间。
+ 如果要使用 PL/SQL 网关，请输入 1，或者输入 2 以跳过该步骤。如果使用 Oracle Application Express 或从 mod\$1plsql 迁移，您必须输入 1 [1]。
选择默认值。
+ 输入 PL/SQL 网关数据库用户名 [APEX\$1PUBLIC\$1USER]
选择默认值。
+ 输入 APEX\$1PUBLIC\$1USER 的数据库密码：
输入密码，然后确认。
+ 输入 1 以指定 Application Express RESTful Services 数据库用户（APEX\$1LISTENER、APEX\$1REST\$1PUBLIC\$1USER）的密码，或输入 2 以跳过此步骤 [1]：
为 APEX 4.1.1.V1 选择 `2`；为所有其他 APEX 版本选择 `1`。
+ [对于 APEX 4.1.1.v1 不需要] APEX\$1LISTENER 的数据库密码
输入密码（如果需要），然后确认。
+ [对于 APEX 4.1.1.v1 不需要] APEX\$1REST\$1PUBLIC\$1USER 的数据库密码
输入密码（如果需要），然后确认。
+ 输入一个数字以选择要启用的特征：
输入 `1` 以启用所有特征：SQL 开发人员 Web、启用 REST 的 SQL 和数据库 API。
+ 如果您希望在独立模式下启动，请输入 1；或输入 2 退出 [1]：
输入 `1`。
+ 输入 APEX 静态资源位置：
如果已将 APEX 安装文件解压缩到 `/home/apexuser` 中，请输入 `/home/apexuser/apex/images`。否则，请输入 `unzip_path/apex/images`，其中 *unzip\$1path* 是解压缩文件的目录。
+ 如果使用 HTTP，则输入 1；如果使用 HTTPS，则输入 2 [1]：
如果您输入 `1`，请指定 HTTP 端口。如果您输入 `2`，请指定 HTTPS 端口和 SSL 主机名。HTTPS 选项提示您指定提供证书的方式：
+ 输入 `1` 以使用自签名证书。
+ 输入 `2` 以提供您自己的证书。如果输入 `2`，请指定 SSL 证书的路径和 SSL 证书私有密钥的路径。
1. 为 APEX `admin` 用户设置密码。为此，请使用 SQL\$1Plus 以主用户身份连接到数据库实例，然后运行以下命令。
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
使用主用户名替换 `master`。在 `apxchpwd.sql` 脚本提示您时，输入新的 `admin` 密码。
1. 启动 ORDS 侦听器。运行以下代码。
```
java -jar ords.war
```
首次启动 ORDS 时，系统会提示您提供 APEX 静态资源的位置。此映像文件夹位于 APEX 安装目录下的 `/apex/images` 目录中。
1. 返回浏览器中的 Oracle APEX 管理窗口，然后选择**管理**。接下来选择 **Application Express Internal Administration**。在提示您输入凭证时，请输入以下信息：
+ **用户名** – `admin`
+ **密码** – 使用 `apxchpwd.sql` 脚本设置的密码
选择 **Login**，然后设置 `admin` 用户的新密码。
您的侦听器现在已可以使用。
## 安装和配置 ORDS 22 及更高版本
现在一切就绪，可以安装和配置用于 Oracle APEX 的 Oracle Rest Data Services (ORDS) 了。对于本节中的示例，我们假定单独主机的名称为 `myapexhost.example.com`，并且主机运行的是 Linux。ORDS 22 的说明与先前版本的说明不同。
**安装并配置 ORDS 22 及更高版本以与 Oracle APEX 结合使用**
1. 转至 [Oracle REST Data Services](http://www.oracle.com/technetwork/developer-tools/rest-data-services/downloads/index.html)，查看您计划下载的 ORDS 版本的自述文件。确保安装了所需的 Java 版本。
1. 为 ORDS 安装创建一个新目录。
```
mkdir /home/apexuser/ORDS
cd /home/apexuser/ORDS
```
1. 从 [Oracle REST Data Services](http://www.oracle.com/technetwork/developer-tools/rest-data-services/downloads/index.html) 下载文件 `ords.version.number.zip` 或 `ords-latest.zip`。
1. 将该文件解压缩到 `/home/apexuser/ORDS` 目录中。
1. 为主用户授予所需的权限以安装 ORDS。
在安装 `APEX` 选项后，为主用户提供所需的权限以安装 ORDS 架构。您可以登录到数据库并运行以下命令来完成该操作。将 `MASTER_USER` 替换为主用户的大写名称。
**重要**
输入用户名时，除非您使用区分大小写的标识符创建了用户，否则请使用大写字母。例如，如果您运行 `CREATE USER myuser` 或 `CREATE USER MYUSER`，则数据字典将存储 `MYUSER`。但是，如果您在 `CREATE USER "MyUser"` 中使用双引号，则数据字典将存储 `MyUser`。有关更多信息，请参阅 [向 SYS 对象授予 SELECT 或 EXECUTE 权限](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)。
```
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_ROLE_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONS_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONSTRAINTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_PROCEDURES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TABLES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_VIEWS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPIUTL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SESSION', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_UTILITY', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_LOB', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_ASSERT', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_OUTPUT', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SCHEDULER', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('HTP', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('OWA', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPG_DOCLOAD', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_CRYPTO', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_METADATA', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SQL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('UTL_SMTP', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_NETWORK_ACL_ADMIN', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('SESSION_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_USERS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_NETWORK_ACL_PRIVILEGES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_NETWORK_ACLS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_REGISTRY', 'MASTER_USER', 'SELECT', true);
```
**注意**
上述命令适用于 ORDS 22 及更高版本。
1. 使用下载的 `ords` 脚本安装 ORDS 架构。指定要包含配置文件和日志文件的目录。Oracle Corporation 建议不要将这些目录放在包含 ORDS 产品软件的目录中。
```
mkdir -p /home/apexuser/ords_config /home/apexuser/ords_logs
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config \
install --interactive --log-folder /home/apexuser/ords_logs
```
对于运行容器数据库（CDB）架构的数据库实例，请使用 ORDS 23.3 及更高版本，并在安装 ORDS 时传递 `--pdb-skip-disable-lockdown` 参数。
```
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config \
install --interactive --log-folder /home/apexuser/ords_logs --pdb-skip-disable-lockdown
```
程序会提示您输入以下信息。括号中为默认值。有关更多信息，请参阅 Oracle 文档中的 [Oracle REST Data Services 简介](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/20.2/aelig/installing-REST-data-services.html#GUID-6F7B4E61-B730-4E73-80B8-F53299123730)。
+ `Choose the type of installation:`
选择 **2** 可在数据库中安装 ORDS 架构，并在本地 ORDS 配置文件中创建数据库连接池。
+ `Specify the database connection type to use. Enter number for [1] Basic [2] TNS [3] Custom URL:`
选择所需的连接类型。此示例假设您选择 **1**。
+ `Enter the name of the database server [localhost]:` ***DB\$1instance\$1endpoint***
选择默认值或输入正确的值。
+ `Enter the database listener port [1521]:` ***DB\$1instance\$1port***
选择默认值 **1521** 或输入正确的值。
+ `Enter the database service name [orcl]:`
输入 RDS for Oracle 数据库实例所使用的数据库名称。
+ `Provide database user name with administrator privileges`
输入 RDS for Oracle 数据库实例的主用户名。
+ `Enter the database password for [username]:`
输入 RDS for Oracle 数据库实例的主用户密码。
+ `Enter the default tablespace for ORDS_METADATA and ORDS_PUBLIC_USER [SYSAUX]:`
+ `Enter the temporary tablespace for ORDS_METADATA [TEMP]. Enter the default tablespace for ORDS_PUBLIC_USER [USERS]. Enter the temporary tablespace for ORDS_PUBLIC_USER [TEMP].`
+ `Enter a number to select additional feature(s) to enable [1]:`
+ `Enter a number to configure and start ORDS in standalone mode [1]: `
选择 **2** 可在独立模式下立即跳过启动 ORDS。
+ `Enter a number to select the protocol [1] HTTP`
+ `Enter the HTTP port [8080]:`
+ `Enter the APEX static resources location:`
输入 Oracle APEX 安装文件的路径（`/home/apexuser/apex/images`）。
1. 为 Oracle APEX `admin` 用户设置密码。为此，请使用 SQL\$1Plus 以主用户身份连接到数据库实例，然后运行以下命令。
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
使用主用户名替换 `master`。在 `apxchpwd.sql` 脚本提示您时，输入新的 `admin` 密码。
1. 使用带有 `serve` 命令的 `ords` 脚本在独立模式下运行 ORDS。对于生产部署，可以考虑使用支持的 Java EE 应用程序服务器，例如 Apache Tomcat 或 Oracle WebLogic 服务器。有关更多信息，请参阅 Oracle 数据库文档中的 [Deploying and Monitoring Oracle REST Data Services](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/23.1/ordig/deploying-and-monitoring-oracle-rest-data-services.html#GUID-6791F5DF-AC67-4885-BFFA-B80964C17EC9)。
```
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config serve \
--port 8193 \
--apex-images /home/apexuser/apex/images
```
如果 ORDS 正在运行但无法访问 Oracle APEX 安装，您可能会看到以下错误，尤其是在非 CDB 实例上。
```
The procedure named apex_admin could not be accessed, it may not be declared, or the user executing this request may not have been granted execute privilege on the procedure, or a function specified by security.requestValidationFunction configuration property has prevented access.
```
要修复此错误，请通过运行带有 `config` 命令的 `ords` 脚本来更改 ORDS 使用的请求验证函数。默认情况下，ORDS 使用 `ords_util.authorize_plsql_gateway` 程序包，只有 CDB 实例支持该程序包。对于非 CDB 实例，您可以将此程序包更改为 `wwv_flow_epg_include_modules.authorize` 软件包。有关为您的用例配置正确的请求验证函数的最佳实践，请参阅 Oracle 数据库文档和 Oracle Support。
1. 返回浏览器中的 Oracle APEX 管理窗口，然后选择**管理**。接下来选择 **Application Express Internal Administration**。在提示您输入凭证时，请输入以下信息：
+ **用户名** – `admin`
+ **密码** – 使用 `apxchpwd.sql` 脚本设置的密码
选择 **Login**，然后设置 `admin` 用户的新密码。
您的侦听器现在已可以使用。
# 升级和移除 Oracle APEX
要升级和移除 Oracle APEX，请遵循本主题中的说明：
**Topics**
+ [升级 Oracle APEX 版本](#Appendix.Oracle.Options.APEX.Upgrade)
+ [移除 APEX 和 APEX-DEV 选项](#Appendix.Oracle.Options.APEX.Remove)
## 升级 Oracle APEX 版本
**重要**
在升级 Oracle APEX 之前，请对数据库实例进行备份。有关更多信息，请参阅[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)和[测试 Oracle 数据库升级](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)。
要将 Oracle APEX 与数据库实例一起升级，请执行以下操作：
+ 为数据库实例的升级后版本创建一个新的选项组。
+ 将 `APEX` 和 `APEX-DEV` 选项的升级后版本添加到新的选项组。确保包括数据库实例使用的任何其他选项。有关更多信息，请参阅“[选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)”。
+ 在升级数据库实例时，请为升级后的数据库实例指定该新选项组。
在升级 Oracle APEX 的版本后，早期版本的 Oracle APEX 架构可能仍在您的数据库中。如果您不再需要旧的 Oracle APEX 架构，可在升级后从数据库中将其删除。
如果您升级 Oracle APEX 版本，并且在先前的 Oracle APEX 版本中未配置 RESTful 服务，我们建议您配置 RESTful 服务。有关更多信息，请参阅 [为 Oracle APEX 配置 RESTful 服务](Appendix.Oracle.Options.APEX.settingUp.md#Appendix.Oracle.Options.APEX.ConfigureRESTful)。
在某些情况下，当您计划对数据库实例进行主要版本升级时，您可能会发现您使用的是与目标数据库版本不兼容的 Oracle APEX 版本。在这些情况下，您可以在升级数据库实例之前升级 Oracle APEX 的版本。先升级 Oracle APEX 可以减少升级数据库实例所需的时间。
**注意**
在升级 Oracle APEX 后，安装并配置用于已升级版本的侦听器。有关说明，请参阅[设置 Oracle APEX Listener](Appendix.Oracle.Options.APEX.settingUp.md#Appendix.Oracle.Options.APEX.Listener)。
## 移除 APEX 和 APEX-DEV 选项
您可以从数据库实例中移除 `APEX` 和 `APEX-DEV` 选项。要从数据库实例中移除这些选项，请执行下列操作之一：
+ 要从多个数据库实例中移除 `APEX` 和 `APEX-DEV` 选项，请从其所属的选项组中移除这些选项。此更改会影响使用该选项组的所有数据库实例。如果从已附加到多个数据库实例的选项组中移除选项，数据库实例重新启动时会发生短暂中断。
有关更多信息，请参阅 [从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)。
+ 要从单个数据库实例中移除 `APEX` 和 `APEX-DEV` 选项，请修改数据库实例，并指定不包含这些选项的另一个选项组。您可以指定默认 (空) 选项组，或指定其他自定义选项组。如果移除选项，数据库实例在自动重新启动时会出现短暂中断。
有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
在从数据库实例中移除 `APEX` 和 `APEX-DEV` 选项时，将从数据库中移除 APEX 架构。
# Amazon EFS 集成
Amazon Elastic File System（Amazon EFS）提供无服务器的完全弹性文件存储，因此，您无需预调配或管理存储容量和性能，即可共享文件数据。使用 Amazon EFS，您可以创建文件系统，然后通过 NFS 版本 4.0 和 4.1（NFSv4）协议将其安装在您的 VPC 中。然后，您可以像任何其他兼容 POSIX 的文件系统一样使用 EFS 文件系统。有关一般信息，请参阅[什么是 Amazon Elastic File System？](https://docs.amazonaws.cn/efs/latest/ug/whatisefs.html)和 Amazon 博客[将 Amazon RDS for Oracle 与 Amazon EFS 集成](https://www.amazonaws.cn//blogs/database/integrate-amazon-rds-for-oracle-with-amazon-efs/)。
**Topics**
+ [Amazon EFS 集成概述](#oracle-efs-integration.overview)
+ [为 RDS for Oracle 与 Amazon EFS 集成配置网络权限](oracle-efs-integration.network.md)
+ [为 RDS for Oracle 与 Amazon EFS 集成配置 IAM 权限](oracle-efs-integration.iam.md)
+ [添加 EFS\$1INTEGRATION 选项](oracle-efs-integration.adding.md)
+ [配置 Amazon EFS 文件系统权限](oracle-efs-integration.file-system.md)
+ [在 RDS for Oracle 和 Amazon EFS 文件系统之间传输文件](oracle-efs-integration.transferring.md)
+ [删除 EFS\$1INTEGRATION 选项](oracle-efs-integration.removing.md)
+ [Amazon EFS 集成问题排查](oracle-efs-integration.troubleshooting.md)
## Amazon EFS 集成概述
使用 Amazon EFS，您可以在 RDS for Oracle 数据库实例和 EFS 文件系统之间传输文件。例如，您可以使用 EFS 来支持以下使用案例：
+ 在应用程序和多个数据库服务器之间共享文件系统。
+ 为与迁移相关的文件（包括可传输的表空间数据文件）创建共享目录。有关更多信息，请参阅 [使用 Oracle 可传输表空间进行迁移](oracle-migrating-tts.md)。
+ 存储和共享存档的重做日志文件，无需在服务器上分配额外的存储空间。
+ 使用 Oracle 数据库实用程序（例如 `UTL_FILE`）读取和写入文件。
### Amazon EFS 集成的优势
当您选择 EFS 文件系统而不是替代的数据传输解决方案时，您将获得以下优势：
+ 您可以在 Amazon EFS 和 RDS for Oracle 数据库实例之间传输 Oracle Data Pump 文件。您无需在本地复制这些文件，因为 Data Pump 直接从 EFS 文件系统导入。有关更多信息，请参阅 [将数据导入到 Amazon RDS 上的 Oracle](Oracle.Procedural.Importing.md)。
+ 数据迁移比使用数据库链接更快。
+ 避免在 RDS for Oracle 数据库实例上分配存储空间来存放文件。
+ EFS 文件系统可以自动扩展存储，无需您进行预调配。
+ Amazon EFS 集成没有最低费用或设置成本。您仅需按实际用量付费。
+ Amazon EFS 集成支持两种形式的加密：传输中数据加密和静态加密。默认情况下，使用 TLS 版本 1.2 启用传输中数据加密。您可以在创建 Amazon EFS 文件系统时启用静态数据加密。有关更多信息，请参阅 *Amazon Elastic File System User Guide*（《Amazon Elastic File System 用户指南》）中的 [Encrypting data at rest](https://docs.amazonaws.cn/efs/latest/ug/encryption-at-rest.html)（加密静态数据）。
### Amazon EFS 集成的要求
确保您满足以下要求：
+ 数据库必须运行数据库版本 19.0.0.0.ru-2022-07.rur-2022-07.r1 或更高版本。
+ 数据库实例和 EFS 文件系统必须位于同一个 Amazon Web Services 区域、VPC 和 Amazon Web Services 账户中。RDS for Oracle 不支持 EFS 的跨账户和跨区域访问。
+ VPC 必须同时启用了 **DNS 解析**和 **DNS 主机名**。有关更多信息，请参阅《Amazon Virtual Private Cloud 用户指南》**中的 [VPC 中的 DNS 属性](https://docs.amazonaws.cn/vpc/latest/userguide/vpc-dns.html#vpc-dns-support)。
+ 如果您在 `mount` 命令中使用 DNS 名称，请确保 VPC 配置为使用由 Amazon 提供的 DNS 服务器。不支持自定义 DNS 服务器。
+ 必须使用非 RDS 解决方案来备份 EFS 文件系统。RDS for Oracle 不支持 EFS 文件系统的自动备份或手动数据库快照。有关更多信息，请参阅[备份您的 Amazon EFS 文件系统](https://docs.amazonaws.cn/efs/latest/ug/efs-backup-solutions.html)。
# 为 RDS for Oracle 与 Amazon EFS 集成配置网络权限
要让 RDS for Oracle 与 Amazon EFS 集成，请确保您的数据库实例具有网络访问权限，可访问 EFS 文件系统。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的 [控制 NFS 客户端对 Amazon EFS 文件系统的网络访问权限](https://docs.amazonaws.cn/efs/latest/ug/NFS-access-control-efs.html)。
**Topics**
+ [使用安全组控制网络访问权限](#oracle-efs-integration.network.inst-access)
+ [使用文件系统策略控制网络访问权限](#oracle-efs-integration.network.file-system-policy)
## 使用安全组控制网络访问权限
您可以使用 VPC 安全组等网络层安全机制控制数据库实例对 EFS 文件系统的访问权限。要允许访问数据库实例的 EFS 文件系统，请确保您的 EFS 文件系统满足以下要求：
+ EFS 挂载目标存在于 RDS for Oracle 数据库实例使用的每个可用区中。
*EFS 挂载目标*提供您可以在其中挂载 EFS 文件系统的 NFSv4 端点的 IP 地址。您使用其 DNS 名称挂载文件系统，该名称将解析为数据库实例的可用区使用的 EFS 挂载目标的 IP 地址。
您可以将不同可用区中的数据库实例配置为使用相同的 EFS 文件系统。对于多可用区，部署中的每个可用区都需要一个挂载点。您可能需要将数据库实例移到其他可用区。出于这些原因，我们建议您在 VPC 的每个可用区中创建一个 EFS 挂载点。默认情况下，当您使用控制台创建新的 EFS 文件系统时，RDS 会为所有可用区创建挂载目标。
+ 安全组已连接到挂载目标。
+ 安全组有一条入站规则，允许在 TCP/2049（类型 NFS）上使用 RDS for Oracle 数据库实例的网络子网或安全组。
有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[创建 Amazon EFS 文件系统](https://docs.amazonaws.cn/efs/latest/ug/creating-using-create-fs.html#configure-efs-network-access)和[创建和管理 EFS 挂载目标和安全组](https://docs.amazonaws.cn/efs/latest/ug/accessing-fs.html)。
## 使用文件系统策略控制网络访问权限
Amazon EFS 与 RDS for Oracle 的集成使用默认（空）EFS 文件系统策略。默认策略不使用 IAM 进行身份验证。相反，它向可以使用挂载目标连接到文件系统的任何匿名客户端授予完全访问权限。当用户配置的文件系统策略不生效时（包括在创建文件系统时），默认策略将生效。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[默认 EFS 文件系统策略](https://docs.amazonaws.cn/efs/latest/ug/iam-access-control-nfs-efs.html#default-filesystempolicy)。
要增强所有客户端（包括 RDS for Oracle）的 EFS 文件系统的访问权限，您可以配置 IAM 权限。使用这种方法，您可以创建文件系统策略。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[创建文件系统策略](https://docs.amazonaws.cn/efs/latest/ug/create-file-system-policy.html)。
# 为 RDS for Oracle 与 Amazon EFS 集成配置 IAM 权限
默认情况下，Amazon EFS 集成功能不使用 IAM 角色：`USE_IAM_ROLE` 选项设置为 `FALSE`。要将 RDS for Oracle 与 Amazon EFS 和 IAM 角色集成，您的数据库实例必须具有可以访问 Amazon EFS 文件系统的 IAM 权限。
**Topics**
+ [步骤 1：为您的数据库实例创建 IAM 角色并附加策略](#oracle-efs-integration.iam.role)
+ [步骤 2：为您的 Amazon EFS 文件系统创建文件系统策略](#oracle-efs-integration.iam.policy)
+ [步骤 3：将您的 IAM 角色与 RDS for Oracle 数据库实例关联](#oracle-efs-integration.iam.instance)
## 步骤 1：为您的数据库实例创建 IAM 角色并附加策略
在此步骤中，您将为 RDS for Oracle 数据库实例创建一个角色，以允许 Amazon RDS 访问您的 EFS 文件系统。
### 控制台
**创建 IAM 角色以允许 Amazon RDS 访问 EFS 文件系统**
1. 打开 [IAM 管理控制台](https://console.amazonaws.cn/iam/home?#home)。
1. 在导航窗格中，选择**角色**。
1. 选择 **Create role (创建角色)**。
1. 对于 **Amazon service (亚马逊云科技服务)**，选择 **RDS**。
1. 对于 **Select your use case (选择您的用例)**，选择 **RDS – Add Role to Database (RDS - 将角色添加到数据库)**。
1. 选择**下一步**。
1. 不要添加任何权限策略。选择**下一步**。
1. 将 **Role name (角色名称)** 设置为您的 IAM 角色的名称，例如，`rds-efs-integration-role`。您也可以添加可选的**描述**值。
1. 选择**创建角色**。
### Amazon CLI
要限制服务对特定资源的权限，我们建议在基于资源的信任关系中使用 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 和 [https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.amazonaws.cn/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) 全局条件上下文键。这是防范[混淆代理问题](https://docs.amazonaws.cn/IAM/latest/UserGuide/confused-deputy.html)最有效的方法。
您可以使用这两个全局条件上下文键并让 `aws:SourceArn` 值包含账户 ID。在这种情况下，当 `aws:SourceAccount` 值和 `aws:SourceArn` 值中的账户使用相同策略语句时，确保二者使用相同的账户 ID。
+ 如果您想对单个资源进行跨服务访问，请使用 `aws:SourceArn`。
+ 如果您想允许该账户中的任何资源与跨服务使用操作相关联，请使用 `aws:SourceAccount`。
在信任关系中，请务必使用 `aws:SourceArn` 全局条件上下文键和访问角色资源的完整 Amazon Resource Name (ARN)。
以下 Amazon CLI 命令会创建名为 `rds-efs-integration-role` 的角色来实现此目的。
**Example**
对于 Linux、macOS 或 Unix：
```
aws iam create-role \
--role-name rds-efs-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": my_account_ID,
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
对于：Windows
```
aws iam create-role ^
--role-name rds-efs-integration-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": my_account_ID,
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
有关更多信息，请参阅《IAM 用户指南》**中的[创建向 IAM 用户委派权限的角色](https://docs.amazonaws.cn/IAM/latest/UserGuide/id_roles_create_for-user.html)。
## 步骤 2：为您的 Amazon EFS 文件系统创建文件系统策略
在此步骤中，您将为 EFS 文件系统创建文件系统策略。
**创建或编辑 EFS 文件系统策略**
1. 打开 [EFS 管理控制台](https://console.amazonaws.cn/efs/home?#home)。
1. 选择 **File Systems (文件系统)**。
1. 在 **File systems**（文件系统）页面上，选择要为其编辑或创建文件系统策略的文件系统。将显示该文件系统的详细信息页面。
1. 选择 **File system policy**（文件系统策略）选项卡。
如果策略为空，则使用默认 EFS 文件系统策略。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[默认 EFS 文件系统策略](https://docs.amazonaws.cn/efs/latest/ug/iam-access-control-nfs-efs.html#default-filesystempolicy )。
1. 选择**编辑**。此时将显示 **File system policy (文件系统策略)** 页面。
1. 在 **Policy editor**（策略编辑器）中，输入如下所示的策略，然后选择 **Save**（保存）。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "ExamplePolicy01",
"Statement": [
{
"Sid": "ExampleStatement01",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/rds-efs-integration-role"
},
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite",
"elasticfilesystem:ClientRootAccess"
],
"Resource": "arn:aws:elasticfilesystem:us-east-1:123456789012:file-system/fs-1234567890abcdef0"
}
]
}
```
------
## 步骤 3：将您的 IAM 角色与 RDS for Oracle 数据库实例关联
在此步骤中，您将您的 IAM 角色与数据库实例关联。请注意以下要求：
+ 您必须具有访问 IAM 角色的权限，并向此角色附加所需的 Amazon EFS 权限策略。
+ 您一次只能将一个 IAM 角色与 RDS for Oracle 数据库实例关联。
+ 实例的状态必须为 **Available**（可用）。
有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的 [Amazon EFS 的身份和访问权限管理](https://docs.amazonaws.cn/efs/latest/ug/auth-and-access-control.html)。
### 控制台
**将您的 IAM 角色与 RDS for Oracle 数据库实例关联**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 选择**数据库**。
1. 如果数据库实例不可用，请选择 **Actions (操作)**，然后选择 **Start (启动)**。当实例状态显示 **Started (已启动)** 时，请转至下一步。
1. 选择 Oracle 数据库实例名称以显示其详细信息。
1. 在 **Connectivity & security**（连接性和安全性）选项卡上，向下滚动到页面底部的 **Manage IAM roles**（管理 IAM 角色）部分。
1. 选择要添加到 **Add IAM roles to this instance**（将 IAM 角色添加到此实例）部分的角色。
1. 对于 **Feature**（特征），选择 **EFS\$1INTEGRATION**。
1. 选择**添加角色**。
### Amazon CLI
以下 Amazon CLI 命令将角色添加到名为 `mydbinstance` 的 Oracle 数据库实例。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds add-role-to-db-instance \
--db-instance-identifier mydbinstance \
--feature-name EFS_INTEGRATION \
--role-arn your-role-arn
```
对于：Windows
```
aws rds add-role-to-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name EFS_INTEGRATION ^
--role-arn your-role-arn
```
将 `your-role-arn` 替换为您在上一步中记下的角色 ARN。必须为 `EFS_INTEGRATION` 选项指定 `--feature-name`。
# 添加 EFS\$1INTEGRATION 选项
要将 Amazon RDS for Oracle 与 Amazon EFS 集成，您的数据库实例必须与包括 `EFS_INTEGRATION` 选项的选项组关联。
属于同一选项组的多个 Oracle 数据库实例共享相同的 EFS 文件系统。不同的数据库实例可以访问相同的数据，但可以通过使用不同的 Oracle 目录来划分访问权限。有关更多信息，请参阅[在 RDS for Oracle 和 Amazon EFS 文件系统之间传输文件](oracle-efs-integration.transferring.md)。
## 控制台
**为 Amazon EFS 集成配置选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `EFS_INTEGRATION` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `EFS_INTEGRATION` 选项添加到该选项组。您需要指定 `EFS_ID` 文件系统 ID 并设置 `USE_IAM_ROLE` 标志。
有关更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 通过以下任一方式将选项组与数据库实例关联：
+ 创建新的 Oracle 数据库实例并将选项组与其关联。有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 修改 Oracle 数据库实例以将选项组与其关联。有关修改 Oracle 数据库实例的信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## Amazon CLI
**为 EFS 集成配置选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `EFS_INTEGRATION` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `EFS_INTEGRATION` 选项添加到该选项组。
例如，以下 Amazon CLI 命令将 `EFS_INTEGRATION` 选项添加到名为 **myoptiongroup** 的选项组。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name myoptiongroup \
--options "OptionName=EFS_INTEGRATION,OptionSettings=\
[{Name=EFS_ID,Value=fs-1234567890abcdef0},{Name=USE_IAM_ROLE,Value=TRUE}]"
```
对于 Windows：
```
aws rds add-option-to-option-group ^
--option-group-name myoptiongroup ^
--options "OptionName=EFS_INTEGRATION,OptionSettings=^
[{Name=EFS_ID,Value=fs-1234567890abcdef0},{Name=USE_IAM_ROLE,Value=TRUE}]"
```
1. 通过以下任一方式将选项组与数据库实例关联：
+ 创建新的 Oracle 数据库实例并将选项组与其关联。有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 修改 Oracle 数据库实例以将选项组与其关联。有关修改 Oracle 数据库实例的信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# 配置 Amazon EFS 文件系统权限
默认情况下，对于新创建的 EFS 文件系统，只有根用户（UID `0`）具有读取、写入和执行权限。为了让其他用户也能修改文件系统，根用户必须明确授予他们访问权限。RDS for Oracle 数据库实例的用户属于 `others` 类别。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[在网络文件系统（NFS）级别处理用户、组和权限](https://docs.amazonaws.cn/efs/latest/ug/accessing-fs-nfs-permissions.html)。
要允许您的 RDS for Oracle 数据库实例在 EFS 文件系统上读取和写入文件，请执行以下操作：
+ 在您的 Amazon EC2 或本地实例上本地挂载 EFS 文件系统。
+ 配置精细权限。
例如，要授予 `other` 用户写入 EFS 文件系统根目录的权限，请在此目录上运行 `chmod 777`。有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[示例 Amazon EFS 文件系统使用案例和权限](https://docs.amazonaws.cn/efs/latest/ug/accessing-fs-nfs-permissions.html#accessing-fs-nfs-permissions-ex-scenarios)。
# 在 RDS for Oracle 和 Amazon EFS 文件系统之间传输文件
要在 RDS for Oracle 实例和 Amazon EFS 文件系统之间传输文件，请至少创建一个 Oracle 目录并配置 EFS 文件系统权限以控制数据库实例访问权限。
**Topics**
+ [创建 Oracle 目录](#oracle-efs-integration.transferring.od)
+ [向 EFS 文件系统传输数据和从其中传输数据：示例](#oracle-efs-integration.transferring.upload)
## 创建 Oracle 目录
要创建 Oracle 目录，请使用过程 `rdsadmin.rdsadmin_util.create_directory_efs`。 过程具有以下参数。
****
| 参数名称 | 数据类型 | 默认值 | 必需 | 描述 |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | – | 是 | Oracle 目录的名称。 |
| `p_path_on_efs` | VARCHAR2 | – | 是 | EFS 文件系统上的路径。路径名的前缀使用模式 `/rdsefs-fsid/`，其中 *fsid* 是 EFS 文件系统 ID 的占位符。 例如，如果您的 EFS 文件系统名为 `fs-1234567890abcdef0`，并且您在此文件系统上创建了一个名为 `mydir` 的子目录，则可以指定以下值： /rdsefs-fs-1234567890abcdef0/mydir
|
假设您在 EFS 文件系统 `fs-1234567890abcdef0` 上创建了一个名为 `/datapump1` 的子目录。以下示例创建一个 Oracle 目录 `DATA_PUMP_DIR_EFS`，该目录指向 EFS 文件系统上的 `/datapump1` 目录。`p_path_on_efs` 参数的文件系统路径值以字符串 `/rdsefs-` 为前缀。
```
BEGIN
rdsadmin.rdsadmin_util.create_directory_efs(
p_directory_name => 'DATA_PUMP_DIR_EFS',
p_path_on_efs => '/rdsefs-fs-1234567890abcdef0/datapump1');
END;
/
```
## 向 EFS 文件系统传输数据和从其中传输数据：示例
以下示例使用 Oracle Data Pump 将名为 `MY_TABLE` 的表导出到文件 `datapump.dmp`。此文件位于 EFS 文件系统上。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(operation => 'EXPORT', job_mode => 'TABLE', job_name=>null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump.dmp',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump-exp.log',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'NAME_EXPR','IN (''MY_TABLE'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
以下示例使用 Oracle Data Pump 从文件 `datapump.dmp` 中导出名为 `MY_TABLE` 的表。此文件位于 EFS 文件系统上。
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'TABLE',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump.dmp',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump-imp.log',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'NAME_EXPR','IN (''MY_TABLE'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
有关更多信息，请参阅 [将数据导入到 Amazon RDS 上的 Oracle](Oracle.Procedural.Importing.md)。
# 删除 EFS\$1INTEGRATION 选项
删除 `EFS_INTEGRATION` 选项的步骤取决于您是从多个数据库实例还是单个实例中删除该选项。
| 数据库实例数 | 操作 | 相关信息 |
| --- | --- | --- |
| 多个 | 从数据库实例所属的选项组中删除 EFS\$1INTEGRATION 选项。此更改会影响使用该选项组的所有实例。 | [从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption) |
| 单列排序 | 修改数据库实例并指定不包含 EFS\$1INTEGRATION 选项的另一个选项组。您可以指定默认（空）选项组，或指定其他自定义选项组。 | [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md) |
删除 `EFS_INTEGRATION` 选项后，您可以选择删除已连接到数据库实例的 EFS 文件系统。
# Amazon EFS 集成问题排查
您的 RDS for Oracle 数据库实例监控与 Amazon EFS 文件系统的连接。当监控检测到问题时，它可能会尝试更正问题并在 RDS 控制台中发布事件。有关更多信息，请参阅[查看 Amazon RDS 事件](https://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/USER_ListEvents.html)。
使用本部分中的信息帮助您诊断和修复在使用 Amazon EFS 集成时的常见问题。
| 通知 | 说明 | Action |
| --- | --- | --- |
| `The EFS for RDS Oracle instance instance_name isn't available on the primary host. NFS port 2049 of your EFS isn't reachable.` | 数据库实例无法与 EFS 文件系统通信。 | 请确保满足以下条件： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `The EFS isn't reachable.` | 安装 `EFS_INTEGRATION` 选项时出错。 | 请确保满足以下条件： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `The associated role with your DB instance wasn't found.` | 安装 `EFS_INTEGRATION` 选项时出错。 | 确保您已将 IAM 角色与 RDS for Oracle 数据库实例关联。 |
| `The associated role with your DB instance wasn't found.` | 安装 `EFS_INTEGRATION` 选项时出错。RDS for Oracle 已从数据库快照中还原，`USE_IAM_ROLE` 选项设置为 `TRUE`。 | 确保您已将 IAM 角色与 RDS for Oracle 数据库实例关联。 |
| `The associated role with your DB instance wasn't found.` | 安装 `EFS_INTEGRATION` 选项时出错。RDS for Oracle 是根据一个多合一的 CloudFormation 模板创建的，其 `USE_IAM_ROLE` 选项设置为 `TRUE`。 | 作为解决方法，请完成以下步骤： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `PLS-00302: component 'CREATE_DIRECTORY_EFS' must be declared` | 当您使用不支持 Amazon EFS 的 RDS for Oracle 版本时，可能会发生此错误。 | 确保您使用的是 RDS for Oracle 数据库实例版本 19.0.0.0.ru-2022-07.rur-2022-07.r1 或更高版本。 |
| `Read access of your EFS is denied. Check your file system policy.` | 您的数据库实例无法读取 EFS 文件系统。 | 确保您的 EFS 文件系统允许通过 IAM 角色或在 EFS 文件系统级别进行读取访问。 |
| 不适用 | 您的数据库实例无法写入 EFS 文件系统。 | 执行以下步骤： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
# Oracle Java 虚拟机
Amazon RDS 通过使用 `JVM` 选项来支持 Oracle Java 虚拟机 (JVM)。Oracle Java 提供了 SQL 架构和函数以在 Oracle 数据库中利用 Oracle Java 功能。有关更多信息，请参阅 Oracle 文档中的 [Oracle Database 中的 Java 简介](https://docs.oracle.com/database/121/JJDEV/chone.htm)。您可以将 Oracle JVM 与所有版本的 Oracle Database 21c（21.0.0）和 Oracle Database 19c（19.0.0）结合使用。
## Oracle JVM 的注意事项
Amazon RDS 中的 Java 实施拥有一组有限的权限。主用户被授予 `RDS_JAVA_ADMIN` 角色，进而授予 `JAVA_ADMIN` 角色所获权限的一个子集。若要列出授予 `RDS_JAVA_ADMIN` 角色的权限，请在您的数据库实例上运行以下查询：
```
SELECT * FROM dba_java_policy
WHERE grantee IN ('RDS_JAVA_ADMIN', 'PUBLIC')
AND enabled = 'ENABLED'
ORDER BY type_name, name, grantee;
```
## Oracle JVM 的先决条件
以下是使用 Oracle Java 的先决条件：
+ 您的数据库实例必须属于足够大的类。db.t3.small 数据库实例类不支持 Oracle Java。有关更多信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。
+ 数据库实例必须已启用**自动次要版本升级**。此选项使您的数据库实例在次要数据库引擎版本升级可用时自动接收该升级。Amazon RDS 使用该选项将数据库实例更新为最新的 Oracle 补丁集更新（PSU）或版本更新（RU）。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## Oracle JVM 的最佳实践
以下是使用 Oracle Java 的最佳实践：
+ 为了实现最高安全性，可将 `JVM` 选项与安全套接字层 (SSL) 结合使用。有关更多信息，请参阅“[Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)”。
+ 配置您的数据库实例以限制网络访问。有关更多信息，请参阅“[在 VPC 中访问数据库实例的场景](USER_VPC.Scenarios.md)”和“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。
+ 如果您满足以下条件，请更新 HTTPS 终端节点的配置以支持 TLSv1.2：
+ 您可以使用 Oracle Java 虚拟机 (JVM) 通过 TLSv1 或 TLSv1.1 协议连接 HTTPS 终端节点。
+ 您的终端节点不支持 TLSv1.2 协议。
+ 您尚未将 2021 年 4 月版本更新应用于 Oracle 数据库。
通过更新终端节点配置，您可以确保 JVM 与 HTTPS 终端节点的连接将继续有效。有关 Oracle JRE 和 JDK 中 TLS 更改的更多信息，请参阅 [Oracle JRE 和 JDK 加密路线图](https://java.com/en/jre-jdk-cryptoroadmap.html)。
## 添加 Oracle JVM 选项
下面是将 `JVM` 选项添加到数据库实例的一般过程：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
添加 `JVM` 选项后，将出现短暂中断。在添加 选项后，您无需重新启动数据库实例。在选项组处于活动状态后，Oracle Java 将立即可用。
**注意**
在该中断期间，将短暂禁用密码验证功能。您还可能会在中断期间看到与密码验证功能相关的事件。在 Oracle 数据库实例变得可用之前，将再次启用密码验证功能。
**将 JVM 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
+ 对于**引擎**，选择数据库实例使用的数据库引擎（**oracle-ee**、**oracle-se**、**oracle-se1** 或 **oracle-se2**）。
+ 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **JVM** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，请在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，请修改实例并附加新的选项组以应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
1. 为用户授予所需的权限。
默认情况下，Amazon RDS 主用户具有使用 `JVM` 选项的权限。如果其他用户需要具有这些权限，请在 SQL 客户端中以主用户身份连接到数据库实例，并为用户授予这些权限。
以下示例为 `JVM` 用户授予使用 `test_proc` 选项的权限。
```
create user test_proc identified by password;
CALL dbms_java.grant_permission('TEST_PROC', 'oracle.aurora.security.JServerPermission', 'LoadClassInPackage.*', '');
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
在为用户授予这些权限后，以下查询将返回输出。
```
select * from dba_java_policy where grantee='TEST_PROC';
```
**注意**
Oracle 用户名区分大小写，通常全部为大写字符。
## 删除 Oracle JVM 选项
您可以从数据库实例中删除 `JVM` 选项。删除该选项后，将出现短暂中断。删除 `JVM` 选项后，您无需重新启动数据库实例。
**警告**
如果数据库实例使用的是在选项中启用的数据类型，则删除 `JVM` 选项会导致数据丢失。请先备份数据，然后再继续。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
要从数据库实例中删除 `JVM` 选项，请执行下列操作之一：
+ 从 `JVM` 选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例并指定不包含 `JVM` 选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# Oracle Enterprise Manager
Amazon RDS 支持 Oracle Enterprise Manager (OEM)。OEM 是 Oracle 的企业信息技术集成管理产品线。
Amazon RDS 在 Oracle Database 19c 非 CDB 或 CDB 上支持 OEM。下表描述了支持的 OEM 选项。
****
| 选项 | 选项 ID | 支持的 OEM 版本 |
| --- | --- | --- |
| [OEM Database Express](Appendix.Oracle.Options.OEM_DBControl.md) | `OEM` | OEM Database Express 19c |
| [OEM Management Agent](Oracle.Options.OEMAgent.md) | `OEM_AGENT` | OEM Cloud Control for 13c |
**注意**
您可以使用 OEM Database 或 OEM Management Agent，但不能同时使用二者。
# Oracle Enterprise Manager Database Express
Amazon RDS 可通过使用 OEM 选项支持 Oracle Enterprise Manager Database Express（EM Express）。Amazon RDS 支持使用 CDB 或非 CDB 架构的 EM Express for Oracle Database 19c。
EM Express 是数据库中包含的基于 Web 的数据库管理工具，仅在打开时才可用。该工具支持关键性能管理和基本数据库管理功能。有关更多信息，请参阅 Oracle 数据库文档中的 [Introduction to Oracle Enterprise Manager Database Express](https://docs.oracle.com/en/database/oracle/oracle-database/19/admqs/getting-started-with-database-administration.html#GUID-BA75AD46-D22E-4914-A31E-C395CD6A2BBA)。
**注意**
db.t3.small 数据库实例类不支持 EM Express。有关数据库实例类的更多信息，请参阅[RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
## OEM 选项设置
Amazon RDS 支持 OEM 选项的以下设置。
****
| 选项设置 | 有效值 | 描述 |
| --- | --- | --- |
| **端口** | 一个整数值 | RDS for Oracle 数据库实例上负责侦听 EM Express 的端口。默认端口为 5500。 |
| **安全组** | — | 对 **Port** 具有访问权限的安全组。 |
## 步骤 1：添加 OEM 选项
将 OEM 选项添加到数据库实例的一般过程如下所示：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果添加 OEM 选项，则在数据库实例自动重新启动时会出现短暂中断。
**将 OEM 选项添加到数据库实例**
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于**引擎**，请选择适用于您的数据库实例的 Oracle 版本。
1. 对于**主引擎版本**，请选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 OEM 选项添加到选项组中，然后配置选项设置。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。有关各项设置的更多信息，请参阅[OEM 选项设置](#Appendix.Oracle.Options.OEM_DBControl.Options)。
**注意**
如果在已附加到一个或多个数据库实例的现有选项组中添加 OEM 选项，所有数据库实例自动重新启动时都会发生短暂中断。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，请在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，请修改实例并附加新的选项组以应用选项组。如果添加 OEM 选项，则在数据库实例自动重新启动时会出现短暂中断。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
**注意**
您还可以使用 Amazon CLI 添加 OEM 选项。有关示例，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
## 步骤 2：（仅限 CDB）解锁 DBSNMP 用户账户
如果数据库实例使用 CDB 架构，您必须以 `DBSNMP` 身份登录 EM Express。在 CDB 中，`DBSNMP` 是普通用户。默认情况下，此账户处于锁定状态。如果数据库实例不使用 CDB 架构，请跳过此步骤。
**解锁 CDB 实例中的 DBSNMP 用户账户**
1. 在 SQL\$1Plus 或其他 Oracle SQL 应用程序中，以主用户身份登录到数据库实例。
1. 运行以下存储过程来解锁 `DBSNMP` 账户：
```
1. EXEC rdsadmin.rdsadmin_util.reset_oem_agent_password('new_password');
```
如果您收到错误消息，指出该过程不存在，请重启 CDB 实例来自动安装它。有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
## 步骤 3：通过浏览器访问 EM Express
当您从 Web 浏览器访问 EM Express 时，将显示一个登录窗口，提示您输入用户名和密码。
**通过浏览器访问 EM Express**
1. 确定 Amazon RDS 数据库实例的端点和 EM Express 端口。有关查找 Amazon RDS 数据库实例的端点的信息，请参阅 [查找 RDS for Oracle 数据库实例的端点](USER_Endpoint.md)。
1. 使用以下格式在浏览器定位器栏中输入 URL。
```
https://endpoint.rds.amazonaws.com:port/em
```
例如，如果 Amazon RDS 数据库实例的端点为 `mydb.a1bcde234fgh.us-east-1.rds.amazonaws.com`，而 EM Express 端口为 `1158`，则使用以下 URL 访问 EM Express。
```
1. https://mydb.f9rbfa893tft.us-east-1.rds.amazonaws.com:1158/em
```
1. 当系统提示您输入登录详细信息时，根据数据库架构，执行以下操作之一：
**数据库为非 CDB。**
键入数据库实例的主用户名和主密码。
**数据库为 CDB。**
对于用户输入 `DBSNMP`，并输入 `DBSNMP` 密码。将 `Container` 字段留空。
## 修改 OEM Database 设置
启用 OEM Database 后，可以修改该选项的安全组设置。
将选项组与数据库实例相关联后，将无法修改 OEM 端口号。要更改数据库实例的 OEM 端口号，可执行以下操作：
1. 创建新的选项组。
1. 将具有新端口号的 OEM 选项添加到新选项组。
1. 删除数据库实例的现有选项组。
1. 将新选项组添加到数据库实例。
有关如何修改选项设置的更多信息，请参阅 [修改选项设置](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption)。有关各项设置的更多信息，请参阅[OEM 选项设置](#Appendix.Oracle.Options.OEM_DBControl.Options)。
## 运行 OEM Database Express 任务
您可以使用 Amazon RDS 过程运行某些 OEM Database Express 任务。通过运行这些过程，您可以执行下面列出的任务。
**注意**
OEM Database Express 任务异步运行。
**Topics**
+ [将 OEM Database Express 的网站前端切换到 Adobe Flash](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToFlash)
+ [将 OEM Database Express 的网站前端切换到 Oracle JET](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToOracleJET)
### 将 OEM Database Express 的网站前端切换到 Adobe Flash
**注意**
此任务仅适用于 Oracle Database 19c 非 CDB。
从 Oracle Database 19c 开始，Oracle 已弃用以前的 OEM Database Express 用户界面，该界面是基于 Adobe Flash 的。相反，OEM Database Express 现在使用通过 Oracle JET 构建的界面。如果您在使用新界面时遇到困难，可以切换回已弃用的基于 Flash 的界面。可能遇到的困难包括登录 OEM Database Express 后卡在 `Loading` 屏幕上。您可能还会失去基于 Flash 的 OEM Database Express 版本中存在的某些功能。
要将 OEM Database Express 网站前端切换到 Adobe Flash，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash`。该过程相当于 `execemx emx` SQL 命令。
安全最佳实践不鼓励使用 Adobe Flash。虽然您可以恢复到基于 Flash 的 OEM Database Express，但我们建议您尽可能使用基于 JET 的 OEM Database Express 网站。如果您恢复使用 Adobe Flash 并希望切换回使用 Oracle JET，请使用 `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet` 过程。Oracle 数据库升级后，较新版本的 Oracle JET 可能会解决 OEM Database Express 中与 JET 相关的问题。有关切换到 Oracle JET 的更多信息，请参阅[将 OEM Database Express 的网站前端切换到 Oracle JET](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToOracleJET)。
**注意**
从只读副本的源数据库实例运行此任务也会导致只读副本将其 OEM Database Express 网站前端切换到 Adobe Flash。
以下过程调用将创建一个任务，以将 OEM Database Express 网站切换到 Adobe Flash，并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash() as TASK_ID from DUAL;
```
您可以通过显示任务的输出文件来查看结果。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
将 *`task-id`* 替换为由此过程返回的任务 ID。有关 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file` 的更多信息，请参阅[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
您还可以通过在 **Logs & events (日志和事件)** 部分中搜索 Amazon Web Services 管理控制台 的相关日志条目，查看 `task-id` 中的任务输出文件的内容。
### 将 OEM Database Express 的网站前端切换到 Oracle JET
**注意**
此任务仅适用于 Oracle Database 19c 非 CDB。
要将 OEM Database Express 网站前端切换到 Oracle JET，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet`。该过程相当于 `execemx omx` SQL 命令。
默认情况下，运行 19c 或更高版本的 Oracle 数据库实例的 OEM Database Express 网站使用 Oracle JET。如果您使用了 `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash` 过程将 OEM Database Express 网站前端切换到 Adobe Flash，则可以切换回 Oracle JET。要执行此操作，请使用 `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet` 过程。有关切换到 Adobe Flash 的更多信息，请参阅[将 OEM Database Express 的网站前端切换到 Adobe Flash](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToFlash)。
**注意**
从只读副本的源数据库实例运行此任务也会导致只读副本将其 OEM Database Express 网站前端切换到 Oracle JET。
以下过程调用将创建一个任务以将 OEM Database Express 网站切换到 Oracle JET，并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet() as TASK_ID from DUAL;
```
您可以通过显示任务的输出文件来查看结果。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
将 *`task-id`* 替换为由此过程返回的任务 ID。有关 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file` 的更多信息，请参阅[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
您还可以通过在 **Logs & events (日志和事件)** 部分中搜索 Amazon Web Services 管理控制台 的相关日志条目，查看 `task-id` 中的任务输出文件的内容。
## 删除 OEM Database 选项
可以从数据库实例中删除 OEM 选项。如果删除 OEM 选项，实例在自动重新启动时会出现短暂中断。因此，在删除 OEM 选项后，不需要重新启动数据库实例。
要从数据库实例中删除 OEM 选项，请执行下列操作之一：
+ 从“OEM ”选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例，并指定不包含“OEM ”选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# 适用于 Enterprise Manager Cloud Control 的 Oracle Management Agent
Oracle Enterprise Manager (OEM) Management Agent 是一种软件组件，可监控在主机上运行的目标并将该信息传达到中间层 Oracle Management Service (OMS)。Amazon RDS 通过使用 `OEM_AGENT` 选项支持 Management Agent。
有关更多信息，请参阅 Oracle 文档中的 [Oracle Enterprise Manager Cloud Control 12c 概述](http://docs.oracle.com/cd/E24628_01/doc.121/e25353/overview.htm)和 [Oracle Enterprise Manager Cloud Control 13c 概述](http://docs.oracle.com/cd/E63000_01/EMCON/overview.htm#EMCON109)。
**Topics**
+ [Management Agent 的要求](#Oracle.Options.OEMAgent.PreReqs)
+ [OMS 主机通信先决条件](#Oracle.Options.OEMAgent.PreReqs.host)
+ [Management Agent 的限制](#Oracle.Options.OEMAgent.limitations)
+ [Management Agent 的选项设置](#Oracle.Options.OEMAgent.Options)
+ [为数据库实例启用 Management Agent 选项](#Oracle.Options.OEMAgent.Enable)
+ [删除 Management Agent 选项](#Oracle.Options.OEMAgent.Remove)
+ [使用 Management Agent 执行数据库任务](#Oracle.Options.OEMAgent.DBTasks)
## Management Agent 的要求
以下是使用 Management Agent 的一般要求：
+ 数据库实例必须运行 Oracle Database 19c（19.0.0.0）。可以使用 CDB 或非 CDB 架构。
+ 您必须使用配置为连接到您的数据库实例的 Oracle Management Service（OMS）。请注意以下 OMS 要求：
+ Management Agent 版本 13.5.0.0.v2 和 13.5.0.0.v3 需要 OMS 版本 13.5.0.23 或 24.1。
+ Management Agent 版本 13.5.0.0.v1 需要 OMS 版本 13.5.0.0 或 24.1。
+ Management Agent 版本 13.4.0.9.v1 和 13.4.0.9.v2 需要 OMS 版本 13.4.0.9 或更高版本及补丁 32198287。
+ 在大多数情况下，您必须配置 VPC 以允许 OMS 与数据库实例之间的连接。如果您不熟悉 Amazon Virtual Private Cloud (Amazon VPC)，建议您在继续之前先完成 [教程：创建 VPC 以用于数据库实例（仅限 IPv4）](CHAP_Tutorials.WebServerDB.CreateVPC.md) 中的步骤。
+ 您可以将 Management Agent 与适用于 12c 和 13c 的 Oracle Enterprise Manager Cloud Control 结合使用。确保您的 OEM 版本有足够的存储空间：
+ OEM 13c 版本 5 至少 8.5GiB
+ OEM 13c 版本 4 至少 8.5 GiB
+ OEM 13c 版本 3 至少 8.5 GiB
+ OEM 13c 版本 2 至少 5.5 GiB
+ OEM 13c 版本 1 至少 4.5 GiB
+ OEM 12c 至少 2.5 GiB
+ 如果您使用的是 Management Agent 版本 `OEM_AGENT 13.2.0.0.v3` 和 `13.3.0.0.v2`，并且想要使用 TCPS 连接，请按照 Oracle 文档中的[配置第三方 CA 证书以便与目标数据库通信](https://docs.oracle.com/cd/E73210_01/EMSEC/GUID-8337AD48-1A32-4CD5-84F3-256FAE93D043.htm#EMSEC15996)中的说明进行操作。另外，按照 Oracle 文档 ID 为 2241358.1 的 Oracle 文档中的说明更新 OMS 上的 JDK。此步骤可确保 OMS 支持数据库支持的所有密码套件。
**注意**
Management Agent `OEM_AGENT 13.2.0.0.v3`、`13.3.0.0.v2`、`13.4.0.9.v1` 和更高版本支持 Management Agent 和数据库实例之间的 TCPS 连接。
## OMS 主机通信先决条件
确保您的 OMS 主机和您的 Amazon RDS 数据库实例可以通信。执行以下操作：
+ 当 OMS 主机位于防火墙后时，要从 Management Agent 连接到 OMS 主机，请将数据库实例的 IP 地址添加到防火墙中。确保 OMS 防火墙允许以下网络流量：
从 OMS 主机到数据库实例
配置单向防火墙规则，以便支持从 OMS 主机到数据库侦听器端口（默认为 1521）和 OEM Agent 端口（默认为 3872）的流量。
从数据库实例到 OMS 主机
配置单向防火墙规则，以便支持从数据库实例到 OMS HTTP 端口（默认为 4903）的流量。
+ 要从 OMS 连接到 Management Agent（如果 OMS 具有一个可公开解析的主机名），需将该 OMS 地址添加到安全组。您的安全组必须拥有允许访问数据库侦听器端口和 Management Agent 端口的入站规则。有关创建安全组并添加入站规则的示例，请参阅[教程：创建 VPC 以用于数据库实例（仅限 IPv4）](CHAP_Tutorials.WebServerDB.CreateVPC.md)。
+ 要从 OMS 连接到 Management Agent (如果 OMS 没有可公开解析的主机名)，请使用下列项目之一：
+ 如果 OMS 已在私有 VPC 中的 Amazon Elastic Compute Cloud (Amazon EC2) 实例上托管，则可设置 VPC 对等连接以从 OMS 连接到 Management Agent。有关更多信息，请参阅“[VPC 中的数据库实例由另一 VPC 中的 EC2 实例访问](USER_VPC.Scenarios.md#USER_VPC.Scenario3)”。
+ 如果您的 OMS 已在本地托管，则可设置 VPN 连接以允许从 OMS 访问 Management Agent。有关更多信息，请参阅 [VPC 中的数据库实例由客户端应用程序通过互联网访问](USER_VPC.Scenarios.md#USER_VPC.Scenario4)或 [VPN 连接](https://docs.amazonaws.cn/vpc/latest/userguide/vpn-connections.html)。
+ 要将 OEM Management Agent 版本 13.5.0.0（v1-v3）连接到 24.1 OMS 主机，请在配置选项中将 `MINIMUM_TLS_VERSION` 设置为使用 TLS 1.2 协议 `TLSv1.2`。
## Management Agent 的限制
以下是使用 Management Agent 的一些限制：
+ 您无法提供自定义 Oracle 管理代理映像。
+ 不支持需要主机凭证的管理任务（例如作业执行和数据库修补）。
+ 不保证主机指标和进程列表反映实际的系统状态。因此，您不应使用 OEM 来监视根文件系统或挂载点文件系统。有关监控操作系统的更多信息，请参阅 [使用增强监控来监控操作系统指标](USER_Monitoring.OS.md)。
+ 不支持自动发现。您必须手动添加数据库目标。
+ OMS 模块可用性取决于数据库版本。例如，数据库性能诊断和优化模块仅适用于 Oracle Database 企业版。
+ Management Agent 会占用额外的内存和计算资源。如果您在启用 `OEM_AGENT` 选项后遇到了性能问题，建议您向上扩展至更大的数据库实例类。有关更多信息，请参阅“[数据库实例类](Concepts.DBInstanceClass.md)”和“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
+ 在 Amazon RDS 主机上运行 `OEM_AGENT` 的用户没有对警报日志的操作系统访问权限。因此，您无法收集 OEM 中 `DB Alert Log` 和 `DB Alert Log Error Status` 的指标。
## Management Agent 的选项设置
Amazon RDS 支持 Management Agent 选项的以下设置。
| 选项设置 | 必需 | 有效值 | 描述 |
| --- | --- | --- | --- |
| **版本** (`AGENT_VERSION`) | 是 | `13.5.0.0.v3` `13.5.0.0.v2` `13.5.0.0.v1` `13.4.0.9.v2` `13.4.0.9.v1` `13.3.0.0.v2` `13.3.0.0.v1` `13.2.0.0.v3` `13.2.0.0.v2` `13.2.0.0.v1` `13.1.0.0.v1` | Management Agent 软件的版本。支持的最低版本为 `13.1.0.0.v1`。 Amazon CLI 选项名称为 `OptionVersion`。 在 Amazon GovCloud (US)区域中，13.1 版本不可用。 |
| **端口** (`AGENT_PORT`) | 是 | 一个整数值 | 侦听 OMS 主机的数据库实例上的端口。默认值为 3872。您的 OMS 主机必须属于对此端口具有访问权限的安全组。 Amazon CLI 选项名称为 `Port`。 |
| ** 安全组** | 是 | 现有安全组 | 对 **Port** 具有访问权限的安全组。您的 OMS 主机必须属于此安全组。 Amazon CLI 选项名称为 `VpcSecurityGroupMemberships` 或 `DBSecurityGroupMemberships`。 |
| **OMS\$1HOST** | 是 | 一个字符串值，例如 *my.example.oms* | OMS 的可公开访问的主机名或 IP 地址。 Amazon CLI 选项名称为 `OMS_HOST`。 |
| **OMS\$1PORT** | 是 | 一个整数值 | OMS 主机上侦听 Management Agent 的 HTTPS 上传端口。 要确定 HTTPS 上传端口，请连接到 OMS 主机，然后运行以下命令 (此操作需要 `SYSMAN` 密码)： emctl status oms -details Amazon CLI 选项名称为 `OMS_PORT`。 |
| **AGENT\$1REGISTRATION\$1PASSWORD** | 是 | 一个字符串值 | Management Agent 用于通过 OMS 自行进行身份验证的密码。建议您在启用 `OEM_AGENT` 选项之前先在 OMS 中创建一个永久性密码。使用永久性密码，您可以在多个 Amazon RDS 数据库之中共享一个 Management Agent 选项组。 Amazon CLI 选项名称为 `AGENT_REGISTRATION_PASSWORD`。 |
| **ALLOW\$1TLS\$1ONLY** | 否 | `true`、`false`（默认值） | 一个值，该值将 OEM 代理配置为仅在代理作为服务器侦听时支持 `TLSv1` 协议。不再支持此设置。默认情况下，Management Agent 版本 13.1.0.0.v1 及更高版本支持传输层安全性协议（TLS）。 |
| **MINIMUM\$1TLS\$1VERSION** | 否 | `TLSv1` (默认值)`TLSv1.2` | 一个值，该值指定 OEM 代理在代理作为服务器侦听时支持的最低 TLS 版本。失去支持的代理版本仅支持 `TLSv1` 设置。 要将 13.5.0.0（v1-v3）连接到 24.1 OMS 主机，请将其设置为 `TLSv1.2`。 |
| **TLS\$1CIPHER\$1SUITE** | 否 | 请参阅[Management Agent 的选项设置](#Oracle.Options.OEMAgent.Options)。 | 一个值，该值指定 OEM 代理在代理作为服务器侦听时使用的 TLS 密码套件。 |
下表列出了 Management Agent 选项支持的 TLS 密码套件。
| 密码套件 | 支持的引擎版本 | 符合 FedRAMP 要求 |
| --- | --- | --- |
| TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 全部 | 否 |
| TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 | 13.1.0.0.v1 及更高版本 | 否 |
| TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 13.2.0.0.v3 及更高版本 | 否 |
| TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 | 13.2.0.0.v3 及更高版本 | 否 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 13.2.0.0.v3 及更高版本 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 13.2.0.0.v3 及更高版本 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 | 13.2.0.0.v3 及更高版本 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | 13.2.0.0.v3 及更高版本 | 是 |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 | 13.4.0.9.v1 及更高版本 | 是 |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | 13.4.0.9.v1 及更高版本 | 是 |
### 证书与密码套件的兼容性
RDS for Oracle 同时支持 RSA 和椭圆曲线数字签名算法（ECDSA）证书。在为数据库实例配置 OEM Agent 选项时，必须确保在 `TLS_CIPHER_SUITE` 选项设置中指定的密码套件与数据库实例使用的证书类型兼容。
下表展示了证书类型和密码套件之间的兼容性：
| 证书类型 | 兼容的密码套件 | 不兼容的密码套件 |
| --- | --- | --- |
| RSA 证书（rds-ca-2019、rds-ca-rsa2048-g1、rds-ca-rsa4096-g1） | TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 |
| ECDSA 证书（rds-ca-ecc384-g1） | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 |
在 `TLS_CIPHER_SUITE` 选项设置中指定密码套件时，请确保其与数据库实例所用的证书类型兼容。如果您尝试将选项组与包含和数据库实例的证书类型不兼容的密码套件的 OEM Agent 选项相关联，操作将失败，并显示一条错误消息，指出不兼容。
## 为数据库实例启用 Management Agent 选项
要启用 Management Agent 选项，请使用以下步骤：
**Topics**
+ [步骤 1：将 Management Agent 选项添加到数据库实例](#Oracle.Options.OEMAgent.Add)
+ [步骤 2：解锁 DBSNMP 用户账户](#Oracle.Options.OEMAgent.DBSNMP)
+ [步骤 3：将目标添加到 Management Agent 控制台](#Oracle.Options.OEMAgent.Using)
### 步骤 1：将 Management Agent 选项添加到数据库实例
要将 Management Agent 选项添加到数据库实例，请执行以下操作：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果遇到错误，请查看[我的 Oracle 支持](https://support.oracle.com/)文档以了解有关解决特定问题的信息。
在添加“Management Agent”选项后，您无需重新启动数据库实例。只要选项组处于活动状态，OEM Agent 就处于活动状态。
如果 OMS 主机使用的是不受信任的第三方证书，则 Amazon RDS 将返回以下错误。
```
You successfully installed the OEM_AGENT option. Your OMS host is using an untrusted third party certificate.
Configure your OMS host with the trusted certificates from your third party.
```
如果返回此错误，则在更正问题之前，不会启用 Management Agent 选项。有关更正问题的信息，请参阅“我的 Oracle 支持”文档 [2202569.1](https://support.oracle.com/epmos/faces/DocContentDisplay?id=2202569.1)。
#### 控制台
**将 Management Agent 选项添加到数据库实例**
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于**引擎**，请选择适用于您的数据库实例的 Oracle 版本。
1. 对于**主引擎版本**，请选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **OEM\$1AGENT** 选项添加到选项组，然后配置选项设置。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。有关各项设置的更多信息，请参阅[Management Agent 的选项设置](#Oracle.Options.OEMAgent.Options)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
#### Amazon CLI
以下示例使用 Amazon CLI [add-option-to-option-group](https://docs.amazonaws.cn/cli/latest/reference/rds/add-option-to-option-group.html) 命令将 `OEM_AGENT` 选项添加到名为 `myoptiongroup` 的选项组。
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options OptionName=OEM_AGENT,OptionVersion=13.1.0.0.v1,Port=3872,VpcSecurityGroupMemberships=sg-1234567890,OptionSettings=[{Name=OMS_HOST,Value=my.example.oms},{Name=OMS_PORT,Value=4903},{Name=AGENT_REGISTRATION_PASSWORD,Value=password}] \
--apply-immediately
```
对于：Windows
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options OptionName=OEM_AGENT,OptionVersion=13.1.0.0.v1,Port=3872,VpcSecurityGroupMemberships=sg-1234567890,OptionSettings=[{Name=OMS_HOST,Value=my.example.oms},{Name=OMS_PORT,Value=4903},{Name=AGENT_REGISTRATION_PASSWORD,Value=password}] ^
--apply-immediately
```
### 步骤 2：解锁 DBSNMP 用户账户
Management Agent 使用 `DBSNMP` 用户账户连接到数据库，并向 Oracle Enterprise Manager 报告问题。在 CDB 中，`DBSNMP` 是普通用户。Management Agent 和 OEM Database Express 都需要此用户账户。默认情况下，此账户处于锁定状态。解锁此账户的过程会有所不同，具体取决于数据库使用的是非 CDB 还是 CDB 架构。
**解锁 DBSNMP 用户账户**
1. 在 SQL\$1Plus 或其他 Oracle SQL 应用程序中，以主用户身份登录到数据库实例。
1. 根据数据库架构，执行以下操作之一：
**数据库为非 CDB。**
运行以下 SQL 语句：
```
1. ALTER USER dbsnmp IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**数据库为 CDB。**
运行以下存储过程来解锁 `DBSNMP` 账户：
```
1. EXEC rdsadmin.rdsadmin_util.reset_oem_agent_password('new_password');
```
如果您收到错误消息，指出该过程不存在，请重启 CDB 实例来自动安装它。有关更多信息，请参阅 [重启数据库实例](USER_RebootInstance.md)。
### 步骤 3：将目标添加到 Management Agent 控制台
要将数据库实例添加为目标，请确保您知道端点和端口。有关查找 Amazon RDS 数据库实例的端点的信息，请参阅 [查找 RDS for Oracle 数据库实例的端点](USER_Endpoint.md)。如果数据库使用 CDB 架构，则将 `CDB$ROOT` 容器单独添加为目标。
**将目标添加到 Management Agent 控制台**
1. 在 OMS 控制台中，选择 **Setup**、**Add Target**、**Add Targets Manually**。
1. 选择 **Add Targets Declaratively by Specifying Target Monitoring Properties**。
1. 对于 **Target Type**，选择 **Database Instance**。
1. 对于 **Monitoring Agent (监控代理)**，请选择标识符与 RDS 数据库实例标识符相同的代理。
1. 选择 **Add Manually**。
1. 输入 Amazon RDS 数据库实例的端点，或者从主机名列表中选择该端点。确保指定的主机名与 Amazon RDS 数据库实例的端点匹配。
1. 指定以下数据库属性：
+ 对于 **Target name (目标名称)**，输入一个名称。
+ 对于 **Database system name (数据库系统名称)**，输入一个名称。
+ 对于 **Monitor username (监控用户名)**，输入 **dbsnmp**。
+ 对于**监控密码**，输入[步骤 2：解锁 DBSNMP 用户账户](#Oracle.Options.OEMAgent.DBSNMP)中的密码。
+ 对于 **Role (角色)**，输入 **normal (正常)**。
+ 对于 **Oracle home path (Oracle 主路径)**，输入 **/oracle**。
+ 对于 **Listener Machine name**，已显示该代理标识符。
+ 对于 **Port (端口)**，输入数据库端口。RDS 默认端口为 1521。
+ 对于 **Database name (数据库名称)**，输入数据库的名称。如果数据库为 CDB，则此名称为 `RDSCDB`。
1. 选择 **Test Connection**。
1. 选择 **Next (下一步)**。目标数据库将显示在所监控资源的列表中。
## 删除 Management Agent 选项
可以从数据库实例中删除 OEM Agent。删除 OEM Agent 后，您无需重新启动数据库实例。
要从数据库实例中删除 OEM Agent，请执行下列操作之一：
+ 从“OEM Agent”选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例，并指定不包含“OEM Agent”选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## 使用 Management Agent 执行数据库任务
您可以使用 Amazon RDS 过程在 Management Agent 上运行某些 EMCTL 命令。通过运行这些过程，您可以执行下面列出的任务。
**注意**
任务以异步方式执行。
**Topics**
+ [保护 Management Agent](#Oracle.Options.OEMAgent.DBTasks.SecureAgent)
+ [获取 Management Agent 的状态](#Oracle.Options.OEMAgent.DBTasks.GetAgentStatus)
+ [重新启动 Management Agent](#Oracle.Options.OEMAgent.DBTasks.RestartAgent)
+ [列出 Management Agent 监控的目标](#Oracle.Options.OEMAgent.DBTasks.ListTargets)
+ [列出 Management Agent 监控的收集线程](#Oracle.Options.OEMAgent.DBTasks.ListCollectionThreads)
+ [清除 Management Agent 的状态](#Oracle.Options.OEMAgent.DBTasks.ClearState)
+ [让 Management Agent 上载其 OMS](#Oracle.Options.OEMAgent.DBTasks.ForceUploadOMS)
+ [为 OMS 执行 ping 操作](#Oracle.Options.OEMAgent.DBTasks.PingOMS)
+ [查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)
### 保护 Management Agent
要保护 Management Agent，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.secure_oem_agent`。该过程相当于运行 `emctl secure agent` 命令。
以下过程创建一个任务来保护 Management Agent 并返回任务的 ID：
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.secure_oem_agent as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 获取 Management Agent 的状态
要获取 Management Agent 的状态，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.get_status_oem_agent`。该过程相当于 `emctl status agent` 命令。
以下过程创建一个任务来获取管理代理的状态，并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.get_status_oem_agent() as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 重新启动 Management Agent
要重新启动 Management Agent，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.restart_oem_agent`。该过程相当于运行 `emctl stop agent` 和 `emctl start agent` 命令。
以下过程创建一个任务来重新启动管理代理并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.restart_oem_agent as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 列出 Management Agent 监控的目标
要列出 Management Agent 监控的目标，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.list_targets_oem_agent`。该过程相当于运行 `emctl config agent listtargets` 命令。
以下过程创建一个任务来列出管理代理监控的目标并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.list_targets_oem_agent as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 列出 Management Agent 监控的收集线程
要列出管理代理监控的所有正在运行、就绪和计划的收集线程，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.list_clxn_threads_oem_agent`。该过程相当于 `emctl status agent scheduler` 命令。
以下过程创建一个任务来列出收集线程并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.list_clxn_threads_oem_agent() as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 清除 Management Agent 的状态
要清除 Management Agent 的状态，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.clearstate_oem_agent`。该过程相当于运行 `emctl clearstate agent` 命令。
以下过程创建一个任务来清除管理代理的状态并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.clearstate_oem_agent() as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 让 Management Agent 上载其 OMS
要让 Management Agent 上载与其关联的 Oracle Management Server (OMS)，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.upload_oem_agent`。该过程相当于运行 `emclt upload agent` 命令。
以下过程创建一个任务，使 Management Agent 上传其关联的 OMS 并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.upload_oem_agent() as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 为 OMS 执行 ping 操作
要为 Management Agent 的 OMS 执行 ping 操作，请运行 Amazon RDS 过程 `rdsadmin.rdsadmin_oem_agent_tasks.ping_oms_oem_agent`。该过程相当于运行 `emctl pingOMS` 命令。
以下过程创建一个任务来 Ping 管理代理的 OMS 并返回任务的 ID。
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.ping_oms_oem_agent() as TASK_ID from DUAL;
```
要显示任务的输出文件并查看结果，请参阅[查看正在执行的任务的状态](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)。
### 查看正在执行的任务的状态
您可以查看 bdump 文件中的持续任务的状态。bdump 文件位于 `/rdsdbdata/log/trace` 目录下。每个 bdump 文件名称格式如下。
```
dbtask-task-id.log
```
如果要监控任务，请将 `task-id` 替换为要监控的任务的 ID。
要查看 bdump 文件的内容，请运行 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file`。以下查询返回 `dbtask-1546988886389-2444.log` bdump 文件的内容。
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1546988886389-2444.log'));
```
有关 Amazon RDS 过程 `rdsadmin.rds_file_util.read_text_file` 的更多信息，请参阅[读取数据库实例目录中的文件](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)。
# Oracle Label Security
Amazon RDS 通过使用 OLS 选项支持 Oracle Database 企业版的 Oracle Label Security。
大多数数据库安全性控制对象级别的访问。Oracle Label Security 提供对针对各个表格行的访问的精细控制。例如，您可以使用 Label Security 通过基于策略的管理模型实施法规合规性。您可以使用 Label Security 策略控制对敏感数据的访问，并限制对具有相应清除级别的用户的访问。有关更多信息，请参阅 Oracle 文档中的 [Oracle Label Security 简介](https://docs.oracle.com/database/121/OLSAG/intro.htm#OLSAG001)。
**Topics**
+ [Oracle Label Security 的要求](#Oracle.Options.OLS.PreReqs)
+ [使用 Oracle Label Security 时的注意事项](#Oracle.Options.OLS.Using)
+ [添加“Oracle Label Security”选项](#Oracle.Options.OLS.Add)
+ [问题排查](#Oracle.Options.OLS.Troubleshooting)
## Oracle Label Security 的要求
熟悉 Oracle Label Security 的以下要求：
+ 数据库实例必须使用自带许可模式。有关更多信息，请参阅“[RDS for Oracle 许可选项](Oracle.Concepts.Licensing.md)”。
+ 您必须拥有 Oracle 企业版的有效许可证以及软件更新许可证和支持。
+ 您的 Oracle 许可证必须包含 Label Security 选项。
## 使用 Oracle Label Security 时的注意事项
要使用 Oracle Label Security，请创建可控制对您表格中特定行的访问的策略。有关更多信息，请参阅 Oracle 文档中的[创建 Oracle Label Security 策略](https://docs.oracle.com/database/121/OLSAG/getstrtd.htm#OLSAG3096)。
请考虑以下事项：
+ Oracle Label Security 是永久性的持续选项。因为该选项是永久性的，所以不能将其从选项组中删除。如果您将 Oracle Label Security 添加到选项组并将其与您的数据库实例关联，则可以稍后将其他选项组与您的数据库实例关联，但该组还必须包含 Oracle Label Security 选项。
+ 使用 Label Security 时，您以 `LBAC_DBA` 角色执行所有操作。数据库实例的主用户将被授予 `LBAC_DBA` 角色。您可以向其他用户授予 `LBAC_DBA` 角色，以便他们可以管理 Label Security 策略。
+ 请确保将对 `OLS_ENFORCEMENT` 程序包的访问权限授予需要访问 Oracle Label Security 的任何新用户。要授予对 `OLS_ENFORCEMENT` 包的访问权限，请以主用户身份连接到数据库实例，然后运行以下 SQL 语句：
```
GRANT ALL ON LBACSYS.OLS_ENFORCEMENT TO username;
```
+ 可以通过 Oracle Enterprise Manager（OEM）Cloud Control 配置 Label Security。Amazon RDS 通过 Management Agent 选项支持 OEM Cloud Control。有关更多信息，请参阅 [适用于 Enterprise Manager Cloud Control 的 Oracle Management Agent](Oracle.Options.OEMAgent.md)。
## 添加“Oracle Label Security”选项
将“Oracle Label Security”选项添加到数据库实例的一般过程如下所示：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
**重要**
Oracle Label Security 是永久性的持续选项。
1. 将选项组与数据库实例相关联。
在添加“Label Security”选项后，一旦激活该选项组，就会激活 Label Security。
**将“Label Security”选项添加到数据库实例**
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于 **引擎**，请选择 **oracle-ee**。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **OLS** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
**重要**
如果您向已附加到一个或多个数据库实例的现有选项组添加“Label Security”，则将重新启动所有数据库实例。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。如果您将“Label Security”选项添加到现有数据库实例，则在数据库实例自动重新启动时会出现短暂中断。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## 问题排查
以下是您在使用 Oracle Label Security 时可能遇到的问题。
****
| 问题 | 故障排除建议 |
| --- | --- |
| 当尝试创建策略时，您会看到一条与以下内容类似的错误消息：`insufficient authorization for the SYSDBA package`。 | 有关 Oracle 的 Label Security 功能的已知问题阻止了用户名为 16 或 24 个字符的用户运行 Label Security 命令。您可以使用其他数量的字符创建新用户，向该新用户授予 LBAC\$1DBA 角色，以该新用户的身份登录，并以该新用户的身份运行 OLS 命令。有关更多信息，请联系 Oracle Support。 |
# Oracle Locator
Amazon RDS 通过使用 `LOCATOR` 选项支持 Oracle Locator。Oracle Locator 提供支持基于 Internet 和无线服务的应用程序与基于合作伙伴的 GIS 解决方案通常所需的功能。Oracle Locator 是 Oracle Spatial 的有限子集。有关更多信息，请参阅 Oracle 文档中的 [Oracle Locator](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#SPATL340)。
**重要**
如果您使用 Oracle Locator，则当存在通用漏洞评分系统 (CVSS) 评分为 9\$1 的安全漏洞或其他公布的安全漏洞时，Amazon RDS 会自动将数据库实例更新为最新的 Oracle PSU。
## Oracle Locator 支持的数据库版本
RDS for Oracle 支持 Oracle Locator for Oracle Database 19c。Oracle Database 21c 不支持 Oracle Locator，但 Oracle Spatial 选项中提供了其功能。以前，Spatial 选项需要额外的许可证。Oracle Locator 是 Oracle Spatial 功能的子集，不需要额外的许可证。2019 年，Oracle 宣布，所有 Oracle Spatial 功能都包含在企业版和标准版 2 许可证中，无需额外费用。因此，Oracle Spatial 选项不再需要额外的许可。有关更多信息，请参阅 Oracle Database Insider 博客中的[Machine Learning、Spatial 和 Graph - 无需许可证！](https://blogs.oracle.com/database/post/machine-learning-spatial-and-graph-no-license-required)。
## Oracle Locator 的先决条件
以下是使用 Oracle Locator 的先决条件：
+ 数据库实例必须属于足够的类。db.t3.small 数据库实例类不支持 Oracle Locator。有关更多信息，请参阅 [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
+ 数据库实例必须已启用**自动次要版本升级**。该选项允许数据库实例在次要数据库引擎版本升级可用时自动接收这些升级，这对于安装 Oracle Java 虚拟机（JVM）的任意选项是必需的。Amazon RDS 使用该选项将数据库实例更新为最新的 Oracle 补丁集更新（PSU）或版本更新（RU）。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## Oracle Locator 的最佳实践
以下是使用 Oracle Locator 的最佳实践：
+ 为了实现最高安全性，可将 `LOCATOR` 选项与安全套接字层 (SSL) 结合使用。有关更多信息，请参阅“[Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)”。
+ 配置数据库实例以限制对它的访问。有关更多信息，请参阅“[在 VPC 中访问数据库实例的场景](USER_VPC.Scenarios.md)”和“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。
## 添加 Oracle Locator 选项
下面是将 `LOCATOR` 选项添加到数据库实例的一般过程：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则添加 `LOCATOR` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。在添加 选项后，您无需重新启动数据库实例。只要选项组处于活动状态，Oracle Locator 就可用。
**注意**
在该中断期间，将短暂禁用密码验证功能。您还可能会在中断期间看到与密码验证功能相关的事件。在 Oracle 数据库实例变得可用之前，将再次启用密码验证功能。
**将 `LOCATOR` 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于**引擎**，请选择适用于数据库实例的 Oracle 版本。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **LOCATOR** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## 使用 Oracle Locator
在启用 Oracle Locator 选项后，可以开始使用它。您应仅使用 Oracle Locator 功能。请勿使用任何 Oracle Spatial 功能，除非您有 Oracle Spatial 的许可证。
有关 Oracle Locator 支持的功能的列表，请参阅 Oracle 文档中的 [Locator 附带的功能](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#GUID-EC6DEA23-8FD7-4109-A0C1-93C0CE3D6FF2__CFACCEEG)。
有关 Oracle Locator 不支持的功能的列表，请参阅 Oracle 文档中的 [Locator 未附带的功能](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#GUID-EC6DEA23-8FD7-4109-A0C1-93C0CE3D6FF2__CFABACEA)。
## 删除 Oracle Locator 选项
删除使用 `LOCATOR` 选项提供的数据类型的所有对象后，您可以从数据库实例中删除该选项。如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则删除 `LOCATOR` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。删除 `LOCATOR` 选项后，您无需重新启动数据库实例。
**删除 `LOCATOR` 选项**
1. 备份您的数据。
**警告**
如果实例使用作为选项一部分启用的数据类型，并且您删除了 `LOCATOR` 选项，则可能会丢失数据。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
1. 检查是否有任何现有对象引用了 `LOCATOR` 选项的数据类型或功能。
如果存在 `LOCATOR` 选项，则在应用无 `LOCATOR` 选项的新选项组时，实例可能会卡住。您可以使用以下查询标识对象：
```
SELECT OWNER, SEGMENT_NAME, TABLESPACE_NAME, BYTES/1024/1024 mbytes
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE '%TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT DISTINCT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE='SDO_GEOMETRY'
AND OWNER <> 'MDSYS')
ORDER BY 1,2,3,4;
SELECT OWNER, TABLE_NAME, COLUMN_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE = 'SDO_GEOMETRY'
AND OWNER <> 'MDSYS'
ORDER BY 1,2,3;
```
1. 删除引用了 `LOCATOR` 选项的数据类型或功能的任何对象。
1. 请执行下列操作之一：
+ 从 `LOCATOR` 选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例并指定不包含 `LOCATOR` 选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# Oracle 本机网络加密
Amazon RDS 支持 Oracle 本机网络加密 (NNE)。利用 `NATIVE_NETWORK_ENCRYPTION` 选项，您可以在数据进出数据库实例时对数据进行加密。Amazon RDS 支持所有版本的 Oracle Database 的 NNE。
详细讨论 Oracle Native Network Encryption 超出了本指南的范围，但在您确定部署解决方案前，应该了解每个算法和密钥的优缺点。有关通过 Oracle 本机网络加密提供的算法和密钥的信息，请参阅 Oracle 文档中的[配置网络数据加密](http://www.oracle.com/webfolder/technetwork/tutorials/obe/db/11g/r2/prod/security/network_encrypt/ntwrkencrypt.htm)。有关Amazon安全性的更多信息，请参阅[Amazon安全中心](https://www.amazonaws.cn/security)。
**注意**
您可以使用本机网络加密或安全套接字层，但不能同时使用二者。有关更多信息，请参阅 [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)。
**Topics**
+ [NATIVE\$1NETWORK\$1ENCRYPTION 选项设置](Oracle.Options.NNE.Options.md)
+ [添加 NATIVE\$1NETWORK\$1ENCRYPTION 选项](Oracle.Options.NNE.Add.md)
+ [在 sqlnet.ora 中设置 NNE 值](Oracle.Options.NNE.Using.md)
+ [修改 NATIVE\$1NETWORK\$1ENCRYPTION 选项设置](Oracle.Options.NNE.ModifySettings.md)
+ [删除 NATIVE\$1NETWORK\$1ENCRYPTION 选项](Oracle.Options.NNE.Remove.md)
# NATIVE\$1NETWORK\$1ENCRYPTION 选项设置
您可以在服务器和客户端上指定加密要求。例如，当数据库实例使用数据库链接连接到另一个数据库时，它可以充当客户端。您可能希望避免在服务器端强制加密。例如，您可能不希望强制所有客户端通信使用加密，因为服务器需要加密。在这种情况下，您可以使用 `SQLNET.*CLIENT` 选项强制在客户端加密。
Amazon RDS 支持 `NATIVE_NETWORK_ENCRYPTION` 选项的以下设置。
**注意**
当您使用逗号分隔选项设置的值时，不要在逗号后面放置空格。
****
| 选项设置 | 有效值 | 默认值 | 说明 |
| --- | --- | --- | --- |
| `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` | `TRUE`, `FALSE` | `TRUE` | 使用非安全密码的客户端尝试连接到数据库时服务器的行为。如果为 `TRUE`，即使客户没有使用 2021 年 7 月 PSU 修补也可以连接。 如果设置为 `FALSE`，客户端只有在使用 2021 年 7 月 PSU 修补后才能连接到数据库。将 `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` 设置为 `FALSE` 之前，确保满足以下条件： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) |
| `SQLNET.ALLOW_WEAK_CRYPTO` | `TRUE`, `FALSE` | `TRUE` | 使用非安全密码的客户端尝试连接到数据库时服务器的行为。以下密码被视为不安全： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) 如果设置为 `TRUE`，则客户端可以在使用上述非安全密码时进行连接。 如果设置为 `FALSE`，则数据库会在客户端可以在使用上述非安全密码时阻止客户端进行连接。将 `SQLNET.ALLOW_WEAK_CRYPTO` 设置为 `FALSE` 之前，确保满足以下条件： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) |
| `SQLNET.CRYPTO_CHECKSUM_CLIENT` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | 当客户端或充当客户端的服务器连接到数据库实例时的数据集成行为。当数据库实例使用数据库链接时，它充当客户端。 `Requested` 表示数据库实例不需要数据库实例执行校验和。 |
| `SQLNET.CRYPTO_CHECKSUM_SERVER` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | 客户端或充当客户端的服务器连接到数据库实例时的数据集成行为。当数据库实例使用数据库链接时，它充当客户端。 `Requested` 表示数据库实例不需要客户端执行校验和。 |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | `SHA256`, `SHA384`, `SHA512` | 校验和算法的列表。 您可以指定一个值，也可以指定逗号分隔的值列表。如果您使用逗号，请不要在逗号后插入空格；否则，您会收到 `InvalidParameterValue` 错误。 此参数和 `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER ` 必须有一个通用的密码。 |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | 校验和算法的列表。 您可以指定一个值，也可以指定逗号分隔的值列表。如果您使用逗号，请不要在逗号后插入空格；否则，您会收到 `InvalidParameterValue` 错误。 此参数和 `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` 必须有一个通用的密码。 |
| `SQLNET.ENCRYPTION_CLIENT` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | 客户端或充当客户端的服务器连接到数据库实例时的客户端加密行为。当数据库实例使用数据库链接时，它充当客户端。 `Requested` 表示数据库实例不需要给来自服务器的流量加密。 |
| `SQLNET.ENCRYPTION_SERVER` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | 客户端或充当客户端的服务器连接到数据库实例时的服务器加密行为。当数据库实例使用数据库链接时，它充当客户端。 `Requested` 表示数据库实例不需要给来自客户端的流量加密。 |
| `SQLNET.ENCRYPTION_TYPES_CLIENT` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | 客户端使用的加密算法的列表。客户端尝试通过按顺序尝试每种算法来对服务器输入进行解密，直到某种算法成功或到达列表末尾。 Amazon RDS 使用 Oracle 中的下列默认列表。RDS 从 `RC4_256` 开始，然后沿列表按顺序下移。您可以更改顺序或限制数据库实例将接受的算法。 [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) 您可以指定一个值，也可以指定逗号分隔的值列表。如果使用逗号，请不要在逗号后插入空格；否则，您会收到 `InvalidParameterValue` 错误。 此参数和 `SQLNET.SQLNET.ENCRYPTION_TYPES_SERVER` 必须有一个通用的密码。 |
| `SQLNET.ENCRYPTION_TYPES_SERVER` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | 数据库实例使用的加密算法的列表。数据库实例使用每种算法，以便尝试对客户端输入解密，直到某种算法成功或到达列表末尾。 Amazon RDS 使用 Oracle 中的下列默认列表。您可以更改顺序或限制客户端将接受的算法。 [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) 您可以指定一个值，也可以指定逗号分隔的值列表。如果使用逗号，请不要在逗号后插入空格；否则，您会收到 `InvalidParameterValue` 错误。 此参数和 `SQLNET.SQLNET.ENCRYPTION_TYPES_SERVER` 必须有一个通用的密码。 |
# 添加 NATIVE\$1NETWORK\$1ENCRYPTION 选项
将 `NATIVE_NETWORK_ENCRYPTION` 选项添加到数据库实例的一般过程如下：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
当选项组处于活动状态时，NNE 就处于活动状态。
**使用 Amazon Web Services 管理控制台将 NATIVE\$1NETWORK\$1ENCRYPTION 选项添加到数据库实例**
1. 对于 **Engine**，请选择要使用的 Oracle 版本。NNE 在所有版本中都受支持。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 **NATIVE\$1NETWORK\$1ENCRYPTION** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
**注意**
添加 **NATIVE\$1NETWORK\$1ENCRYPTION** 选项后，您无需重新启动数据库实例。只要选项组处于活动状态，NNE 就处于活动状态。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。添加 **NATIVE\$1NETWORK\$1ENCRYPTION** 选项后，您无需重新启动数据库实例。只要选项组处于活动状态，NNE 就处于活动状态。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# 在 sqlnet.ora 中设置 NNE 值
借助于 Oracle Native Network Encryption，您还可以在服务器端和客户端设置网络加密。客户端是用来连接到数据库实例的计算机。您可以在 slqnet.ora 中指定以下客户端设置：
+ `SQLNET.ALLOW_WEAK_CRYPTO`
+ `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS`
+ `SQLNET.CRYPTO_CHECKSUM_CLIENT`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT`
+ `SQLNET.ENCRYPTION_CLIENT`
+ `SQLNET.ENCRYPTION_TYPES_CLIENT`
有关信息，请参阅 Oracle 文档中的[配置 Oracle 服务器和客户端的网络数据加密和完整性](http://docs.oracle.com/cd/E11882_01/network.112/e40393/asoconfg.htm)。
有时，数据库实例会拒绝来自应用程序的连接请求。例如，当客户端和服务器上的加密算法不匹配时，可能会发生拒绝。要测试 Oracle Native Network Encryption，请给客户端上的 sqlnet.ora 文件添加下列行：
```
DIAG_ADR_ENABLED=off
TRACE_DIRECTORY_CLIENT=/tmp
TRACE_FILE_CLIENT=nettrace
TRACE_LEVEL_CLIENT=16
```
当尝试连接时，先前的行会在称为 `/tmp/nettrace*` 的客户端上生成跟踪文件。该跟踪文件中包含关于连接的信息。有关使用 Oracle 本机网络加密时的相关连接问题的详细信息，请参阅 Oracle Database 文档中的[关于协商加密和完整性](http://docs.oracle.com/cd/E11882_01/network.112/e40393/asoconfg.htm#autoId12)。
# 修改 NATIVE\$1NETWORK\$1ENCRYPTION 选项设置
启用 `NATIVE_NETWORK_ENCRYPTION` 选项后，您可以修改其设置。目前，您只能使用 Amazon CLI 或 RDS API 修改 `NATIVE_NETWORK_ENCRYPTION` 选项设置。您无法使用控制台。以下示例修改该选项中的两个设置。
```
aws rds add-option-to-option-group \
--option-group-name my-option-group \
--options "OptionName=NATIVE_NETWORK_ENCRYPTION,OptionSettings=[{Name=SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER,Value=SHA256},{Name=SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER,Value=SHA256}]" \
--apply-immediately
```
要了解如何使用 CLI 修改选项设置，请参阅[Amazon CLI](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption.CLI)。有关各项设置的更多信息，请参阅[NATIVE\$1NETWORK\$1ENCRYPTION 选项设置](Oracle.Options.NNE.Options.md)。
**Topics**
+ [修改 CRYPTO\$1CHECKSUM\$1\$1 值](#Oracle.Options.NNE.ModifySettings.checksum)
+ [修改 ALLOW\$1WEAK\$1CRYPTO\$1 设置](#Oracle.Options.NNE.ModifySettings.encryption)
## 修改 CRYPTO\$1CHECKSUM\$1\$1 值
如果修改 **NATIVE\$1NETWORK\$1ENCRYPTION** 选项设置，请确保以下选项设置具有至少一个通用密码：
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT`
以下示例显示修改 `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` 的方案。该配置有效，因为 `CRYPTO_CHECKSUM_TYPES_CLIENT` 和 `CRYPTO_CHECKSUM_TYPES_SERVER` 都使用 `SHA256`。
| 选项设置 | 修改前的值 | 修改后的值 |
| --- | --- | --- |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512` | 无更改 |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | SHA1,MD5,SHA256 |
例如，假设需要将 `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` 从默认设置改为 `SHA1,MD5`。在这种情况下，请确保将 `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` 设置为 `SHA1` 或者 `MD5`。这些算法不包含 `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` 的默认值中。
## 修改 ALLOW\$1WEAK\$1CRYPTO\$1 设置
要将 `SQLNET.ALLOW_WEAK_CRYPTO*` 选项从默认值设置为 `FALSE`，请确保满足以下条件：
+ `SQLNET.ENCRYPTION_TYPES_SERVER` 和 `SQLNET.ENCRYPTION_TYPES_CLIENT` 有一种匹配的安全加密方法。如果方法并非 `DES`、`3DES` 或 `RC4`（所有密钥长度），则该方法被视为安全。
+ `SQLNET.CHECKSUM_TYPES_SERVER` 和 `SQLNET.CHECKSUM_TYPES_CLIENT` 有一种匹配的安全校验和方法。如果方法并非 `MD5`，则该方法被视为安全。
+ 该客户端使用 2021 年 7 月的 PSU 进行了修补。如果客户端没有进行修补，则客户端将失去连接并收到 `ORA-12269` 错误。
下面的示例显示了示例 NNE 设置。假设您想要将 `SQLNET.ENCRYPTION_TYPES_SERVER` 和 `SQLNET.ENCRYPTION_TYPES_CLIENT` 设置为 FALSE，从而阻止不安全的连接。校验和选项设置满足先决条件，因为它们都具有 `SHA256`。但是，`SQLNET.ENCRYPTION_TYPES_CLIENT` 和 `SQLNET.ENCRYPTION_TYPES_SERVER` 使用 `DES`、`3DES` 和 `RC4` 加密方法，这些方法不安全。因此，要将 `SQLNET.ALLOW_WEAK_CRYPTO*` 选项设置为 `FALSE`，请首先将 `SQLNET.ENCRYPTION_TYPES_SERVER` 和 `SQLNET.ENCRYPTION_TYPES_CLIENT` 设置为安全加密方法，例如 `AES256`。
| 选项设置 | 值 |
| --- | --- |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512` |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | SHA1,MD5,SHA256 |
| `SQLNET.ENCRYPTION_TYPES_CLIENT` | `RC4_256`, `3DES168`, `DES40` |
| `SQLNET.ENCRYPTION_TYPES_SERVER` | `RC4_256`, `3DES168`, `DES40` |
# 删除 NATIVE\$1NETWORK\$1ENCRYPTION 选项
您可以从数据库实例中删除 NNE。
要从数据库实例中删除 `NATIVE_NETWORK_ENCRYPTION` 选项，请执行下列操作之一：
+ 要从多个数据库实例中删除该选项，请从其所属的选项组中删除 `NATIVE_NETWORK_ENCRYPTION` 选项。此更改会影响使用该选项组的所有数据库实例。删除 `NATIVE_NETWORK_ENCRYPTION` 选项后，您无需重新启动数据库实例。有关更多信息，请参阅 [从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)。
+ 要从单个数据库实例中删除此选项，请修改该数据库实例，并指定另一个不包含 `NATIVE_NETWORK_ENCRYPTION` 选项的选项组。您可以指定默认 (空) 选项组，或指定其他自定义选项组。删除 `NATIVE_NETWORK_ENCRYPTION` 选项后，您无需重新启动数据库实例。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# Oracle OLAP
Amazon RDS 通过使用 `OLAP` 选项支持 Oracle OLAP。此选项为 Oracle 数据库实例提供在线分析处理 (OLAP)。您可以使用 Oracle OLAP，根据 OLAP 标准创建维度对象和多维数据集来分析大量数据。有关更多信息，请参阅 [Oracle 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/olaug/index.html)。
**重要**
如果您使用 Oracle OLAP，则当存在通用漏洞评分系统 (CVSS) 评分为 9\$1 的安全漏洞或其他公布的安全漏洞时，Amazon RDS 会自动将数据库实例更新为最新的 Oracle PSU。
Amazon RDS 支持 Enterprise Edition 的 Oracle Database 19c 及更高版本的 Oracle LAP。
## Oracle OLAP 的先决条件
以下是使用 Oracle OLAP 的先决条件：
+ 您必须拥有 Oracle 提供的 Oracle OLAP 许可证。有关更多信息，请参阅 Oracle 文档中的[许可信息](https://docs.oracle.com/en/database/oracle/oracle-database/19/dblic/Licensing-Information.html#GUID-B6113390-9586-46D7-9008-DCC9EDA45AB4)。
+ 您的数据库实例必须具有足够的实例类。db.t3.small 数据库实例类不支持 Oracle OLAP。有关更多信息，请参阅 [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
+ 数据库实例必须已启用**自动次要版本升级**。该选项允许数据库实例在次要数据库引擎版本升级可用时自动接收这些升级，这对于安装 Oracle Java 虚拟机（JVM）的任意选项是必需的。Amazon RDS 使用该选项将数据库实例更新为最新的 Oracle 补丁集更新（PSU）或版本更新（RU）。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
+ 您的数据库实例不能有名为 `OLAPSYS` 的用户。如果是这样，OLAP 选项安装将失败。
## Oracle OLAP 的最佳实践
以下是使用 Oracle OLAP 的最佳实践：
+ 为了实现最高安全性，可将 `OLAP` 选项与安全套接字层 (SSL) 结合使用。有关更多信息，请参阅“[Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)”。
+ 配置数据库实例以限制对它的访问。有关更多信息，请参阅“[在 VPC 中访问数据库实例的场景](USER_VPC.Scenarios.md)”和“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。
## 添加 Oracle OLAP 选项
下面是将 `OLAP` 选项添加到数据库实例的一般过程：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则添加 `OLAP` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。在添加 选项后，您无需重新启动数据库实例。在选项组处于活动状态后，Oracle OLAP 将立即可用。
**将 OLAP 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
+ 对于**引擎**，请选择适用于您的数据库实例的 Oracle 版本。
+ 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **OLAP** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，请在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，请修改实例并附加新的选项组以应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## 使用 Oracle OLAP
在启用 Oracle OLAP 选项后，可以开始使用它。有关 Oracle OLAP 支持的功能的列表，请参阅 [Oracle 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/olaug/overview.html#GUID-E2056FE4-C623-4D29-B7D8-C4762F941966)。
## 删除 Oracle OLAP 选项
删除使用 `OLAP` 选项提供的数据类型的所有对象后，您可以从数据库实例中删除该选项。如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则删除 `OLAP` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。删除 `OLAP` 选项后，您无需重新启动数据库实例。
**删除 `OLAP` 选项**
1. 备份您的数据。
**警告**
如果实例使用作为选项一部分启用的数据类型，并且您删除了 `OLAP` 选项，则可能会丢失数据。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
1. 检查是否有任何现有对象引用了 `OLAP` 选项的数据类型或功能。
1. 删除引用了 `OLAP` 选项的数据类型或功能的任何对象。
1. 请执行下列操作之一：
+ 从 `OLAP` 选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例并指定不包含 `OLAP` 选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# Oracle 安全套接字层
要为 RDS for Oracle 数据库实例启用 SSL 加密，请向与数据库实例关联的选项组添加 Oracle SSL 选项。根据 Oracle 的要求，Amazon RDS 使用另一个端口连接 SSL。此方法允许数据库实例与 SQL\$1Plus 之间能够同时进行明文通信和 SSL 加密通信。例如，您可以使用用于明文通信的端口与 VPC 内的其他资源通信，同时使用用于 SSL 加密通信的端口与 VPC 外部的资源通信。
**注意**
您可以在同一 RDS for Oracle 数据库实例上使用 SSL 或原生网络加密（NNE），但不能同时使用两者。如果您使用 SSL 加密，则必须禁用任何其他连接加密。有关更多信息，请参阅 [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md)。
SSL/TLS 和 NNE 不再是 Oracle 高级安全的一部分。在 RDS for Oracle 中，您可以对以下数据库版本的所有许可版本使用 SSL 加密：
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c（19.0.0）
**Topics**
+ [Oracle SSL 选项的 TLS 版本](#Appendix.Oracle.Options.SSL.TLS)
+ [Oracle SSL 选项的密码套件](#Appendix.Oracle.Options.SSL.CipherSuites)
+ [FIPS 支持](#Appendix.Oracle.Options.SSL.FIPS)
+ [证书与密码套件的兼容性](#Appendix.Oracle.Options.SSL.CertificateCompatibility)
+ [添加 SSL 选项](Appendix.Oracle.Options.SSL.OptionGroup.md)
+ [配置 SQL\$1Plus 以将 SSL 用于 RDS for Oracle 数据库实例](Appendix.Oracle.Options.SSL.ClientConfiguration.md)
+ [使用 SSL 连接到 RDS for Oracle 数据库实例](Appendix.Oracle.Options.SSL.Connecting.md)
+ [设置通过 JDBC 的 SSL 连接](Appendix.Oracle.Options.SSL.JDBC.md)
+ [使用 SSL 连接强制执行 DN 匹配](Appendix.Oracle.Options.SSL.DNMatch.md)
+ [排查 SSL 连接问题](Appendix.Oracle.Options.SSL.troubleshooting.md)
## Oracle SSL 选项的 TLS 版本
Amazon RDS for Oracle 支持传输层安全性 (TLS) 版本 1.0 和 1.2。在添加新的 Oracle SSL 选项时，请显式将 `SQLNET.SSL_VERSION` 设置为有效值。下面是该选项设置允许的值：
+ `"1.0"` – 客户端只能使用 TLS 版本 1.0 连接到数据库实例。对于现有 Oracle SSL 选项，`SQLNET.SSL_VERSION` 自动设置为 `"1.0"`。您可以根据需要更改设置。
+ `"1.2"` – 客户端只能使用 TLS 1.2 连接到数据库实例。
+ `"1.2 or 1.0"` – 客户端只能使用 TLS 1.2 或 1.0 连接到数据库实例。
## Oracle SSL 选项的密码套件
Amazon RDS for Oracle 支持多个 SSL 密码套件。默认情况下，Oracle SSL 选项配置为使用 `SSL_RSA_WITH_AES_256_CBC_SHA` 密码套件。要指定不同的密码套件以在 SSL 连接中使用，请使用 `SQLNET.CIPHER_SUITE` 选项设置。
可以为 `SQLNET.CIPHER_SUITE` 指定多个值。如果数据库实例之间具有数据库链接并且您决定更新密码套件，则此技术很有用。
下表总结了所有版本的 Oracle Database 19c 和 21c 中对 RDS for Oracle 的 SSL 支持。
| 密码套件（SQLNET.CIPHER\$1SUITE） | TLS 版本支持（SQLNET.SSL\$1VERSION） | FIPS 支持 | 符合 FedRAMP 要求 |
| --- | --- | --- | --- |
| SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA（原定设置） | 1.0 和 1.2 | 是 | 否 |
| SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 | 1.2 | 是 | 否 |
| SSL\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 | 1.2 | 是 | 否 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1SHA256 | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 | 1.2 | 支持 | 是 |
| TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | 1.2 | 支持 | 是 |
## FIPS 支持
RDS for Oracle 使您能够使用 140-2 联邦信息处理标准（FIPS）。FIPS 140-2 是一项美国政府标准，它定义了密码模块的安全要求。您可以通过针对 Oracle SSL 选项将 `FIPS.SSLFIPS_140` 设置为 `TRUE` 来开启 FIPS 标准。为 SSL 配置 FIPS 140-2 时，加密库会加密客户端与 RDS for Oracle 数据库实例之间的数据。
客户端必须使用符合 FIPS 条件的密码套件。建立连接时，客户端和 RDS for Oracle 数据库实例协商为来回传输消息使用的密码套件。[Oracle SSL 选项的密码套件](#Appendix.Oracle.Options.SSL.CipherSuites)中的表显示了适用于各个 TLS 版本的符合 FIPS 条件的 SSL 密码套件。有关更多信息，请参阅 Oracle 数据库文档中的 [Oracle 数据库 FIPS 140-2 设置](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/dbseg/oracle-database-fips-140-settings.html#GUID-DDBEB3F9-B216-44BB-8C18-43B5E468CBBB)。
## 证书与密码套件的兼容性
RDS for Oracle 同时支持 RSA 和椭圆曲线数字签名算法（ECDSA）证书。在为数据库实例配置 SSL 时，必须确保在 `SQLNET.CIPHER_SUITE` 选项设置中指定的密码套件与数据库实例使用的证书类型兼容。
下表展示了证书类型和密码套件之间的兼容性：
| 证书类型 | 兼容的密码套件 | 不兼容的密码套件 |
| --- | --- | --- |
| RSA 证书（rds-ca-2019、rds-ca-rsa2048-g1、rds-ca-rsa4096-g1） | SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 SSL\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 |
| ECDSA 证书（rds-ca-ecc384-g1） | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 | SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA256 SSL\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1GCM\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1GCM\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA384 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA |
在 `SQLNET.CIPHER_SUITE` 选项设置中指定多个密码套件时，请确保至少包含一个与数据库实例使用的证书类型兼容的密码套件。如果您使用的选项组包含多个具有不同证书类型的数据库实例，请为每种证书类型至少包含一个密码套件。
如果您尝试将选项组与仅包含和数据库实例的证书类型不兼容的密码套件的 SSL 选项相关联，操作将失败，并显示一条错误消息，指出不兼容。
# 添加 SSL 选项
要使用 SSL，您的 RDS for Oracle 数据库实例必须与包括 `SSL` 选项的选项组关联。
## 控制台
**将 SSL 选项添加到选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `SSL` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `SSL` 选项添加到该选项组。
如果要为 SSL 连接仅使用 FIPS 验证的密码套件，请将选项 `FIPS.SSLFIPS_140` 设置为 `TRUE`。有关 FIPS 标准的信息，请参阅 [FIPS 支持](Appendix.Oracle.Options.SSL.md#Appendix.Oracle.Options.SSL.FIPS)。
有关向选项组添加选项的信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 创建新的 RDS for Oracle 数据库实例并将选项组与其关联，或者修改要将选项组与其关联的 RDS for Oracle 数据库实例。
有关创建数据库实例的信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
有关修改数据库实例的信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## Amazon CLI
**将 SSL 选项添加到选项组**
1. 创建新选项组或识别现有选项组，然后您可以将 `SSL` 选项添加到其中。
有关创建选项组的信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `SSL` 选项添加到该选项组。
指定以下选项设置：
+ `Port` – SSL 端口号
+ `VpcSecurityGroupMemberships` – 为其启用此选项的 VPC 安全组
+ `SQLNET.SSL_VERSION` – 客户端可用来连接到数据库实例的 TLS 版本
例如，以下 Amazon CLI 命令将 `SSL` 选项添加到名为 `ora-option-group` 的选项组。
**Example**
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group --option-group-name ora-option-group \
--options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
```
对于 Windows：
```
aws rds add-option-to-option-group --option-group-name ora-option-group ^
--options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
```
1. 创建新的 RDS for Oracle 数据库实例并将选项组与其关联，或者修改要将选项组与其关联的 RDS for Oracle 数据库实例。
有关创建数据库实例的信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
有关修改数据库实例的信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# 配置 SQL\$1Plus 以将 SSL 用于 RDS for Oracle 数据库实例
在连接到使用 Oracle SSL 选项的 RDS for Oracle 数据库实例之前，您必须先配置 SQL\$1Plus。
**注意**
若要允许从适当的客户端访问数据库实例，请确保已正确配置安全组。有关更多信息，请参阅“[使用安全组控制访问权限](Overview.RDSSecurityGroups.md)”。另外，这些说明适用于 SQL\$1Plus 和其他直接使用 Oracle 主目录的客户端。有关 JDBC 连接，请参阅[设置通过 JDBC 的 SSL 连接](Appendix.Oracle.Options.SSL.JDBC.md)。
**将 SQL\$1Plus 配置为使用 SSL 连接到 RDS for Oracle 数据库实例**
1. 将 `ORACLE_HOME` 环境变量设置为 Oracle 主目录的位置。
Oracle 主目录的路径取决于您的安装。以下示例设置 `ORACLE_HOME` 环境变量。
```
prompt>export ORACLE_HOME=/home/user/app/user/product/19.0.0/dbhome_1
```
有关设置 Oracle 环境变量的信息，请参阅 Oracle 文档中的 [SQL\$1Plus 环境变量](http://docs.oracle.com/database/121/SQPUG/ch_two.htm#SQPUG331)，另请参阅适用于您的操作系统的 Oracle 安装指南。
1. 将 `$ORACLE_HOME/lib` 追加到 `LD_LIBRARY_PATH` 环境变量。
下面是一个设置 LD\$1LIBRARY\$1PATH 环境变量的示例。
```
prompt>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib
```
1. 为 `$ORACLE_HOME/ssl_wallet` 处的 Oracle wallet 创建一个目录。
下面是一个创建 Oracle wallet 目录的示例。
```
prompt>mkdir $ORACLE_HOME/ssl_wallet
```
1. 下载适用于所有 Amazon Web Services 区域的证书捆绑 .pem 文件并将此文件放在 ssl\$1wallet 目录中。有关信息，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
1. 在 `$ORACLE_HOME/network/admin` 目录中，修改或创建 `tnsnames.ora` 文件并包含下列条目。
```
net_service_name =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS =
(PROTOCOL = TCPS)
(HOST = endpoint)
(PORT = ssl_port_number)
)
)
(CONNECT_DATA =
(SID = database_name)
)
(SECURITY =
(SSL_SERVER_CERT_DN = "C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=endpoint")
)
)
```
1. 在同一目录中，修改或创建 sqlnet.ora 文件并包含下列参数。
**注意**
要通过 TLS 安全连接与实体进行通信，Oracle 需要包含身份验证所需证书的钱夹。您可以使用 Oracle 的 ORAPKI 实用工具来创建和维护 Oracle 钱夹，如步骤 7 中所示。有关更多信息，请参阅 Oracle 文档中的[使用 ORAPKI 设置 Oracle 钱夹](https://docs.oracle.com/cd/E92519_02/pt856pbr3/eng/pt/tsvt/task_SettingUpOracleWalletUsingORAPKI.html)。
```
WALLET_LOCATION = (SOURCE = (METHOD = FILE) (METHOD_DATA = (DIRECTORY = $ORACLE_HOME/ssl_wallet)))
SSL_CLIENT_AUTHENTICATION = FALSE
SSL_VERSION = 1.0
SSL_CIPHER_SUITES = (SSL_RSA_WITH_AES_256_CBC_SHA)
SSL_SERVER_DN_MATCH = ON
```
**注意**
您可以将 `SSL_VERSION` 设置为较高值（如果您的数据库实例支持它）。
1. 运行下列命令以创建 Oracle Wallet。
```
prompt>orapki wallet create -wallet $ORACLE_HOME/ssl_wallet -auto_login_only
```
1. 使用操作系统实用程序将 .pem 捆绑文件中的每个证书解压缩到单独的 .pem 文件中。
1. 使用单独的 `orapki` 命令将每个证书添加到 Wallet 中，将 `certificate-pem-file` 替换为 .pem 文件的绝对文件名。
```
prompt>orapki wallet add -wallet $ORACLE_HOME/ssl_wallet -trusted_cert -cert
certificate-pem-file -auto_login_only
```
有关更多信息，请参阅 [轮换 SSL/TLS 证书](UsingWithRDS.SSL-certificate-rotation.md)。
# 使用 SSL 连接到 RDS for Oracle 数据库实例
在如前所述将 SQL\$1Plus 配置为使用 SSL 之后，您可以使用 SSL 选项连接到 RDS for Oracle 数据库实例。您也可以选择首先导出指向包含 tnsnames.ora 和 sqlnet.ora 文件的目录的 `TNS_ADMIN` 值。这样做可确保 SQL\$1Plus 可始终找到这些文件。以下示例导出 `TNS_ADMIN` 值。
```
export TNS_ADMIN = ${ORACLE_HOME}/network/admin
```
连接到数据库实例。例如，您可以使用 SQL\$1Plus，通过 tnsnames.ora 文件中的 ** 进行连接。
```
sqlplus mydbuser@net_service_name
```
您还可以通过以下命令，使用 SQL\$1Plus 连接到数据库实例，而无需使用 tnsnames.ora 文件。
```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCPS)(HOST = endpoint) (PORT = ssl_port_number))(CONNECT_DATA = (SID = database_name)))'
```
您还可在不使用 SSL 的情况下连接到 RDS for Oracle 数据库实例。例如，以下命令通过不带 SSL 加密的明文端口连接到数据库实例。
```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = endpoint) (PORT = port_number))(CONNECT_DATA = (SID = database_name)))'
```
如果要关闭传输控制协议 (TCP) 端口访问，请创建一个没有 IP 地址入口的安全组并将此组添加到实例。添加此组将会关闭通过 TCP 端口的连接，同时仍然允许从 SSL 选项安全组允许的范围内的 IP 地址通过 SSL 端口进行指定的连接。
# 设置通过 JDBC 的 SSL 连接
要使用通过 JDBC 的 SSL 连接，您必须创建密钥存储，信任 Amazon RDS 根 CA 证书并使用下面指定的代码段。
要创建 JKS 格式的 keystore，可以使用以下命令。有关创建 keystore 的更多信息，请参阅 Oracle 文档中的[创建 keystore](https://docs.oracle.com/cd/E35822_01/server.740/es_admin/src/tadm_ssl_jetty_keystore.html)。有关参考信息，请参阅《Java Platform, Standard Edition Tools Reference》**中的 [keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/keytool.html)。
```
keytool -genkey -alias client -validity 365 -keyalg RSA -keystore clientkeystore
```
按照下列步骤信任 Amazon RDS 根 CA 证书。
**信任 Amazon RDS 根 CA 证书**
1. 下载适用于所有 Amazon Web Services 区域的证书捆绑 .pem 文件并将此文件放在 ssl\$1wallet 目录中。
有关下载证书的信息，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
1. 使用操作系统实用程序将 .pem 文件中的每个证书解压缩到单独的文件中。
1. 使用单独的 `openssl` 命令将每个证书转换为 .der 格式，同时将证书 *certificate-pem-file* 替换为证书 .pem 文件的名称（不带 .pem 扩展名）。
```
openssl x509 -outform der -in certificate-pem-file.pem -out certificate-pem-file.der
```
1. 使用以下命令将每个证书导入 keystore。
```
keytool -import -alias rds-root -keystore clientkeystore.jks -file certificate-pem-file.der
```
有关更多信息，请参阅 [轮换 SSL/TLS 证书](UsingWithRDS.SSL-certificate-rotation.md)。
1. 确认成功创建了密钥存储。
```
keytool -list -v -keystore clientkeystore.jks
```
在出现提示时，输入密钥存储密码。
以下代码说明如何设置使用 JDBC 的 SSL 连接。
```
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
public class OracleSslConnectionTest {
private static final String DB_SERVER_NAME = "dns-name-provided-by-amazon-rds";
private static final Integer SSL_PORT = "ssl-option-port-configured-in-option-group";
private static final String DB_SID = "oracle-sid";
private static final String DB_USER = "user-name";
private static final String DB_PASSWORD = "password";
// This key store has only the prod root ca.
private static final String KEY_STORE_FILE_PATH = "file-path-to-keystore";
private static final String KEY_STORE_PASS = "keystore-password";
public static void main(String[] args) throws SQLException {
final Properties properties = new Properties();
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))",
DB_SERVER_NAME, SSL_PORT, DB_SID);
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
properties.put("oracle.jdbc.J2EE13Compliant", "true");
properties.put("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
properties.put("javax.net.ssl.trustStoreType", "JKS");
properties.put("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
final Connection connection = DriverManager.getConnection(connectionString, properties);
// If no exception, that means handshake has passed, and an SSL connection can be opened
}
}
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
# 使用 SSL 连接强制执行 DN 匹配
您可以使用 Oracle 参数 `SSL_SERVER_DN_MATCH` 强制数据库服务器的可分辨名称 (DN) 与其服务名称匹配。如果您强制执行匹配验证，则 SSL 将确保证书来自服务器。如果您未强制执行匹配验证，则 SSL 将执行检查，但允许连接，而不管是否存在匹配项。如果您未强制执行匹配，则会允许服务器潜在的伪造身份行为。
要强制执行 DN 匹配，请添加 DN 匹配属性并使用下面指定的连接字符串。
将属性添加到客户端连接以强制执行 DN 匹配。
```
properties.put("oracle.net.ssl_server_dn_match", "TRUE");
```
使用 SSL 时使用以下连接字符串强制执行 DN 匹配。
```
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))" +
"(CONNECT_DATA=(SID=%s))" +
"(SECURITY = (SSL_SERVER_CERT_DN =
\"C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=%s\")))",
DB_SERVER_NAME, SSL_PORT, DB_SID, DB_SERVER_NAME);
```
# 排查 SSL 连接问题
您可能会查询数据库并收到 `ORA-28860` 错误。
```
ORA-28860: Fatal SSL error
28860. 00000 - "Fatal SSL error"
*Cause: An error occurred during the SSL connection to the peer. It is likely that this side sent data which the peer rejected.
*Action: Enable tracing to determine the exact cause of this error.
```
当客户端尝试使用服务器不支持的 TLS 版本进行连接时，就会发生此错误。要避免此错误，请编辑 sqlnet.ora 并将 `SSL_VERSION` 设置为正确的 TLS 版本。有关更多信息，请参阅 My Oracle Support 中的 [Oracle 支持文档 2748438.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2748438.1)。
# Oracle Spatial
Amazon RDS 通过使用 `SPATIAL` 选项支持 Oracle Spatial。Oracle Spatial 提供了一个 SQL 架构和一些功能，可帮助在 Oracle 数据库中存储、检索、更新和查询空间数据集合。有关更多信息，请参阅 Oracle 文档中的 [Spatial 概念](http://docs.oracle.com/database/121/SPATL/spatial-concepts.htm#SPATL010)。Amazon RDS 在所有受支持发行版的所有版本中均支持 Oracle Spatial。
## Spatial 补丁包（SPB）的工作原理
每个季度，RDS for Oracle 都会为每个受支持的主要引擎发布新的次要引擎版本。版本更新（RU）引擎版本通过包含指定季度的 RU 补丁，纳入了 Oracle 提供的错误修复。Spatial 补丁包（SPB）引擎版本包含 RU 补丁以及特定于 Oracle Spatial 的补丁。例如，19.0.0.0.ru-2025-01.spb-1.r1 是一个次要引擎版本，其中包含引擎版本 19.0.0.0.ru-2025-01.rur-2025-01.r1 中的 RU 补丁以及 Spatial 补丁。只有 Oracle Database 19c 才支持 SPB。
尽管 SPB 与 RU 的命名方式不同，但它们的功能相同。RU 使用命名格式 19.0.0.0.ru-2025-01.rur-2025-01.r1。SPB 名称包括文本“spb”，如 19.0.0.0.ru-2025-01.spb-1.r1。通常，SPB 在其相应的季度 RU 发布后的 2-3 周内发布。例如，19.0.0.0.ru-2025-01.spb-1.r1 在 19.0.0.0.ru-2025-01.rur-2025-01.r1 之后发布。
RDS for Oracle 具有单独的途径来自动升级 RU 和 SPB 的次要版本。如果数据库实例使用 RU，则 RDS 会自动将实例升级到 RU。如果数据库实例使用 SPB，则 RDS 会将实例升级到 SPB。
有关 RU 和 SPB 的更多信息，请参阅 [Oracle 次要版本升级](USER_UpgradeDBInstance.Oracle.Minor.md)。有关 Oracle Database 19c 支持的 RU 和 SPB 的列表，请参阅《Amazon RDS for Oracle Release Notes》**中的 [Amazon RDS for Oracle Database 19c (19.0.0.0)](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html)。
## 使用 Oracle Spatial 的先决条件
以下是使用 Oracle Spatial 的先决条件：
+ 确保您的数据库实例具有足够的实例类。db.t3.small 数据库实例类不支持 Oracle Spatial。有关更多信息，请参阅 [RDS for Oracle 数据库实例类](Oracle.Concepts.InstanceClasses.md)。
+ 确保您的数据库实例已启用**自动次要版本升级**。该选项允许数据库实例在次要数据库引擎版本升级可用时自动接收这些升级，这对于安装 Oracle Java 虚拟机（JVM）的任意选项是必需的。Amazon RDS 使用该选项将数据库实例更新为最新的 Oracle 补丁集更新（PSU）或版本更新（RU）。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## Oracle Spatial 的最佳实践
以下是使用 Oracle Spatial 的最佳实践：
+ 为了实现最高安全性，可将 `SPATIAL` 选项与安全套接字层 (SSL) 结合使用。有关更多信息，请参阅“[Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md)”。
+ 配置数据库实例以限制对它的访问。有关更多信息，请参阅“[在 VPC 中访问数据库实例的场景](USER_VPC.Scenarios.md)”和“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。
## 添加 Oracle Spatial 选项
下面是将 `SPATIAL` 选项添加到数据库实例的一般过程：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则添加 `SPATIAL` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。在添加 选项后，您无需重新启动数据库实例。只要选项组处于活动状态，Oracle Spatial 就可用。
**注意**
在该中断期间，将短暂禁用密码验证功能。您还可能会在中断期间看到与密码验证功能相关的事件。在 Oracle 数据库实例变得可用之前，将再次启用密码验证功能。
**将 `SPATIAL` 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于**引擎**，请选择适用于您的数据库实例的 Oracle 版本。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **SPATIAL** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## 删除 Oracle Spatial 选项
删除使用 `SPATIAL` 选项提供的数据类型的所有对象后，可以从数据库实例中删除该选项。如果数据库实例上*未* 安装 Oracle Java 虚拟机 (JVM)，则删除 `SPATIAL` 选项时会出现短暂中断。如果数据库实例上已安装 Oracle Java 虚拟机 (JVM)，则不会出现中断。删除 `SPATIAL` 选项后，您无需重新启动数据库实例。
**删除 `SPATIAL` 选项**
1. 备份您的数据。
**警告**
如果实例使用作为选项一部分启用的数据类型，并且您删除了 `SPATIAL` 选项，则可能会丢失数据。有关更多信息，请参阅“[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)”。
1. 检查是否有任何现有对象引用了 `SPATIAL` 选项的数据类型或功能。
如果存在 `SPATIAL` 选项，则在应用无 `SPATIAL` 选项的新选项组时，实例可能会卡住。您可以使用以下查询标识对象：
```
SELECT OWNER, SEGMENT_NAME, TABLESPACE_NAME, BYTES/1024/1024 mbytes
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE '%TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT DISTINCT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE='SDO_GEOMETRY'
AND OWNER <> 'MDSYS')
ORDER BY 1,2,3,4;
SELECT OWNER, TABLE_NAME, COLUMN_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE = 'SDO_GEOMETRY'
AND OWNER <> 'MDSYS'
ORDER BY 1,2,3;
```
1. 删除引用了 `SPATIAL` 选项的数据类型或功能的任何对象。
1. 请执行下列操作之一：
+ 从 `SPATIAL` 选项所属的选项组中删除该选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 修改数据库实例并指定不包含 `SPATIAL` 选项的另一个选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# Oracle SQLT
Amazon RDS 通过使用 SQLT 选项来支持 Oracle SQLTXPLAIN (SQLT)。您可对任一版本的 Oracle Database 19c 及更高版本使用 SQLT。
Oracle `EXPLAIN PLAN` 语句可以确定 SQL 语句的执行计划。它可以验证 Oracle 优化程序是否选择某个执行计划，例如嵌套循环联接。它还可以帮助您了解优化程序的决定，例如为什么选择嵌套循环联接而不是哈希联接。所以 `EXPLAIN PLAN` 可帮助您了解该语句的效果。
SQLT 是一个生成报告的 Oracle 实用程序。报告包括对象统计信息、对象元数据、与优化程序相关的初始化参数，以及数据库管理员可用于调整 SQL 语句以获得最佳性能的其他信息。SQLT 会生成一个 HTML 报告，其中包含报表中所有部分的超链接。
与 Automatic Workload Repository 或 Statspack 报告不同，SQLT 适用于单个 SQL 语句。SQLT 是收集、存储和显示性能数据的 SQL、PL/SQL 和 SQL\$1Plus 文件的集合。
下面是每个 SQLT 版本支持的 Oracle 版本。
****
| SQLT 版本 | Oracle Database 21c | Oracle Database 19c |
| --- | --- | --- |
| 2018-07-25.v1 | 支持 | 支持 |
| 2018-03-31.v1 | 不支持 | 不支持 |
| 2016-04-29.v1 | 不支持 | 不支持 |
下载 SQLT 并了解它的使用说明：
+ 登录到 My Oracle Support 账户，然后打开以下文档：
+ 下载 SQLT：[文档 215187.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=215187.1)
+ SQLT 使用说明：[文档 1614107.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1614107.1)
+ 有关 SQLT 的常见问题：[文档 1454160.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454160.1)
+ 有关读取 SQLT 输出的信息：[文档 1456176.1](https://support.oracle.com/epmos/main/downloadattachmentprocessor?parent=DOCUMENT&sourceId=1456176.1&attachid=1456176.1:58&clickstream=yes)
+ 主报告解释：[文档 1922234.1](https://support.oracle.com/epmos/faces/DocumentDisplay?parent=DOCUMENT&sourceId=215187.1&id=1922234.1)
Amazon RDS 不支持以下 SQLT 方法：
+ `XPLORE`
+ `XHUME`
## SQLT 的先决条件
以下是使用 SQLT 的先决条件：
+ 您必须删除 SQLT 所需的用户和角色 (如果存在)。
SQLT 选项将在数据库实例上创建以下用户和角色：
+ `SQLTXPLAIN` 用户
+ `SQLTXADMIN` 用户
+ `SQLT_USER_ROLE` 角色
如果数据库实例具有这些用户或角色中的任意一个，请使用 SQL 客户端登录到数据库实例，并使用以下语句将其删除：
```
DROP USER SQLTXPLAIN CASCADE;
DROP USER SQLTXADMIN CASCADE;
DROP ROLE SQLT_USER_ROLE CASCADE;
```
+ 您必须删除 SQLT 所需的表空间 (如果存在)。
SQLT 选项将在数据库实例上创建以下表空间：
+ `RDS_SQLT_TS`
+ `RDS_TEMP_SQLT_TS`
如果数据库实例有这些表空间，请使用 SQL 客户端登录数据库实例，并将其删除。
## SQLT 选项设置
SQLT 可以使用由 Oracle Tuning Pack 和 Oracle Diagnostics Pack 提供的许可功能。Oracle Tuning Pack 包括 SQL Tuning Advisor，Oracle Diagnostics Pack 包括 Automatic Workload Repository。SQLT 设置可允许或禁止从 SQLT 访问这些功能。
Amazon RDS 支持 SQLT 选项的以下设置。
****
| 选项设置 | 有效值 | 默认值 | 描述 |
| --- | --- | --- | --- |
| `LICENSE_PACK` | `T`, `D`, `N` | `N` | 要使用 SQLT 访问的 Oracle 管理包。输入以下值之一： [\[See the AWS documentation website for more details\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/Oracle.Options.SQLT.html) Amazon RDS 不提供这些 Oracle 管理包的许可。如果您指示要使用未包含在数据库实例中的包，则可以对数据库实例使用 SQLT。不过，SQLT 无法访问该包，并且 SQLT 报告不包括该包的数据。例如，如果您指定 `T`，但数据库实例不包括 Oracle Tuning Pack，则 SQLT 可用于数据库实例，但其生成的报告不包含与 Oracle Tuning Pack 相关的数据。 |
| `VERSION` | `2016-04-29.v1` `2018-03-31.v1` `2018-07-25.v1` | `2016-04-29.v1` | 要安装的 SQLT 版本。 对于 Oracle Database 19c 和 21c，唯一受支持的版本是 `2018-07-25.v1`。此版本是这些发布的默认版本。 |
## 添加 SQLT 选项
下面是将 SQLT 选项添加到数据库实例的一般过程：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 向选项组添加 SQLT 选项。
1. 将选项组与数据库实例相关联。
在添加 SQLT 选项后，一旦激活该选项组，就会激活 SQLT。
**将 SQLT 选项添加到数据库实例**
1. 确定您要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于 **Engine**，请选择要使用的 Oracle 版本。所有版本均支持 SQLT 选项。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **SQLT** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
1. (可选) 使用 SQLT 选项验证每个数据库实例上的 SQLT 安装。
1. 使用 SQL 客户端以主用户身份连接到数据库实例。
有关使用 SQL 客户端连接到 Oracle 数据库实例的信息，请参阅[连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 运行以下查询：
```
SELECT sqltxplain.sqlt$a.get_param('tool_version') sqlt_version FROM DUAL;
```
查询返回 Amazon RDS 上的 SQLT 选项的当前版本。`12.1.160429` 是 Amazon RDS 上可用的 SQLT 版本的一个例子。
1. 更改由 SQLT 选项创建的用户的密码。
1. 使用 SQL 客户端以主用户身份连接到数据库实例。
1. 运行以下 SQL 语句更改 `SQLTXADMIN` 用户的密码：
```
ALTER USER SQLTXADMIN IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 运行以下 SQL 语句更改 `SQLTXPLAIN` 用户的密码：
```
ALTER USER SQLTXPLAIN IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
**注意**
升级 SQLT 需要卸载 SQLT 的旧版本然后安装新版本。因此，在升级 SQLT 时，所有 SQLT 元数据都可能会丢失。数据库的主要版本升级也会卸载并重新安装 SQLT。主版本升级的示例是从 Oracle Database 19c 升级到 Oracle Database 21c。
## 使用 SQLT
SQLT 可与 Oracle SQL\$1Plus 实用程序一起使用。
**使用 SQLT**
1. 从 My Oracle Support 网站上的[文档 215187.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=215187.1) 下载 SQLT .zip 文件。
**注意**
您无法从 My Oracle Support 网站中下载 SQLT 12.1.160429。Oracle 已弃用该旧版本。
1. 解压缩 SQLT .zip 文件。
1. 从命令提示符处，转到文件系统上的 `sqlt/run` 目录。
1. 从命令提示符处，打开 SQL\$1Plus，并以主用户身份连接到数据库实例。
有关使用 SQL\$1Plus 连接到数据库实例的信息，请参阅 [连接到 Oracle 数据库实例](USER_ConnectToOracleInstance.md)。
1. 获取 SQL 语句的 SQL ID：
```
SELECT SQL_ID FROM V$SQL WHERE SQL_TEXT='sql_statement';
```
输出类似于以下内容：
```
SQL_ID
-------------
chvsmttqjzjkn
```
1. 使用 SQLT 分析 SQL 语句：
```
START sqltxtract.sql sql_id sqltxplain_user_password
```
例如，对于 SQL ID `chvsmttqjzjkn`，输入以下内容：
```
START sqltxtract.sql chvsmttqjzjkn sqltxplain_user_password
```
SQLT 在运行 SQLT 命令的目录中生成 HTML 报告和相关资源作为 .zip 文件。
1. (可选) 要允许应用程序用户使用 SQLT 诊断 SQL 语句，请使用以下语句向每个应用程序用户授予 `SQLT_USER_ROLE`：
```
GRANT SQLT_USER_ROLE TO application_user_name;
```
**注意**
Oracle 不建议对 `SYS` 用户或具有 `DBA` 角色的用户运行 SQLT。最佳实践是通过向应用程序用户授予 `SQLT_USER_ROLE`，使用应用程序用户账户运行 SQLT 诊断。
## 升级 SQLT 选项
对于 Amazon RDS for Oracle，您可以将 SQLT 选项从现有版本升级到更高版本。要升级 SQLT 选项，请完成[使用 SQLT](#Oracle.Options.SQLT.Using)中的步骤 1–3 以升级到新的 SQLT 版本。此外，如果您在本节的步骤 7 中为以前版本的 SQLT 授予了权限，请再次为新的 SQLT 版本授予权限。
升级 SQLT 选项将导致旧 SQLT 版本的元数据丢失。删除旧 SQLT 版本的架构和相关对象，并安装新版本的 SQLT。有关 SQLT 最新版本中的更改的更多信息，请参阅 My Oracle Support 网站上的[文档 1614201.1](https://support.oracle.com/epmos/faces/DocumentDisplay?parent=DOCUMENT&sourceId=215187.1&id=1614201.1)。
**注意**
不支持版本降级。
## 修改 SQLT 设置
在启用 SQLT 后，您可以修改该选项的 `LICENSE_PACK` 和 `VERSION` 设置。
有关如何修改选项设置的更多信息，请参阅 [修改选项设置](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption)。有关各项设置的更多信息，请参阅[SQLT 选项设置](#Oracle.Options.SQLT.Options)。
## 删除 SQLT 选项
您可以从数据库实例中删除 SQLT。
要从数据库实例中删除 SQLT，请执行下列操作之一：
+ 要从多个数据库实例中删除 SQLT，请从数据库实例所属的选项组中删除 SQLT 选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 要从单个数据库实例中删除 SQLT，请修改该数据库实例，并指定另一个不包含 SQLT 选项的选项组。您可以指定默认（空）选项组，或指定其他自定义选项组。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
# Oracle Statspack
Oracle Statspack 选项安装并启用 Oracle Statspack 性能统计数据功能。Oracle Statspack 是收集、存储和显示性能数据的 SQL、PL/SQL 和 SQL\$1Plus 脚本的集合。有关使用 Oracle Statspack 信息，请参阅 Oracle 文档中的 [Oracle Statspack](http://docs.oracle.com/cd/E13160_01/wli/docs10gr3/dbtuning/statsApdx.html)。
**注意**
Oracle 不再支持 Oracle Statspack，并用更高级的 Automatic Workload Repository (AWR) 取而代之。只有已购买 Diagnostics Pack 的 Oracle 企业版客户才能使用 AWR。您可以在 Amazon RDS 上将 Oracle Statspack 与任何 Oracle 数据库引擎一起使用。您无法在 Amazon RDS 只读副本上运行 Oracle Statspack。
## 设置 Oracle Statspack
要运行 Statspack 脚本，必须添加 Statspack 选项。
**设置 Oracle Statspack**
1. 在 SQL 客户端中，使用管理账户登录到 Oracle 数据库。
1. 根据是否安装了 Statspack，执行以下操作之一：
+ 如果已安装 Statspack ，并且 `PERFSTAT` 账户与 Statspack 关联，请跳到步骤 4。
+ 如果尚未安装 Statspack，并且 `PERFSTAT` 账户存在，请按如下方式删除账户：
```
DROP USER PERFSTAT CASCADE;
```
否则，尝试添加 Statspack 选项会生成错误和 `RDS-Event-0058`。
1. 将 Statspack 选项添加到选项组。请参阅[将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
Amazon RDS 会自动在数据库实例上安装 Statspack 脚本，然后设置 `PERFSTAT` 账户。
1. 使用以下 SQL 语句重置密码，并将 *pwd* 替换为新密码：
```
ALTER USER PERFSTAT IDENTIFIED BY pwd ACCOUNT UNLOCK;
```
您可以使用 `PERFSTAT` 用户账户登录并运行 Statspack 脚本。
1. 使用以下语句向 `PERFSTAT` 账户授予 `CREATE JOB` 权限：
```
GRANT CREATE JOB TO PERFSTAT;
```
1. 确保填充 `PERFSTAT.STATS$IDLE_EVENT` 表中的空闲等待事件。
由于 Oracle 错误 28523746，可能无法填充 `PERFSTAT.STATS$IDLE_EVENT` 中的空闲等待事件。要确保所有空闲事件都可用，请运行以下语句：
```
INSERT INTO PERFSTAT.STATS$IDLE_EVENT (EVENT)
SELECT NAME FROM V$EVENT_NAME WHERE WAIT_CLASS='Idle'
MINUS
SELECT EVENT FROM PERFSTAT.STATS$IDLE_EVENT;
COMMIT;
```
## 生成 Statspack 报告
Statspack 报告比较两个快照。
**生成 Statspack 报告**
1. 在 SQL 客户端中，使用 `PERFSTAT` 账户登录到 Oracle 数据库。
1. 使用以下任一方法创建快照：
+ 手动创建 Statspack 快照。
+ 创建一个在给定时间间隔后拍摄 Statspack 快照的作业。例如，以下作业每小时创建一个 Statspack 快照：
```
VARIABLE jn NUMBER;
exec dbms_job.submit(:jn, 'statspack.snap;',SYSDATE,'TRUNC(SYSDATE+1/24,''HH24'')');
COMMIT;
```
1. 使用以下查询查看快照：
```
SELECT SNAP_ID, SNAP_TIME FROM STATS$SNAPSHOT ORDER BY 1;
```
1. 运行 Amazon RDS 过程 `rdsadmin.rds_run_spreport`，用快照 ID 替换 *begin\$1snap* 和 *end\$1snap*。
```
exec rdsadmin.rds_run_spreport(begin_snap,end_snap);
```
例如，以下命令基于 Statspack 快照 1 和 2 之间的间隔创建报告：
```
exec rdsadmin.rds_run_spreport(1,2);
```
Statspack 报告的文件名包括两个快照的编号。例如，使用 Statspack 快照 1 和 2 创建的报告文件将命名为 `ORCL_spreport_1_2.lst`。
1. 监视输出是否存在错误。
Oracle Statspack 会在运行报表之前执行检查。因此，您还可以在命令输出中看到错误消息。例如，您可能会尝试基于无效范围生成报告，其中起始 Statspack 快照值大于结束值。在这种情况下，输出显示错误消息，但数据库引擎不会生成错误文件。
```
exec rdsadmin.rds_run_spreport(2,1);
*
ERROR at line 1:
ORA-20000: Invalid snapshot IDs. Find valid ones in perfstat.stats$snapshot.
```
如果您使用的 Statspack 快照编号无效，则输出将显示错误。例如，如果您尝试为快照 1 和 50 生成报告，但快照 50 不存在，则输出将显示错误。
```
exec rdsadmin.rds_run_spreport(1,50);
*
ERROR at line 1:
ORA-20000: Could not find both snapshot IDs
```
1. (可选)
要检索报告，请调用跟踪文件过程，如 [使用 Oracle 跟踪文件](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles) 中所述。
或者，从 RDS 控制台下载 Statspack 报告。转到数据库实例详细信息的**日志**部分，然后选择**下载**。下面的示例显示了 `trace/ORCL_spreport_1_2.lst`
![\[在 RDS 控制台中显示 Oracle 日志文件的列表。圈出以下跟踪文件：trace/ORCL_spreport_1_2.lst。\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/statspack1.png)
如果在生成报告时发生错误，则数据库引擎使用与报告相同的命名约定，但扩展名为 `.err`。例如，如果在使用 Statspack 快照 1 和 7 创建报告时出错，报告文件将命名为 `ORCL_spreport_1_7.err`。您可以使用与标准快照报告相同的方法下载错误报告。
## 删除 Statspack 快照
要删除一系列 Oracle Statspack 快照，请使用以下命令：
```
exec statspack.purge(begin snap, end snap);
```
# Oracle 时区
要更改您的 Oracle 数据库实例使用的系统时区，请使用时区选项。例如，您可能需要更改数据库实例的时区，从而与本地环境或旧版应用程序兼容。时区选项在主机级别更改时区。更改时区会影响所有日期列和值 (包括 `SYSDATE` 和 `SYSTIMESTAMP`)。
时区选项与 `rdsadmin_util.alter_db_time_zone` 命令不同。`alter_db_time_zone` 命令只能更改某些数据类型的时区。时区选项会更改所有日期列和值的时区。有关 `alter_db_time_zone` 的更多信息，请参阅[设置数据库时区](Appendix.Oracle.CommonDBATasks.TimeZoneSupport.md)。有关升级注意事项的更多信息，请参阅 [时区注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST)。
## 有关设置时区的限制
时区选项是永久、持续的选项。因此，您无法执行以下操作：
+ 添加时区选项后，将从选项组中删除该选项。
+ 添加选项后，将其从数据库实例中删除。
+ 将此选项的时区设置修改为其他时区。
## 有关设置时区的建议
将时区选项添加到生产数据库之前，我们强烈建议您执行以下操作：
+ 为您的数据库实例拍摄快照。如果不小心错误地设置了时区，则必须将数据库实例恢复到其以前的时区设置。有关更多信息，请参阅 [为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)。
+ 为测试数据库实例添加时区选项。对于使用系统日期添加日期或时间的表，添加时区选项可能引起问题。建议您对测试实例上的数据和应用程序进行分析。这样一来，您便能评测更改生产实例上的时区所产生的影响。
如果数据库实例使用默认选项组，请执行以下步骤：
1. 为您的数据库实例拍摄快照。
1. 向数据库实例添加时区选项。
如果您的数据库实例当前使用非默认选项组，请执行以下步骤：
1. 为您的数据库实例拍摄快照。
1. 创建新的选项组。
1. 向其中添加时区选项，以及当前与现有选项组关联的所有其他选项。
这样可以防止在启用时区选项时卸载现有选项。
1. 将选项添加到您的数据库实例。
## 时区选项设置
Amazon RDS 支持时区选项的以下设置。
****
| 选项设置 | 有效值 | 描述 |
| --- | --- | --- |
| `TIME_ZONE` | 可用时区之一。完整列表请参阅 [可用时区](#Appendix.Oracle.Options.Timezone.Zones)。 | 数据库实例的新时区。 |
## 添加时区选项
完成以下步骤以将时区选项添加到数据库实例：
1. （推荐）为您的数据库实例拍摄快照。
1. 请执行以下任务之一：
+ 从头开始创建一个新选项组。有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
+ 使用 Amazon CLI 或 API 复制现有选项组。有关更多信息，请参阅 [复制选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy)。
+ 重复使用现有的非默认选项组。最佳实践是使用当前未与任何数据库实例或快照关联的选项组。
1. 将新选项添加到您在前面的步骤中创建的选项组。
1. 如果当前与您的数据库实例关联的选项组已启用一些选项，请将这些选项添加到您的新选项组。此策略可以防止在启用新选项时卸载现有选项。
1. 将新选项添加到您的数据库实例。
添加时区选项时，数据库实例在自动重新启动时会出现短暂中断。
### 控制台
**将时区选项添加到一个选项组并将该选项组与数据库实例关联**
1. 在 RDS 控制台中，选择**选项组**。
1. 选择要将选项添加到的选项组的名称。
1. 选择**添加选项**。
1. 对于**选项名称**，选择**时区**，然后配置选项设置。
1. 将该选项组与新的或现有的数据库实例关联：
+ 对于新数据库实例，请在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，请修改实例并附加新的选项组以应用选项组。如果您将新选项添加到现有数据库实例，则在数据库实例自动重新启动时会出现短暂中断。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
### Amazon CLI
以下示例使用 Amazon CLI [add-option-to-option-group](https://docs.amazonaws.cn/cli/latest/reference/rds/add-option-to-option-group.html) 命令将 `Timezone` 选项和 `TIME_ZONE` 选项设置添加到名为 `myoptiongroup` 的选项组。时区设置为 `Africa/Cairo`。
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=Timezone,OptionSettings=[{Name=TIME_ZONE,Value=Africa/Cairo}]" \
--apply-immediately
```
对于：Windows
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=Timezone,OptionSettings=[{Name=TIME_ZONE,Value=Africa/Cairo}]" ^
--apply-immediately
```
## 修改时区设置
时区选项是永久、持续的选项。将此选项添加到选项组后不能将其删除。将选项组添加到数据库实例后不能将其删除。您不能将此选项的时区设置修改为其他时区。在未能正确设置时区的情况下，可以使用添加时区选项之前的数据库实例快照进行恢复。
## 删除时区选项
时区选项是永久、持续的选项。将此选项添加到选项组后不能将其删除。将选项组添加到数据库实例后不能将其删除。要删除时区选项，可以使用添加时区选项之前的数据库实例快照进行恢复。
## 可用时区
以下值可用于时区选项。
****
| 区 | 时区 |
| --- | --- |
| 非洲 | 非洲/开罗、非洲/卡萨布兰卡、非洲/哈拉雷、非洲/拉各斯、非洲/罗安达、非洲/蒙罗维亚、非洲/内罗毕、非洲/的黎波里、非洲/温得和克 |
| 美洲 | 美洲/阿拉瓜伊纳、美洲/阿根廷/布宜诺斯艾利斯、美洲/亚森松、美洲/Bogota、美洲/加拉加斯、美洲/芝加哥、美洲/奇瓦瓦、美洲/库亚巴、美洲/丹佛、美洲/底特律、美洲/福塔莱萨、美洲/戈特霍布、美洲/危地马拉、美洲/哈利法克斯、美洲/利马、美洲/洛杉矶、美洲/玛瑙斯、美洲/马塔莫罗斯、美洲/墨西哥城、美洲/蒙特雷、美洲/蒙特维多、美洲/纽约、美洲/菲尼克斯、美洲/圣地亚哥、美洲/圣保罗、美洲/蒂华纳、美洲/多伦多 |
| 亚洲 | 亚洲/阿曼、亚洲/阿什哈巴德、亚洲/巴格达、亚洲/巴库、亚洲/曼谷、亚洲/贝鲁特、亚洲/加尔各答、亚洲/大马士革、亚洲/达卡、亚洲/香港、亚洲/伊尔库茨克、亚洲/雅加达、亚洲/耶路撒冷、亚洲/喀布尔、亚洲/卡拉奇、亚洲/加德满都、亚洲/加尔各答、亚洲/克拉斯诺亚尔斯克、亚洲/马加丹、亚洲/马尼拉、亚洲/马斯喀特、亚洲/新西伯利亚、亚洲/阳光、亚洲/利雅得、亚洲/首尔、亚洲/上海、亚洲/新加坡、亚洲/台北、亚洲/德黑兰、亚洲/东京、亚洲/乌兰巴托、亚洲/符拉迪沃斯托克、亚洲/雅库茨克、亚洲/埃里温 |
| 大西洋 | 大西洋/亚速尔、大西洋/佛得角 |
| 澳大利亚 | 澳大利亚/阿德莱德、澳大利亚/布里斯班、澳大利亚/达尔文、澳大利亚/尤克拉、澳大利亚/霍巴特、澳大利亚/豪勋爵岛、澳大利亚/珀斯、澳大利亚/悉尼 |
| 巴西 | 巴西/迪诺罗尼亚、巴西/东部 |
| 加拿大 | 加拿大/纽芬兰、加拿大/萨斯喀彻温省 |
| ETC | ETC/GMT-3 |
| 欧洲 | 欧洲/阿姆斯特丹、欧洲/雅典、欧洲/柏林、欧洲/都柏林、欧洲/赫尔辛基、欧洲/加里宁格勒、欧洲/伦敦、欧洲/马德里、欧洲/莫斯科、欧洲/巴黎、欧洲/布拉格、欧洲/罗马、欧洲/萨拉热窝 |
| 太平洋 | 太平洋/阿皮亚、太平洋/奥克兰、太平洋/查塔姆、太平洋/斐济、太平洋/关岛、太平洋/檀香山、太平洋/圣诞岛、太平洋/玛贵斯、太平洋/萨摩亚、太平洋/汤加塔布岛、太平洋/韦克 |
| US | 美国/阿拉斯加、美国/中部、美国/印第安纳东部、美国/东部、美国/太平洋地区 |
| UTC | UTC |
# Oracle 时区文件自动升级
使用 `TIMEZONE_FILE_AUTOUPGRADE` 选项，您可以将当前时区文件升级到 RDS for Oracle 数据库实例上的最新版本。
**Topics**
+ [Oracle 时区文件概览](Appendix.Oracle.Options.Timezone-file-autoupgrade.tz-overview.md)
+ [更新时区文件的策略](Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.md)
+ [时区文件更新期间的停机时间](Appendix.Oracle.Options.Timezone-file-autoupgrade.considerations.md)
+ [准备更新时区文件](Appendix.Oracle.Options.Timezone-file-autoupgrade.preparing.md)
+ [添加时区文件自动升级选项](Appendix.Oracle.Options.Timezone-file-autoupgrade.adding.md)
+ [更新时区文件后检查数据](Appendix.Oracle.Options.Timezone-file-autoupgrade.checking.md)
# Oracle 时区文件概览
Oracle Database *时区文件*存储以下信息：
+ 相对于协调世界时（UTC）的偏移量
+ 夏令时（DST）的过渡时间
+ 标准时间和 DST 的缩写
Oracle Database 提供多个版本的时区文件。在本地环境中创建 Oracle 数据库时，可以选择时区文件版本。有关更多信息，请参阅《Oracle Database 全球化支持指南》**中的[选择时区文件](https://docs.oracle.com/en/database/oracle/oracle-database/19/nlspg/datetime-data-types-and-time-zone-support.html#GUID-805AB986-DE12-4FEA-AF56-5AABCD2132DF)。
如果 DST 的规则发生变化，Oracle 将发布新的时区文件。Oracle 发布这些新的时区文件与每季度版本更新（RU）和版本更新修订（RUR）的时间表无关。时区文件位于数据库主机上的目录 `$ORACLE_HOME/oracore/zoneinfo/` 中。时区文件名使用的格式为 DstV*version*，如 DSTV35 所示。
## 时区文件如何影响数据传输
在 Oracle 数据库中，`TIMESTAMP WITH TIME ZONE` 数据类型存储时间戳和时区数据。`TIMESTAMP WITH TIME ZONE` 数据类型的数据使用关联时区文件版本中的规则。这样，当您更新时区文件时，现有 `TIMESTAMP WITH TIME ZONE` 数据会受到影响。
在使用不同版本时区文件的数据库之间传输数据时，可能会出现问题。例如，如果您从时区文件版本比目标数据库更高的源数据库导入数据，数据库会发出 `ORA-39405` 错误。以前，您必须使用以下任一方法解决此错误：
+ 使用所需的时区文件创建 RDS for Oracle 数据库实例，从源数据库导出数据，然后将其导入到新数据库中。
+ 使用 Amazon DMS 或逻辑复制来迁移数据。
## 使用 TIMEZONE\$1FILE\$1AUTOUPGRADE 选项进行自动更新
当附加到 RDS for Oracle 数据库实例的选项组包括 `TIMEZONE_FILE_AUTOUPGRADE` 选项时，RDS 将自动更新您的时区文件。通过确保 Oracle 数据库使用相同的时区文件版本，可以避免在不同环境之间移动数据时采用耗时的手动方法。容器数据库（CDB）和非 CDB 均支持 `TIMEZONE_FILE_AUTOUPGRADE` 选项。
当您向选项组添加 `TIMEZONE_FILE_AUTOUPGRADE` 选项时，您可以选择是立即添加此选项，还是在维护时段添加此选项。数据库实例应用新选项后，RDS 会检查它是否可以安装更新的 DSTv*version* 文件。目标 DSTv*version* 取决于以下内容：
+ 数据库实例当前正在运行的次要引擎版本
+ 您要将数据库实例升级到的次要引擎版本
例如，您当前的时区文件版本可能是 DSTv33。当 RDS 将更新应用到选项组时，它可能会确定 DSTv34 在数据库实例文件系统上当前可用。然后，RDS 自动将您的时区文件更新到 DSTv34。
要在支持的 RDS 版本更新中查找可用的 DST 版本，请查看[适用于 Oracle 的 Amazon Relational Database Service（Amazon RDS）发布说明](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html)中的补丁。例如，[版本 19.0.0.0.ru-2022-10.rur-2022-10.r1](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2022-10.rur-2022-10.r1) 列出补丁 34533061: RDBMS - DSTV39 UPDATE - TZDATA2022C。
# 更新时区文件的策略
升级数据库引擎和将 `TIMEZONE_FILE_AUTOUPGRADE` 选项添加到选项组是单独的操作。如果有较新的时区文件可用，则添加 `TIMEZONE_FILE_AUTOUPGRADE` 选项会启动对时区文件的更新。您可以立即或在下一个维护时段运行以下命令（仅显示相关选项）：
+ 仅使用以下 RDS CLI 命令升级数据库引擎：
```
modify-db-instance --engine-version name ...
```
+ 仅使用以下 CLI 命令添加 `TIMEZONE_FILE_AUTOUPGRADE` 选项：
```
add-option-to-option-group --option-group-name name --options OptionName=TIMEZONE_FILE_AUTOUPGRADE ...
```
+ 使用以下 CLI 命令升级您的数据库引擎并向您的实例添加新的选项组：
```
modify-db-instance --engine-version name --option-group-name name ...
```
更新策略取决于是要一起升级数据库和时区文件，还是只执行其中一个操作。请记住，如果您更新选项组，然后在单独的 API 操作中升级数据库引擎，则在升级数据库引擎时，当前可能正在进行时区文件更新。
本部分中的示例假定以下内容：
+ 您尚未将 `TIMEZONE_FILE_AUTOUPGRADE` 添加到当前与您的数据库实例关联的选项组。
+ 您的数据库实例使用数据库版本 19.0.0.0.ru-2019-07.rur-2019-07.r1 和时区文件 DSTv33。
+ 您的数据库实例文件系统包含文件 DSTV34。
+ 版本更新 19.0.0.0.ru-2022-10.rur-2022-10.r1 包含 DSTv35。
要更新时区文件，您可以使用以下策略。
**Topics**
+ [更新时区文件而不升级引擎](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.no-upgrade)
+ [升级时区文件和数据库引擎版本](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.upgrade)
+ [升级数据库引擎版本而不更新时区文件](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.upgrade-only)
## 更新时区文件而不升级引擎
在这种情况下，您的数据库使用 DSTv33，但 DSTv34 在您的数据库实例文件系统上可用。您希望将数据库实例使用的时区文件从 DSTv33 更新到 DSTv34，但您不想将您的引擎升级到新的次要版本，其中包括 DSTv35。
在 `add-option-to-option-group` 命令中，将 `TIMEZONE_FILE_AUTOUPGRADE` 添加到您的数据库实例使用的选项组。指定是立即添加此选项，还是将其推迟到维护时段。应用 `TIMEZONE_FILE_AUTOUPGRADE` 选项后，RDS 将执行以下操作：
1. 检查是否有新的 DST 版本。
1. 确定 DSTv34 在文件系统上是否可用。
1. 立即更新时区文件。
## 升级时区文件和数据库引擎版本
在这种情况下，您的数据库使用 DSTv33，但 DSTv34 在您的数据库实例文件系统上可用。您希望将数据库引擎升级到包含 DSTv35 的次要版本 19.0.0.0.ru-2022-10.rur-2022-10.r1，并在引擎升级期间将时区文件更新到 DSTv5。这样，您的目标是跳过 DSTv34 并将时区文件直接更新到 DSTv35。
要同时升级引擎和时区文件，请使用 `--option-group-name` 和 `--engine-version` 选项运行 `modify-db-instance`。您可以立即运行此命令，也可以将其推迟到维护时段。在 `In --option-group-name` 中指定包含 `TIMEZONE_FILE_AUTOUPGRADE` 选项的选项组。例如：
```
aws rds modify-db-instance
--db-instance-identifier my-instance \
--engine-version new-version \
----option-group-name og-with-timezone-file-autoupgrade \
--apply-immediately
```
RDS 开始将引擎升级到 19.0.0.0.ru-2022-10.rur-2022-10.r1。应用 `TIMEZONE_FILE_AUTOUPGRADE` 选项后，RDS 会检查是否有新的 DST 版本，看到 DSTv35 在 19.0.0.0.ru-2022-10.rur-2022-10.r1 中可用，并立即开始更新到 DSTv35。
要立即升级您的引擎，然后升级您的时区文件，请按顺序执行操作：
1. 仅使用以下 CLI 命令升级数据库引擎：
```
aws rds modify-db-instance \
--db-instance-identifier my-instance \
--engine-version new-version \
--apply-immediately
```
1. 使用以下 CLI 命令将 `TIMEZONE_FILE_AUTOUPGRADE` 选项添加到附加到您的实例的选项组：
```
aws rds add-option-to-option-group \
--option-group-name og-in-use-by-your-instance \
--options OptionName=TIMEZONE_FILE_AUTOUPGRADE \
--apply-immediately
```
## 升级数据库引擎版本而不更新时区文件
在这种情况下，您的数据库使用 DSTv33，但 DSTv34 在您的数据库实例文件系统上可用。您希望将数据库引擎升级到版本 19.0.0.0.ru-2022-10.rur-2022-10.r1（其中包含 DSTv35），但保留时区文件 DSTv33。您可能出于以下原因来选择该策略：
+ 您的数据不使用 `TIMESTAMP WITH TIME ZONE` 数据类型。
+ 您的数据使用 `TIMESTAMP WITH TIME ZONE` 数据类型，但您的数据不受时区更改的影响。
+ 您想推迟更新时区文件，因为您无法容忍额外的停机时间。
您的策略取决于以下哪些可能性是确实存在的：
+ 您的数据库实例未与包含 `TIMEZONE_FILE_AUTOUPGRADE` 的选项组关联。在 `modify-db-instance` 命令中，不要指定新的选项组，这样 RDS 就不会更新您的时区文件。
+ 您的数据库实例目前与一个包含 `TIMEZONE_FILE_AUTOUPGRADE` 的选项组关联。在单个 `modify-db-instance` 命令中，将您的数据库实例与不包含 `TIMEZONE_FILE_AUTOUPGRADE` 的选项组关联，并将您的数据库引擎升级到 19.0.0.0.ru-2022-10.rur-2022-10.r1。
# 时区文件更新期间的停机时间
当 RDS 更新时区文件时，使用 `TIMESTAMP WITH TIME ZONE` 的现有数据可能会发生变化。在这种情况下，您首要的考虑因素是停机时间。
**警告**
如果您添加 `TIMEZONE_FILE_AUTOUPGRADE` 选项，则您引擎升级的停机时间可能要延长。更新大型数据库的时区数据可能需要数小时甚至数天。
时区文件更新的长度取决于如下因素：
+ 数据库中的 `TIMESTAMP WITH TIME ZONE` 数据量
+ 数据库实例配置
+ 数据库实例类
+ 存储配置
+ 数据库配置
+ 数据库参数设置
执行以下操作时，可能会产生额外的停机时间：
+ 当数据库实例使用过时的时区文件时，将此选项添加到选项组
+ 当新引擎版本包含时区文件的新版本时，升级 Oracle 数据库引擎
**注意**
在时区文件更新期间，RDS for Oracle 调用 `PURGE DBA_RECYCLEBIN`。
# 准备更新时区文件
时区文件升级有两个不同的阶段：准备和升级。虽然准备步骤并非必需，但强烈建议您执行此步骤。在此步骤中，您将了解哪些数据将受到运行 PL/SQL 过程 `DBMS_DST.FIND_AFFECTED_TABLES` 的影响。有关准备窗口的更多信息，请参阅 Oracle 数据库文档中的[使用时区数据升级时区文件和时间戳](https://docs.oracle.com/en/database/oracle/oracle-database/19/nlspg/datetime-data-types-and-time-zone-support.html#GUID-B0ACDB2E-4B49-4EB4-B4CC-9260DAE1567A)。
**准备更新时区文件**
1. 使用 SQL 客户端连接到您的 Oracle 数据库。
1. 确定当前使用的时区文件版本。
```
SELECT * FROM V$TIMEZONE_FILE;
```
1. 确定数据库实例上可用的最新时区文件版本。
```
SELECT DBMS_DST.GET_LATEST_TIMEZONE_VERSION FROM DUAL;
```
1. 确定具有类型为 `TIMESTAMP WITH LOCAL TIME ZONE` 或 `TIMESTAMP WITH TIME ZONE` 的列的表总大小。
```
SELECT SUM(BYTES)/1024/1024/1024 "Total_size_w_TSTZ_columns_GB"
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE 'TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE LIKE 'TIMESTAMP%TIME ZONE');
```
1. 确定具有类型为 `TIMESTAMP WITH LOCAL TIME ZONE` 或 `TIMESTAMP WITH TIME ZONE` 的列的段的名称和大小。
```
SELECT OWNER, SEGMENT_NAME, SUM(BYTES)/1024/1024/1024 "SEGMENT_SIZE_W_TSTZ_COLUMNS_GB"
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE 'TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE LIKE 'TIMESTAMP%TIME ZONE')
GROUP BY OWNER, SEGMENT_NAME;
```
1. 运行准备步骤。
+ 过程 `DBMS_DST.CREATE_AFFECTED_TABLE` 可创建表来存储任何受影响的数据。将此表的名称传递给 `DBMS_DST.FIND_AFFECTED_TABLES` 过程。有关更多信息，请参阅 Oracle 数据库文档中的 [CREATE\$1AFFECTED\$1TABLE 过程](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-C53BAABA-914A-404C-9CD5-823257BE0B00)。
+ 此过程 `CREATE_ERROR_TABLE` 创建用于记录错误的表。有关更多信息，请参阅 Oracle 数据库文档中的 [CREATE\$1ERROR\$1TABLE 过程](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-6A7EA024-B02D-4486-B1D6-EF6ABF5DE507)。
以下示例创建受影响的数据和错误表，并查找所有受影响的表。
```
EXEC DBMS_DST.CREATE_ERROR_TABLE('my_error_table')
EXEC DBMS_DST.CREATE_AFFECTED_TABLE('my_affected_table')
EXEC DBMS_DST.BEGIN_PREPARE(new_version);
EXEC DBMS_DST.FIND_AFFECTED_TABLES('my_affected_table', TRUE, 'my_error_table');
EXEC DBMS_DST.END_PREPARE;
SELECT * FROM my_affected_table;
SELECT * FROM my_error_table;
```
1. 查询受影响表和错误表。
```
SELECT * FROM my_affected_table;
SELECT * FROM my_error_table;
```
# 添加时区文件自动升级选项
当您向选项组添加选项时，该选项组将处于以下状态之一：
+ 一个现有选项组当前已附加到至少一个数据库实例。添加该选项时，所有使用此选项组的数据库实例都会自动重新启动。这会导致短暂中断。
+ 现有选项组未附加到任何数据库实例。您计划添加该选项，然后将现有选项组与现有数据库实例或新数据库实例相关联。
+ 您创建一个新的选项组并添加该选项。您计划将新的选项组与现有数据库实例或新的数据库实例关联。
## 控制台
**将时区文件自动升级选项添加到数据库实例**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择**选项组**。
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于 **Engine**（引擎），选择适用于您的数据库实例的 Oracle Database 版本。
1. 对于**主引擎版本**，请选择数据库实例的版本。
有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 选择要修改的选项组，然后选择 **Add Option (添加选项)**。
1. 在**添加选项**窗口中，执行以下操作：
1. 选择 **TIMEZONE\$1FILE\$1AUTOUPGRADE**。
1. 要在添加选项后在所有关联数据库实例上启用该选项，对于**立即应用**，请选择**是**。如果选择**否**（默认），则会在下一个维护时段为每个关联数据库实例启用此选项。
1. 根据需要设置完毕后，选择 **Add Option (添加选项)**。
## Amazon CLI
以下示例使用 Amazon CLI [add-option-to-option-group](https://docs.amazonaws.cn/cli/latest/reference/rds/add-option-to-option-group.html) 命令将 `TIMEZONE_FILE_AUTOUPGRADE` 选项添加到名为 `myoptiongroup` 的选项组。
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=TIMEZONE_FILE_AUTOUPGRADE" \
--apply-immediately
```
对于：Windows
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=TIMEZONE_FILE_AUTOUPGRADE" ^
--apply-immediately
```
# 更新时区文件后检查数据
建议您在更新时区文件后检查数据。在准备步骤过程中，RDS for Oracle 会自动创建以下表：
+ `rdsadmin.rds_dst_affected_tables` – 列出包含受更新影响的数据的表
+ `rdsadmin.rds_dst_error_table` – 列出更新过程中生成的错误
这些表独立于您在准备时段中创建的任何表。要查看更新的结果，请按如下方式查询表。
```
SELECT * FROM rdsadmin.rds_dst_affected_tables;
SELECT * FROM rdsadmin.rds_dst_error_table;
```
有关受影响数据和错误表的架构的更多信息，请参阅 Oracle 文档中的 [FIND\$1AFFECTED\$1TABLES 过程](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-1F977505-671C-4D5B-8570-86956F136199)。
# Oracle 透明数据加密
Amazon RDS 支持 Oracle 透明数据加密 (TDE)，这是 Oracle 企业版中提供的 Oracle 高级安全选项中的功能。该功能在将数据写入到存储之前自动对数据进行加密，并在从存储读取数据时自动对数据进行解密。仅自带许可（BYOL）模式支持此选项。
TDE 在需要加密敏感数据以防第三方获取数据文件和备份的情况下非常有用。当您需要遵守安全相关法规时，TDE 也非常有用。
有关 Oracle 数据库中 TDE 的详细说明超出了本指南的范围。有关信息，请参阅以下 Oracle 数据库资源：
+ Oracle 数据库文档中的 [Introduction to Transparent Data Encryption](https://docs.oracle.com/en/database/oracle/oracle-database/19/asoag/introduction-to-transparent-data-encryption.html#GUID-62AA9447-FDCD-4A4C-B563-32DE04D55952)
+ Oracle 数据库文档中的 [Oracle 高级安全性](https://www.oracle.com/security/database-security/)
+ [Oracle 高级安全透明数据加密最佳实践](https://www.oracle.com/br/a/tech/docs/technical-resources/twp-transparent-data-encryption-bestpractices.pdf)，这是 Oracle 白皮书
有关将 TDE 和 RDS for Oracle 结合使用的更多信息，请参阅以下博客：
+ [Oracle Database Encryption Options on Amazon RDS](https://www.amazonaws.cn/blogs/apn/oracle-database-encryption-options-on-amazon-rds/)
+ [Migrate a cross-account TDE-enabled Amazon RDS for Oracle DB instance with reduced downtime using Amazon DMS](https://www.amazonaws.cn/blogs/database/migrate-a-cross-account-tde-enabled-amazon-rds-for-oracle-db-instance-with-reduced-downtime-using-aws-dms/)
## TDE 加密模式
Oracle 透明数据加密支持两种加密方式，即 TDE 表空间加密和 TDE 列加密。TDE 表空间加密用于加密整个应用程序表。TDE 列加密用于加密单个包含敏感数据的数据元素。此外，您还可以应用同时使用 TDE 表空间和列加密的混合加密解决方案。
**注意**
Amazon RDS 为数据库实例管理 Oracle Wallet 和 TDE 主密钥。您无需使用命令 `ALTER SYSTEM set encryption key` 设置加密密钥。
启用 `TDE` 选项之后，可以使用以下命令检查 Oracle Wallet 的状态：
```
SELECT * FROM v$encryption_wallet;
```
要创建加密的表空间，请使用以下命令：
```
CREATE TABLESPACE encrypt_ts ENCRYPTION DEFAULT STORAGE (ENCRYPT);
```
要指定加密算法，请使用以下命令：
```
CREATE TABLESPACE encrypt_ts ENCRYPTION USING 'AES256' DEFAULT STORAGE (ENCRYPT);
```
前面用于加密表空间的语句与您在本地 Oracle 数据库上使用的语句相同。
## TDE 选项的限制
TDE 选项是持久和永久的。在将您的数据库实例与启用了 TDE 选项的选项组关联后，您无法执行以下操作：
+ 在当前关联的选项组中禁用 `TDE` 选项。
+ 将您的数据库实例与不包含 `TDE` 的选项组相关联。
+ 共享使用 `TDE` 选项的数据库快照。有关共享数据库快照的更多信息，请参阅 [共享 Amazon RDS 的数据库快照](USER_ShareSnapshot.md)。
有关持久和永久选项的更多信息，请参阅[持久性和永久性选项](USER_WorkingWithOptionGroups.md#Overview.OptionGroups.Permanent)。
## 确定您的数据库实例是否使用 TDE
您可能需要确定您的数据库实例是否与启用了 `TDE` 选项的选项组相关联。要查看与数据库实例关联的选项组，请使用 RDS 控制台、Amazon CLI 命令 [describe-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-instances.html) 或 API 操作 [DescribeDBInstances](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html)。
## 添加 TDE 选项
要将 `TDE` 选项添加到数据库实例，请完成以下步骤：
1. （推荐）为您的数据库实例拍摄快照。
1. 请执行以下任务之一：
+ 从头开始创建一个新选项组。有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
+ 使用 Amazon CLI 或 API 复制现有选项组。有关更多信息，请参阅 [复制选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy)。
+ 重复使用现有的非默认选项组。最佳实践是使用当前未与任何数据库实例或快照关联的选项组。
1. 将新选项添加到您在前面的步骤中创建的选项组。
1. 如果当前与您的数据库实例关联的选项组已启用一些选项，请将这些选项添加到您的新选项组。此策略可以防止在启用新选项时卸载现有选项。
1. 将新选项添加到您的数据库实例。
### 控制台
**将 TDE 选项添加到一个选项组并将该选项组与您的数据库实例关联**
1. 在 RDS 控制台中，选择**选项组**。
1. 选择要将选项添加到的选项组的名称。
1. 选择**添加选项**。
1. 对于**选项名称**，选择 **TDE**，然后配置选项设置。
1. 选择**添加选项**。
**重要**
如果在当前已附加到一个或多个数据库实例的选项组中添加 **TDE** 选项，则所有数据库实例自动重新启动时都会发生短暂中断。
有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将该选项组与新的或现有的数据库实例关联：
+ 对于新数据库实例，请在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，请修改实例并附加新的选项组以应用选项组。数据库实例不会作为此操作的一部分重启。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
### Amazon CLI
在以下示例中，您使用 Amazon CLI [add-option-to-option-group](https://docs.amazonaws.cn/cli/latest/reference/rds/add-option-to-option-group.html) 命令将 `TDE` 选项添加到名为 `myoptiongroup` 的选项组。有关更多信息，请参阅[开始使用：Flink 1.13.2](https://docs.amazonaws.cn/managed-flink/latest/java/earlier.html#getting-started-1-13)。
对于 Linux、macOS 或 Unix：
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=TDE" \
--apply-immediately
```
对于：Windows
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=TDE" ^
--apply-immediately
```
## 将您的数据复制到不包含 TDE 选项的数据库实例
您无法从数据库实例中删除 TDE 选项或将其与不包括 TDE 选项的选项组关联。要将数据迁移到不包含 TDE 选项的实例，请执行以下操作：
1. 解密数据库实例上的数据。
1. 将数据复制到未与已启用 `TDE` 的选项组关联的新数据库实例。
1. 删除原始数据库实例。
您可以将上一个数据库实例的名称用于新实例。
## 将 TDE 与 Oracle Data Pump 结合使用时的注意事项
可以使用 Oracle Data Pump 导入或导出加密转储文件。Amazon RDS 支持 Oracle Data Pump 的密码加密模式 `(ENCRYPTION_MODE=PASSWORD)`。Amazon RDS 不支持 Oracle Data Pump 的透明加密模式 `(ENCRYPTION_MODE=TRANSPARENT)`。有关更多信息，请参阅 [使用 Oracle Data Pump 导入](Oracle.Procedural.Importing.DataPump.md)。
# Oracle UTL\$1MAIL
Amazon RDS 通过使用 UTL\$1MAIL 选项和 SMTP 服务器支持 Oracle UTL\$1MAIL。您可以通过使用 UTL\$1MAIL 包直接从您的数据库发送电子邮件。Amazon RDS 支持适用于以下版本 Oracle 的 UTL\$1MAIL：
+ Oracle Database 21c (21.0.0.0)，所有版本
+ Oracle Database 19c (19.0.0.0)，所有版本
以下是使用 UTL\$1MAIL 的一些限制：
+ UTL\$1MAIL 不支持传输层安全性 (TLS)，因此，不会对电子邮件进行加密。
要通过创建和上传自定义 Oracle wallet 来安全地连接到远程 SSL/TLS 资源，请按照 [使用证书和 Oracle Wallet 配置 UTL\$1HTTP 访问](Oracle.Concepts.ONA.md) 中的说明操作。
Wallet 所需的具体证书因服务而异。对于 Amazon 服务，通常可在 [Amazon Trust Services 存储库](https://www.amazontrust.com/repository/)中了解到相关信息。
+ UTL\$1MAIL 不支持对 SMTP 服务器进行身份验证。
+ 您在一封电子邮件中只能发送一个附件。
+ 您无法发送 32 K 以上的附件。
+ 您只能使用 ASCII 和广义二进制编码的十进制交换码 (EBCDIC) 字符编码。
+ SMTP 端口 (25) 根据弹性网络接口所有者的策略进行限制。
当您启用 UTL\$1MAIL 时，仅向数据库实例的主用户授予执行权限。如果需要，主用户可向其他用户授予执行权限，以便他们能够使用 UTL\$1MAIL。
**重要**
建议您启用 Oracle 的内置审核功能以跟踪 UTL\$1MAIL 过程的使用情况。
## Oracle UTL\$1MAIL 的先决条件
以下是使用 Oracle UTL\$1MAIL 的先决条件：
+ 一个或多个 SMTP 服务器，及对应的 IP 地址或公有或私有域名服务器 (DNS) 名称。有关通过自定义 DNS 服务器解析的私有 DNS 名称的详细信息，请参阅 [设置自定义 DNS 服务器](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS)。
## 添加“Oracle UTL\$1MAIL”选项
将“Oracle UTL\$1MAIL”选项添加到数据库实例的一般过程如下所示：
1. 创建新的选项组，或者复制或修改现有选项组。
1. 将 选项添加到该选项组。
1. 将选项组与数据库实例相关联。
在添加“UTL\$1MAIL”选项后，一旦激活该选项组，就会激活 UTL\$1MAIL。
**将“UTL\$1MAIL”选项添加到数据库实例**
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。或者，通过以下设置创建自定义数据库选项组：
1. 对于**引擎**，请选择要使用的 Oracle 版本。
1. 对于**主引擎版本**，选择数据库实例的版本。
有关更多信息，请参阅“[创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)”。
1. 将 **UTL\$1MAIL** 选项添加到该选项组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 将选项组应用到新的或现有的数据库实例：
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## 使用 Oracle UTL\$1MAIL
在启用“UTL\$1MAIL”选项后，您必须先配置 SMTP 服务器，然后才能开始使用它。
通过将 SMTP\$1OUT\$1SERVER 参数设置为有效的 IP 地址或公有 DNS 名称来配置 SMTP 服务器。对于 SMTP\$1OUT\$1SERVER 参数，您可以指定多个服务器的地址的逗号分隔的列表。如果第一个服务器不可用，则 UTL\$1MAIL 会尝试下一个服务器，依此类推。
您可以通过使用[数据库参数组](https://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html)设置数据库实例的默认 SMTP\$1OUT\$1SERVER。您可以通过在数据库实例的数据库上运行以下代码来设置会话的 SMTP\$1OUT\$1SERVER 参数。
```
1. ALTER SESSION SET smtp_out_server = mailserver.domain.com:25;
```
在启用“UTL\$1MAIL”选项并配置 SMTP\$1OUT\$1SERVER 后，您可以通过使用 `SEND` 过程来发送邮件。有关更多信息，请参阅 Oracle 文档中的 [UTL\$1MAIL](http://docs.oracle.com/cd/B19306_01/appdev.102/b14258/u_mail.htm#BABFJJBD)。
## 删除“Oracle UTL\$1MAIL”选项
您可以从数据库实例中删除“Oracle UTL\$1MAIL”。
要从数据库实例中删除“UTL\$1MAIL”，请执行下列操作之一：
+ 要从多个数据库实例中删除“UTL\$1MAIL”，请从其所属的选项组中删除“UTL\$1MAIL”选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”。
+ 要从单个数据库实例中删除“UTL\$1MAIL”选项，请修改该数据库实例，并指定另一个不包含“UTL\$1MAIL”选项的选项组。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
## 故障排除
以下是您在将 UTL\$1MAIL 用于 Amazon RDS 时可能遇到的问题。
+ 限制。SMTP 端口 (25) 根据弹性网络接口所有者的策略进行限制。如果您可以使用 UTL\$1MAIL 成功发送电子邮件，并且看到错误 `ORA-29278: SMTP transient error: 421 Service not available`，则您可能被限制。如果您在发送电子邮件时遇到限制，我们建议您实施回退算法。有关回退算法的更多信息，请参阅 [Amazon中的错误重试和指数回退](https://docs.amazonaws.cn/general/latest/gr/api-retries.html)以及[如何处理“throttling – Maximum sending rate exceeded”错误](https://www.amazonaws.cn/blogs/ses/how-to-handle-a-throttling-maximum-sending-rate-exceeded-error/)。
您可以请求删除此限制。有关更多信息，请参阅[如何从 EC2 实例删除端口 25 上的限制？](https://www.amazonaws.cn/premiumsupport/knowledge-center/ec2-port-25-throttle/)。
# Oracle XML DB
Oracle XML DB 向数据库实例添加本机 XML 支持。利用 XML DB，可以存储和检索结构化或非结构化 XML 以及关系数据。RDS for Oracle 不支持 XML DB 协议服务器。
XML DB 预安装在 Oracle Database 12c 及更高版本上。因此，您无需使用选项组来显式安装 XML DB 作为附加特征。
要了解如何配置和使用 XML DB，请参阅 Oracle 数据库文档中的 [Oracle XML DB Developer's Guide](https://docs.oracle.com/en/database/oracle/oracle-database/19/adxdb/)。
# 升级 RDS for Oracle 数据库引擎
如果 Amazon RDS 支持新版本的 Oracle 数据库，您可以将数据库实例升级到新版本。有关 Amazon RDS 上可用的 Oracle 版本的信息，请参阅 [https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html)。
**重要**
不再支持 RDS for Oracle Databases 11g、12c 和 18c。如果您维护 Oracle Database 11g、12c 或 18c 快照，可以将其升级到更高版本。有关更多信息，请参阅 [升级 Oracle 数据库快照](USER_UpgradeDBSnapshot.Oracle.md)。
**Topics**
+ [RDS for Oracle 引擎升级概述](USER_UpgradeDBInstance.Oracle.Overview.md)
+ [Oracle 主要版本升级](USER_UpgradeDBInstance.Oracle.Major.md)
+ [Oracle 次要版本升级](USER_UpgradeDBInstance.Oracle.Minor.md)
+ [Oracle 数据库升级注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md)
+ [测试 Oracle 数据库升级](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)
+ [升级 RDS for Oracle 数据库实例版本](USER_UpgradeDBInstance.Oracle.Upgrading.md)
+ [升级 Oracle 数据库快照](USER_UpgradeDBSnapshot.Oracle.md)
# RDS for Oracle 引擎升级概述
升级 RDS for Oracle 数据库实例之前，请自行熟悉以下概念。
**Topics**
+ [主要和次要版本升级](#USER_UpgradeDBInstance.Oracle.Overview.versions)
+ [RDS for Oracle 的支持日期和强制升级](#Aurora.VersionPolicy.MajorVersionLifetime)
+ [Oracle 引擎版本管理](#Oracle.Concepts.Patching)
+ [在引擎升级期间自动拍摄快照](#USER_UpgradeDBInstance.Oracle.Overview.snapshots)
+ [多可用区部署中的 Oracle 升级](#USER_UpgradeDBInstance.Oracle.Overview.multi-az)
+ [只读副本的 Oracle 升级](#USER_UpgradeDBInstance.Oracle.Overview.read-replicas)
## 主要和次要版本升级
主要版本是 Oracle 数据库的主要版本，每 1-2 年发布一次。Oracle Database 19c 和 Oracle Database 21c 是主要版本。
每个季度，RDS for Oracle 都会为每个受支持的主要引擎发布新的次要引擎版本。版本更新（RU）引擎版本通过包含指定季度的 RU 补丁，纳入了 Oracle 提供的错误修复。例如，21.0.0.0.ru-2024-10.rur-2024-10.r1 是 Oracle Database 21c 的次要版本，其中包含 2024 年 10 月的 RU。
Spatial 补丁包（SPB）引擎版本包含 RU 补丁和特定于 Oracle Spatial 的补丁。例如，19.0.0.0.ru-2025-01.spb-1.r1 是一个次要引擎版本，其中包含引擎版本 19.0.0.0.ru-2025-01.rur-2025-01.r1 中的 RU 补丁以及 Spatial 补丁。通常，RDS for Oracle 会在相应 RU 发布后 2-3 周内发布 SPB。有关 RU 和 SPB 之间差异的解释，请参阅[版本更新（RU）和 Spatial 补丁包（SPB）](USER_UpgradeDBInstance.Oracle.Minor.md#RUs-and-SPBs)。有关支持的 RU 和 SPB 的信息，请参阅 [Release notes for Amazon Relational Database Service (Amazon RDS) for Oracle](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes)。
RDS for Oracle 支持对数据库实例进行以下升级。
| 升级类型 | 应用程序兼容性 | 升级方法 | 示例升级途径 |
| --- | --- | --- | --- |
| 主要版本 | 主版本升级可能引入与现有应用程序不兼容的更改。 | 仅限手动 | 从 Oracle Database 19c 到 Oracle Database 21c |
| 次要版本 | 次要版本升级仅包含与现有应用程序向后兼容的更改。 | 自动或手动 | 从 21.0.0.0.ru-2023-07.rur-2022-07.r1 到 21.0.0.0.ru-2023-10.rur-2022-10.r1 |
**重要**
当您更新数据库引擎时，发生中断。中断时长取决于引擎版本和数据库实例大小。
在将升级应用到生产数据库之前，确保彻底地测试任何升级，验证您的应用程序是否正常工作。有关更多信息，请参阅 [测试 Oracle 数据库升级](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)。
## RDS for Oracle 的支持日期和强制升级
RDS for Oracle 的数据库版本具有预期的支持日期。当 RDS for Oracle 数据库引擎的主要或次要版本接近其支持终止日期时，RDS 将开始强制升级，也成为*被迫升级*。RDS 发布以下信息：
+ 建议您开始手动将已弃用版本上的实例升级到支持的版本
+ 一个日期，在此日期之后，您将无法再在不受支持的版本上创建实例
+ RDS 开始在维护时段内自动将您的实例升级到受支持版本的日期
+ RDS 开始在维护时段之外自动将您的实例升级到受支持版本的日期
**重要**
强制升级可能会对 Amazon CloudFormation 堆栈产生意外的后果。如果您依靠 RDS 来自动升级数据库实例，则可能会遇到与 Amazon CloudFormation 有关的问题。
本节包含以下主题：
**Topics**
+ [RDS for Oracle 主要版本的支持日期](#oracle-major-support-dates)
+ [RDS for Oracle 次要版本的支持日期](#oracle-minor-support-dates)
### RDS for Oracle 主要版本的支持日期
RDS for Oracle 主要版本至少会在相应的 Oracle Database 发行版的终止支持日期之前保持可用状态。您可以参照下列日期规划您的测试和升级周期。这些日期表示可能需要升级到较新版本的最早日期。如果 Amazon 对某个 RDS for Oracle 版本的支持时间比原定时间更长，我们会计划更新此表格以反映较晚的日期。
**注意**
您还可以运行 [describe-db-major-engine-versions](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-major-engine-versions.html) Amazon CLI 命令或者使用 [DescribeDBMajorEngineVersions](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_DescribeDBMajorEngineVersions.html) RDS API 操作，来查看 Oracle 数据库的主要版本。
| Oracle Database 主要发行版 | 升级到较新版本的预计日期 |
| --- | --- |
| Oracle Database 19c | 2029 年 12 月 31 日，提供 BYOL 卓越支持（扩展支持免收费用） 2032 年 12 月 31 日，提供 BYOL 扩展支持（额外费用）或无限许可协议 2029 年 12 月 31 日，附带许可（LI） |
| Oracle Database 21c | 2027 年 7 月 31 日（不适用于扩展支持） |
RDS 会在您需要升级到较新的主要版本前至少 12 个月通知您。通知介绍升级过程，包括重要里程碑的时间安排、对数据库实例的影响以及建议的操作。我们建议您在将数据库升级到主要版本之前，使用新的 RDS for Oracle 版本彻底测试您的应用程序。
在该预先通知期限过后，对后续主要版本的自动升级可能会应用于任何仍在运行较久版本的 RDS for Oracle 数据库实例。如果此类情况发生，自动升级将在设定的维护时段内启动。
有关更多信息，请参阅 My Oracle Support 中的 [Release Schedule of Current Database Releases](https://support.oracle.com/knowledge/Oracle%20Database%20Products/742060_1.html)。
### RDS for Oracle 次要版本的支持日期
在某些情况下，我们会终止对 RDS for Oracle 中主要发行版的次要版本的支持。RDS 会在您需要升级到较新的次要版本前至少 6 个月通知您。通知会介绍升级过程，包括重要里程碑的时间安排、对运行已弃用次要版本的数据库实例的影响以及建议的操作。建议您在将数据库升级到新的次要版本之前，使用新的 RDS for Oracle 版本全面测试您的应用程序。
有关已弃用和不支持的次要版本的更多信息，请参阅 [Amazon Relational Database Service（Amazon RDS）for Oracle 发布说明](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html)。
## Oracle 引擎版本管理
利用数据库引擎版本管理，您可以控制修补和升级数据库引擎的时间和方式。您可以灵活地保持与数据库引擎补丁版本的兼容性。您还可以测试 RDS for Oracle 的新补丁版本，以确保在将这些补丁部署到生产中之前，它们能够与您的应用程序配合工作。此外，您可以根据自己的条款和时间表升级版本。
**注意**
Amazon RDS 使用 Amazon RDS 特定的数据库引擎版本定期汇总官方 Oracle 数据库补丁。要查看某个 Amazon RDS Oracle 特定引擎版本中包含的 Oracle 补丁的列表，请转到 [https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html)。
## 在引擎升级期间自动拍摄快照
升级 Oracle 数据库实例时，快照可防止出现升级问题。如果数据库实例的备份保留期大于 0，Amazon RDS 在升级过程中拍摄以下数据库快照：
1. 在进行任何升级更改之前数据库实例的快照。如果升级失败，您可以还原此快照，以创建运行旧版本的数据库实例。
1. 升级完成后的数据库实例快照。
**注意**
要更改您的备份保留期，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
升级后，您无法恢复到以前的引擎版本。但是，您可以通过恢复升级前的快照来创建新的 Oracle 数据库实例。
## 多可用区部署中的 Oracle 升级
如果数据库实例在多可用区部署中，Amazon RDS 会同时升级主要副本和备用副本。如果不需要操作系统更新，则主升级和备用升级同时进行。在升级完成之前，这些实例不可用。
如果多可用区部署中需要操作系统更新，Amazon RDS 会在您请求数据库升级时应用更新。Amazon RDS 执行以下步骤：
1. 更新当前备用数据库实例上的操作系统。
1. 将主数据库实例失效转移到备用数据库实例。
1. 升级以前是备用实例的新主数据库实例上的数据库版本。主数据库在升级期间不可用。
1. 更新以前是主数据库实例的新备用数据库实例上的操作系统。
1. 升级新的备用数据库实例上的数据库版本。
1. 将新的主数据库实例失效转移回原始主数据库实例，并且将新的备用数据库实例失效转移回原始备用数据库实例。因此，Amazon RDS 会将复制配置返回到其原始状态。
## 只读副本的 Oracle 升级
源数据库实例及其所有只读副本的 Oracle 数据库引擎版本必须相同。Amazon RDS 在以下阶段执行升级：
1. 升级源数据库实例。只读副本在此阶段可用。
1. 并行升级只读副本，而不考虑副本维护时段。源数据库在此阶段可用。
对于跨区域只读副本的主要版本升级，Amazon RDS 执行其他操作：
+ 自动为目标版本生成选项组
+ 将所有选项和选项设置从原始选项组复制到新选项组
+ 将升级的跨区域只读副本与新选项组关联
# Oracle 主要版本升级
要执行主要版本升级，请手动修改数据库实例。主要版本升级不会自动进行。
**重要**
在将升级应用到生产数据库之前，确保彻底地测试任何升级，验证您的应用程序是否正常工作。有关更多信息，请参阅 [测试 Oracle 数据库升级](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)。
**Topics**
+ [主要版本升级支持的版本](#USER_UpgradeDBInstance.Oracle.Major.supported-versions)
+ [主要版本升级支持的实例类](#USER_UpgradeDBInstance.Oracle.Major.instance-classes)
+ [在主要版本升级之前收集统计信息](#USER_UpgradeDBInstance.Oracle.Major.gathering-stats)
+ [允许主要版本升级](#USER_UpgradeDBInstance.Oracle.Major.allowing-upgrades)
## 主要版本升级支持的版本
Amazon RDS 支持以下主要版本升级。
****
| 当前版本 | 支持升级 |
| --- | --- |
| 使用 CDB 架构的 19.0.0.0 | 21.0.0.0 |
Oracle 数据库的主要版本升级必须升级到在同一个月或更晚发布的版本更新 (RU)。任何 Oracle Database 版本都不支持主要版本降级。
## 主要版本升级支持的实例类
您当前的 Oracle 数据库实例可能在您要升级到的版本不支持的数据库实例类上运行。在这种情况下，在升级之前，请将数据库实例迁移到受支持的数据库实例类。有关 Amazon RDS for Oracle 的每个版本支持的数据库实例类的更多信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。
## 在主要版本升级之前收集统计信息
在执行主要版本升级前，Oracle 建议您对您要升级的数据库实例收集优化器统计数据。此操作可以减少升级过程中的数据库实例停机时间。
要收集优化器统计数据，请以主用户身份连接到数据库实例，然后运行以下 `DBMS_STATS.GATHER_DICTIONARY_STATS` 过程，如以下示例所示。
```
EXEC DBMS_STATS.GATHER_DICTIONARY_STATS;
```
有关更多信息，请参阅 Oracle 文档中的 [GATHER\$1DICTIONARY\$1STATS 过程](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_STATS.html?source=%3Aso%3Atw%3Aor%3Aawr%3Aodv%3A%3A#GUID-867989C7-ADFC-4464-8981-437CEA7F331E)。
## 允许主要版本升级
主要引擎版本升级可能与您的应用程序不兼容。升级是不可逆的。如果为 EngineVersion 参数指定的主要版本与当前主要版本不同，则必须允许主要版本升级。
如果使用 CLI 命令 [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 升级主要版本，请指定 `--allow-major-version-upgrade`。由于此设置不具备持久性，因此只要执行主要升级，就必须指定 `--allow-major-version-upgrade`。此参数对次要引擎版本的升级没有影响。有关更多信息，请参阅“[升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)”。
如果您使用控制台升级主要版本，则无需选择允许升级的选项。相反，控制台会显示一条警告，指出主要升级是不可逆的。
# Oracle 次要版本升级
在 RDS for Oracle 中，次要版本升级是对主要数据库引擎版本的更新。在 RDS 中，次要引擎版本可以是版本更新（RU）或 Spatial 补丁包（SPB）。例如，如果数据库实例运行的是主要版本 Oracle Database 19c 和次要版本 19.0.0.0.ru-2025-10.rur-2025-10.r1，则可以将数据库引擎升级到次要版本 19.0.0.0.ru-2026-01.rur-2026-01.r1。RDS for Oracle 不支持次要版本降级。
您可以手动或自动将数据库引擎升级到次要版本。要了解如何手动升级，请参阅[手动升级引擎版本](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual)。要了解如何配置自动升级，请参阅[自动升级次要引擎版本](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades)。无论是手动升级还是自动升级，次要版本升级都需要停机。在计划升级时，请考虑此停机。
Amazon RDS 还支持升级推出策略，以管理跨多个数据库资源和 Amazon Web Services 账户的自动次要版本升级。有关更多信息，请参阅 [使用 Amazon Organizations 升级推出策略自动升级次要版本](RDS.Maintenance.AMVU.UpgradeRollout.md)。
**重要**
在将升级应用到生产数据库之前，确保彻底地测试任何升级，验证您的应用程序是否正常工作。有关更多信息，请参阅 [测试 Oracle 数据库升级](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)。
**Topics**
+ [版本更新（RU）和 Spatial 补丁包（SPB）](#RUs-and-SPBs)
+ [开启 Oracle 的自动次要版本升级](#oracle-minor-version-upgrade-tuning-on)
+ [使用 Amazon Organizations 升级推出策略自动升级次要版本](#oracle-minor-version-upgrade-rollout)
+ [RDS for Oracle 中的自动次要版本升级通知](#oracle-minor-version-upgrade-advance)
+ [Amazon RDS 如何计划自动次要版本升级](#oracle-minor-version-upgrade-scheduled)
+ [管理 RDS for Oracle 中的自动次要版本升级](#oracle-minor-version-upgrade-managing)
## 版本更新（RU）和 Spatial 补丁包（SPB）
在 RDS 中，版本更新（RU）是每季度发布的次要引擎版本，其中包括 Oracle Database 的安全修复、错误修复和新功能。Spatial 补丁包（SPB）是 RU 引擎版本，其中包含专为 Oracle Spatial 选项设计的补丁。例如，名为 19.0.0.0.ru-2025-01.spb-1.r1 的 SPB 包括相应 RU 19.0.0.0.ru-2025-01.rur-2025-01.r1 中的所有补丁，以及特定于 Spatial 的补丁。只有 Oracle Database 19c 才支持 SPB。
当实例配置为自动升级次要版本时，RU 和 SPB 位于单独的升级途径上。通常，SPB 在其相应的 RU 发布后的 2-3 周内发布。下表显示 Oracle Database 19c 的示例次要版本。
| 标准 RU 升级途径 | SPB 升级途径 |
| --- | --- |
| 19.0.0.0.ru-2025-01.rur-2025-01.r1 | 19.0.0.0.ru-2025-01.spb-1.r1 |
| 19.0.0.0.ru-2025-04.rur-2025-04.r1 | 19.0.0.0.ru-2025-04.spb-1.r1 |
| 19.0.0.0.ru-2025-07.rur-2025-07.r1 | 19.0.0.0.ru-2025-07.spb-1.r1 |
| 19.0.0.0.ru-2025-10.rur-2025-10.r1 | 19.0.0.0.ru-2025-10.spb-1.r1 |
如果数据库实例配置为自动升级，则实例处于与当前版本对应的升级途径上。例如，如果数据库实例运行版本 19.0.0.0.ru-2025-01.rur-2025-01.r1，则当发布 19.0.0.0.ru-2025-04.rur-2025-04.r1 时，实例会自动升级到此 RU。同样，如果数据库实例运行 19.0.0.0.ru-2025-01.spb-1.r1，那么当发布 19.0.0.0.ru-2025-04.spb-1.r1 时，实例会自动升级到此 SPB。运行 19.0.0.0.ru-2025-01.rur-2025-01.r1（为 RU）的实例不会自动升级到 19.0.0.0.ru-2025-04.spb-1.r1（这是位于单独升级途径上的 SPB）。
即使实例不使用 Spatial，也可以将数据库实例升级到 SPB，但是 Spatial 补丁仅适用于 Oracle Spatial。可以手动从 RU 升级到相同或更高引擎版本的 SPB。例如，可以将实例从 19.0.0.0.ru-2025-01.rur-2025-01.r1 升级到以下任一引擎版本：
+ 19.0.0.0.ru-2025-01.spb-1.r1
+ 19.0.0.0.ru-2025-04.spb-1.r1
只有当 RU 是更高的引擎版本时，您才能将实例从 SPB 升级到 RU。例如，可以从 SPB 版本 19.0.0.0.ru-2025-04.spb-1.r1 升级到更高的 RU 版本 19.0.0.0.ru-2025-07.rur-2025-07.r1，但不能升级到相同的 RU 版本 19.0.0.0.ru-2025-04.rur-2025-04.r1。
如果数据库实例配置为自动次要版本升级，并且您手动从 RU 升级到 SPB 或从 SPB 升级到 RU，则自动升级途径会发生变化。假设您手动从 RU 版本 19.0.0.0.ru-2025-01.rur-2025-01.r1 版本升级到 SPB 版本 19.0.0.0.ru-2025-01.spb-1.r1。您的下一个自动次要版本升级将是升级到 SPB 版本 19.0.0.0.ru-2025-04.spb-1.r1。
由于 SPB 和 RU 功能相同，因此，用于将实例升级到 RU 和 SPB 的 RDS API 是相同的。以下命令演示如何升级到 RU 和 SPB。
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--engine-version 19.0.0.0.ru-2025-01.rur-2025-01.r1
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--engine-version 19.0.0.0.ru-2025-01.spb-1.r1
```
有关 Oracle Spatial 选项的更多信息，请参阅 [Spatial 补丁包（SPB）的工作原理](Oracle.Options.Spatial.md#Oracle.Options.Spatial.SPBs)。有关 Oracle Database 19c 支持的 RU 和 SPB，请参阅 [Amazon RDS for Oracle Database 19c (19.0.0.0)](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html)。
## 开启 Oracle 的自动次要版本升级
在自动次要版本升级过程中，RDS 无需手动干预，即可将最新的可用次要版本应用到您的 Oracle 数据库。在以下情况下，Amazon RDS for Oracle 数据库实例会计划在下一个维护时段期间升级：
+ 您的数据库实例开启了**自动次要版本升级**选项。
+ 您的数据库实例尚未运行最新的次要数据库引擎版本。
要了解如何开启自动升级，请参阅[自动升级次要引擎版本](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades)。
## 使用 Amazon Organizations 升级推出策略自动升级次要版本
Amazon RDS for Oracle 支持 Amazon Organizations 升级推出策略，以管理跨多个数据库资源和 Amazon Web Services 账户的自动次要版本升级。此策略消除了手动或通过自定义工具协调自动次要版本升级的操作开销，同时确保升级首先应用于非生产环境，然后再推出到生产环境。在有新的次要引擎版本可用时，Amazon RDS 会根据配置的升级推出顺序升级您的数据库实例：
| 升级推出顺序 | 典型使用案例 | 升级何时开始 |
| --- | --- | --- |
| 第一个 | 开发和测试环境 | 最早：非常适合验证新版本 |
| 秒 | 暂存和非关键生产环境 | “第一个”阶段完成后 |
| 最后一个 | 关键生产环境 | “第二个”阶段完成后 |
**重要**
如果您没有为数据库实例配置升级推出顺序，则默认为第二个。
有关阶段时机和持续时间的详细信息，请参阅 [Amazon RDS 如何计划自动次要版本升级](#oracle-minor-version-upgrade-scheduled)。有关在 Amazon Organizations 中配置升级推出策略的信息，请参阅[使用 Amazon Organizations 升级推出策略自动升级次要版本](RDS.Maintenance.AMVU.UpgradeRollout.md)。
## RDS for Oracle 中的自动次要版本升级通知
如果您的数据库实例启用了自动次要版本升级，则 RDS for Oracle 会创建待处理的维护操作，以便在应用升级之前通知您。您可以在 Amazon RDS 控制台中数据库详细信息页面的**维护和备份**选项卡上，查看这些待处理的维护操作。
如果有新的次要版本推出，RDS for Oracle 会提前发布通知（待处理的维护操作）。提前通知的格式如下：
```
An automatic minor version upgrade to engine-version will be applied during your maintenance window on apply-date based on the upgrade rollout order rollout-order. You can change the upgrade rollout order or apply this upgrade manually at any time before the scheduled date through the Amazon console or Amazon CLI.
```
提前通知中的 `apply-date` 表示 Amazon RDS 将升级您的数据库实例的日期。`rollout-order` 表示您的升级推出顺序（第一个、第二个或最后一个）。如果您尚未配置升级推出策略，则默认情况下，此值为第二个。有关更多信息，请参阅 [使用 Amazon Organizations 升级推出策略自动升级次要版本](RDS.Maintenance.AMVU.UpgradeRollout.md)。
升级推出阶段开始时，待处理的维护操作消息将更改为以下格式：
```
Automatic minor version upgrade to engine-version
```
此消息表示已安排升级，将在预定应用日期的维护时段内应用升级。您可以在 Amazon RDS 控制台中数据库详细信息页面的**维护和备份**选项卡中，或者在 `describe-pending-maintenance-actions` API 响应的 `CurrentApplyDate` 字段中，查看预定的应用日期。
以下示例显示您可以使用 Amazon CLI 中的 `describe-pending-maintenance-actions` 命令获取有关待处理维护操作的详细信息：
```
aws rds describe-pending-maintenance-actions
"PendingMaintenanceActions": [
{
"ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:db:orclinst1",
"PendingMaintenanceActionDetails": [
{
"Action": "db-upgrade",
"Description": "Automatic minor version upgrade to 21.0.0.0.ru-2024-07.rur-2024-07.r1",
"CurrentApplyDate": "2024-12-02T08:10:00Z"
}
]
}, ...
```
有关 [describe-pending-maintenance-actions](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-pending-maintenance-actions.html) 的更多信息，请参阅《Amazon CLI 命令参考》**。
## Amazon RDS 如何计划自动次要版本升级
当您使用 Amazon Organizations 升级推出策略时，Amazon RDS 会根据数据库实例配置的推出顺序，分阶段升级实例。本节介绍每个阶段的时机和持续时间。
**第 0 阶段：提前通知**
当 RDS for Oracle 发布新的次要版本时（通常在 Oracle 每季度 RU 发布后 3 到 4 周），所有启用了自动次要版本升级的数据库实例都会提前收到通知。此通知显示在 Amazon RDS 控制台的数据库详细信息页面的**维护和备份**选项卡中，以及 `describe-pending-maintenance-actions` API 响应中。提前通知阶段持续 2 周。在此阶段，不会进行自动升级。
**第 1 阶段：升级推出顺序的第一个**
在提前通知阶段结束时，RDS for Oracle 按照“升级推出顺序的第一个”顺序开始升级数据库实例。对于 1 月、4 月和 7 月的季度次要版本，此阶段持续 2 到 3 周；对于 10 月的季度次要版本，此阶段持续 7 到 8 周。10 月次要版本的延长时间段为在年终假日季期间测试新的次要版本提供了充足的时间。在此阶段按照“升级推出顺序的第一个”顺序创建的新数据库实例将自动升级。
**第 2 阶段：升级推出顺序的第二个**
在第 1 阶段结束时，RDS for Oracle 按照“升级推出顺序的第二个”顺序开始升级数据库实例。对于所有季度次要版本，此阶段持续 2 周。在此阶段使用“升级推出顺序的第一个”或“升级推出顺序的第二个”顺序创建的新数据库实例将自动升级。
**第 3 阶段：升级推出顺序的最后一个**
在第 2 阶段结束时，RDS for Oracle 按照“升级推出顺序的最后一个”顺序开始升级数据库实例。此阶段将持续到下一次季度次要版本发布。在此阶段使用“升级推出顺序的第一个”、“升级推出顺序的第二个”或“升级推出顺序的最后一个”顺序创建的新数据库实例将自动升级。
| 阶段 | 什么时候开始 | Duration | 待处理维护操作消息 |
| --- | --- | --- | --- |
| 第 0 阶段：提前通知 | 当 RDS for Oracle 发布新的次要版本时 | 2 周 | 根据升级推出顺序 rollout-order，将在 apply-date 的维护时段内，对 engine-version 应用自动次要版本升级。在预定日期之前，您可以随时通过 Amazon 控制台或 Amazon CLI 更改升级推出顺序或者手动应用此升级。 |
| 第 1 阶段：升级推出顺序的第一个 | 提前通知阶段结束 | 对于 1 月/4 月/7 月次要版本，为 2 到 4 周；对于 10 月次要版本，为 7 到 9 周 | 自动次要版本升级到 engine-version |
| 第 2 阶段：升级推出顺序的第二个 | 阶段 1 结束 | 2 周 | 自动次要版本升级到 engine-version |
| 第 3 阶段：升级推出顺序的最后一个 | 阶段 2 结束 | 直到下一次季度次要版本发布 | 自动次要版本升级到 engine-version |
## 管理 RDS for Oracle 中的自动次要版本升级
如果数据库实例启用自动次要版本升级，Amazon RDS 会在维护时段，自动将您的数据库实例升级到最新的次要版本。但是，您可以选择在预定日期之前，使用 Amazon CLI 或者在数据库详细信息页面的**维护和备份**选项卡上手动应用升级。
要立即升级数据库实例而不是等待在计划的维护时段升级，请执行以下操作：
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:123456789012:db:orclinst1 \
--apply-action db-upgrade \
--opt-in-type immediate
```
要在下一个维护时段而不是计划的应用日期应用升级，请执行以下操作：
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:123456789012:db:orclinst1 \
--apply-action db-upgrade \
--opt-in-type next-maintenance
```
要选择退出自动次要版本升级，请修改数据库实例并关闭自动次要版本升级选项。这会取消安排任何待处理的自动升级。
要了解如何关闭自动次要版本升级，请参阅[自动升级次要引擎版本](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades)。如需关于关闭自动次要版本升级的帮助，请联系 Amazon Support。
有时，在 RDS 应用先前的次要版本之前，就会有新的次要版本可用。例如，您运行的实例版本为 `21.0.0.0.ru-2025-07.rur-2025-07.r1`，而 `both 21.0.0.0.ru-2025-10.rur-2025-10.r1` 和 `21.0.0.0.ru-2026-01.rur-2026-01.r1` 同时可作为升级目标。在这种情况下，为了避免数据库实例出现不必要的停机时间，RDS 会计划自动将次要版本升级到最新版本，跳过对先前版本的升级。在此示例中，RDS 将您的实例从 `21.0.0.0.ru-2025-07.rur-2025-07.r1` 直接升级到 `21.0.0.0.ru-2026-01.rur-2026-01.r1`。
# Oracle 数据库升级注意事项
在升级 Oracle 实例之前，请查看以下信息。
**Topics**
+ [Oracle 多租户注意事项](#USER_UpgradeDBInstance.Oracle.multi)
+ [选项组注意事项](#USER_UpgradeDBInstance.Oracle.OGPG.OG)
+ [参数组注意事项](#USER_UpgradeDBInstance.Oracle.OGPG.PG)
+ [时区注意事项](#USER_UpgradeDBInstance.Oracle.OGPG.DST)
+ [Spatial 补丁包（SPB）注意事项](#USER_UpgradeDBInstance.Oracle.SPB)
## Oracle 多租户注意事项
下表介绍了不同版本中支持的 Oracle 数据库架构。
| Oracle Database 版本 | RDS 支持状态 | 架构 |
| --- | --- | --- |
| Oracle Database 21c | 支持 | 仅 CDB |
| Oracle Database 19c | 支持 | CDB 或非 CDB |
下表描述了支持和不支持的升级途径。
| 升级途径 | 是否支持？ |
| --- | --- |
| CDB 升级至 CDB | 是 |
| 非 CDB 升级至 CDB | 否，但您可以将非 CDB 转换为 CDB，然后对其进行升级 |
| CDB 升级至非 CDB | 否 |
有关 RDS for Oracle 中 Oracle 多租户的更多信息，请参阅[CDB 架构的单租户配置](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant)。
## 选项组注意事项
如果您的数据库实例使用自定义选项组，Amazon RDS 有时会无法自动分配新的选项组。例如，在升级到新的主要版本时，会发生这种情况。在这种情况下，请在升级时指定新的选项组。我们建议您创建新的选项组，然后向该组添加与现有自定义选项组相同的选项。
有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create) 或 [复制选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy)。
如果数据库实例使用包含 `APEX` 和 `APEX-DEV` 选项的自定义选项组，您有时可以减少升级用时。为此，请在升级数据库实例的同时升级 Oracle APEX 版本。有关更多信息，请参阅 [升级 Oracle APEX 版本](Appendix.Oracle.Options.APEX.UpgradeandRemove.md#Appendix.Oracle.Options.APEX.Upgrade)。
## 参数组注意事项
如果数据库实例使用自定义参数组，则有时 Amazon RDS 无法自动向数据库实例分配新的参数组。例如，在升级到新的主要版本时，会发生这种情况。在这种情况下，请确保在升级时指定一个新的参数组。我们建议您创建新参数组，然后配置您现有的自定义参数组中的那些参数。
有关更多信息，请参阅 [在 Amazon RDS 中创建数据库参数组](USER_WorkingWithParamGroups.Creating.md) 或 [在 Amazon RDS 中复制数据库参数组](USER_WorkingWithParamGroups.Copying.md)。
## 时区注意事项
您可以使用时区选项更改您的 Oracle 数据库实例使用的*系统时区*。例如，您可能需要更改数据库实例的时区，从而与本地环境或旧版应用程序兼容。时区选项在主机级别更改时区。Amazon RDS for Oracle 全年自动更新系统时区。有关更改系统时区的更多信息，请参阅 [Oracle 时区](Appendix.Oracle.Options.Timezone.md)。
创建 Oracle 数据库实例时，数据库会自动设置*数据库时区*。数据库时区也称为夏令时 (DST) 时区。数据库时区不同于系统时区。
在 Oracle 数据库版本之间，补丁集或单个补丁可能包含新的 DST 版本。这些补丁反映不同时区区域的转换规则变化。例如，政府可能会更改 DST 生效的时间。对 DST 规则的更改可能会影响 `TIMESTAMP WITH TIME ZONE` 数据类型的现有数据。
如果升级 RDS for Oracle 数据库实例，Amazon RDS 不会自动升级数据库时区文件。要自动升级时区文件，您可以在引擎版本升级期间或之后与数据库实例关联的选项组中添加 `TIMEZONE_FILE_AUTOUPGRADE` 选项。有关更多信息，请参阅 [Oracle 时区文件自动升级](Appendix.Oracle.Options.Timezone-file-autoupgrade.md)。
或者，要手动升级数据库时区文件，请创建具有所需 DST 补丁的新 Oracle 数据库实例。但是，我们建议您使用 `TIMEZONE_FILE_AUTOUPGRADE` 选项来升级数据库时区文件。
升级时区文件后，将数据从您的当前实例迁移到新实例。您可以使用多种技术迁移数据，包括：
+ Amazon Database Migration Service
+ Oracle GoldenGate
+ Oracle Data Pump
+ 原始导出/导入（不再支持一般用途）
**注意**
使用 Oracle Data Pump 迁移数据时，当目标时区版本低于源时区版本时，此实用程序会引发错误 ORA-39405。
有关更多信息，请参阅 Oracle 文档中的 [TIMESTAMP WITH TIMEZONE 限制](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-9B6C92EE-860E-43DD-9728-735B17B9DA89)。
## Spatial 补丁包（SPB）注意事项
在 RDS for Oracle 中，版本更新（RU）是次要引擎版本，其中包括 Oracle Database 的安全修复、错误修复和新功能。Spatial 补丁包（SPB）是次要引擎版本，其中也包含专为 Oracle Spatial 选项设计的补丁。例如，19.0.0.0.ru-2025-01.spb-1.r1 是一个次要引擎版本，其中包含引擎版本 19.0.0.0.ru-2025-01.rur-2025-01.r1 中的 RU 补丁以及 Spatial 补丁。
将数据库升级到 SPB 时，请考虑以下事项：
+ 只有 Oracle Database 19c 才支持 SPB。
+ 通常，SPB 在其相应的季度 RU 发布后的 2-3 周内发布。
+ 即使数据库实例不使用 Oracle Spatial 选项，也可以将该实例升级到 SPB，但引擎版本中的 Spatial 补丁仅适用于 Oracle Spatial。您可以在 SPB 上创建新实例，稍后再安装 Oracle Spatial 选项。
+ 如果您为数据库实例启用自动次要版本升级，则升级途径取决于您的实例当前使用的是 SPB 还是 RU。如果您的实例使用 SPB，则 RDS 会自动将您的实例升级到最新的 SPB。如果您的实例使用 RU，则 RDS 会自动将您的实例升级到最新的 RU。
+ 只有当 SPB 的引擎版本与当前 RU 相同或更高时，才能手动将数据库实例从 RU 升级到 SPB。
+ 只有当 RU 为更高版本时，才能手动将数据库实例从 SPB 升级到 RU。
# 测试 Oracle 数据库升级
在将数据库实例上升级到主要版本前，应该彻底地测试数据库以及访问该数据库的所有应用程序，了解是否与新版本兼容。我们建议您使用以下过程。
**测试主要版本升级**
1. 检查新版数据库引擎的 Oracle 升级文档以了解是否存在可能会影响数据库或应用程序的兼容性问题。有关更多信息，请参阅 Oracle 文档中的[数据库升级指南](https://docs.oracle.com/database/121/UPGRD/toc.htm)。
1. 如果数据库实例使用自定义选项组，则创建与您正升级到的新版本兼容的新选项组。有关更多信息，请参阅“[选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)”。
1. 如果数据库实例使用自定义参数组，则创建与您正升级到的新版本兼容的新参数组。有关更多信息，请参阅“[参数组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.PG)”。
1. 为要升级的数据库实例创建数据库快照。有关更多信息，请参阅“[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)”。
1. 恢复数据库快照，以便创建一个新的测试数据库实例。有关更多信息，请参阅“[还原到数据库实例](USER_RestoreFromSnapshot.md)”。
1. 使用下面介绍的一种方法来修改此新测试数据库实例，以将其升级到新版本：
+ [控制台](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.Console)
+ [Amazon CLI](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.CLI)
+ [RDS API](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.API)
1. 执行测试：
+ 对升级的数据库实例运行所需次数的质量保证测试以确保数据库和应用程序可正常使用新版本。
+ 实施任何必需的新测试，评估您在步骤 1 中发现的任何兼容性问题的影响。
+ 测试存储的所有过程、函数和触发器。
+ 将应用程序的测试版本指向所升级的数据库实例。验证各应用程序可与新版本一起正常使用。
+ 计算升级的实例使用的存储容量以决定升级是否需要额外的存储容量。为了在生产中支持新版本，您可能需要选择较大的实例类。有关更多信息，请参阅“[数据库实例类](Concepts.DBInstanceClass.md)”。
1. 如果所有测试都通过，请升级您的生产数据库实例。我们建议您在允许对数据库实例进行写入操作之前确认数据库实例是否正常工作。
# 升级 RDS for Oracle 数据库实例版本
要手动升级 RDS for Oracle 数据库实例的数据库引擎版本，可以使用 Amazon Web Services 管理控制台、Amazon CLI 或 RDS API。有关 RDS 数据库升级的一般信息，请参阅[升级 RDS for Oracle 数据库实例版本](#USER_UpgradeDBInstance.Oracle.Upgrading)。要实现有效的升级目标，请使用 Amazon CLI [ describe-db-engine-versions](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-engine-versions.html) 命令。
## 控制台
**使用控制台升级 RDS for Oracle 数据库实例的引擎版本**
1. 登录 Amazon Web Services 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择 **Databases (数据库)**，然后选择要升级的数据库实例。
1. 选择**修改**。
1. 对于**数据库引擎版本**，请选择更高的数据库版本。
1. 选择**继续**，查看修改摘要。请确保您了解数据库版本升级的含义。无法将升级的数据库实例转换回之前的版本。在继续操作之前，请确保已经使用新版本测试了数据库和应用程序。
1. 决定何时安排升级数据库实例。要立即应用更改，请选择**立即应用**。选择此选项在某些情况下可能导致中断。有关更多信息，请参阅“[使用计划修改设置](USER_ModifyInstance.ApplyImmediately.md)”。
1. 在确认页面上，检查您的更改。如果更改正确无误，请选择 **Modify DB Instance（修改数据库实例）**保存更改。
或者，选择 **Back (返回)** 编辑您的更改，或者选择 **Cancel (取消)** 取消更改。
## Amazon CLI
要升级 RDS for Oracle 数据库实例的引擎版本，可以使用 CLI [modify-db-instance](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-instance.html) 命令。指定以下参数：
+ `--db-instance-identifier` – RDS for Oracle 数据库实例的名称。
+ `--engine-version` – 数据库引擎要升级到的版本号。
有关有效的引擎版本的信息，请使用 Amazon CLI [describe-db-engine-versions](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-engine-versions.html) 命令。
+ `--allow-major-version-upgrade` – 升级数据库引擎版本。
+ `--no-apply-immediately` – 在下一维护时段内应用更改。要立即应用更改，请使用 `--apply-immediately`。
**Example**
以下示例将名为 `myorainst` 的 CDB 实例从其当前版本 `19.0.0.0.ru-2024-01.rur-2024-01.r1` 升级到版本 `21.0.0.0.ru-2024-04.rur-2024-04.r1`。
对于 Linux、macOS 或 Unix：
```
1. aws rds modify-db-instance \
2. --db-instance-identifier myorainst \
3. --engine-version 21.0.0.0.ru-2024-04.rur-2024-04.r1 \
4. --allow-major-version-upgrade \
5. --no-apply-immediately
```
对于：Windows
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier myorainst ^
3. --engine-version 21.0.0.0.ru-2024-04.rur-2024-04.r1 ^
4. --allow-major-version-upgrade ^
5. --no-apply-immediately
```
## RDS API
要升级 RDS for Oracle DB 数据库实例，可执行 [ModifyDBInstance](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) 操作。指定以下参数：
+ `DBInstanceIdentifier` – 数据库实例的名称，例如 *`myorainst`*。
+ `EngineVersion` – 数据库引擎要升级到的版本号。有关有效的引擎版本的信息，请使用 [DescribeDBEngineVersions](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_DescribeDBEngineVersions.html) 操作。
+ `AllowMajorVersionUpgrade` – 是否允许主版本升级。为此，请将该值设置为 `true`。
+ `ApplyImmediately` – 是立即应用更改还是在下一个维护时段内应用更改。要立即应用更改，请将该值设置为 `true`。要在下一个维护时段内应用更改，请将该值设置为 `false`。
# 升级 Oracle 数据库快照
在 Amazon RDS 中升级 Oracle 数据库快照，可确保数据库保持安全、兼容并得到全面支持。随着较旧 Oracle 版本的补丁支持结束，您可以升级与这些版本关联的任何手动数据库快照，以避免潜在的漏洞或服务限制。有关更多信息，请参阅 [Oracle 引擎版本管理](USER_UpgradeDBInstance.Oracle.Overview.md#Oracle.Concepts.Patching)。
Amazon RDS 支持在所有 Amazon Web Services 区域中升级快照。
## 控制台
**升级 Oracle 数据库快照**
1. 登录Amazon Web Services 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.amazonaws.cn/rds/)。
1. 在导航窗格中，选择 **Snapshots**，然后选择您希望升级的数据库快照。
1. 对于 **Actions (操作)**，选择 **Upgrade snapshot (升级快照)**。此时会显示 **Upgrade snapshot (升级快照)** 页面。
1. 选择要将快照升级到的**新引擎版本**。
1. (可选) 对于**选项组**，选择所升级数据库快照的选项组。升级数据库实例时的选项组注意事项在升级数据库快照时同样适用。有关更多信息，请参阅“[选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)”。
1. 选择**保存更改**以保存您的更改。
在升级过程中，将为此数据库快照禁用所有快照操作。此外，数据库快照状态由 **available** 变为 **upgrading**，完成后变为 **active**。如果由于快照损坏导致数据库快照不能升级，状态将变为 **unavailable**。此状态的快照无法恢复。
**注意**
如果数据库快照升级失败，则快照将回滚到具有原始版本的原始状态。
## Amazon CLI
要使用 Amazon CLI 升级 Oracle 数据库快照，请使用以下参数调用 [modify-db-snapshot](https://docs.amazonaws.cn/cli/latest/reference/rds/modify-db-snapshot.html) 命令：
+ `--db-snapshot-identifier` – 数据库快照的名称。
+ `--engine-version` – 要将快照升级到的版本。
您可能还需要包含以下参数。升级数据库实例时的选项组注意事项在升级数据库快照时同样适用。有关更多信息，请参阅“[选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)”。
+ `--option-group-name` – 所升级数据库快照的选项组。
**Example**
以下示例是升级数据库快照的示例。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-snapshot \
--db-snapshot-identifier mydbsnapshot \
--engine-version 19.0.0.0.ru-2020-10.rur-2020-10.r1 \
--option-group-name default:oracle-se2-19
```
对于 Windows：
```
aws rds modify-db-snapshot ^
--db-snapshot-identifier mydbsnapshot ^
--engine-version 19.0.0.0.ru-2020-10.rur-2020-10.r1 ^
--option-group-name default:oracle-se2-19
```
## RDS API
要使用 Amazon RDS API 升级 Oracle 数据库快照，请使用以下参数调用 [ModifyDBSnapshot](https://docs.amazonaws.cn/AmazonRDS/latest/APIReference/API_ModifyDBSnapshot.html) 操作：
+ `DBSnapshotIdentifier` – 数据库快照的名称。
+ `EngineVersion` – 要将快照升级到的版本。
您可能还需要包含 `OptionGroupName` 参数。升级数据库实例时的选项组注意事项在升级数据库快照时同样适用。有关更多信息，请参阅“[选项组注意事项](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG)”。
# 使用第三方软件和 RDS for Oracle 数据库实例
您可以托管支持工具和第三方软件的 RDS for Oracle 数据库实例。
**Topics**
+ [将 Oracle GoldenGate 与 Amazon RDS for Oracle 结合使用](Appendix.OracleGoldenGate.md)
+ [在 RDS for Oracle 上使用 Oracle Repository Creation Utility](Oracle.Resources.RCU.md)
+ [在 Amazon EC2 实例上配置 Oracle Connection Manager](oracle-cman.md)
+ [在 Amazon RDS 上的 Oracle 中安装 Siebel 数据库](Oracle.Resources.Siebel.md)
# 将 Oracle GoldenGate 与 Amazon RDS for Oracle 结合使用
Oracle GoldenGate 可收集、复制和管理数据库之间的事务数据。它是一个基于日志的更改数据捕获（CDC）和复制软件包，与数据库结合使用，适用于联机事务处理（OLTP）系统。Oracle GoldenGate 从源数据库创建包含最近更改的数据的跟踪记录文件。然后，它将这些文件推送到服务器，在此处，一个进程将跟踪记录文件转换为标准 SQL 以应用于目标数据库。
Oracle GoldenGate 与 RDS for Oracle 结合使用可支持以下功能：
+ 主动/主动数据库复制
+ 灾难恢复
+ 数据保护
+ 区域内和跨区域复制
+ 零停机时间迁移和升级
+ 在 RDS for Oracle 数据库实例与非 Oracle 数据库之间复制数据
**注意**
有关支持的数据库的列表，请参阅 Oracle 文档中的 [Oracle Fusion Middleware 支持的系统配置](https://www.oracle.com/middleware/technologies/fusion-certification.html)。
您可以将 Oracle GoldenGate 与 RDS for Oracle 结合使用以升级到 Oracle Database 的主要版本。例如，可以使用 Oracle GoldenGate，从 Oracle Database 11g 本地数据库升级到 Amazon RDS 数据库实例上的 Oracle Database 19c。
**Topics**
+ [Oracle GoldenGate 支持的版本和许可选项](#Appendix.OracleGoldenGate.licensing)
+ [Oracle GoldenGate 的要求和限制](#Appendix.OracleGoldenGate.requirements)
+ [Oracle GoldenGate 架构](Appendix.OracleGoldenGate.Overview.md)
+ [设置 Oracle GoldenGate](Appendix.OracleGoldenGate.setting-up.md)
+ [使用 Oracle GoldenGate 的 EXTRACT 和 REPLICAT 实用程序](Appendix.OracleGoldenGate.ExtractReplicat.md)
+ [监控 Oracle GoldenGate](Appendix.OracleGoldenGate.Monitoring.md)
+ [Oracle GoldenGate 问题排查](Appendix.OracleGoldenGate.Troubleshooting.md)
## Oracle GoldenGate 支持的版本和许可选项
可以将 RDS for Oracle 的标准版 2（SE2）或企业版（EE）与 Oracle GoldenGate 版本 12c 和更高版本结合使用。您可以使用以下 Oracle GoldenGate 功能：
+ 支持 Oracle GoldenGate 远程捕获（提取）。
+ 使用传统非 CDB 数据库架构的 RDS for Oracle 数据库实例支持捕获（提取）。运行 Oracle Database 21c 或 Oracle Database 19c 版本 19.0.0.0.ru-2024-04.rur-2024-04.r1 或更高版本的 CDB 支持 Oracle GoldenGate 远程 PDB 捕获。
+ 使用非 CDB 或 CDB 架构的 RDS for Oracle 数据库实例支持 Oracle GoldenGate 远程交付（复制）。远程交付支持集成复制、并行复制、协调复制和经典复制。
+ RDS for Oracle 支持 Oracle GoldenGate 的经典和微服务架构。
+ 在使用集成捕获模式时，支持 Oracle GoldenGate DDL 和序列值复制。
您负责管理 Oracle GoldenGate 许可（自带许可）以用于所有 Amazon Web Services 区域中的 Amazon RDS。有关更多信息，请参阅 [RDS for Oracle 许可选项](Oracle.Concepts.Licensing.md)。
## Oracle GoldenGate 的要求和限制
在使用 Oracle GoldenGate 和 RDS for Oracle 时，请考虑以下要求和限制：
+ 您负责设置和管理 Oracle GoldenGate 以用于 RDS for Oracle。
+ 您负责设置经过源数据库和目标数据库认证的 Oracle GoldenGate 版本。有关更多信息，请参阅 Oracle 文档中的 [Oracle Fusion Middleware 支持的系统配置](https://www.oracle.com/middleware/technologies/fusion-certification.html)。
+ 您可以在许多不同的 Amazon 环境中将 Oracle GoldenGate 用于许多不同的使用案例。如果您遇到与 Oracle GoldenGate 相关的支持相关问题，请联系 Oracle 支持服务。
+ 您可以在使用 Oracle 透明数据加密（TDE）的 RDS for Oracle 数据库实例上使用 Oracle GoldenGate。要保持复制数据的完整性，请使用 Amazon EBS 加密卷或跟踪记录文件加密在 Oracle GoldenGate 枢纽上配置加密。同时，为 Oracle GoldenGate 枢纽与源和目标数据库实例之间发送的数据配置加密。RDS for Oracle 数据库实例支持使用 [Oracle 安全套接字层](Appendix.Oracle.Options.SSL.md) 或 [Oracle 本机网络加密](Appendix.Oracle.Options.NetworkEncryption.md) 加密。
# Oracle GoldenGate 架构
与 Amazon RDS 结合使用的 Oracle GoldenGate 架构包含以下解耦模块：
源数据库
源数据库可以是本地 Oracle 数据库、Amazon EC2 实例上的 Oracle 数据库或 Amazon RDS 数据库实例上的 Oracle 数据库。
Oracle GoldenGate 枢纽
Oracle GoldenGate 枢纽将事务信息从源数据库移动到目标数据库。枢纽可以是以下任意一种：
+ 安装了 Oracle Database 和 Oracle GoldenGate 的 Amazon EC2 实例
+ 本地 Oracle 安装
可以有多个 Amazon EC2 枢纽。如果要将 Oracle GoldenGate 用于跨区域复制，建议您使用两个枢纽。
目标数据库
目标数据库可位于 Amazon RDS 数据库实例上、位于 Amazon EC2 实例上或位于一个本地位置。
以下各节介绍 Amazon RDS 上 Oracle GoldenGate 的常见场景。
**Topics**
+ [本地源数据库和 Oracle GoldenGate 枢纽](#Appendix.OracleGoldenGate.on-prem-source-gg-hub)
+ [本地源数据库和 Amazon EC2 枢纽](#Appendix.OracleGoldenGate.on-prem-source-ec2-hub)
+ [Amazon RDS 源数据库和 Amazon EC2 枢纽](#Appendix.OracleGoldenGate.rds-source-ec2-hub)
+ [Amazon EC2 源数据库和 Amazon EC2 枢纽](#Appendix.OracleGoldenGate.ec2-source-ec2-hub)
+ [不同 Amazon 区域中的 Amazon EC2 枢纽](#Appendix.OracleGoldenGate.cross-region-hubs)
## 本地源数据库和 Oracle GoldenGate 枢纽
在此场景中，本地 Oracle 源数据库和本地 GoldenGate 枢纽向目标 Amazon RDS 数据库实例提供数据。
![\[使用 Amazon RDS 的 Oracle GoldenGate 配置 0\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-gg0.png)
## 本地源数据库和 Amazon EC2 枢纽
在此场景中，本地 Oracle 数据库充当源数据库。其会连接到 Amazon EC2 实例枢纽。此枢纽向目标 RDS for Oracle 数据库实例提供数据。
![\[使用 Amazon RDS 的 Oracle GoldenGate 配置 1\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-gg1.png)
## Amazon RDS 源数据库和 Amazon EC2 枢纽
在此场景中，RDS for Oracle 数据库实例充当源数据库。其会连接到 Amazon EC2 实例枢纽。此枢纽向目标 RDS for Oracle 数据库实例提供数据。
![\[使用 Amazon RDS 的 Oracle GoldenGate 配置 2\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-gg2.png)
## Amazon EC2 源数据库和 Amazon EC2 枢纽
在此场景中，Amazon EC2 实例上的 Oracle 数据库充当源数据库。其会连接到 Amazon EC2 实例枢纽。此枢纽向目标 RDS for Oracle 数据库实例提供数据。
![\[使用 Amazon RDS 的 Oracle GoldenGate 配置 3\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-gg3.png)
## 不同 Amazon 区域中的 Amazon EC2 枢纽
在此场景中，Amazon RDS 数据库实例上的 Oracle 数据库连接到相同 Amazon 区域中的 Amazon EC2 实例枢纽。该枢纽连接到其他 Amazon 区域中的 Amazon EC2 实例枢纽。第二个枢纽向与第二个 Amazon EC2 实例枢纽位于相同 Amazon 区域中的目标 RDS for Oracle 数据库实例提供数据。
![\[使用 Amazon RDS 的 Oracle GoldenGate 配置 4\]](http://docs.amazonaws.cn/AmazonRDS/latest/UserGuide/images/oracle-gg4.png)
**注意**
影响在本地环境中运行 Oracle GoldenGate 的任何问题也会影响在 Amazon 上运行 Oracle GoldenGate。强烈建议对 Oracle GoldenGate 枢纽进行监控，确保在发生故障转移的情况下恢复 `EXTRACT` 和 `REPLICAT`。由于 Oracle GoldenGate 枢纽在 Amazon EC2 实例上运行，因此 Amazon RDS 不会管理 Oracle GoldenGate 枢纽，也无法确保其是否在运行。
# 设置 Oracle GoldenGate
要使用 Amazon RDS 设置 Oracle GoldenGate，请在 Amazon EC2 实例上配置枢纽，然后配置源数据库和目标数据库。以下各节举例说明了如何设置 Oracle GoldenGate 以便与 Amazon RDS for Oracle 结合使用。
**Topics**
+ [在 Amazon EC2 上设置 Oracle GoldenGate 枢纽](#Appendix.OracleGoldenGate.Hub)
+ [设置源数据库以便与 Amazon RDS 上的 Oracle GoldenGate 结合使用](#Appendix.OracleGoldenGate.Source)
+ [设置目标数据库以便与 Amazon RDS 上的 Oracle GoldenGate 结合使用](#Appendix.OracleGoldenGate.Target)
## 在 Amazon EC2 上设置 Oracle GoldenGate 枢纽
要在 Amazon EC2 实例上创建 Oracle GoldenGate 枢纽，首先应使用 Oracle RDBMS 的完整客户端安装创建 Amazon EC2 实例。Amazon EC2 实例也必须已安装 Oracle GoldenGate 软件。Oracle GoldenGate 软件版本取决于源和目标数据库版本。有关安装 Oracle GoldenGate 的更多信息，请参阅 [Oracle GoldenGate 文档](https://docs.oracle.com/en/middleware/goldengate/core/index.html)。
用作 Oracle GoldenGate 枢纽的 Amazon EC2 实例会处理来自源数据库的事务信息并将这些信息存储到跟踪记录文件中。要支持此过程，请确保满足以下要求：
+ 您为跟踪记录文件分配了足够的存储空间。
+ Amazon EC2 实例有足够的处理能力来管理数据量。
+ EC2 实例在写入跟踪文件之前，有足够的内存来存储事务信息。
**在 Amazon EC2 实例上建立 Oracle GoldenGate 经典架构枢纽**
1. 在 Oracle GoldenGate 目录中创建子目录。
在 Amazon EC2 命令行 shell 中，启动 `ggsci`（Oracle GoldenGate 命令解释器）。`CREATE SUBDIRS` 命令在 `/gg` 目录下为参数、报告和检查点文件创建子目录。
```
prompt$ cd /gg
prompt$ ./ggsci
GGSCI> CREATE SUBDIRS
```
1. 配置 `mgr.prm` 文件。
以下示例向 `$GGHOME/dirprm/mgr.prm` 文件中添加行。
```
PORT 8199
PurgeOldExtracts ./dirdat/*, UseCheckpoints, MINKEEPDAYS 5
```
1. 启动管理器。
以下示例启动 `ggsci` 并运行 `start mgr` 命令。
```
GGSCI> start mgr
```
Oracle GoldenGate 枢纽现已就绪，可供使用。
## 设置源数据库以便与 Amazon RDS 上的 Oracle GoldenGate 结合使用
完成以下任务，设置源数据库以便与 Oracle GoldenGate 结合使用：
**Topics**
+ [步骤 1：在源数据库上开启补充日志记录](#Appendix.OracleGoldenGate.Source.Logging)
+ [步骤 2：将 ENABLE\$1GOLDENGATE\$1REPLICATION 初始化参数设置为 true](#Appendix.OracleGoldenGate.Source.enable-gg-rep)
+ [步骤 3：在源数据库上设置日志保留期](#Appendix.OracleGoldenGate.Source.Retention)
+ [步骤 4：在源数据库上创建 Oracle GoldenGate 用户账户。](#Appendix.OracleGoldenGate.Source.Account)
+ [步骤 5：向用户账户授予对源数据库的权限](#Appendix.OracleGoldenGate.Source.Privileges)
+ [步骤 6：为源数据库添加 TNS 别名](#Appendix.OracleGoldenGate.Source.TNS)
### 步骤 1：在源数据库上开启补充日志记录
要启用最低数据库级别的补充日志记录，请运行以下 PL/SQL 过程：
```
EXEC rdsadmin.rdsadmin_util.alter_supplemental_logging(p_action => 'ADD')
```
### 步骤 2：将 ENABLE\$1GOLDENGATE\$1REPLICATION 初始化参数设置为 true
将 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数设置为 `true` 时，它允许数据库服务支持逻辑复制。如果源数据库位于 Amazon RDS 数据库实例上，请确保为数据库实例分配一个参数组，且将 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数设置为 `true`。有关 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数的更多信息，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/ENABLE_GOLDENGATE_REPLICATION.html)。
### 步骤 3：在源数据库上设置日志保留期
确保将源数据库配置为保留存档重做日志。请考虑以下准则：
+ 以小时为单位指定日志保留的持续时间。最小值为一小时。
+ 设置持续时间以超过源数据库实例的任何可能的停机时间、任何可能的通信时间以及源实例的任何可能的联网问题期间。指定这样的持续时间后，可允许 Oracle GoldenGate 根据需要从源实例恢复日志。
+ 确保您的实例上有足够的文件存储空间。
例如，将存档重做日志的保留期设置为 24 小时。
```
EXEC rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours',24)
```
如果未启用日志保留，或者保留值太小，则将收到类似以下内容的错误消息。
```
2022-03-06 06:17:27 ERROR OGG-00446 error 2 (No such file or directory)
opening redo log /rdsdbdata/db/GGTEST3_A/onlinelog/o1_mf_2_9k4bp1n6_.log for sequence 1306
Not able to establish initial position for begin time 2022-03-06 06:16:55.
```
由于您的数据库实例会保留存档的重做日志，因此请确保您有足够的空间存放这些文件。要查看过去 *num\$1hours* 小时内使用了多少空间，请使用以下查询，并将 *num\$1hours* 替换为小时数。
```
SELECT SUM(BLOCKS * BLOCK_SIZE) BYTES FROM V$ARCHIVED_LOG
WHERE NEXT_TIME>=SYSDATE-num_hours/24 AND DEST_ID=1;
```
### 步骤 4：在源数据库上创建 Oracle GoldenGate 用户账户。
Oracle GoldenGate 作为数据库用户运行，并且需要相应数据库权限才能访问源数据库的重做和存档的重做日志。要提供这些权限，请在源数据库上创建用户账户。有关 Oracle GoldenGate 用户账户权限的更多信息，请参阅 [Oracle 文档](https://docs.oracle.com/en/middleware/goldengate/core/19.1/oracle-db/establishing-oracle-goldengate-credentials.html#GUID-79122058-27B0-4FB6-B3DC-B7D1B67EB053)。
下列语句创建名为 `oggadm1` 的用户账户。
```
CREATE TABLESPACE administrator;
CREATE USER oggadm1 IDENTIFIED BY "password"
DEFAULT TABLESPACE ADMINISTRATOR TEMPORARY TABLESPACE TEMP;
ALTER USER oggadm1 QUOTA UNLIMITED ON administrator;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
### 步骤 5：向用户账户授予对源数据库的权限
在此任务中，您将为源数据库上的数据库用户授予必要的账户权限。
**向账户授予对源数据库的权限**
1. 使用 SQL 命令 `grant` 和 `rdsadmin.rdsadmin_util` 过程 `grant_sys_object` 向 Oracle GoldenGate 用户账户授予必要权限。下列语句向名为 `oggadm1` 的用户授予权限。
```
GRANT CREATE SESSION, ALTER SESSION TO oggadm1;
GRANT RESOURCE TO oggadm1;
GRANT SELECT ANY DICTIONARY TO oggadm1;
GRANT FLASHBACK ANY TABLE TO oggadm1;
GRANT SELECT ANY TABLE TO oggadm1;
GRANT SELECT_CATALOG_ROLE TO rds_master_user_name WITH ADMIN OPTION;
EXEC rdsadmin.rdsadmin_util.grant_sys_object ('DBA_CLUSTERS', 'OGGADM1');
GRANT EXECUTE ON DBMS_FLASHBACK TO oggadm1;
GRANT SELECT ON SYS.V_$DATABASE TO oggadm1;
GRANT ALTER ANY TABLE TO oggadm1;
```
1. 授予用户账户作为 Oracle GoldenGate 管理员所需的权限。运行以下 PL/SQL 程序。
```
EXEC rdsadmin.rdsadmin_dbms_goldengate_auth.grant_admin_privilege (
grantee => 'OGGADM1',
privilege_type => 'capture',
grant_select_privileges => true,
do_grants => TRUE);
```
要撤消权限，请使用同一个程序包中的 `revoke_admin_privilege` 过程。
### 步骤 6：为源数据库添加 TNS 别名
将以下条目添加到 Oracle 主目录中的 `$ORACLE_HOME/network/admin/tnsnames.ora`，以供 `EXTRACT` 进程使用。有关 `tnsnames.ora` 文件的更多信息，请参阅 [Oracle 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/netrf/local-naming-parameters-in-tns-ora-file.html#GUID-7F967CE5-5498-427C-9390-4A5C6767ADAA)。
```
OGGSOURCE=
(DESCRIPTION=
(ENABLE=BROKEN)
(ADDRESS_LIST=
(ADDRESS=(PROTOCOL=TCP)(HOST=goldengate-source.abcdef12345.us-west-2.rds.amazonaws.com)(PORT=8200)))
(CONNECT_DATA=(SERVICE_NAME=ORCL))
)
```
## 设置目标数据库以便与 Amazon RDS 上的 Oracle GoldenGate 结合使用
在本任务中，您将设置一个目标数据库实例以与 Oracle GoldenGate 结合使用。
**Topics**
+ [步骤 1：将 ENABLE\$1GOLDENGATE\$1REPLICATION 初始化参数设置为 true](#Appendix.OracleGoldenGate.Target.enable-gg-rep)
+ [步骤 2：在目标数据库上创建 Oracle GoldenGate 用户账户](#Appendix.OracleGoldenGate.Target.User)
+ [步骤 3：授予账户对目标数据库的权限](#Appendix.OracleGoldenGate.Target.Privileges)
+ [步骤 4：为目标数据库添加 TNS 别名](#Appendix.OracleGoldenGate.Target.TNS)
### 步骤 1：将 ENABLE\$1GOLDENGATE\$1REPLICATION 初始化参数设置为 true
将 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数设置为 `true` 时，它允许数据库服务支持逻辑复制。如果源数据库位于 Amazon RDS 数据库实例上，请确保为数据库实例分配一个参数组，且将 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数设置为 `true`。有关 `ENABLE_GOLDENGATE_REPLICATION` 初始化参数的更多信息，请参阅 [Oracle Database 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/ENABLE_GOLDENGATE_REPLICATION.html)。
### 步骤 2：在目标数据库上创建 Oracle GoldenGate 用户账户
Oracle GoldenGate 以数据库用户身份运行，并且需要相应的数据库权限。为了确保它具备这些权限，请在目标数据库上创建用户帐户。
下列语句将创建名为 `oggadm1` 的用户。
```
CREATE TABLESPSACE administrator;
CREATE USER oggadm1 IDENTIFIED BY "password"
DEFAULT TABLESPACE administrator
TEMPORARY TABLESPACE temp;
ALTER USER oggadm1 QUOTA UNLIMITED ON administrator;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
### 步骤 3：授予账户对目标数据库的权限
在此任务中，您将为目标数据库上的数据库用户授予必要的账户权限。
**授予账户对目标数据库的权限**
1. 向目标数据库上的 Oracle GoldenGate 用户账户授予必要权限。在以下示例中，您向 `oggadm1` 授予权限。
```
GRANT CREATE SESSION TO oggadm1;
GRANT ALTER SESSION TO oggadm1;
GRANT CREATE CLUSTER TO oggadm1;
GRANT CREATE INDEXTYPE TO oggadm1;
GRANT CREATE OPERATOR TO oggadm1;
GRANT CREATE PROCEDURE TO oggadm1;
GRANT CREATE SEQUENCE TO oggadm1;
GRANT CREATE TABLE TO oggadm1;
GRANT CREATE TRIGGER TO oggadm1;
GRANT CREATE TYPE TO oggadm1;
GRANT SELECT ANY DICTIONARY TO oggadm1;
GRANT CREATE ANY TABLE TO oggadm1;
GRANT ALTER ANY TABLE TO oggadm1;
GRANT LOCK ANY TABLE TO oggadm1;
GRANT SELECT ANY TABLE TO oggadm1;
GRANT INSERT ANY TABLE TO oggadm1;
GRANT UPDATE ANY TABLE TO oggadm1;
GRANT DELETE ANY TABLE TO oggadm1;
```
1. 授予用户账户作为 Oracle GoldenGate 管理员所需的权限。运行以下 PL/SQL 程序。
```
EXEC rdsadmin.rdsadmin_dbms_goldengate_auth.grant_admin_privilege (
grantee => 'OGGADM1',
privilege_type => 'apply',
grant_select_privileges => true,
do_grants => TRUE);
```
要撤消权限，请使用同一个程序包中的 `revoke_admin_privilege` 过程。
### 步骤 4：为目标数据库添加 TNS 别名
将以下条目添加到 Oracle 主目录中的 `$ORACLE_HOME/network/admin/tnsnames.ora`，以供 `REPLICAT` 进程使用。对于 Oracle 多租户数据库，请确保 TNS 别名指向 PDB 的服务名称。有关 `tnsnames.ora` 文件的更多信息，请参阅 [Oracle 文档](https://docs.oracle.com/en/database/oracle/oracle-database/19/netrf/local-naming-parameters-in-tns-ora-file.html#GUID-7F967CE5-5498-427C-9390-4A5C6767ADAA)。
```
OGGTARGET=
(DESCRIPTION=
(ENABLE=BROKEN)
(ADDRESS_LIST=
(ADDRESS=(PROTOCOL=TCP)(HOST=goldengate-target.abcdef12345.us-west-2.rds.amazonaws.com)(PORT=8200)))
(CONNECT_DATA=(SERVICE_NAME=ORCL))
)
```
# 使用 Oracle GoldenGate 的 EXTRACT 和 REPLICAT 实用程序
Oracle GoldenGate 实用程序 `EXTRACT` 和 `REPLICAT` 结合使用，以使用跟踪记录文件通过增量事务复制将源数据库和目标数据库保持同步。源数据库上发生的所有更改会由 `EXTRACT` 自动检测，进行格式设置，然后传输至 Oracle GoldenGate 本地或 Amazon EC2 实例枢纽上的跟踪文件。初始加载完成后，由 `REPLICAT` 实用程序从这些文件读取数据并复制到目标数据库。
## 运行 Oracle GoldenGate EXTRACT 实用程序
`EXTRACT` 实用程序可对源数据库中的数据进行检索、转换并输出至跟踪文件。基本过程如下所示：
1. `EXTRACT` 将事务详细信息排队到内存或临时磁盘存储中。
1. 源数据库提交事务。
1. `EXTRACT` 将事务详细信息写入跟踪文件。
1. 跟踪记录文件将这些详细信息路由到 Oracle GoldenGate 本地或 Amazon EC2 实例枢纽，然后路由到目标数据库。
以下步骤启动 `EXTRACT` 实用程序，从源数据库 `OGGSOURCE` 的 `EXAMPLE.TABLE` 中捕获数据，然后创建跟踪记录文件。
**运行 EXTRACT 实用程序**
1. 在 Oracle GoldenGate 枢纽（本地或 Amazon EC2 实例）上配置 `EXTRACT` 参数文件。下面的列表显示了一个名为 `$GGHOME/dirprm/eabc.prm` 的示例 `EXTRACT` 参数文件。
```
EXTRACT EABC
USERID oggadm1@OGGSOURCE, PASSWORD "my-password"
EXTTRAIL /path/to/goldengate/dirdat/ab
IGNOREREPLICATES
GETAPPLOPS
TRANLOGOPTIONS EXCLUDEUSER OGGADM1
TABLE EXAMPLE.TABLE;
```
1. 在 Oracle GoldenGate 枢纽上，登录到源数据库，并启动 Oracle GoldenGate 命令行界面 `ggsci`。下面的示例说明了登录格式。
```
dblogin oggadm1@OGGSOURCE
```
1. 添加事务数据以便为数据库表开启补充日志记录。
```
add trandata EXAMPLE.TABLE
```
1. 使用 `ggsci` 命令行以及下列命令，启用 `EXTRACT` 实用程序。
```
add extract EABC tranlog, INTEGRATED tranlog, begin now
add exttrail /path/to/goldengate/dirdat/ab
extract EABC,
MEGABYTES 100
```
1. 向数据库注册 `EXTRACT` 实用程序，以便不删除存档日志。此任务可让您在必要时恢复未提交的旧事务。要向数据库注册 `EXTRACT` 实用程序，请使用下面的命令。
```
register EXTRACT EABC, DATABASE
```
1. 使用下面的命令启动 `EXTRACT` 实用程序。
```
start EABC
```
## 运行 Oracle GoldenGate REPLICAT 实用程序
`REPLICAT` 实用程序将跟踪记录文件中的事务信息“推送”至目标数据库。
以下步骤启用并启动 `REPLICAT` 实用程序，以便它可以将捕获的数据复制到目标数据库 `OGGTARGET` 的表 `EXAMPLE.TABLE` 中。
**运行 REPLICATE 实用程序**
1. 在 Oracle GoldenGate 枢纽（本地或 EC2 实例）上配置 `REPLICAT` 参数文件。下面的列表显示了一个名为 `$GGHOME/dirprm/rabc.prm` 的示例 `REPLICAT` 参数文件。
```
REPLICAT RABC
USERID oggadm1@OGGTARGET, password "my-password"
ASSUMETARGETDEFS
MAP EXAMPLE.TABLE, TARGET EXAMPLE.TABLE;
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 登录目标数据库并启动 Oracle GoldenGate 命令行界面（`ggsci`）。下面的示例说明了登录格式。
```
dblogin userid oggadm1@OGGTARGET
```
1. 使用 `ggsci` 命令行，添加检查点表。所指示的用户应是 Oracle GoldenGate 用户账户，而不是目标表架构拥有者。下面的示例创建一个名为 `gg_checkpoint` 的检查点表。
```
add checkpointtable oggadm1.oggchkpt
```
1. 要启用 `REPLICAT` 实用程序，请使用下面的命令。
```
add replicat RABC EXTTRAIL /path/to/goldengate/dirdat/ab CHECKPOINTTABLE oggadm1.oggchkpt
```
1. 使用下面的命令启动 `REPLICAT` 实用程序。
```
start RABC
```
# 监控 Oracle GoldenGate
使用 Oracle GoldenGate 进行复制时，请确保 Oracle GoldenGate 进程已启动并正在运行，且源数据库和目标数据库已同步。您可以使用以下监控工具：
+ [Amazon CloudWatch](https://docs.amazonaws.cn/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) 是一种监控服务，在这种模式下用于监控 GoldenGate 错误日志。
+ [Amazon SNS](https://docs.amazonaws.cn/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html) 是一种消息通知服务，在此模式中用于发送电子邮件通知。
有关详细说明，请参阅[使用 Amazon CloudWatch 监控 Oracle GoldenGate 日志](https://docs.amazonaws.cn/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html)。
# Oracle GoldenGate 问题排查
本节说明 Oracle GoldenGate 与 Amazon RDS for Oracle 结合使用时的最常见问题。
**Topics**
+ [打开联机重做日志时出错](#Appendix.OracleGoldenGate.Troubleshooting.Logs)
+ [Oracle GoldenGate 似乎配置正确，但复制不起作用](#Appendix.OracleGoldenGate.Troubleshooting.Replication)
+ [由于 SYS 上的查询，集成 REPLICAT 速度缓慢。"\$1DBA\$1APPLY\$1CDR\$1INFO"](#Appendix.OracleGoldenGate.IR)
## 打开联机重做日志时出错
确保将数据库配置为保留存档的重做日志。请考虑以下准则：
+ 以小时为单位指定日志保留的持续时间。最小值为一小时。
+ 设置持续时间以超过源数据库实例的任何可能的停机时间、任何可能的通信时间以及源数据库实例的任何可能的联网问题期间。指定这样的持续时间后，可允许 Oracle GoldenGate 根据需要从源数据库实例恢复日志。
+ 确保您的实例上有足够的文件存储空间。
如果未启用日志保留，或者保留值太小，则将收到类似以下内容的错误消息。
```
2022-03-06 06:17:27 ERROR OGG-00446 error 2 (No such file or directory)
opening redo log /rdsdbdata/db/GGTEST3_A/onlinelog/o1_mf_2_9k4bp1n6_.log for sequence 1306
Not able to establish initial position for begin time 2022-03-06 06:16:55.
```
## Oracle GoldenGate 似乎配置正确，但复制不起作用
对于预先存在的表，您必须指定 Oracle GoldenGate 从中运行的 SCN。
**修复此问题**
1. 登录源数据库并启动 Oracle GoldenGate 命令行界面（`ggsci`）。下面的示例说明了登录格式。
```
dblogin userid oggadm1@OGGSOURCE
```
1. 使用 `ggsci` 命令行为 `EXTRACT` 进程设置起始 SCN。以下示例为 `EXTRACT` 将 SCN 设置为 223274。
```
ALTER EXTRACT EABC SCN 223274
start EABC
```
1. 登录到目标数据库。下面的示例说明了登录格式。
```
dblogin userid oggadm1@OGGTARGET
```
1. 使用 `ggsci` 命令行为 `REPLICAT` 进程设置起始 SCN。以下示例为 `REPLICAT` 将 SCN 设置为 223274。
```
start RABC atcsn 223274
```
## 由于 SYS 上的查询，集成 REPLICAT 速度缓慢。"\$1DBA\$1APPLY\$1CDR\$1INFO"
Oracle GoldenGate 冲突检测和解决 (CDR) 提供了基本的冲突解决例程。例如，CDR 可以解决 `INSERT` 语句的唯一冲突。
在 CDR 解决冲突时，它可以临时将记录插入异常表 `_DBA_APPLY_CDR_INFO` 中。集成的 `REPLICAT` 稍后会删除这些记录。在极少数情况下，集成的 `REPLICAT` 可以处理大量冲突，但是新的集成 `REPLICAT` 并不能取代它。`_DBA_APPLY_CDR_INFO` 中的现有行不会被删除而是被孤立。任何新的集成 `REPLICAT` 进程都会减慢，因为它们正在查询 `_DBA_APPLY_CDR_INFO` 中的孤立行。
要从 `_DBA_APPLY_CDR_INFO` 中删除所有行，请使用 Amazon RDS 过程 `rdsadmin.rdsadmin_util.truncate_apply$_cdr_info`。此过程是作为 2020 年 10 月版本和补丁程序更新的一部分发布的。以下数据库版本中提供该过程：
+ [版本 21.0.0.0.ru-2022-01.rur-2022-01.r1](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-21-0.html#oracle-version-RU-RUR.21.0.0.0.ru-2022-01.rur-2022-01.r1) 及更高版本
+ [版本 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) 及更高版本
以下示例展示了将表 `_DBA_APPLY_CDR_INFO` 截断。
```
SET SERVEROUTPUT ON SIZE 2000
EXEC rdsadmin.rdsadmin_util.truncate_apply$_cdr_info;
```
# 在 RDS for Oracle 上使用 Oracle Repository Creation Utility
您可以使用 Amazon RDS 托管 RDS for Oracle 数据库实例，此实例保留架构以支持 Oracle Fusion Middleware 组件。必须先在数据库中为 Fusion Middleware 组件创建和填充架构，然后才能使用这些组件。可使用 Oracle Repository Creation Utility (RCU) 来创建和填充架构。
## RCU 支持的版本和许可选项
Amazon RDS 仅支持 Oracle Repository Creation Utility (RCU) 版本 12c。您可以在以下配置中使用 RCU：
+ 带 Oracle Database 21c 的 RCU 12c
+ 带 Oracle Database 19c 的 RCU 12c
在使用 RCU 之前，请确保执行以下操作：
+ 获得 Oracle Fusion Middleware 的许可证。
+ 遵循托管存储库的 Oracle 数据库的 Oracle 许可指南。有关更多信息，请参阅 Oracle 文档中的 [Oracle Fusion Middleware 许可信息用户手册](https://docs.oracle.com/en/middleware/fusion-middleware/fmwlc/)。
Fusion MiddleWare 支持 Oracle Database 企业版和标准版 2 上的存储库。Oracle 建议将 Enterprise Edition 用于需要分区的生产安装和需要在线重新建立索引的安装。
在创建 RDS for Oracle 数据库实例之前，确认支持要部署的组件所需的 Oracle 数据库版本。要查找要部署的 Fusion Middleware 组件和版本的要求，请使用 Certification Matrix。有关更多信息，请参阅 Oracle 文档中的 [Oracle Fusion Middleware 支持的系统配置](http://www.oracle.com/technetwork/middleware/ias/downloads/fusion-certification-100350.html)。
Amazon RDS 根据需要支持 Oracle 数据库版本升级。有关更多信息，请参阅 [升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)。
## RCU 的要求和限制
您需要 Amazon VPC 才能使用 RCU。您的 Amazon RDS 数据库实例必须仅对您的 Fusion Middleware 组件可用，而不是公共互联网。因此，在私有子网中托管您的 Amazon RDS 数据库实例，可提供更好的安全性。您还需要 RDS for Oracle 数据库实例。有关更多信息，请参阅 [创建并连接到 Oracle 数据库实例](CHAP_GettingStarted.CreatingConnecting.Oracle.md)。
可以为 Amazon RDS 数据库实例中的任何 Fusion Middleware 组件存储架构。已经验证以下架构安装正确：
+ 分析 (ACTIVITIES)
+ 审核服务 (IAU)
+ Audit Services Append (IAU\$1APPEND)
+ Audit Services Viewer (IAU\$1VIEWER)
+ 讨论 (DISCUSSIONS)
+ 元数据服务 (MDS)
+ Oracle Business Intelligence (BIPLATFORM)
+ Oracle Platform Security Services (OPSS)
+ 门户和服务 (WEBCENTER)
+ Portlet 创建者 (PORTLET)
+ 服务表 (STB)
+ SOA 基础设施 (SOAINFRA)
+ User Messaging Service (UCSUMS)
+ WebLogic Services (WLS)
## RCU 的使用准则
以下是针对在此方案中使用数据库实例的一些建议：
+ 建议您对生产工作负载使用多可用区。有关使用多个可用区的更多信息，请参阅[区域、可用区和 Local Zones ](Concepts.RegionsAndAvailabilityZones.md)。
+ 为了提高安全性，Oracle 建议您使用透明数据加密 (TDE) 对静态数据进行加密。如果您拥有包含高级安全选项的 Enterprise Edition 许可证，则可使用 TDE 选项启用静态加密。有关更多信息，请参阅“[Oracle 透明数据加密](Appendix.Oracle.Options.AdvSecurity.md)”。
Amazon RDS 还提供适用于所有数据库版本的静态加密选项。有关更多信息，请参阅“[加密 Amazon RDS 资源](Overview.Encryption.md)”。
+ 将 VPC 安全组配置为允许应用程序服务器和 Amazon RDS 数据库实例之间的通信。承载 Fusion Middleware 组件的应用程序服务器可位于 Amazon EC2 上或位于本地。
## 运行 RCU
要创建和填充架构以支持 Fusion Middleware 组件，请使用 Oracle Repository Creation Utility (RCU)。可通过不同方式运行 RCU。
**Topics**
+ [使用命令行通过一个步骤运行 RCU](#Oracle.Resources.RCU.SilentSingle)
+ [使用命令行通过多个步骤运行 RCU](#Oracle.Resources.RCU.SilentMulti)
+ [以交互式模式运行 RCU](#Oracle.Resources.RCU.Interactive)
### 使用命令行通过一个步骤运行 RCU
如果您在填充任何架构之前不需要对其进行编辑，则可通过一个步骤运行 RCU。否则，请参阅下一部分以了解通过多个步骤运行 RCU。
可使用命令行参数 `-silent` 在静默模式下运行 RCU。在静默模式下运行 RCU 时，可通过创建包含密码的文本文件来避免在命令行中输入密码。创建一个文本文件，其中 `dbUser` 的密码位于第一行，每个组件的密码位于后续行。您将密码文件的名称指定为 RCU 命令的最后一个参数。
**Example**
以下示例通过一个步骤为 SOA 基础设施组件 (及其依赖项) 创建和填充建构。
对于 Linux、macOS 或 Unix：
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-createRepository \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-f < /tmp/passwordfile.txt
```
有关更多信息，请参阅 Oracle 文档中的[从命令行运行 Repository Creation Utility](https://docs.oracle.com/middleware/1221/core/RCUUG/GUID-0D3A2959-7CC8-4001-997E-718ADF04C5F2.htm#RCUUG248)。
### 使用命令行通过多个步骤运行 RCU
要手动编辑架构脚本，请通过多个步骤运行 RCU：
1. 使用 `-generateScript` 命令行参数在 **Prepare Scripts for System Load** 模式下运行 RCU 以便为架构创建脚本。
1. 手动编辑和运行生成的脚本 `script_systemLoad.sql`。
1. 再次使用 `-dataLoad` 命令行参数在 **Perform Product Load** 模式下运行 RCU 以填充架构。
1. 运行生成的清理脚本 `script_postDataLoad.sql`。
要在静默模式下运行 RCU，请指定命令行参数 `-silent`。在静默模式下运行 RCU 时，可通过创建包含密码的文本文件来避免在命令行中键入密码。创建一个文本文件，其中 `dbUser` 的密码位于第一行，每个组件的密码位于后续行。将密码文件的名称指定为 RCU 命令的最后一个参数。
**Example**
以下示例为 SOA 基础设施组件及其依赖项创建架构脚本。
对于 Linux、macOS 或 Unix：
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-generateScript \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
[-encryptTablespace true] \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-scriptLocation /tmp/rcuscripts \
-f < /tmp/passwordfile.txt
```
现在，您可以编辑生成的脚本，连接到您的 Oracle 数据库实例和运行脚本。生成的脚本名为 `script_systemLoad.sql`。有关连接到 Oracle 数据库实例的信息，请参阅[步骤 3：将 SQL 客户端连接到 Oracle 数据库实例](CHAP_GettingStarted.CreatingConnecting.Oracle.md#CHAP_GettingStarted.Connecting.Oracle)。
以下示例为 SOA 基础设施组件 (及其依赖项) 填充架构。
对于 Linux、macOS 或 Unix：
```
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-dataLoad \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-f < /tmp/passwordfile.txt
```
最后，您连接到 Oracle 数据库实例，并运行清除脚本。该脚本名为 `script_postDataLoad.sql`。
有关更多信息，请参阅 Oracle 文档中的[从命令行运行 Repository Creation Utility](https://docs.oracle.com/middleware/1221/core/RCUUG/GUID-0D3A2959-7CC8-4001-997E-718ADF04C5F2.htm#RCUUG248)。
### 以交互式模式运行 RCU
要使用 RCU 图形用户界面，请以交互模式运行 RCU。加入 `-interactive` 参数，然后省略 `-silent` 参数。有关更多信息，请参阅 Oracle 文档中的[了解 Repository Creation Utility 屏幕](https://docs.oracle.com/middleware/1213/core/RCUUG/rcu_screens.htm#RCUUG143)。
**Example**
以下示例以交互模式启动 RCU 并预填写连接信息。
对于 Linux、macOS 或 Unix：
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-interactive \
-createRepository \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal
```
## RCU 问题排查
请注意以下问题。
**Topics**
+ [Oracle Managed Files (OMF)](#Oracle.Resources.RCU.KnownIssues.OMF)
+ [对象权限](#Oracle.Resources.RCU.KnownIssues.object-privs)
+ [Enterprise Scheduler Service](#Oracle.Resources.RCU.KnownIssues.Scheduler)
### Oracle Managed Files (OMF)
Amazon RDS 使用 OMF 数据文件来简化存储管理。您可以自定义表空间属性，例如大小和范围管理。但是，如果在运行 RCU 时指定数据文件名，则表空间代码将失败，错误为 `ORA-20900`。可通过以下方式将 RCU 与 OMF 结合使用：
+ 在 RCU 12.2.1.0 和更高版本中，使用 `-honorOMF` 命令行参数。
+ 在 RCU 12.1.0.3 和更高版本中，使用多个步骤并编辑生成的脚本。有关更多信息，请参阅 [使用命令行通过多个步骤运行 RCU](#Oracle.Resources.RCU.SilentMulti)。
### 对象权限
由于 Amazon RDS 是一项托管式服务，因此，您不具有对 RDS for Oracle 数据库实例的完全 `SYSDBA` 访问权限。不过，RCU 12c 支持具有较低权限的用户。在大多数情况下，主用户权限足以创建存储库。
主账户可以直接授予已授予 `WITH GRANT OPTION` 的权限。在某些情况下，在尝试授予 `ORA-01031` 对象权限时，RCU 可能失败，错误为 `SYS`。您可以重试并运行 `rdsadmin_util.grant_sys_object` 存储过程，如以下示例所示：
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('GV_$SESSION','MY_DBA','SELECT');
END;
/
```
如果您尝试授予对于对象 `SCHEMA_VERSION_REGISTRY` 的 `SYS` 权限，则操作可能会失败，错误为 `ORA-20199: Error in rdsadmin_util.grant_sys_object`。您可以使用架构拥有者名称（即 `SYSTEM`）限定表 `SCHEMA_VERSION_REGISTRY$` 和视图 `SCHEMA_VERSION_REGISTRY`，然后重试该操作。或者，您可以创建同义词。以主用户身份登录并运行以下语句：
```
CREATE OR REPLACE VIEW SYSTEM.SCHEMA_VERSION_REGISTRY
AS SELECT * FROM SYSTEM.SCHEMA_VERSION_REGISTRY$;
CREATE OR REPLACE PUBLIC SYNONYM SCHEMA_VERSION_REGISTRY FOR SYSTEM.SCHEMA_VERSION_REGISTRY;
CREATE OR REPLACE PUBLIC SYNONYM SCHEMA_VERSION_REGISTRY$ FOR SCHEMA_VERSION_REGISTRY;
```
### Enterprise Scheduler Service
当您使用 RCU 删除 Enterprise Scheduler Service 存储库时，RCU 可能失败，错误为 `Error: Component drop check failed`。
# 在 Amazon EC2 实例上配置 Oracle Connection Manager
Oracle Connection Manager (CMAN) 是一种代理服务器，可将连接请求转发到数据库服务器或其他代理服务器。您可以使用 CMAN 配置以下内容：
访问控制
您可以创建规则来筛选掉用户指定的客户端请求并接受其他请求。
会话多路复用
您可以通过网络连接将多个客户端会话汇集到共享服务器目标。
通常，CMAN 驻留在独立于数据库服务器和客户端主机的主机上。有关更多信息，请参阅 Oracle Database 文档中的[配置 Oracle Connection Manager](https://docs.oracle.com/en/database/oracle/oracle-database/19/netag/configuring-oracle-connection-manager.html#GUID-AF8A511E-9AE6-4F4D-8E58-F28BC53F64E4)。
**Topics**
+ [CMAN 支持的版本和许可选项](#oracle-cman.Versions)
+ [CMAN 的要求和限制](#oracle-cman.requirements)
+ [配置 CMAN](#oracle-cman.configuring-cman)
## CMAN 支持的版本和许可选项
CMAN 支持 Amazon RDS 支持的所有版本的 Oracle Database Enterprise Edition。有关更多信息，请参阅 [RDS for Oracle 版本](Oracle.Concepts.database-versions.md)。
您可以在安装 Oracle Database 的主机之外的主机上安装 Oracle Connection Manager。运行 CMAN 的主机不需要单独的许可证。
## CMAN 的要求和限制
为了提供完全托管式体验，Amazon RDS 限制了对操作系统的访问。您无法修改需要操作系统访问权限的数据库参数。因此，Amazon RDS 不支持要求您登录操作系统的 CMAN 功能。
## 配置 CMAN
配置 CMAN 时，您会在 RDS for Oracle 数据库之外执行大部分工作。
**Topics**
+ [步骤 1：在与 RDS for Oracle 实例相同的 VPC 中的 Amazon EC2 实例上配置 CMAN](#oracle-cman.configuring-cman.vpc)
+ [步骤 2：为 CMAN 配置数据库参数](#oracle-cman.configuring-cman.parameters)
+ [步骤 3：将数据库实例与参数组相关联](#oracle-cman.configuring-cman.parameter-group)
### 步骤 1：在与 RDS for Oracle 实例相同的 VPC 中的 Amazon EC2 实例上配置 CMAN
要了解如何设置 CMAN，请按照博客文章《[在 Amazon EC2 上为 Amazon RDS for Oracle 配置和使用 Oracle Connection Manager](https://www.amazonaws.cn/blogs/database/configuring-and-using-oracle-connection-manager-on-amazon-ec2-for-amazon-rds-for-oracle/)》中的详细说明进行操作。
### 步骤 2：为 CMAN 配置数据库参数
对于 CMAN 功能（如 Traffic Director 模式和会话多路复用），请将 `REMOTE_LISTENER` 参数设置为数据库参数组中 CMAN 实例的地址。考虑以下情况：
+ CMAN 实例驻留在具有 IP 地址 `10.0.159.100` 的主机上，并使用端口 `1521`。
+ 数据库 `orcla`、`orclb` 和 `orclc` 位于单独的 RDS for Oracle 数据库实例上。
下表显示了如何设置 `REMOTE_LISTENER` 值。Amazon RDS 自动设置 `LOCAL_LISTENER` 值。
| 数据库实例名称 | 数据库实例 IP | 本地侦听器值（自动设置） | 远程侦听器值（用户设置） |
| --- | --- | --- | --- |
| orcla | 10.0.159.200 | ( address=
(protocol=tcp)
(host=10.0.159.200)
(port=1521)
)
| 10.0.159.100:1521 |
| orclb | 10.0.159.300 | ( address=
(protocol=tcp)
(host=10.0.159.300)
(port=1521)
)
| 10.0.159.100:1521 |
| orclc | 10.0.159.400 | ( address=
(protocol=tcp)
(host=10.0.159.400)
(port=1521)
)
| 10.0.159.100:1521 |
### 步骤 3：将数据库实例与参数组相关联
创建或修改数据库实例，以便使用在 [步骤 2：为 CMAN 配置数据库参数](#oracle-cman.configuring-cman.parameters) 中配置的参数组。有关更多信息，请参阅 [在 Amazon RDS 中将数据库参数组与数据库实例关联](USER_WorkingWithParamGroups.Associating.md)。
# 在 Amazon RDS 上的 Oracle 中安装 Siebel 数据库
您可以使用 Amazon RDS 将 Siebel 数据库托管在 Oracle 数据库实例上。Siebel 数据库是 Siebel 客户关系管理 (CRM) 应用程序架构的一部分。有关说明，请参阅 [Siebel 业务应用程序的通用架构](https://docs.oracle.com/cd/E63029_01/books/PerformTun/performtun_archinfra.htm#i1043361)。
使用以下主题可帮助在 Amazon RDS 上的 Oracle 数据库实例中设置 Siebel 数据库。您还可以了解如何使用 Amazon Web Services 支持 Siebel CRM 应用程序架构所需的其他组件。
**注意**
要在 Amazon RDS 上的 Oracle 中安装 Siebel 数据库，您需要使用主用户账户。您无需 `SYSDBA` 权限；主用户权限就已足够。有关更多信息，请参阅“[主用户账户权限](UsingWithRDS.MasterAccounts.md)”。
## 许可和版本
要在 Amazon RDS 上安装 Siebel 数据库，您必须使用自己的 Oracle Database 许可和 Siebel 许可。您必须拥有与数据库实例类和 Oracle Database 版本对应的 Oracle Database 许可 (及软件更新授权和支持)。有关更多信息，请参阅“[RDS for Oracle 许可选项](Oracle.Concepts.Licensing.md)”。
Oracle Database Enterprise Edition 是 Siebel 针对此场景发布的唯一认证版本。Amazon RDS 支持 Siebel CRM 15.0 版或 16.0 版。
Amazon RDS 支持数据库版本升级。有关更多信息，请参阅“[升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)”。
## 开始前的准备工作
在开始之前，您需要 Amazon VPC。由于您的 Amazon RDS 数据库实例仅需要在 Siebel Enterprise Server (而非公共 Internet) 上可用，因此您的 Amazon RDS 数据库实例将托管在私有子网上，以便提高安全性。有关如何创建 Amazon VPC，从而与 Siebel CRM 配合使用的信息，请参阅 [创建并连接到 Oracle 数据库实例](CHAP_GettingStarted.CreatingConnecting.Oracle.md)。
在开始之前，您还需要 Oracle 数据库实例。有关如何创建用于 Siebel CRM 的 Oracle 数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
## 安装并配置 Siebel 数据库
创建 Oracle 数据库实例后，您可以安装 Siebel 数据库。您可以通过以下方法安装数据库：创建表所有者和管理员账户，安装存储的过程功能，然后运行 Siebel 数据库配置向导。有关更多信息，请参阅[在 RDBMS 上安装 Siebel 数据库](https://docs.oracle.com/cd/E63029_01/books/SiebInstWIN/SiebInstCOM_ConfigDB.html)。
要运行 Siebel 数据库配置向导，您需要使用主用户账户。您无需 `SYSDBA` 权限；主用户权限就已足够。有关更多信息，请参阅“[主用户账户权限](UsingWithRDS.MasterAccounts.md)”。
## 将其他 Amazon RDS 功能与 Siebel 数据库结合使用
创建 Oracle 数据库实例后，可使用其他 Amazon RDS 功能来帮助您自定义 Siebel 数据库。
### 使用 Oracle Statspack 选项收集统计信息
您可以通过使用数据库选项组中的选项向数据库实例添加各项功能。创建 Oracle 数据库实例时，您使用了默认的数据库选项组。如果要向数据库添加功能，您可以为数据库实例创建新的选项组。
如果要收集关于 Siebel 数据库的性能统计数据，您可以添加 Oracle Statspack 功能。有关更多信息，请参阅“[Oracle Statspack](Appendix.Oracle.Options.Statspack.md)”。
有些选项更改将立即应用，另一些选项更改将在数据库实例的下一维护时段内应用。有关更多信息，请参阅“[使用选项组](USER_WorkingWithOptionGroups.md)”。创建自定义选项组后，请修改数据库实例以附加选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
### 使用参数优化性能
您可以使用数据库参数组中的参数来管理数据库引擎配置。创建 Oracle 数据库实例时，您使用了默认的数据库参数组。如果要自定义数据库配置，您可以为数据库实例创建一个新的参数组。
更改参数时，更改可以立即生效，也可以在手动重新启动数据库实例后生效，具体取决于参数类型。有关更多信息，请参阅“[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)”。创建自定义参数组后，请修改数据库实例以附加参数组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
要针对 Siebel CRM 优化 Oracle 数据库实例，您可以自定义某些参数。下表显示了一些推荐的参数设置。有关 Siebel CRM 性能优化的更多信息，请参阅 [Siebel CRM 性能优化指南](https://docs.oracle.com/cd/E63029_01/books/PerformTun/toc.htm)。
****
| 参数名称 | 默认值 | 最佳 Siebel CRM 性能指南 |
| --- | --- | --- |
| \$1always\$1semi\$1join | `CHOOSE` | `OFF` |
| \$1b\$1tree\$1bitmap\$1plans | `TRUE` | `FALSE` |
| \$1like\$1with\$1bind\$1as\$1equality | `FALSE` | `TRUE` |
| \$1no\$1or\$1expansion | `FALSE` | `FALSE` |
| \$1optimizer\$1join\$1sel\$1sanity\$1check | `TRUE` | `TRUE` |
| \$1optimizer\$1max\$1permutations | 2000 | 100 |
| \$1optimizer\$1sortmerge\$1join\$1enabled | `TRUE` | `FALSE` |
| \$1partition\$1view\$1enabled | `TRUE` | `FALSE` |
| open\$1cursors | `300` | 至少 **2000**。 |
### 创建快照
创建 Siebel 数据库后，您可以使用 Amazon RDS 的快照功能来复制数据库。有关更多信息，请参阅“[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)”和“[还原到数据库实例](USER_RestoreFromSnapshot.md)”。
## 对其他 Siebel CRM 组件的支持
除了 Siebel 数据库以外，您还可以使用 Amazon Web Services 来支持 Siebel CRM 应用程序架构的其他组件。可在下表中找到有关 Amazon Amazon 为其他 Siebel CRM 组件提供的支持的更多信息。
****
| Siebel CRM 组件 | Amazon Amazon Support |
| --- | --- |
| Siebel Enterprise (配备一个或多个 Siebel 服务器) | 您可以在 Amazon Elastic Compute Cloud (Amazon EC2) 实例上托管 Siebel 服务器。您可以根据需要使用 Amazon EC2 启动任意数量的虚拟服务器。利用 Amazon EC2，您可以轻松进行向上扩展或向下扩展，以便应对需求变化。有关更多信息，请参阅[什么是 Amazon EC2？](https://docs.amazonaws.cn/AWSEC2/latest/UserGuide/concepts.html) 您可以将服务器与数据库实例放置在同一 VPC 中，并使用 VPC 安全组来访问数据库。有关更多信息，请参阅“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。 |
| Web 服务器 (配备 Siebel Web 服务器扩展) | 您可以在多个 EC2 实例上安装多个 Web 服务器。然后，您可以使用 Elastic Load Balancing 在实例之间分发传入流量。有关更多信息，请参阅[什么是 Elastic Load Balancing？](https://docs.amazonaws.cn/elasticloadbalancing/latest/userguide/elastic-load-balancing.html)。 |
| Siebel 网关名称服务器 | 您可以在 EC2 实例上托管 Siebel 网关名称服务器。然后，您可以将服务器与数据库实例放置在同一 VPC 中，并使用 VPC 安全组访问数据库。有关更多信息，请参阅“[在 VPC 中使用数据库实例](USER_VPC.WorkingWithRDSInstanceinaVPC.md)”。 |
# Oracle Database 引擎版本注释
对 Amazon RDS for Oracle 数据库实例的更新，确保为最新版本。如果您应用更新，则可以确信数据库实例正在运行已由 Oracle 和 Amazon 进行测试的数据库软件版本。我们不支持对单独的 RDS for Oracle 数据库实例应用一次性补丁。
当您创建新的数据库实例时，您可以指定目前支持的任何 Oracle Database 版本。您可以指定主要版本（例如 Oracle Database 19c），以及所指定主要版本的任何受支持的次要版本。如果没有指定版本，Amazon RDS 会默认使用支持的版本，通常是最新的版本。如果指定了主要版本但未指定次要版本，Amazon RDS 将默认使用您指定的主要版本的最新版本。要查看受支持版本的列表以及新建数据库实例的默认值，请使用 [https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-engine-versions.html](https://docs.amazonaws.cn/cli/latest/reference/rds/describe-db-engine-versions.html) Amazon CLI 命令。
有关 Amazon RDS 支持的 Oracle Database 版本的详细信息，请参阅 [https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.amazonaws.cn/AmazonRDS/latest/OracleReleaseNotes/Welcome.html)。