# Amazon RDS for MySQL
Amazon RDS 支持多个 MySQL 版本的数据库实例。有关支持的版本的完整信息，请参阅 [Amazon RDS 上的 MySQL 版本](MySQL.Concepts.VersionMgmt.md)。
要创建 Amazon RDS for MySQL 数据库实例，请使用 Amazon RDS 管理工具或界面。然后，您可执行以下操作：
+ 调整数据库实例大小
+ 授权与您的数据库实例的连接
+ 从备份或快照创建和还原
+ 创建多可用区辅助实例
+ 创建只读副本
+ 监控数据库实例的性能
要存储和访问数据库实例中的数据，请使用标准 MySQL 实用程序和应用程序。
Amazon RDS for MySQL 符合很多行业标准。例如，您可以使用 RDS for MySQL 数据库来构建符合 HIPAA 标准的应用程序。您可以使用 RDS for MySQL 数据库依据与 AWS 签订的业务合作协议 (BAA) 存储与医疗保健相关的信息，包括受保护医疗信息 (PHI)。Amazon RDS for MySQL 还满足联邦风险与授权管理项目 (FedRAMP) 安全要求。此外，在 AWS GovCloud (US) 区域中，Amazon RDS for MySQL 获得了 FedRAMP 联合授权委员会 (JAB) 的 FedRAMP 高基准临时操作授权 (P-ATO)。有关支持的合规性标准的更多信息，请参阅[AWS云合规性](https://aws.amazon.com/compliance/)。
有关每个 MySQL 版本中的功能的信息，请参阅 MySQL 文档中的 [MySQL 的主要功能](https://dev.mysql.com/doc/refman/8.0/en/features.html)。
在创建数据库实例之前，完成[设置 Amazon RDS 环境](CHAP_SettingUp.md) 中的步骤。创建数据库实例时，RDS 主用户将获得 DBA 权限，但有一些限制。此账户用于管理任务，如创建其他数据库账户。
您可执行以下操作：
+ 数据库实例
+ 数据库快照
+ 时间点恢复
+ 自动备份
+ 手动备份
您可以在基于 Amazon VPC 的虚拟私有云 (VPC) 中使用运行 MySQL 的数据库实例。您还可以通过开启各种选项向 MySQL 数据库实例添加功能。Amazon RDS 支持对 MySQL 进行多可用区部署，作为一种高可用性失效转移解决方案。
**重要**
为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。并且还限制了对需要高级权限的某些系统程序和表的访问。您可以使用标准 SQL 客户端（例如 mysql 客户端）访问您的数据库。但是，您无法使用远程登录或安全外壳 (SSH) 直接访问主机。
**Topics**
+ [
# Amazon RDS 上的 MySQL 功能支持
](MySQL.Concepts.FeatureSupport.md)
+ [
# Amazon RDS 上的 MySQL 版本
](MySQL.Concepts.VersionMgmt.md)
+ [
# 连接到 MySQL 数据库实例
](USER_ConnectToInstance.md)
+ [
# 保护 MySQL 数据库实例连接安全
](securing-mysql-connections.md)
+ [
# 使用 Amazon RDS 优化读取提高 RDS for MySQL 的查询性能
](rds-optimized-reads.md)
+ [
# 使用适用于 MySQL 的 RDS 优化型写入功能提高写入性能
](rds-optimized-writes.md)
+ [
# 升级 RDS for MySQL 数据库引擎
](USER_UpgradeDBInstance.MySQL.md)
+ [
# 升级 MySQL 数据库快照引擎版本
](mysql-upgrade-snapshot.md)
+ [
# 将数据导入到 Amazon RDS for MySQL 数据库实例
](MySQL.Procedural.Importing.Other.md)
+ [
# 在 Amazon RDS 中使用 MySQL 复制
](USER_MySQL.Replication.md)
+ [
# 为 RDS for MySQL 配置主动-主动集群
](mysql-active-active-clusters.md)
+ [
# 使用复制从 MySQL 数据库实例中导出数据
](MySQL.Procedural.Exporting.NonRDSRepl.md)
+ [
# 适用于 MySQL 数据库实例的选项
](Appendix.MySQL.Options.md)
+ [
# MySQL 的参数
](Appendix.MySQL.Parameters.md)
+ [
# MySQL 数据库实例的数据库管理员常见任务
](Appendix.MySQL.CommonDBATasks.md)
+ [
# MySQL 数据库实例的本地时区
](MySQL.Concepts.LocalTimeZone.md)
+ [
# Amazon RDS for MySQL 的已知问题和限制
](MySQL.KnownIssuesAndLimitations.md)
+ [
# RDS for MySQL 存储过程参考
](Appendix.MySQL.SQLRef.md)
# Amazon RDS 上的 MySQL 功能支持
RDS for MySQL 支持 MySQL 的大部分特性和功能。有些功能可能仅提供有限支持或受限制的权限。
您可以在[数据库的新增功能？](https://aws.amazon.com/about-aws/whats-new/database/)页面上筛选新的 Amazon RDS 特征。对于 **Products (产品)**，请选择 **Amazon RDS**。然后使用 **MySQL 2022** 之类的关键词进行搜索。
**注意**
以下列表并不详尽。
**Topics**
+ [
## Amazon RDS for MySQL 主要版本上的 MySQL 功能支持
](#MySQL.Concepts.FeatureSupport.MajorVersions)
+ [
## 支持的 RDS for MySQL 存储引擎
](#MySQL.Concepts.Storage)
+ [
## 在 Amazon RDS 上通过 MySQL 使用 memcached 和其他选项
](#MySQL.Concepts.General.Options)
+ [
## Amazon RDS 上 MySQL 的 InnoDB 缓存预热
](#MySQL.Concepts.InnoDBCacheWarming)
+ [
## 有关 RDS for MySQL 8.4 的包容性语言更改
](#mysql-8-4-inclusive-language-changes)
+ [
## Amazon RDS 不支持的 MySQL 功能
](#MySQL.Concepts.Features)
## Amazon RDS for MySQL 主要版本上的 MySQL 功能支持
在以下几节中，可查找有关 Amazon RDS for MySQL 主要版本上的 MySQL 功能支持的信息：
**Topics**
+ [
### Amazon RDS 支持 MySQL 8.4
](#MySQL.Concepts.FeatureSupport.8-4)
有关受支持的 Amazon RDS for MySQL 次要版本的信息，请参阅[Amazon RDS 上支持的 MySQL 次要版本](MySQL.Concepts.VersionMgmt.md#MySQL.Concepts.VersionMgmt.Supported)。
### Amazon RDS 支持 MySQL 8.4
对于运行 MySQL 8.4 或更高版本的数据库实例，Amazon RDS 支持以下新功能。
+ **密码库** – RDS for MySQL 将 OpenSSL 替换为已获得 FIPS 140-3 认证的 AWS Libcrypto（AWS-LC）。有关更多信息，请参阅 AWS-LC GitHub 存储库（网址为 [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc)）。
+ **TLS 更改** – RDS for MySQL 仅支持 TLS 1.2 和 TLS 1.3。有关更多信息，请参阅 [Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)。
+ **Memcached 支持** – Memcached 接口在 MySQL 8.4 上不再可用。有关更多信息，请参阅 [MySQL memcached 支持](Appendix.MySQL.Options.memcached.md)。
+ **默认身份验证插件** - 默认身份验证插件是 `caching_sha2_password`。有关更多信息，请参阅 [MySQL 默认身份验证插件](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.authentication-plugin)。
+ **`mysqlpump` 客户端实用工具** – MySQL 8.4 中不再提供 `mysqlpump` 客户端实用工具。有关更多信息，请参阅《AWS 规范性指南》中的 [RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)以及 [mysqldump and mysqlpump](https://docs.aws.amazon.com/prescriptive-guidance/latest/migration-large-mysql-mariadb-databases/mysqldump-and-mysqlpump.html)。**
+ **托管复制存储过程** - 在使用这些存储过程管理复制时，如果其复制用户配置了 `caching_sha2_password`，则必须通过指定 `SOURCE_SSL=1` 来配置 TLS。`caching_sha2_password` 是 RDS for MySQL 8.4 的默认身份验证插件。
+ **参数行为更改** - MySQL 8.4 的以下参数已更改。
+ `innodb_dedicated_server` – 此参数默认处于启用状态。有关更多信息，请参阅 [在 MySQL 8.4 中配置缓冲池大小和重做日志容量](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md)。
+ `innodb_buffer_pool` – 数据库引擎现在计算此参数，但您可以覆盖此设置。有关更多信息，请参阅 [在 MySQL 8.4 中配置缓冲池大小和重做日志容量](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md)。
+ `innodb_redo_log_capacity` – 此参数现在控制重做日志文件的大小。数据库引擎现在计算此参数，但您可以覆盖此设置。有关更多信息，请参阅 [在 MySQL 8.4 中配置缓冲池大小和重做日志容量](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md)。
+ **已弃用或删除的参数** – RDS for MySQL 从 MySQL 8.4 数据库实例的参数组中删除了以下参数。`innodb_redo_log_capacity` 参数现在控制重做日志文件的大小。
+ `innodb_log_file_size`
+ `innodb_log_files_in_group`
+ **参数的新默认值** – 对于 MySQL 8.4 数据库实例，以下参数具有新的默认值：
+ 与性能相关的各种 MySQL 社区参数发生了更改。有关更多信息，请参阅 [What is New in MySQL 8.4 since MySQL 8.0](https://dev.mysql.com/doc/refman/8.4/en/mysql-nutshell.html)。
建议您在迁移生产实例之前，在 RDS for MySQL 8.4 上测试应用程序的性能。
+ `innodb_purge_threads` – 将默认值设置为公式 `LEAST({DBInstanceVCPU/2},4)`，以防止 InnoDB 历史记录列表长度变得过大。
+ `group_replication_exit_state_action` – 默认值为 `OFFLINE_MODE`，这与 MySQL 社区中的默认值一致。有关更多信息，请参阅 [RDS for MySQL 主动-主动集群的注意事项和最佳实践](mysql-active-active-clusters-considerations-limitations.md#mysql-active-active-clusters-considerations)。
+ `binlog_format` – 默认值为 `ROW`，这与 MySQL 社区中的默认值一致。您可以修改单可用区数据库实例或多可用区数据库实例的参数，但多可用区数据库集群的参数不可修改。多可用区数据库集群使用半同步复制，当 `binlog_format` 设置为 `MIXED` 或 `STATEMENT` 时，复制将失败。
+ **包容性语言更改** – RDS for MySQL 8.4 包含自 RDS for MySQL 8.0 起，与包容性语言的关键字和系统架构相关的更改。有关更多信息，请参阅 [有关 RDS for MySQL 8.4 的包容性语言更改](#mysql-8-4-inclusive-language-changes)。
要查看所有 MySQL 8.4 功能和更改的列表，请参阅 MySQL 文档中的 [What is New in MySQL 8.4 since MySQL 8.0](https://dev.mysql.com/doc/refman/8.4/en/mysql-nutshell.html)。
有关不支持特征的列表，请参阅 [Amazon RDS 不支持的 MySQL 功能](#MySQL.Concepts.Features)。
## 支持的 RDS for MySQL 存储引擎
虽然 MySQL 支持功能不同的多种存储引擎，但并非所有引擎都为恢复和数据持久性进行了优化。Amazon RDS 完全支持 MySQL 数据库实例的 InnoDB 存储引擎。Amazon RDS 的时间点恢复和快照恢复功能要求使用恢复存储引擎，且仅支持 InnoDB 存储引擎。有关更多信息，请参阅 [MySQL memcached 支持](Appendix.MySQL.Options.memcached.md)。
Amazon RDS for MySQL 当前不支持联合存储引擎。
对于用户创建的架构，MyISAM 存储引擎不支持可靠的恢复，并且在恢复后重新启动 MySQL 时可能会导致数据丢失或损坏，使时间点还原或快照还原无法发挥预期的作用。不过，如果您仍选择配合使用 MyISAM 和 Amazon RDS，在某些情况下，快照可能也会有所帮助。
**注意**
`mysql` 架构中的系统表可以位于 MyISAM 存储中。
如果要将现有的 MyISAM 表转换为 InnoDB 表，您可以使用 `ALTER TABLE` 命令（例如，`alter table TABLE_NAME engine=innodb;`）。请注意，MyISAM 和 InnoDB 各有优点和缺点，所以在执行前请充分评估转换可能对您的应用程序造成的影响。
Amazon RDS 不再支持 MySQL 5.1、5.5 和 5.6。但您可以还原现有的 MySQL 5.1、5.5 和 5.6 快照。在还原 MySQL 5.1、5.5 和 5.6 快照时，数据库实例将自动升级到 MySQL 5.7。
## 在 Amazon RDS 上通过 MySQL 使用 memcached 和其他选项
大多数 Amazon RDS 数据库引擎均支持一些选项组，通过这些选项组，可选择其他功能用于数据库实例。RDS for MySQL 数据库实例支持 `memcached` 选项，它是一个简单的基于键的缓存。有关 `memcached` 和其他选项的更多信息，请参阅[适用于 MySQL 数据库实例的选项](Appendix.MySQL.Options.md)。有关使用选项组的详细信息，请参阅[使用选项组](USER_WorkingWithOptionGroups.md)。
## Amazon RDS 上 MySQL 的 InnoDB 缓存预热
InnoDB 缓存预热可为您的 MySQL DB 实例提供性能收益，方式是在数据库实例关闭时保存缓冲池的当前状态，然后在数据库实例启动时从保存的信息重新加载缓冲池。这将不再需要缓冲池使用常规数据库进行“预热”，而是预加载具有已知常见查询的页的缓冲池。存储已保存缓冲池信息的文件仅存储缓冲池内的页的元数据，而不是存储页本身。因此，此文件需要的存储空间不多。此文件的大小约为缓存大小的 0.2%。例如，对于 64 GiB 的缓存，缓存预热文件大小为 128 MiB。有关 InnoDB 缓存预热的更多信息，请参阅 MySQL 文档中的[保存和还原缓冲池状态](https://dev.mysql.com/doc/refman/8.0/en/innodb-preload-buffer-pool.html)。
RDS for MySQL 数据库实例支持 InnoDB 缓存预热。要启用 InnoDB 缓存预热，请将数据库实例的参数组中的 `innodb_buffer_pool_dump_at_shutdown` 和 `innodb_buffer_pool_load_at_startup` 参数设置为 1。更改参数组中的这些参数值将影响使用该参数组的所有 MySQL 数据库实例。要为特定 MySQL 数据库实例启用 InnoDB 缓存预热，您可能需要为这些实例创建新的参数组。有关参数组的信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
InnoDB 缓存预热主要为使用标准存储的数据库实例提供性能收益。如果您使用 PIOPS 存储，则通常看不到显著的性能收益。
**重要**
如果您的 MySQL 数据库实例未正常关闭（例如，在失效转移期间），则缓冲池状态将不会保存到磁盘。在此情况下，MySQL 将在重新启动数据库实例时加载任何可用的缓冲池文件。这不会造成任何损害，但还原后的缓冲池可能不会反映缓冲池在重新启动前的最新状态。要确保您拥有启动时可用于预热 InnoDB 缓存的缓冲池的最新状态，建议您定期“按需”转储缓冲池。
您可创建事件来定期自动转储缓冲池。例如，以下语句创建一个名为 `periodic_buffer_pool_dump` 的事件，该事件每小时转储一次缓冲池。
```
1. CREATE EVENT periodic_buffer_pool_dump
2. ON SCHEDULE EVERY 1 HOUR
3. DO CALL mysql.rds_innodb_buffer_pool_dump_now();
```
有关 MySQL 事件的更多信息，请参阅 MySQL 文档中的[事件语法](https://dev.mysql.com/doc/refman/8.0/en/events-syntax.html)。
### 按需转储和加载缓冲池
您可“按需”保存和加载 InnoDB 缓存。
+ 要将缓冲池的当前状态转储到磁盘，请调用 [mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_dump_now) 存储过程。
+ 要从磁盘加载缓冲池的已保存状态，请调用 [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_now) 存储过程。
+ 要取消正在进行的加载操作，请调用 [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_abort) 存储过程。
## 有关 RDS for MySQL 8.4 的包容性语言更改
RDS for MySQL 8.4 包含 MySQL 8.4 社区版本中与包容性语言的关键字和系统架构相关的更改。例如，`SHOW REPLICA STATUS` 命令替换了 `SHOW SLAVE STATUS`。
**Topics**
+ [
### 配置参数名称更改
](#mysql-8-4-inclusive-language-changes-params)
+ [
### 存储过程名称更改
](#mysql-8-4-inclusive-language-changes-sp)
### 配置参数名称更改
以下配置参数在 RDS for MySQL 8.4 中具有新名称。
为实现兼容，您可以在 `mysql` 客户端使用任何一个名称检查参数名称。当修改自定义 MySQL 8.4 参数组中的值时，只能使用新名称。有关更多信息，请参阅 [原定设置和自定义参数组](parameter-groups-overview.md#parameter-groups-overview.custom)。
| 要删除的名称 | 新名称或首选名称 |
| --- | --- |
| `init_slave` | `init_replica` |
| `log_slave_updates` | `log_replica_updates` |
| `log_slow_slave_statements` | `log_slow_replica_statements` |
| `rpl_stop_slave_timeout` | `rpl_stop_replica_timeout` |
| `skip_slave_start` | `skip_replica_start` |
| `slave_checkpoint_group` | `replica_checkpoint_group` |
| `slave_checkpoint_period` | `replica_checkpoint_period` |
| `slave_compressed_protocol` | `replica_compressed_protocol` |
| `slave_exec_mode` | `replica_exec_mode` |
| `slave_load_tmpdir` | `replica_load_tmpdir` |
| `slave_max_allowed_packet` | `replica_max_allowed_packet` |
| `slave_net_timeout` | `replica_net_timeout` |
| `slave_parallel_type` | `replica_parallel_type` |
| `slave_parallel_workers` | `replica_parallel_workers` |
| `slave_pending_jobs_size_max` | `replica_pending_jobs_size_max` |
| `slave_preserve_commit_order` | `replica_preserve_commit_order` |
| `slave_skip_errors` | `replica_skip_errors` |
| `slave_sql_verify_checksum` | `replica_sql_verify_checksum` |
| `slave_transaction_retries` | `replica_transaction_retries` |
| `slave_type_conversions` | `replica_type_conversions` |
| `sql_slave_skip_counter` | `sql_replica_skip_counter` |
**注意**
参数 `replica_allow_batching` 不可用，因为 Amazon RDS 不支持 NDB 集群。
### 存储过程名称更改
以下存储过程在 RDS for MySQL 8.4 中具有新名称。
为实现兼容，您可以在 RDS for MySQL 8.4 初始版本中使用任一名称。未来版本将删除旧的过程名称。有关更多信息，请参阅 [配置、启动和停止二进制日志（binlog）复制](mysql-stored-proc-replicating.md)。
| 要删除的名称 | 新名称或首选名称 |
| --- | --- |
| `mysql.rds_next_master_log` | `mysql.rds_next_source_log ` |
| `mysql.rds_reset_external_master` | `mysql.rds_reset_external_source` |
| `mysql.rds_set_external_master` | `mysql.rds_set_external_source` |
| `mysql.rds_set_external_master_with_auto_position` | `mysql.rds_set_external_source_with_auto_position` |
| `mysql.rds_set_external_master_with_delay` | `mysql.rds_set_external_source_with_delay` |
| `mysql.rds_set_master_auto_position` | `mysql.rds_set_source_auto_position` |
## Amazon RDS 不支持的 MySQL 功能
Amazon RDS 当前不支持以下 MySQL 功能：
+ 身份验证插件
+ 将错误记录到系统日志
+ InnoDB 表空间加密
+ NDB 集群
+ 密码强度插件
+ 永久保存的系统变量
+ Rewriter 查询重写插件
+ 半同步复制，多可用区数据库集群除外
+ 可传输的表空间
+ X 插件
为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。并且它还限制了对需要高级权限的某些系统程序和表的访问。Amazon RDS 支持使用任何标准 SQL 客户端应用程序访问数据库实例上的数据库。Amazon RDS 不允许使用 Telnet、安全外壳（SSH）或 Windows 远程桌面连接直接从主机访问数据库实例。创建数据库实例时，系统会将您分配为该实例上所有数据库的 *db\$1owner*，并且您将具有除用于备份的权限以外的所有数据库级别权限。Amazon RDS 会为您管理备份。
# Amazon RDS 上的 MySQL 版本
对于 MySQL，版本号的组织方式为版本 = X.Y.Z。在 Amazon RDS 术语中，X.Y 表示主要版本号，Z 是次要版本号。对于 Amazon RDS 实现，如果主要版本号更改，则将版本更改视为重大更改—例如，从版本 5.7 更改为 8.0。如果只有次要版本号发生更改（例如，从版本 8.0.32 更改为 8.0.34），则将版本更改视为次要更改。
**Topics**
+ [
## Amazon RDS 上支持的 MySQL 次要版本
](#MySQL.Concepts.VersionMgmt.Supported)
+ [
## Amazon RDS 上支持的 MySQL 主要版本
](#MySQL.Concepts.VersionMgmt.ReleaseCalendar)
+ [
## 适用于 RDS for MySQL 的 Amazon RDS 扩展支持版本
](#mysql-extended-support-releases)
+ [
## 使用数据库预览环境
](#mysql-working-with-the-database-preview-environment)
+ [
## 数据库预览环境中的 MySQL 版本 9.5
](#mysql-preview-environment-version-9-5)
+ [
## 数据库预览环境中的 MySQL 版本 9.4
](#mysql-preview-environment-version-9-4)
+ [
## 数据库预览环境中的 MySQL 版本 9.3
](#mysql-preview-environment-version-9-3)
+ [
## Amazon RDS for MySQL 已弃用的版本
](#MySQL.Concepts.DeprecatedVersions)
## Amazon RDS 上支持的 MySQL 次要版本
Amazon RDS 目前支持 MySQL 的以下次要版本。
**注意**
Amazon RDS 扩展支持不适用于次要版本。
下表显示了 Amazon RDS 当前支持的 MySQL 8.4 的次要版本。
| MySQL 引擎版本 | 社区发布日期 | RDS 发布日期 | RDS 标准支持终止日期 |
| --- | --- | --- | --- |
| 8.4.8 | 2026 年 1 月 20 日 | 2026 年 2 月 3 日 | 2027 年 2 月 3 日 |
| 8.4.7 | 2025 年 10 月 21 日 | 2025 年 11 月 13 日 | 2026 年 11 月 30 日 |
| 8.4.6 | 2025 年 7 月 22 日 | 2025 年 8 月 1 日 | 2026 年 9 月 30 日 |
| 8.4.5 | 2025 年 4 月 15 日 | 2025 年 4 月 29 日 | 2026 年 9 月 30 日 |
| 8.4.4 | 2025 年 1 月 21 日 | 2025 年 2 月 19 日 | 2026 年 5 月 31 日 |
| 8.4.3 | 2024 年 10 月 15 日 | 2024 年 11 月 21 日 | 2026 年 5 月 31 日 |
下表显示了 Amazon RDS 当前支持的 MySQL 8.0 的次要版本。
**注意**
次要版本可以先于主要版本终止标准支持。例如，次要版本 8.0.28 的标准支持终止日期为 2024 年 3 月 28 日，而主要版本 8.0 的标准支持终止日期为 2026 年 7 月 31 日。RDS 将支持 MySQL 社区在这两个日期之间发布的其他 8.0.\$1 次要版本。建议您尽快将所有主要版本升级到可用的最新次要版本。
| MySQL 引擎版本 | 社区发布日期 | RDS 发布日期 | RDS 标准支持终止日期 |
| --- | --- | --- | --- |
| 8.0.45 | 2026 年 1 月 20 日 | 2026 年 2 月 3 日 | 2026 年 7 月 31 日 |
| 8.0.44 | 2025 年 10 月 21 日 | 2025 年 11 月 13 日 | 2026 年 7 月 31 日 |
| 8.0.43 | 2025 年 7 月 22 日 | 2025 年 8 月 1 日 | 2026 年 7 月 31 日 |
| 8.0.42 | 2025 年 4 月 15 日 | 2025 年 4 月 29 日 | 2026 年 7 月 31 日 |
| 8.0.41 | 2025 年 1 月 21 日 | 2025 年 2 月 19 日 | 2026 年 5 月 31 日 |
| 8.0.40 | 2024 年 10 月 15 日 | 2024 年 11 月 13 日 | 2026 年 5 月 31 日 |
下表显示了 Amazon RDS 扩展支持下可用的 MySQL 5.7 的次要版本。
**注意**
次要版本可能先于主要版本到达扩展支持终止日期。例如，次要版本 5.7.44-RDS.20240529 将于 2025 年 9 月到达扩展支持终止日期，而主要版本 5.7 将于 2027 年 2 月 28 日到达该日期。RDS 将在这些日期之间生成并发布其他 5.7.44-rds.xxyyzz 次要版本。建议您尽快将所有主要版本升级到可用的最新次要版本。
| MySQL 引擎版本 | 社区发布日期 | RDS 发布日期 | RDS 扩展支持终止日期 |
| --- | --- | --- | --- |
| 5.7.44-RDS.20260212\$1 | 不适用 | 2026 年 2 月 26 日 | 2027 年 2 月 28 日 |
| 5.7.44-RDS.20251212\$1 | 不适用 | 2025 年 12 月 12 日 | 2026 年 12 月 30 日 |
| 5.7.44-RDS.20250818\$1 | 不适用 | 2025 年 9 月 15 日 | 2026 年 9 月 30 日 |
| 5.7.44-RDS.20250508\$1 | 不适用 | 2025 年 5 月 20 日 | 2026 年 9 月 30 日 |
| 5.7.44-RDS.20250213\$1 | 不适用 | 2025 年 3 月 12 日 | 2026 年 9 月 30 日 |
| 5.7.44-RDS.20250103\$1 | 不适用 | 2025 年 2 月 13 日 | 2026 年 5 月 31 日 |
\$1 MySQL 社群已停用主要版本 5.7，并且不会发布新的次要版本。这是 Amazon RDS 发布的次要版本，包含适用于 MySQL 5.7 数据库的关键安全补丁和错误修复，这些补丁和错误修复在 RDS 扩展支持涵盖范围内。有关这些次要版本的更多信息，请参阅[适用于 RDS for MySQL 的 Amazon RDS 扩展支持版本](#mysql-extended-support-releases)。有关 RDS 扩展支持的更多信息，请参阅[Amazon RDS 的 Amazon RDS 扩展支持](extended-support.md)。
在创建新数据库实例时，您可以指定目前支持的任何 MySQL 版本。您可以指定主要版本（例如 MySQL 5.7），以及所指定主要版本的任何受支持的次要版本。如果没有指定版本，Amazon RDS 会默认使用支持的版本，通常是最新的版本。如果指定了主要版本但未指定次要版本，Amazon RDS 将默认使用您指定的主要版本的最新版本。要查看受支持版本的列表以及新建数据库实例的默认值，请运行 [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html) AWS CLI 命令。
例如，要列出 RDS For MySQL 支持的引擎版本，请运行以下 CLI 命令：
```
aws rds describe-db-engine-versions --engine mysql --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
默认 MySQL 版本可能因 AWS 区域而异。要创建具有特定次要版本的数据库实例，请在数据库实例创建过程中指定次要版本。可以通过运行以下 AWS CLI 命令来确定 AWS 区域的默认次要版本：
```
aws rds describe-db-engine-versions --default-only --engine mysql --engine-version major_engine_version --region region --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
将 *major\$1engine\$1version* 替换为主要引擎版本，并将 *region* 替换为 AWS 区域。例如，以下 AWS CLI 命令返回 5.7 主要版本和美国西部（俄勒冈州）AWS 区域 (us-west-2) 的默认 MySQL 次要引擎版本：
```
aws rds describe-db-engine-versions --default-only --engine mysql --engine-version 5.7 --region us-west-2 --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
借助于 Amazon RDS，您就可以控制何时将 MySQL 实例升级到 Amazon RDS 支持的新主要版本。可与 MySQL 的特定版本保持兼容、对应用程序测试新版本，然后再部署到生产环境中以及在最适合计划的时间执行主要版本升级。
启用自动次要版本升级后，您的数据库实例将自动升级到 Amazon RDS 支持的新 MySQL 次要版本。此修补在计划的维护时段内进行。您可以修改数据库实例以启用或禁用自动次要版本升级。
如果选择退出自动计划的升级，您可以按照与主要版本更新相同的步骤手动升级到支持的次要版本。有关信息，请参阅[升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)。
Amazon RDS 目前支持 MySQL 数据库引擎的以下主要版本升级：
+ MySQL 5.7 到 MySQL 8.0
+ MySQL 8.0 到 MySQL 8.4
由于主要版本升级涉及某些兼容性风险，所以不会自行进行；您必须发出修改数据库实例的请求。您应当在升级生产实例前全面测试任何升级。有关升级 MySQL 数据库实例的信息，请参阅[升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。
在版本升级前，您可以针对新的版本测试数据库实例，方法是：创建现有数据库实例的数据库快照，从该数据库快照进行还原以创建新的数据库实例，然后对新的数据库实例启动版本升级。然后，则可以在升级的数据库实例克隆上安全测试，再决定是否升级原始的数据库实例。
### Amazon RDS 上的 MySQL 次要版本
有关 MySQL 社区对次要版本所做的更改，请参阅 Oracle 网站上的 [Critical Patch Updates, Security Alerts and Bulletins](https://www.oracle.com/security-alerts/)。在**关键补丁更新**下，选择 Oracle 发布次要版本的月份。然后，在**受影响的产品和版本**下选择 MySQL 次要版本。
**Topics**
+ [
#### MySQL 版本 8.4.8
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.4.8)
+ [
#### MySQL 版本 8.4.7
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.4.7)
+ [
#### MySQL 版本 8.4.6
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.4.6)
+ [
#### MySQL 版本 8.4.5
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.4.5)
+ [
#### MySQL 版本 8.4.4
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.4.4)
+ [
#### MySQL 版本 8.0.45
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.45)
+ [
#### MySQL 版本 8.0.44
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.44)
+ [
#### MySQL 版本 8.0.43
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.43)
+ [
#### MySQL 版本 8.0.42
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.42)
+ [
#### MySQL 版本 8.0.41
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.41)
+ [
#### MySQL 版本 8.0.40
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.40)
+ [
#### MySQL 版本 8.0.39
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.39)
+ [
#### MySQL 版本 8.0.37
](#MySQL.Concepts.VersionMgmt.Supported.Minor.8.0.37)
#### MySQL 版本 8.4.8
MySQL 版本 8.4.8 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025c`。
+ 修复了可能导致某些 SQL 语句无法记录在审计日志中的问题。
#### MySQL 版本 8.4.7
MySQL 版本 8.4.7 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
#### MySQL 版本 8.4.6
MySQL 版本 8.4.6 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
#### MySQL 版本 8.4.5
MySQL 版本 8.4.5 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025b`。
#### MySQL 版本 8.4.4
MySQL 版本 8.4.4 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025a`。
+ 修复了在执行 Amazon RDS 存储过程 `mysql.rds_set_configuration` 和 `mysql.rds_kill` 时导致排序规则错误的错误。
#### MySQL 版本 8.0.45
MySQL 版本 8.0.45 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025c`。
+ 修复了可能导致某些 SQL 语句无法记录在审计日志中的问题。
#### MySQL 版本 8.0.44
MySQL 版本 8.0.44 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
#### MySQL 版本 8.0.43
MySQL 版本 8.0.43 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
#### MySQL 版本 8.0.42
MySQL 版本 8.0.42 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025b`。
#### MySQL 版本 8.0.41
MySQL 版本 8.0.41 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 更新了时区信息，使其基于 `tzdata2025a`。
+ 修复了在执行 Amazon RDS 存储过程 `mysql.rds_set_configuration` 和 `mysql.rds_kill` 时导致排序规则错误的错误。
#### MySQL 版本 8.0.40
MySQL 版本 8.0.40 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 修复了导致数据库升级期间字符集匹配失败的错误。
#### MySQL 版本 8.0.39
MySQL 版本 8.0.39 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 修复了阻止 `sql_log_off` 正确使用 `SESSION_VARIABLES_ADMIN` 权限的错误。
+ 修复了阻止主用户能够向其他数据库用户授予 `SESSION_VARIABLE_ADMIN` 权限的错误。
+ 修复了在执行 RDS 提供的存储过程时导致非法混合排序规则的错误。
#### MySQL 版本 8.0.37
MySQL 版本 8.0.37 现在可在 Amazon RDS 上使用。此版本包含由 MySQL 社区和 Amazon RDS 添加的修复和改进。
**新功能和增强功能**
+ 修复了一个错误，该错误在执行即时 DDL 语句后执行 UPDATE 时会导致断言失败。
## Amazon RDS 上支持的 MySQL 主要版本
RDS for MySQL 主要版本至少会在相应社区版本的社区生命周期终止前，在标准支持下保持可用状态。在 RDS 标准支持终止日期之后，您可以继续运行主要版本，但需付费。有关更多信息，请参阅[Amazon RDS 的 Amazon RDS 扩展支持](extended-support.md)和 [Amazon RDS for MySQL 定价](https://aws.amazon.com/rds/mysql/pricing/)。
您可以参照下列日期规划您的测试和升级周期。
**注意**
您还可以使用 AWS CLI 或 RDS API 查看有关主要引擎版本支持日期的信息。有关更多信息，请参阅 [在 Amazon RDS 扩展支持中查看引擎版本的支持日期](extended-support-viewing-support-dates.md)。
| MySQL 主要版本 | 社区发布日期 | RDS 发布日期 | 社区生命周期终止日期 | RDS 标准支持终止日期 | RDS 扩展支持第 1 年定价开始日期 | RDS 扩展支持第 3 年定价开始日期 | RDS 扩展支持终止日期 |
| --- | --- | --- | --- | --- | --- | --- | --- |
| MySQL 8.4 | 2024 年 4 月 30 日 | 2024 年 11 月 21 日 | 2029 年 4 月 30 日 | 2029 年 7 月 31 日 | 2029 年 8 月 1 日 | 2031 年 8 月 1 日 | 2032 年 7 月 31 日 |
| MySQL 8.0 | 2018 年 4 月 19 日 | 2018 年 10 月 23 日 | 2026 年 4 月 30 日 | 2026 年 7 月 31 日 | 2026 年 8 月 1 日 | 2028 年 8 月 1 日 | 2029 年 7 月 31 日 |
| MySQL 5.7\$1 | 2015 年 10 月 21 日 | 2016 年 2 月 22 日 | 2023 年 10 月 31 日 | 2024 年 2 月 29 日 | 2024 年 3 月 1 日 | 2026 年 3 月 1 日 | 2027 年 2 月 28 日 |
\$1 MySQL 5.7 现已提供 RDS 扩展支持。有关更多信息，请参阅 [Amazon RDS 的 Amazon RDS 扩展支持](extended-support.md)。
## 适用于 RDS for MySQL 的 Amazon RDS 扩展支持版本
以下内容列出了适用于 RDS for MySQL 版本的所有 RDS 扩展支持发行版。
**Topics**
+ [
### RDS for MySQL 版本 5.7.44-RDS.20260212 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-RDS.20260212)
+ [
### RDS for MySQL 版本 5.7.44-RDS.20251212 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-RDS.20251212)
+ [
### RDS for MySQL 版本 5.7.44-RDS.20250818 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-RDS.20250818)
+ [
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250508 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20250508)
+ [
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250213 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20250213)
+ [
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250103 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20250103)
+ [
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20240808 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20240808)
+ [
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20240529 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20240529)
+ [
### RDS for MySQL 版本 5.7.44-RDS.20240408 的 RDS 扩展支持
](#mysql-extended-support-releases-version-5.7.44-20240408)
### RDS for MySQL 版本 5.7.44-RDS.20260212 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20260212 的 RDS 扩展支持已发布。
**已修复错误：**
+ 刷新用于测试错误 22295186 的修复的测试证书。
+ 修复了 blob 列上带有前缀索引的内存泄漏问题。
**已修复 CVE：**
+ [CVE-2026-21936](https://nvd.nist.gov/vuln/detail/CVE-2026-21936)
+ [CVE-2026-21968](https://nvd.nist.gov/vuln/detail/CVE-2026-21968)
+ [CVE-2026-21941](https://nvd.nist.gov/vuln/detail/CVE-2026-21941)
+ [CVE-2026-21948](https://nvd.nist.gov/vuln/detail/CVE-2026-21948)
### RDS for MySQL 版本 5.7.44-RDS.20251212 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20251212 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了缓冲池大小超过上限时服务器启动的问题。
+ 修复了从 `INFORMATION_SCHEMA.INNODB_LOCKS` 中读取导致服务器异常退出的问题。
+ 修复了 MySQL 测试运行（MTR）中与 JUnit 报告支持有关的问题。
+ 修复了使用 `-DWITH_INNODB_MEMCACHED=ON` 选项构建时的编译问题。
+ 修复了在执行 MySQL 测试运行（MTR）时因错误 25182306 而导致的问题。
**已修复 CVE：**
+ [CVE-2025-53054](https://nvd.nist.gov/vuln/detail/CVE-2025-53054)
+ [CVE-2025-53044](https://nvd.nist.gov/vuln/detail/CVE-2025-53044)
+ [CVE-2025-53045](https://nvd.nist.gov/vuln/detail/CVE-2025-53045)
+ [CVE-2025-53062](https://nvd.nist.gov/vuln/detail/CVE-2025-53062)
+ [CVE-2025-53040](https://nvd.nist.gov/vuln/detail/CVE-2025-53040)
+ [CVE-2025-53042](https://nvd.nist.gov/vuln/detail/CVE-2025-53042)
+ [CVE-2025-53067](https://nvd.nist.gov/vuln/detail/CVE-2025-53067)
### RDS for MySQL 版本 5.7.44-RDS.20250818 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20250818 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了当服务器以 `autocommit=OFF` 模式运行时，查询重写插件失败的问题。
+ 修复了阻止 Debian 和 Ubuntu build 在无根模式下运行的权限问题。
+ 修复了错误 30875669 缺少更新的更新。
**已修复 CVE：**
+ [CVE-2025-50082](https://nvd.nist.gov/vuln/detail/CVE-2025-50082)
+ [CVE-2025-50083](https://nvd.nist.gov/vuln/detail/CVE-2025-50083)
+ [CVE-2025-50079](https://nvd.nist.gov/vuln/detail/CVE-2025-50079)
+ [CVE-2025-50084](https://nvd.nist.gov/vuln/detail/CVE-2025-50084)
+ [CVE-2025-50087](https://nvd.nist.gov/vuln/detail/CVE-2025-50087)
+ [CVE-2025-50091](https://nvd.nist.gov/vuln/detail/CVE-2025-50091)
+ [CVE-2025-50101](https://nvd.nist.gov/vuln/detail/CVE-2025-50101)
+ [CVE-2025-50102](https://nvd.nist.gov/vuln/detail/CVE-2025-50102)
+ [CVE-2025-50098](https://nvd.nist.gov/vuln/detail/CVE-2025-50098)
+ [CVE-2025-53023](hhttps://nvd.nist.gov/vuln/detail/CVE-2025-53023)
+ [CVE-2025-50081](https://nvd.nist.gov/vuln/detail/CVE-2025-50081)
+ [CVE-2025-50085](https://nvd.nist.gov/vuln/detail/CVE-2025-50085)
+ [CVE-2025-50077](https://nvd.nist.gov/vuln/detail/CVE-2025-50077)
+ [CVE-2025-50088](https://nvd.nist.gov/vuln/detail/CVE-2025-50088)
+ [CVE-2025-50092](https://nvd.nist.gov/vuln/detail/CVE-2025-50092)
+ [CVE-2025-50099](https://nvd.nist.gov/vuln/detail/CVE-2025-50099)
+ [CVE-2025-50096](https://nvd.nist.gov/vuln/detail/CVE-2025-50096)
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250508 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20250508 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了当 `index_id` 大于最大 `uint32` 时回滚后虚拟索引不稳定的问题。
+ 修复了测试因内存问题而失败的问题。
+ 修复了 `` 对于 `Execute` 为空的问题。
+ 修复了使用 GCC 14 [noclose 5.7] 编译 MySQL 的问题。
**已修复 CVE：**
+ [CVE-2025-30682](https://nvd.nist.gov/vuln/detail/CVE-2025-30682)
+ [CVE-2025-30687](https://nvd.nist.gov/vuln/detail/CVE-2025-30687)
+ [CVE-2025-30688](https://nvd.nist.gov/vuln/detail/CVE-2025-30688)
+ [CVE-2025-21581](https://nvd.nist.gov/vuln/detail/CVE-2025-21581)
+ [CVE-2025-21585](https://nvd.nist.gov/vuln/detail/CVE-2025-21585)
+ [CVE-2025-30689](https://nvd.nist.gov/vuln/detail/CVE-2025-30689)
+ [CVE-2025-30722](https://nvd.nist.gov/vuln/detail/CVE-2025-30722)
+ [CVE-2025-21577](https://nvd.nist.gov/vuln/detail/CVE-2025-21577)
+ [CVE-2025-30693](https://nvd.nist.gov/vuln/detail/CVE-2025-30693)
+ [CVE-2025-30695](https://nvd.nist.gov/vuln/detail/CVE-2025-30695)
+ [CVE-2025-30703](https://nvd.nist.gov/vuln/detail/CVE-2025-30703)
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250213 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20250213 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了 InnoDB 失败断言 `result != FTS_INVALID`。
+ 修复了在 `ALTER TABLE` 操作使用 `INPLACE` 算法重建 InnoDB 表后，空间索引崩溃和广泛损坏的问题。
+ 修复了在 `ON DELETE CASCADE` 时，在 `innobase_get_computed_value` 中生成列崩溃的问题。
+ 修复了 `row_MySQL_pad_col` 中的断言失败。
+ 修复了在线 DDL 导致以下错误的问题：`ERROR 1712 (HY000): Index PRIMARY is corrupted`。
+ 修复了 `Item_rollup_sum_switcher::current_arg` 的崩溃问题。
+ 修复了在 `DROP USER` 时未刷新数据库缓存的问题。
+ 修复了 `my_print_help` 中的缓冲区溢出问题。
+ 修复了一个 InnoDB 问题，即 `FULLTEXT` 索引将 `FTS_DOC_ID` 限制为最大无符号 32 位值。
**已修复 CVE：**
+ [CVE-2025-21497](https://nvd.nist.gov/vuln/detail/CVE-2025-21497)
+ [CVE-2025-21555](https://nvd.nist.gov/vuln/detail/CVE-2025-21555)
+ [CVE-2025-21559](https://nvd.nist.gov/vuln/detail/CVE-2025-21559)
+ [CVE-2025-21490](https://nvd.nist.gov/vuln/detail/CVE-2025-21490)
+ [CVE-2025-21491](https://nvd.nist.gov/vuln/detail/CVE-2025-21491)
+ [CVE-2025-21500](https://nvd.nist.gov/vuln/detail/CVE-2025-21500)
+ [CVE-2025-21501](https://nvd.nist.gov/vuln/detail/CVE-2025-21501)
+ [CVE-2025-21540](https://nvd.nist.gov/vuln/detail/CVE-2025-21540)
+ [CVE-2025-21543](https://nvd.nist.gov/vuln/detail/CVE-2025-21543)
+ [CVE-2025-21520](https://nvd.nist.gov/vuln/detail/CVE-2025-21520)
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20250103 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20250103 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了在同一事务中删除和添加 `FULLTEXT` 索引时的 FTS 清理问题。
+ 优化了 MySQL 客户端中的内存分配时间安排，以防止任何潜在的泄漏。
+ 修复了使用 `UNION` 运算符时结果截断为 34 字节的问题。
+ 修复了由于授权码中的 `ulong bitmask` 而可能导致的越界访问问题。
**已修复 CVE：**
+ [CVE-2024-21230](https://nvd.nist.gov/vuln/detail/CVE-2024-21230)
+ [CVE-2024-21201](https://nvd.nist.gov/vuln/detail/CVE-2024-21201)
+ [CVE-2024-21241](https://nvd.nist.gov/vuln/detail/CVE-2024-21241)
+ [CVE-2024-21203](https://nvd.nist.gov/vuln/detail/CVE-2024-21203)
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20240808 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20240808 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了与字典列索引相关的断言失败。
+ 修复了 `is_binlog_cache_empty()` 函数的问题。
+ 修复了 `sql/item.cc` 文件中的 `heap-use-after-free` 错误。
+ 通过禁用空间索引进行 `index-only` 读取，修复了多个空间索引问题。
+ 修复了 `LOCK_ORDER: CONNECTION_CONTROL` 插件的检测问题。
+ 修复了线程被 `CONNECTION_CONTROL` 插件卡住的问题。
+ 修复了未对 `PREPARED STATEMENTS` 更新 `PSI_THREAD_INFO` 的问题。
+ 修复了使用 `innodb_optimize_fulltext_only` 对 FTS 索引字进行双重处理的问题。
**已修复 CVE：**
+ [CVE-2024-21177](https://nvd.nist.gov/vuln/detail/CVE-2024-21177)
### 适用于 RDS for MySQL 版本 5.7.44-RDS.20240529 的 RDS 扩展支持
适用于 RDS for MySQL 版本 5.7.44-RDS.20240529 的 RDS 扩展支持已发布。
**已修复错误：**
+ 修复了以下错误：实施 `fix_after_pullout` 时出现 `field.cc` 断言失败。
+ 修复了以下错误：向客户端返回某些 SQL 查询的元数据时出现空指针失败。这些查询在 `SELECT` 子句中包含动态参数和子查询。
+ 修复了以下错误：使用 `GROUP BY` 进行松散索引扫描或扫描非连续索引范围时出现错误结果。
+ 修复了以下错误：持久化期间 MySQL 发生崩溃时丢失 GTID 信息。
+ 修复了可能导致 InnoDB 事务无限期挂起的争用条件。
+ 修复了组复制的认证信息清理中出现的争用条件。
+ 修复了并发页面操作的向后索引扫描问题。
+ 修复了并发场景中的全文搜索（FTS）状态不一致的问题。
+ 修复了删除表时更改缓冲区的断言问题。
+ 跨所有插件类型调用 `deinit` 函数的统一行为。
**已修复 CVE：**
+ [CVE-2024-20963](https://nvd.nist.gov/vuln/detail/CVE-2024-20963)
+ [CVE-2024-20993](https://nvd.nist.gov/vuln/detail/CVE-2024-20993)
+ [CVE-2024-20998](https://nvd.nist.gov/vuln/detail/CVE-2024-20998)
+ [CVE-2024-21009](https://nvd.nist.gov/vuln/detail/CVE-2024-21009)
+ [CVE-2024-21054](https://nvd.nist.gov/vuln/detail/CVE-2024-21054)
+ [CVE-2024-21055](https://nvd.nist.gov/vuln/detail/CVE-2024-21055)
+ [CVE-2024-21057](https://nvd.nist.gov/vuln/detail/CVE-2024-21057)
+ [CVE-2024-21062](https://nvd.nist.gov/vuln/detail/CVE-2024-21062)
+ [CVE-2024-21008](https://nvd.nist.gov/vuln/detail/CVE-2024-21008)
+ [CVE-2024-21013](https://nvd.nist.gov/vuln/detail/CVE-2024-21013)
+ [CVE-2024-21047](https://nvd.nist.gov/vuln/detail/CVE-2024-21047)
+ [CVE-2024-21087](https://nvd.nist.gov/vuln/detail/CVE-2024-21087)
+ [CVE-2024-21096](https://nvd.nist.gov/vuln/detail/CVE-2024-21096)
### RDS for MySQL 版本 5.7.44-RDS.20240408 的 RDS 扩展支持
RDS for MySQL 版本 5.7.44-RDS.20240408 的 RDS 扩展支持已可用。
此版本包含以下 CVE 的修补程序：
+ [CVE-2024-20963](https://nvd.nist.gov/vuln/detail/CVE-2024-20963)
## 使用数据库预览环境
2023 年 7 月，Oracle 宣布推出一款适用于 MySQL 的新版本模型。该模型包括两种类型的版本：创新版本和 LTS 版本。Amazon RDS 在 RDS 预览环境中提供 MySQL 创新版本。要了解有关 MySQL 创新版本的更多信息，请参阅 [MySQL 创新和长期支持（LTS）版本简介](https://blogs.oracle.com/mysql/post/introducing-mysql-innovation-and-longterm-support-lts-versions)。
数据库预览环境中的 RDS for MySQL 数据库实例在功能上类似于其他 RDS for MySQL 数据库实例。但是，您不能将数据库预览环境用于生产工作负载。
预览环境具有以下限制：
+ Amazon RDS 会在创建所有数据库实例 60 天之后将其删除，包括其所有备份和快照。
+ 您只能使用通用 SSD 和预置 IOPS SSD 存储。
+ 您无法从 支持 获得数据库实例的帮助。而是可以将您的问题发布到 AWS 托管的问答社群，即 [AWS re:Post](https://repost.aws/tags/TAsibBK6ZeQYihN9as4S_psg/amazon-relational-database-service)。
+ 您无法将数据库实例的快照复制到生产环境。
预览版支持以下选项。
+ 您可以使用 db.m6i、db.r6i、db.m6g、db.m5、db.t3、db.r6g 和 db.r5 数据库实例类创建数据库实例。有关 RDS 实例类的更多信息，请参阅[数据库实例类](Concepts.DBInstanceClass.md)。
+ 您可以同时使用单可用区和多可用区部署。
+ 您可以使用标准 MySQL 转储和加载函数从数据库预览环境中导出数据库或将数据库导入数据库预览环境。
### 数据库预览环境中不支持的功能
以下功能在预览环境中不可用：
+ 跨区域快照复制
+ 跨区域只读副本
+ RDS 代理
### 在数据库预览环境中创建新数据库实例
您可以使用 AWS 管理控制台、AWS CLI 或 RDS API 在数据库预览环境中创建数据库实例。
#### 控制台
**在数据库预览环境中创建数据库实例**
1. 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 从导航窗格选择 **Dashboard (控制面板)**。
1. 在**控制面板**页面中，找到**数据库预览环境**部分，如下图所示。
![\[Amazon RDS 控制台中具有链接的数据库预览环境部分。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/preview-environment-dashboard.png)
您可以直接导航到[数据库预览环境](https://us-east-2.console.aws.amazon.com/rds-preview/home?region=us-east-2#)。在继续操作之前，您必须确认并接受这些限制。
![\[用于确认限制的数据库预览环境服务协议对话框。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/preview-environment-console.png)
1. 要创建 RDS for MySQL 数据库实例，请遵循与创建任何 Amazon RDS 数据库实例相同的流程。有关更多信息，请参阅[创建数据库实例](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating)中的[控制台](USER_CreateDBInstance.md#USER_CreateDBInstance.CON)过程。
#### AWS CLI
要使用 AWS CLI 在数据库预览环境中创建数据库实例，请使用以下端点。
```
rds-preview.us-east-2.amazonaws.com
```
要创建 RDS for MySQL 数据库实例，请遵循与创建任何 Amazon RDS 数据库实例相同的流程。有关更多信息，请参阅[创建数据库实例](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating)中的[AWS CLI](USER_CreateDBInstance.md#USER_CreateDBInstance.CLI)过程。
#### RDS API
要使用 RDS API 在数据库预览环境中创建数据库实例，请使用以下端点。
```
rds-preview.us-east-2.amazonaws.com
```
要创建 RDS for MySQL 数据库实例，请遵循与创建任何 Amazon RDS 数据库实例相同的流程。有关更多信息，请参阅[创建数据库实例](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating)中的[RDS API](USER_CreateDBInstance.md#USER_CreateDBInstance.API)过程。
## 数据库预览环境中的 MySQL 版本 9.5
MySQL 版本 9.5 现可在 Amazon RDS 数据库预览环境中使用。MySQL 版本 9.5 包含一些改进，如 [Changes in MySQL 9.5.0](https://dev.mysql.com/doc/relnotes/mysql/9.5/en/news-9-5-0.html) 中所述。
有关数据库预览环境的信息，请参阅[使用数据库预览环境](#mysql-working-with-the-database-preview-environment)。要从控制台中访问预览环境，请选择 [https://console.aws.amazon.com/rds-preview/](https://console.aws.amazon.com/rds-preview/)。
## 数据库预览环境中的 MySQL 版本 9.4
MySQL 版本 9.4 现可在 Amazon RDS 数据库预览环境中使用。MySQL 版本 9.4 包含一些改进，如 [Changes in MySQL 9.4.0](https://dev.mysql.com/doc/relnotes/mysql/9.4/en/news-9-4-0.html) 中所述。
有关数据库预览环境的信息，请参阅[使用数据库预览环境](#mysql-working-with-the-database-preview-environment)。要从控制台中访问预览环境，请选择 [https://console.aws.amazon.com/rds-preview/](https://console.aws.amazon.com/rds-preview/)。
## 数据库预览环境中的 MySQL 版本 9.3
MySQL 版本 9.3 现可在 Amazon RDS 数据库预览环境中使用。MySQL 版本 9.3 包含一些改进，如 [Changes in MySQL 9.3.0](https://dev.mysql.com/doc/relnotes/mysql/9.3/en/news-9-3-0.html) 中所述。
有关数据库预览环境的信息，请参阅[使用数据库预览环境](#mysql-working-with-the-database-preview-environment)。要从控制台中访问预览环境，请选择 [https://console.aws.amazon.com/rds-preview/](https://console.aws.amazon.com/rds-preview/)。
## Amazon RDS for MySQL 已弃用的版本
Amazon RDS for MySQL 版本 5.1、5.5 和 5.6 已弃用。
Amazon RDS for MySQL 版本 9.1 和 9.2 在数据库预览环境中已弃用。
有关 Amazon RDS for MySQL 的弃用策略的信息，请参阅 [Amazon RDS 常见问题](https://aws.amazon.com/rds/faqs/)。
# 连接到 MySQL 数据库实例
在与运行 MySQL 数据库引擎的数据库实例进行连接之前，您必须首先创建数据库实例。有关信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。Amazon RDS 预配置数据库实例后，您就可以使用标准 MySQL 客户端应用程序或实用程序与该实例连接。在连接字符串中，指定数据库实例端点中的 DNS 地址作为主机参数，并指定数据库实例端点中的端口号作为端口参数。
要对您的 RDS 数据库实例进行身份验证，可以使用一种适用于 MySQL 的身份验证方法和 AWS Identity and Access Management（IAM）数据库身份验证：
+ 要了解如何使用一种适用于 MySQL 的身份验证方法对 MySQL 进行身份验证，请参阅 MySQL 文档中的[身份验证方法](https://dev.mysql.com/doc/internals/en/authentication-method.html)。
+ 要了解如何使用 IAM 数据库身份验证方法对 MySQL 进行身份验证，请参阅 [适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.md)。
可使用 MySQL 命令行客户端等工具连接 MySQL 数据库实例。有关使用 MySQL 命令行客户端的更多信息，请参阅 MySQL 文档中的 [mysql - MySQL 命令行客户端](https://dev.mysql.com/doc/refman/8.0/en/mysql.html)。您可以使用 MySQL Workbench 这款基于 GUI 的应用程序进行连接。有关更多信息，请参阅[下载 MySQL Workbench](http://dev.mysql.com/downloads/workbench/) 页。有关安装 MySQL（包括 MySQL 命令行客户端）的信息，请参阅[安装和升级 MySQL](https://dev.mysql.com/doc/refman/8.0/en/installing.html)。
要从 Amazon VPC 外部连接到数据库实例，数据库实例必须可公开访问，必须使用数据库实例安全组的入站规则授予访问权限，并且必须满足其他要求。有关更多信息，请参阅 [无法连接到 Amazon RDS 数据库实例](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting)。
您可以针对与 MySQL 数据库实例的连接使用安全套接字层 (SSL) 或传输层安全性协议 (TLS) 加密。有关信息，请参阅[Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)。如果您要使用 AWS Identity and Access Management (IAM) 数据库身份验证，请确保使用 SSL/TLS 连接。有关信息，请参阅 [适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.md)。
您也可以从 Web 服务器连接到数据库实例。有关更多信息，请参阅“[教程：创建 Web 服务器和 Amazon RDS 数据库实例](TUT_WebAppWithRDS.md)”。
**注意**
有关连接到 MariaDB 数据库实例的信息，请参阅[连接到 MariaDB 数据库实例](USER_ConnectToMariaDBInstance.md)。
要查找并连接到 RDS for MySQL 数据库实例，请参阅以下主题。
**Topics**
+ [
# 查找 RDS for MySQL 数据库实例的连接信息
](USER_ConnectToInstance.EndpointAndPort.md)
+ [
# 安装 MySQL 命令行客户端
](mysql-install-cli.md)
+ [
# 从 MySQL 命令行客户端连接（未加密）
](USER_ConnectToInstance.CLI.md)
+ [
# 从 MySQL Workbench 连接
](USER_ConnectToInstance.MySQLWorkbench.md)
+ [
# 使用适用于 MySQL 的 AWS JDBC 驱动程序、AWS Python 驱动程序和 AWS ODBC 驱动程序连接到 RDS for MySQL
](MySQL.Connecting.Drivers.md)
+ [
# 排除与 MySQL 数据库实例的连接故障
](USER_ConnectToInstance.Troubleshooting.md)
# 查找 RDS for MySQL 数据库实例的连接信息
数据库实例的连接信息包括其端点、端口和有效数据库用户，如主用户。例如，假设端点值为 `mydb.123456789012.us-east-1.rds.amazonaws.com`。在这种情况下，端口值是 `3306`，数据库用户是 `admin`。鉴于此信息，您可以在连接字符串中指定以下值：
+ 对于主机或主机名或 DNS 名称，请指定 `mydb.123456789012.us-east-1.rds.amazonaws.com`。
+ 对于端口，请指定 `3306`。
+ 对于用户，请指定 `admin`。
要连接到数据库实例，请使用 MySQL 数据库引擎的任何客户端。例如，您可以使用 MySQL 命令行客户端或 MySQL Workbench。
要查找数据库实例的连接信息，您可以使用AWS 管理控制台、AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令，或 Amazon RDS API [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) 操作列出其详细信息。
## 控制台
**在 AWS 管理控制台 中查找数据库实例的连接信息**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择 **数据库** 以显示数据库实例的列表。
1. 选择 MySQL 数据库实例名称以显示其详细信息。
1. 在**连接和安全性**选项卡上，复制端点。另请注意端口号。您需要端点和端口号才能连接到数据库实例。
![\[Amazon RDS 控制台中数据库实例的端点和端口。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/endpoint-port.png)
1. 如果需要查找主用户名，请选择 **Configuration (配置)** 选项卡并查看 **Master username (主用户名)** 值。
## AWS CLI
要使用 AWS CLI 查找 MySQL 数据库实例的相关连接信息，请运行 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令。在调用中，查询数据库实例 ID、端点、端口和主用户名。
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-instances \
--filters "Name=engine,Values=mysql" \
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
对于：Windows
```
aws rds describe-db-instances ^
--filters "Name=engine,Values=mysql" ^
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
您的输出应类似于以下内容。
```
[
[
"mydb1",
"mydb1.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
],
[
"mydb2",
"mydb2.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
]
]
```
## RDS API
要使用 Amazon RDS API 查找数据库实例的连接信息，请调用 [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) 操作。在输出中，找到端点地址、端点端口和主用户名的值。
# 安装 MySQL 命令行客户端
大多数 Linux 发行版包括 MariaDB 客户端，而不是 Oracle MySQL 客户端。要在 Amazon Linux 2023 上安装 MySQL 命令行客户端，请运行以下命令：
```
sudo dnf install mariadb105
```
要在 Amazon Linux 2 上安装 MySQL 命令行客户端，请运行以下命令：
```
sudo yum install mariadb
```
要在大多数基于 DEB 的 Linux 发行版上安装 MySQL 命令行客户端，请运行以下命令：
```
apt-get install mariadb-client
```
要检查 MySQL 命令行客户端版本，请运行以下命令：
```
mysql --version
```
要阅读当前客户端版本的 MySQL 文档，请运行以下命令：
```
man mysql
```
# 从 MySQL 命令行客户端连接（未加密）
**重要**
仅当客户端和服务器位于同一 VPC 中，并且网络受信任时，才会使用未加密的 MySQL 连接。有关使用加密连接的信息，请参阅 [从 MySQL 命令行客户端使用 SSL/TLS 连接到 Amazon RDS 上的 MySQL 数据库实例（已加密）](USER_ConnectToInstanceSSL.CLI.md)。
要使用 MySQL 命令行客户端连接到数据库实例，请在命令提示符处输入以下命令。对于参数 -h，替换为数据库实例的 DNS 名称（端点）。将参数 -P 替换为数据库实例的端口。对于 -u 参数，替换有效数据库用户（如主用户）的用户名。根据系统提示输入主用户密码。
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com -P 3306 -u mymasteruser -p
```
在输入用户的密码后，您应该会看到类似于以下内容的输出。
```
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9738
Server version: 8.0.28 Source distribution
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
```
# 从 MySQL Workbench 连接
**若要从 MySQL Workbench 连接**
1. 在[下载 MySQL Workbench](http://dev.mysql.com/downloads/workbench/) 页面下载并安装 MySQL Workbench。
1. 打开 MySQL Workbench。
![\[MySQL Workbench 中的欢迎屏幕。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/mysql-workbench-main.png)
1. 从 **Database (数据库)** 中选择 **Manage Connections (管理连接)**。
1. 在 **Manage Server Connections (管理服务器连接)** 窗口中，选择 **New (新建)**。
1. 在 **Connect to Database (连接到数据库)** 窗口中，输入以下信息：
+ **Stored Connection (存储连接)** – 输入连接的名称，例如 **MyDB**。
+ **Hostname (主机名)** – 输入数据库实例的端点。
+ **Port (端口)** – 输入数据库实例使用的端口。
+ **Username (用户名)** – 输入有效数据库用户（如主用户）的用户名。
+ **Password (密码)** – （可选）选择 **Store in Vault (存储在文件库中)**，然后输入并保存用户的密码。
窗口看上去类似下面这样：
![\[MySQL Workbench 中的“管理服务器连接”窗口。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/mysql-workbench-connect.png)
您可以使用 MySQL Workbench 的功能来自定义连接。例如，您可以使用 **SSL** 选项卡配置 SSL/TLS 连接。有关使用 MySQL Workbench 的信息，请参阅 [MySQL Workbench 文档](https://dev.mysql.com/doc/workbench/en/)。使用 SSL/TLS 加密客户端与 MySQL 数据库实例的连接，请参阅[使用 SSL/TLS 加密客户端与 Amazon RDS 上 MySQL 数据库实例的连接](mysql-ssl-connections.md)。
1. （可选）选择 **Test Connection (测试连接)** 以确认数据库实例的连接成功。
1. 选择**关闭**。
1. 从 **Database (数据库)** 中选择 **Connect to Database (连接到数据库)**。
1. 从 **Stored Connection (存储连接)** 中选择您的连接。
1. 选择 **OK**。
# 使用适用于 MySQL 的 AWS JDBC 驱动程序、AWS Python 驱动程序和 AWS ODBC 驱动程序连接到 RDS for MySQL
使用适用于 MySQL 的 AWS JDBC 驱动程序、AWS Python 驱动程序和 AWS ODBC 驱动程序连接到 RDS for MySQL 数据库实例。有关更多信息，请参阅以下主题。
**Topics**
+ [
## 使用 Amazon Web Services（AWS）JDBC 驱动程序连接到 RDS for MySQL
](#MySQL.Connecting.JDBCDriver)
+ [
## 使用 Amazon Web Services（AWS）Python 驱动程序连接到 RDS for MySQL
](#MySQL.Connecting.PythonDriver)
+ [
## 使用适用于 MySQL 的 Amazon Web Services（AWS）ODBC 驱动程序连接到 RDS for MySQL
](#USER_ConnectToInstance.ODBCDriverMySQL)
## 使用 Amazon Web Services（AWS）JDBC 驱动程序连接到 RDS for MySQL
Amazon Web Services (AWS) JDBC 驱动程序已设计为高级 JDBC 包装器。此包装器是对现有 JDBC 驱动程序各项功能的补充和扩展。该驱动程序与社区 MySQL Connector/J 驱动程序和社区 MariaDB Connector/J 驱动程序兼容。
要安装 AWS JDBC 驱动程序，请附加 AWS JDBC 驱动程序.jar 文件（位于应用程序 `CLASSPATH` 中），并保留对相应社区驱动程序的引用。按如下方式更新相应的连接 URL 前缀：
+ `jdbc:mysql://`到 `jdbc:aws-wrapper:mysql://`。
+ `jdbc:mariadb://`到 `jdbc:aws-wrapper:mariadb://`。
有关 AWS JDBC 驱动程序的更多信息及其完整使用说明，请参阅 [Amazon Web Services (AWS) JDBC Driver GitHub 存储库](https://github.com/awslabs/aws-advanced-jdbc-wrapper)。
## 使用 Amazon Web Services（AWS）Python 驱动程序连接到 RDS for MySQL
Amazon Web Services（AWS）驱动程序设计为高级 Python 包装器。这款包装器是对开源 Psycopg 驱动程序的各项功能的补充和扩展。AWS Python 驱动程序支持 Python 3.8 及更高版本。您可以使用 `pip` 命令和 `psycopg` 开源软件包安装 `aws-advanced-python-wrapper` 程序包。
有关 AWS Python 驱动程序的更多信息及其完整使用说明，请参阅 [Amazon Web Services (AWS) Python 驱动程序 GitHub 存储库](https://github.com/awslabs/aws-advanced-python-wrapper)。
## 使用适用于 MySQL 的 Amazon Web Services（AWS）ODBC 驱动程序连接到 RDS for MySQL
适用于 MySQL 的 AWS ODBC 驱动程序是专为实现 RDS for MySQL 的高可用性而设计的客户端驱动程序。该驱动程序可以与 MySQL 连接器/ODBC 驱动程序并存，并且与相同的工作流程兼容。
有关适用于 MySQL 的 AWS ODBC 驱动程序的更多信息及其完整安装和使用说明，请参阅 [Amazon Web Services (AWS) ODBC Driver for MySQL](https://github.com/aws/aws-mysql-odbc) GitHub 存储库。
# 排除与 MySQL 数据库实例的连接故障
导致新数据库实例连接故障的两个常见原因是：
+ 创建数据库实例时所用的安全组无法授权连接运行 MySQL 应用程序或实用程序的设备或 Amazon EC2 实例。数据库实例必须具有授权进行连接的 VPC 安全组。有关更多信息，请参阅 [Amazon VPC 和 Amazon RDS](USER_VPC.md)。
您可以在安全组中添加或编辑入站规则。对于 **Source**，选择 **My IP**。这允许从浏览器中检测到的 IP 地址访问数据库实例。
+ 数据库实例是使用默认端口 3306 创建的，而您公司的防火墙规则不允许公司网络中的设备连接到该端口。要修复此故障，请重新创建使用不同端口的实例。
有关连接问题的更多信息，请参阅[无法连接到 Amazon RDS 数据库实例](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting)。
# 保护 MySQL 数据库实例连接安全
您可以实施强有力的安全措施来保护 MySQL 数据库实例免受未经授权的访问和潜在威胁。安全组、SSL/TLS 加密和 IAM 数据库身份验证协同工作，来为 MySQL 数据库实例创建多层连接安全性。这些安全控制措施有助于您满足合规性要求，防止数据泄露，并维护应用程序和数据库之间的安全通信通道。可以通过加密传输中数据、限制对特定 IP 范围的访问以及通过 IAM 角色而不是数据库密码管理用户身份验证，来保护 MySQL 数据库实例。
MySQL 数据库实例的安全性在三个级别上进行管理：
+ AWS Identity and Access Management 控制可以对数据库实例执行 Amazon RDS 管理操作的人员。使用 IAM 证书连接到AWS时，您的 IAM 账户必须具有授予执行 Amazon RDS 管理操作所需的权限的 IAM 策略。有关更多信息，请参阅 [Amazon RDS 的 Identity and Access Management](UsingWithRDS.IAM.md)。
+ 创建数据库实例时，可以使用 VPC 安全组控制哪些设备和 Amazon EC2 实例能够建立到数据库实例的端点和端口的连接。可以使用安全套接字层 (SSL)/传输层安全性协议 (TLS) 建立这些连接。此外，公司的防火墙规则也可以控制公司中运行的哪些设备可以建立到数据库实例的连接。
+ 要对 MySQL 数据库实例的登录信息和权限进行身份验证，可单独或组合采用以下各种方式：
+ 您可采用与独立 MySQL 实例相同的方式。`CREATE USER`、`RENAME USER`、`GRANT`、`REVOKE` 和 `SET PASSWORD` 等命令的作用与它们在本地数据库中的作用相同，就像直接修改数据库架构表。但是，直接修改数据库架构表并不是最佳做法，而且从 RDS for MySQL 版本 8.0.36 开始，不支持直接修改数据库架构表。有关信息，请参阅 MySQL 文档中的[访问控制和账户管理](https://dev.mysql.com/doc/refman/8.0/en/access-control.html)。
+ 您还可以使用 IAM 数据库身份验证。如果采用 IAM 数据库身份验证方式，可使用 IAM 用户或 IAM 角色以及身份验证令牌对数据库实例进行身份验证。*身份验证令牌*是使用签名版本 4 签名流程生成的唯一值。通过使用 IAM 数据库身份验证，您可以使用相同的凭证来控制对 AWS 资源和数据库的访问。有关更多信息，请参阅 [适用于 MariaDB、MySQL 和 PostgreSQL 的IAM 数据库身份验证](UsingWithRDS.IAMDBAuth.md)。
+ 另一个选项是 RDS for MySQL 的 Kerberos 身份验证。数据库实例与 AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD) 配合使用以启用 Kerberos 身份验证。当用户在加入信任域的 MySQL 数据库实例中进行身份验证时，将转发身份验证请求。转发的请求将转到您使用 Directory Service 创建的域目录。有关更多信息，请参阅 [对 Amazon RDS for MySQL 进行 Kerberos 身份验证](mysql-kerberos.md)。
当您创建 Amazon RDS 数据库实例时，主用户有以下默认权限：
| 引擎版本 | 系统权限 | 数据库角色 |
| --- | --- | --- |
| RDS for MySQL 版本 8.4.3 及更高版本 | `GRANT SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE`, `DROP`, `RELOAD`, `PROCESS`, `REFERENCES`,`INDEX`, `ALTER`, `SHOW DATABASES`, `CREATE TEMPORARY TABLES`, `LOCK TABLES`, `EXECUTE`, `REPLICATION SLAVE`, `REPLICATION CLIENT`, `CREATE VIEW`, `SHOW VIEW`, `CREATE ROUTINE`, `ALTER ROUTINE`, `CREATE USER`, `EVENT`, `TRIGGER`, `CREATE ROLE`, `DROP ROLE`, `APPLICATION_PASSWORD_ADMIN`, `FLUSH_OPTIMIZER_COSTS`, `FLUSH_PRIVILEGES`, `FLUSH_STATUS`, `FLUSH_TABLES`, `FLUSH_USER_RESOURCES`, `ROLE_ADMIN`, `SENSITIVE_VARIABLES_OBSERVER`, `SESSION_VARIABLES_ADMIN`, `SET_ANY_DEFINER`, `SHOW_ROUTINE`, `XA_RECOVER_ADMIN` | `rds_superuser_role` 有关 `rds_superuser_role`的更多信息，请参阅[RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)。 |
| RDS for MySQL 版本 8.0.36 及更高版本 | `SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE`, `DROP`, `RELOAD`, `PROCESS`, `REFERENCES`, `INDEX`, `ALTER`, `SHOW DATABASES`, `CREATE TEMPORARY TABLES`, `LOCK TABLES`, `EXECUTE`, `REPLICATION SLAVE`, `REPLICATION CLIENT`, `CREATE VIEW`, `SHOW VIEW`, `CREATE ROUTINE`, `ALTER ROUTINE`, `CREATE USER`, `EVENT`, `TRIGGER`, `CREATE ROLE`, `DROP ROLE`, `APPLICATION_PASSWORD_ADMIN`, `ROLE_ADMIN`, `SET_USER_ID`, `XA_RECOVER_ADMIN` | `rds_superuser_role` 有关 `rds_superuser_role`的更多信息，请参阅[RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)。 |
| 低于 8.0.36 的 RDS for MySQL 版本 | `SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE`, `DROP`, `RELOAD`, `PROCESS`, `REFERENCES`, `INDEX`, `ALTER`, `SHOW DATABASES`, `CREATE TEMPORARY TABLES`, `LOCK TABLES`, `EXECUTE`, `REPLICATION CLIENT`, `CREATE VIEW`, `SHOW VIEW`, `CREATE ROUTINE`, `ALTER ROUTINE`, `CREATE USER`, `EVENT`, `TRIGGER`, `REPLICATION SLAVE` | 无 |
**注意**
尽管能够在数据库实例上删除主用户，但不推荐这样做。要重新创建主用户，请执行 [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API 操作或运行 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) AWS CLI 命令，并使用相应的参数指定新的主用户密码。如果实例中不存在主用户，将使用指定的密码创建主用户。
要为每个数据库实例提供管理服务，需在创建数据库实例时创建 `rdsadmin` 用户。如果试图删掉、重命名、修改密码，或者修改 `rdsadmin` 账户的权限，会导致出错。
若要允许管理数据库实例，需限制标准的 `kill` 和 `kill_query` 命令。通过所提供的 Amazon RDS 命令 `rds_kill` 和 `rds_kill_query`，您可以结束数据库实例上的用户会话或查询。
# RDS for MySQL 的密码验证
MySQL 提供 `validate_password` 插件以提高安全性。该插件使用数据库参数组中的参数为您的 MySQL 数据库实例实施密码策略。运行 MySQL 5.7、8.0 和 8.4 版的数据库实例支持该插件。有关 `validate_password` 插件的更多信息，请参阅 MySQL 文档中的[密码验证插件](https://dev.mysql.com/doc/refman/5.7/en/validate-password.html)。
**为 MySQL 数据库实例启用 `validate_password` 插件**
1. 连接到 MySQL 数据库实例并运行以下命令。
```
INSTALL PLUGIN validate_password SONAME 'validate_password.so';
```
1. 在数据库实例使用的数据库参数组中为插件配置参数。
有关参数插件的更多信息，请参阅 MySQL 文档中的[密码验证插件选项和变量](https://dev.mysql.com/doc/refman/5.7/en/validate-password-options-variables.html)。
有关修改数据库实例参数的更多信息，请参阅[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 重新启动数据库实例。
启用 `validate_password` 插件之后，请重置现有密码以遵循新的验证策略。
您的 MySQL 数据库实例会处理 Amazon RDS 的密码验证。要更改密码，您必须先通过 AWS 管理控制台、`modify-db-instance` CLI 命令或 `ModifyDBInstance` API 操作提交密码更新请求。即使密码不符合您的策略，RDS 最初也会接受您的请求。然后，RDS 会异步处理请求。只有当密码符合您定义的策略时，它才会更新 MySQL 数据库实例中的密码。如果密码不符合这些策略，RDS 会保留现有密码并记录错误事件。
```
Unable to reset your password. Error information: Password failed to meet validation rules.
```
有关 Amazon RDS 事件的更多信息，请参阅 [使用 Amazon RDS 事件通知](USER_Events.md)。
# 使用 SSL/TLS 加密客户端与 Amazon RDS 上 MySQL 数据库实例的连接
安全套接字层 (SSL) 是用于保护客户端和服务器之间的网络连接的行业标准协议。在 SSL 版本 3.0 之后，此名称已更改为传输层安全性协议 (TLS)。Amazon RDS 对于 MySQL 数据库实例支持 SSL/TLS 加密。使用 SSL/TLS，您可加密应用程序客户端和 MySQL 数据库实例之间的连接。SSL/TLS 支持在 MySQL 的所有 AWS 区域中都可用。
借助 Amazon RDS，可以通过使用 SSL/TLS 加密客户端与 MySQL 数据库实例的连接，要求所有与 MySQL 数据库实例的连接都使用 SSL/TLS，以及使用 SSL/TLS（加密）从 MySQL 命令行客户端进行连接，从而保护传输中数据。以下各节提供了有关为 Amazon RDS 上的 MySQL 数据库实例配置和使用 SSL/TLS 加密的指导。
**Topics**
+ [
# Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持
](MySQL.Concepts.SSLSupport.md)
+ [
# Amazon RDS 上 MySQL 数据库实例的特定用户账户需要 SSL/TLS
](mysql-ssl-connections.require-ssl-users.md)
+ [
# 所有与 Amazon RDS 上的 MySQL 数据库实例的连接都需要 SSL/TLS
](mysql-ssl-connections.require-ssl.md)
+ [
# 从 MySQL 命令行客户端使用 SSL/TLS 连接到 Amazon RDS 上的 MySQL 数据库实例（已加密）
](USER_ConnectToInstanceSSL.CLI.md)
# Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持
在 Amazon RDS 预置数据库实例时，Amazon RDS 创建 SSL/TLS 证书，并将该证书安装在数据库实例上。这些证书由证书颁发机构签署。SSL/TLS 证书会将数据库实例端点作为 SSL/TLS 证书的公用名 (CN) 包含在内以防止欺诈攻击。
Amazon RDS 创建的 SSL/TLS 证书是受信任的根实体且在大多数情况下有效，但如果应用程序不接受证书链，则该证书可能会失败。如果应用程序不接受证书链，请尝试使用中间证书连接到 AWS 区域。例如，您必须使用中间证书通过 SSL/TLS 连接到 AWS GovCloud (US) 区域。
有关下载证书的信息，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。有关将 SSL/TLS 与 MySQL 一起使用的更多信息，请参阅[更新应用程序以使用新的 SSL/TLS 证书连接到 MySQL 数据库实例](ssl-certificate-rotation-mysql.md)。
对于 MySQL 8.0 及更低版本，Amazon RDS for MySQL 使用 OpenSSL 进行安全连接。对于 MySQL 8.4 及更高版本，Amazon RDS for MySQL 使用 AWS-LC。TLS 支持取决于 MySQL 版本。下表显示了支持 TLS 的 MySQL 版本。
| MySQL 版本 | TLS 1.0 | TLS 1.1 | TLS 1.2 | TLS 1.3 |
| --- | --- | --- | --- | --- |
| MySQL 8.4 | 不支持 | 不支持 | 支持 | 支持 |
| MySQL 8.0 | 不支持 | 不支持 | 支持 | 支持 |
| MySQL 5.7 | 支持 | 支持 | 支持 | 不支持 |
# Amazon RDS 上 MySQL 数据库实例的特定用户账户需要 SSL/TLS
对于与 Amazon RDS 上的 MySQL 数据库实例的指定用户账户连接，可以要求进行 SSL/TLS 加密。保护敏感信息免遭未经授权的访问或拦截，对于在考虑数据机密性的情况下强制执行安全策略至关重要。
若要求特定用户的账户建立 SSL/TLS 连接，请使用以下语句之一（具体取决于 MySQL 版本），来要求用户账户 `encrypted_user` 建立 SSL/TLS 连接。
为此，请使用以下语句。
```
ALTER USER 'encrypted_user'@'%' REQUIRE SSL;
```
有关使用 MySQL 进行 SSL/TLS 连接的更多信息，请参阅 MySQL 文档中的[使用加密连接](https://dev.mysql.com/doc/refman/8.0/en/encrypted-connections.html)。
# 所有与 Amazon RDS 上的 MySQL 数据库实例的连接都需要 SSL/TLS
使用 `require_secure_transport` 参数要求与 MySQL 数据库实例的所有用户连接都使用 SSL/TLS。默认情况下，`require_secure_transport` 参数设置为 `OFF`。您可将 `require_secure_transport` 参数设置为 `ON` 以要求使用 SSL/TLS 连接到数据库实例。
您可通过更新数据库实例的数据库参数组来设置 `require_secure_transport` 参数值。您无需重启数据库实例即可使更改生效。
当数据库实例的 `require_secure_transport` 参数设置为 `ON` 时，如果数据库客户端能够建立加密连接，则可以连接到该数据库实例。否则，将向客户端返回类似于以下内容的错误消息：
```
MySQL Error 3159 (HY000): Connections using insecure transport are prohibited while --require_secure_transport=ON.
```
有关设置参数的信息，请参阅[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
有关 `require_secure_transport` 参数的更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_require_secure_transport)。
# 从 MySQL 命令行客户端使用 SSL/TLS 连接到 Amazon RDS 上的 MySQL 数据库实例（已加密）
根据您使用的 MySQL 或 MariaDB 版本，`mysql` 客户端程序参数会略有不同。
要查看使用的版本，请使用 `--version` 选项运行 `mysql` 命令。在以下示例中，结果显示客户端程序来自 MariaDB。
```
$ mysql --version
mysql Ver 15.1 Distrib 10.5.15-MariaDB, for osx10.15 (x86_64) using readline 5.1
```
大多数 Linux 发行版（例如 Amazon Linux、CentOS、SUSE 和 Debian）都用 MariaDB 取代了 MySQL，`mysql` 版本来自 MariaDB。
要使用 SSL/TLS 连接到数据库实例，请执行以下步骤：
**使用 MySQL 命令行客户端连接到使用 SSL/TLS 加密的数据库实例**
1. 下载适用于所有 AWS 区域的根证书。
有关下载证书的信息，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
1. 使用 MySQL 命令行客户端，通过 SSL/TLS 加密连接到数据库实例。对于 `-h` 参数，替换为数据库实例的 DNS 名称（端点）。对于 `--ssl-ca` 参数，替换为 SSL/TLS 证书文件名。对于 `-P` 参数，替换为数据库实例的端口。对于 `-u` 参数，替换为有效数据库用户（如主用户）的用户名。根据系统提示输入主用户密码。
以下示例说明了如何在 MySQL 5.7 和更高版本中使用 `--ssl-ca` 参数启动客户端。
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-mode=REQUIRED -P 3306 -u myadmin -p
```
如果要求 SSL/TLS 连接对照 SSL/TLS 证书中的端点验证数据库实例端点，请输入以下命令：
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-mode=VERIFY_IDENTITY -P 3306 -u myadmin -p
```
以下示例说明了如何在 MariaDB 客户端和更高版本中使用 `--ssl-ca` 参数启动客户端。
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl -P 3306 -u myadmin -p
```
1. 根据系统提示输入主用户密码。
您会看到类似以下内容的输出。
```
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9738
Server version: 8.0.28 Source distribution
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
mysql>
```
# 更新应用程序以使用新的 SSL/TLS 证书连接到 MySQL 数据库实例
自 2023 年 1 月 13 日起，Amazon RDS 发布了新的证书颁发机构（CA）证书，以便使用安全套接字层或传输层安全性协议（SSL/TLS）连接到 RDS 数据库实例。接下来，您可以找到有关更新应用程序以使用新证书的信息。
本主题可帮助您确定是否有任何客户端应用程序使用 SSL/TLS 连接到您的数据库实例。如果是这样，您可以进一步检查这些应用程序是否需要证书验证才能连接。
**注意**
某些应用程序配置为仅在它们可以成功验证服务器上的证书时才连接到 MySQL 数据库实例。对于此类应用程序，您必须更新客户端应用程序信任存储，以包括新的 CA 证书。
您可以指定以下 SSL 模式：`disabled`、`preferred` 和 `required`。当您使用 `preferred` SSL 模式且 CA 证书不存在或不是最新时，连接会恢复为不使用 SSL，在不加密的情况下连接。
不建议使用 `preferred` 模式。在 `preferred` 模式下，如果连接遇到无效证书，则会停止使用加密并在未加密的状态下继续。
更新客户端应用程序信任存储中的 CA 证书后，可以在数据库实例上轮换这些证书。强烈建议在生产环境中实现这些过程之前，先在开发或测试环境中测试它们。
有关证书轮换的更多信息，请参阅[轮换 SSL/TLS 证书](UsingWithRDS.SSL-certificate-rotation.md)。有关下载证书的更多信息，请参阅[使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。有关对 MySQL 数据库实例使用 SSL/TLS 的信息，请参阅[Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)。
**Topics**
+ [
## 确定是否有任何应用程序使用 SSL 连接到 MySQL 数据库实例
](#ssl-certificate-rotation-mysql.determining-server)
+ [
## 确定客户端是否需要证书验证才能连接
](#ssl-certificate-rotation-mysql.determining-client)
+ [
## 更新应用程序信任存储
](#ssl-certificate-rotation-mysql.updating-trust-store)
+ [
## 用于建立 SSL 连接的示例 Java 代码
](#ssl-certificate-rotation-mysql.java-example)
## 确定是否有任何应用程序使用 SSL 连接到 MySQL 数据库实例
如果您使用的是 Amazon RDS for MySQL 版本 5.7、8.0 或 8.4，并且启用了 Performance Schema，请运行以下查询来检查连接是否使用了 SSL/TLS。有关启用 Performance Schema 的信息，请参阅 MySQL 文档中的 [Performance Schema 快速入门](https://dev.mysql.com/doc/refman/8.0/en/performance-schema-quick-start.html)。
```
mysql> SELECT id, user, host, connection_type
FROM performance_schema.threads pst
INNER JOIN information_schema.processlist isp
ON pst.processlist_id = isp.id;
```
在该示例输出中，您可以看到自己的会话 (`admin`) 以及作为 `webapp1` 登录的应用程序均在使用 SSL。
```
+----+-----------------+------------------+-----------------+
| id | user | host | connection_type |
+----+-----------------+------------------+-----------------+
| 8 | admin | 10.0.4.249:42590 | SSL/TLS |
| 4 | event_scheduler | localhost | NULL |
| 10 | webapp1 | 159.28.1.1:42189 | SSL/TLS |
+----+-----------------+------------------+-----------------+
3 rows in set (0.00 sec)
```
## 确定客户端是否需要证书验证才能连接
您可以检查 JDBC 客户端和 MySQL 客户端是否需要证书验证才能连接。
### JDBC
以下使用 MySQL Connector/J 8.0 的示例显示了一种方法，用于检查应用程序的 JDBC 连接属性以确定成功的连接是否需要有效证书。有关 MySQL 的所有 JDBC 连接选项的更多信息，请参阅 MySQL 文档中的[配置属性](https://dev.mysql.com/doc/connector-j/en/connector-j-reference-configuration-properties.html)。
当使用 MySQL Connector/J 8.0 时，如果连接属性将 `sslMode` 设置为 `VERIFY_CA` 或 `VERIFY_IDENTITY`，则 SSL 连接需要对数据库服务器证书进行验证，如以下示例所示。
```
Properties properties = new Properties();
properties.setProperty("sslMode", "VERIFY_IDENTITY");
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
```
**注意**
如果您使用 MySQL Java Connector v5.1.38 或更高版本或者 MySQL Java Connector v8.0.9 或更高版本连接到数据库，即使您没有明确配置应用程序在连接到数据库时使用 SSL/TLS，这些客户端驱动程序仍默认为使用 SSL/TLS。此外，在使用 SSL/TLS 时，它们会执行部分证书验证，如果数据库服务器证书过期，则无法连接。
### MySQL
以下使用 MySQL 客户端的示例显示了两种方法，用于检查脚本的 MySQL 连接以确定成功的连接是否需要有效证书。有关 MySQL 客户端的所有连接选项的更多信息，请参阅 MySQL 文档中的[加密连接的客户端配置](https://dev.mysql.com/doc/refman/8.0/en/using-encrypted-connections.html#using-encrypted-connections-client-side-configuration)。
当使用 MySQL 客户端 5.7 及更高版本时，如果对于 `--ssl-mode` 选项，您指定 `VERIFY_CA` 或 `VERIFY_IDENTITY`，则 SSL 连接需要对服务器 CA 证书进行验证，如以下示例所示。
```
mysql -h mysql-database.rds.amazonaws.com -uadmin -ppassword --ssl-ca=/tmp/ssl-cert.pem --ssl-mode=VERIFY_CA
```
## 更新应用程序信任存储
有关更新 MySQL 应用程序的信任存储的信息，请参阅 MySQL 文档中的[安装 SSL 证书](https://dev.mysql.com/doc/mysql-monitor/8.0/en/mem-ssl-installation.html)。
有关下载根证书的信息，请参阅 [使用 SSL/TLS 加密与数据库实例或集群的连接](UsingWithRDS.SSL.md)。
有关导入证书的示例脚本，请参阅 [将证书导入信任存储的示例脚本](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-sample-script)。
**注意**
更新信任存储时，除了添加新证书外，还可以保留较旧证书。
如果在应用程序中使用 mysql JDBC 驱动程序，请在该应用程序中设置以下属性。
```
System.setProperty("javax.net.ssl.trustStore", certs);
System.setProperty("javax.net.ssl.trustStorePassword", "password");
```
启动应用程序时，请设置以下属性。
```
java -Djavax.net.ssl.trustStore=/path_to_trust_store/MyTruststore.jks -Djavax.net.ssl.trustStorePassword=my_trust_store_password com.companyName.MyApplication
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
## 用于建立 SSL 连接的示例 Java 代码
以下代码示例展示了如何设置使用 JDBC 验证服务器证书的 SSL 连接。
```
public class MySQLSSLTest {
private static final String DB_USER = "username";
private static final String DB_PASSWORD = "password";
// This trust store has only the prod root ca.
private static final String TRUST_STORE_FILE_PATH = "file-path-to-trust-store";
private static final String TRUST_STORE_PASS = "trust-store-password";
public static void test(String[] args) throws Exception {
Class.forName("com.mysql.jdbc.Driver");
System.setProperty("javax.net.ssl.trustStore", TRUST_STORE_FILE_PATH);
System.setProperty("javax.net.ssl.trustStorePassword", TRUST_STORE_PASS);
Properties properties = new Properties();
properties.setProperty("sslMode", "VERIFY_IDENTITY");
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
Connection connection = null;
Statement stmt = null;
ResultSet rs = null;
try {
connection = DriverManager.getConnection("jdbc:mysql://mydatabase.123456789012.us-east-1.rds.amazonaws.com:3306",properties);
stmt = connection.createStatement();
rs=stmt.executeQuery("SELECT 1 from dual");
} finally {
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
}
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return;
}
}
```
**重要**
在确定了数据库连接使用 SSL/TLS 并更新了应用程序信任存储之后，可以更新数据库以使用 rds-ca-rsa2048-g1 证书。有关说明，请参阅 [通过修改数据库实例或集群来更新 CA 证书](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-updating) 中的步骤 3。
作为安全最佳实践，请指定除此处所示提示以外的密码。
# 对 Amazon RDS for MySQL 进行 Kerberos 身份验证
当用户连接到 MySQL 数据库实例时，您可以使用 Kerberos 身份验证来验证用户的身份。数据库实例与 AWS Directory Service for Microsoft Active Directory (AWS Managed Microsoft AD) 配合使用以启用 Kerberos 身份验证。当用户在加入信任域的 MySQL 数据库实例中进行身份验证时，将转发身份验证请求。转发的请求将转到您使用 Directory Service 创建的域目录。
将所有凭证保存在同一目录中可以节省您的时间和精力。使用这种方法，您具有一个集中位置用于存储和管理多个数据库实例的凭证。使用目录还可以改善您的整体安全概要。
## 区域和版本可用性
功能可用性和支持因每个数据库引擎的特定版本以及 AWS 区域而异。有关使用 Kerberos 身份验证的 Amazon RDS 的版本和区域可用性的更多信息，请参阅[支持 Amazon RDS 中 Kerberos 身份验证功能的区域和数据库引擎](Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.md)。
## 为 MySQL 数据库实例设置 Kerberos 身份验证概述
要为 MySQL 数据库实例设置 Kerberos 身份验证，请完成以下一般步骤，稍后将详细介绍这些步骤：
1. 使用 AWS Managed Microsoft AD 创建 AWS Managed Microsoft AD 目录。您可以使用 AWS 管理控制台、AWS CLI 或 Directory Service 创建目录。有关执行此操作的详细信息，请参阅 *AWS Directory Service 管理指南*中的[创建 AWS Managed Microsoft AD 目录](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html)。
1. 创建使用托管式 IAM 策略 `AmazonRDSDirectoryServiceAccess` 的 AWS Identity and Access Management（IAM）角色。此角色允许 Amazon RDS 调用您的目录。
为了让角色允许访问，AWS Security Token Service（AWS STS）端点必须在您的 AWS 账户的 AWS 区域中激活。AWS STS 端点默认情况下在所有 AWS 区域中保持活跃，且您无需任何进一步动作即可使用它们。有关更多信息，请参阅《IAM 用户指南》中的[在 AWS 区域中激活和停用 AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#sts-regions-activate-deactivate)。
1. 使用 Microsoft Active Directory 工具在 AWS Managed Microsoft AD 目录中创建和配置用户。有关在 Active Directory 中创建用户的更多信息，请参阅 *AWS 管理指南*中的[在 AWS Directory Service 托管式 Microsoft AD 中管理用户和组](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html)。
1. 创建或修改 MySQL 数据库实例。如果您在创建请求中使用 CLI 或 RDS API，请使用 `Domain` 参数指定域标识符。使用在创建目录时生成的 `d-*` 标识符和您创建的角色的名称。
如果您将现有 MySQL 数据库实例修改为使用 Kerberos 身份验证，请为数据库实例设置域和 IAM 角色参数。在与域目录相同的 VPC 中查找数据库实例。
1. 使用 Amazon RDS 主用户凭证连接到 MySQL 数据库实例。使用 `CREATE USER` 子句 `IDENTIFIED WITH 'auth_pam'` 在 MySQL 中创建用户。您以此方式创建的用户可以使用 Kerberos 身份验证登录到 MySQL 数据库实例。
## 为 MySQL 数据库实例设置 Kerberos 身份验证
您可以使用 AWS Managed Microsoft AD 为 MySQL 数据库实例设置 Kerberos 身份验证。要设置 Kerberos 身份验证，请执行以下步骤。
### 步骤 1：使用 AWS Managed Microsoft AD 创建目录
Directory Service 将在 AWS 云中创建一个完全托管的 Active Directory。创建 AWS Managed Microsoft AD 目录时，Directory Service 将代表您创建两个域控制器和域名系统 (DNS) 服务器。目录服务器在 VPC 中的不同子网中创建。这种冗余有助于确保始终可以访问目录，即使发生了故障。
创建 AWS Managed Microsoft AD 目录时，Directory Service 代表您执行以下任务：
+ 在 VPC 中设置 Active Directory。
+ 使用用户名 Admin 和指定密码创建目录管理员账户。您可以使用此账户管理您的目录。
**注意**
请务必保存此密码。Directory Service 不会存储它。您可以重置它，但无法检索它。
+ 为目录控制器创建安全组。
在启动 AWS Managed Microsoft AD 时，AWS 创建一个组织单位 (OU)，其中包含目录的所有对象。此 OU 具有您在创建目录时键入的 NetBIOS 名称且位于域根目录中。此域根目录由 AWS 拥有和管理。
使用您的 AWS Managed Microsoft AD 目录创建的 Admin 账户对您的 OU 的最常见管理活动具有以下权限：
+ 创建、更新或删除用户
+ 将资源添加到域（如文件或打印服务器），然后为 OU 中的用户分配这些资源的权限
+ 创建额外的 OU 和容器
+ 委托授权
+ 从 Active Directory 回收站还原删除的对象
+ 在 Active Directory Web 服务上运行 AD 和 DNS Windows PowerShell 模块
Admin 账户还具有执行下列域范围活动的权限：
+ 管理 DNS 配置（添加、删除或更新记录、区域和转发器）
+ 查看 DNS 事件日志
+ 查看安全事件日志
**使用 AWS Managed Microsoft AD 创建目录**
1. 登录 AWS 管理控制台，然后打开 Directory Service 控制台，网址为：[https://console.aws.amazon.com/directoryservicev2/](https://console.aws.amazon.com/directoryservicev2/)。
1. 在导航窗格中，选择 **Directories (目录)**，然后选择 **Set up Directory (设置目录)**。
1. 选择 **AWS Managed Microsoft AD**。AWS 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 中创建 MySQL 数据库实例。
**子网**
目录服务器的子网。两个子网必须位于不同的可用区。
1. 查看目录信息并进行必要的更改。如果信息正确，请选择 **Create directory (创建目录)**。
![\[Directory Service 控制台中创建目录期间的审核和创建窗口。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/WinAuth2.png)
目录创建需要几分钟时间。创建成功后，**Status (状态)** 值将更改为 **Active (活动)**。
要查看有关您的目录的信息，请在目录列表中选择目录名称。请记下 **Directory ID (目录 ID)** 值，因为您在创建或修改 MySQL 数据库实例时需要此值。
![\[Directory Service 控制台中具有目录 ID 的目录详细信息部分。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/WinAuth3.png)
### 步骤 2：创建 Amazon RDS 使用的 IAM 角色
要使 Amazon RDS 为您调用 Directory Service，需要使用托管 IAM 策略 `AmazonRDSDirectoryServiceAccess` 的 IAM 角色。该角色允许 Amazon RDS 调用 Directory Service。
使用 AWS 管理控制台 创建数据库实例并且控制台用户具有 `iam:CreateRole` 权限时，控制台将自动创建此角色。在这种情况下，角色名为 `rds-directoryservice-kerberos-access-role`。否则，您必须手动创建 IAM 角色。在创建该 IAM 角色时，请选择 `Directory Service`，然后将 AWS 托管策略 `AmazonRDSDirectoryServiceAccess` 附加到该角色。
有关为服务创建 IAM 角色的更多信息，请参阅 *IAM 用户指南*中的[创建向AWS服务委托权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
**注意**
用于 RDS for SQL Server 的 Windows 身份验证的 IAM 角色不能用于 RDS for MySQL。
或者，您可以创建具有所需权限的角色，而不是使用托管 IAM 策略 `AmazonRDSDirectoryServiceAccess`。在这种情况下，IAM 角色必须具有以下 IAM 信任策略。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
角色还必须具有以下 IAM 角色策略。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ds:DescribeDirectories",
"ds:AuthorizeApplication",
"ds:UnauthorizeApplication",
"ds:GetAuthorizedApplicationDetails"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
### 步骤 3：创建和配置用户
您可以使用“Active Directory 用户和计算机”工具创建用户。该工具是 Active Directory Domain Services 和 Active Directory Lightweight Directory Services 工具的一部分。用户表示有权访问您的目录的独立个人或实体。
要在 Directory Service 目录中创建用户，您必须连接到基于 Microsoft Windows 的 Amazon EC2 实例。此实例必须是 Directory Service 目录的成员，并以具有创建用户权限的用户身份登录。有关更多信息，请参阅*AWS Managed Microsoft AD Directory Service 管理指南*中的[管理 AWS 中的用户和组](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/creating_ad_users_and_groups.html)。
### 步骤 4：创建或修改 MySQL 数据库实例
创建或修改 MySQL 数据库实例，以便与目录一起使用。您可以使用控制台、CLI 或 RDS API 将数据库实例与目录关联。您可以通过下列方式之一来执行该操作：
+ 使用控制台、[create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) CLI 命令或 [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API 操作创建新的 MySQL 数据库实例。
有关说明，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 使用控制台、[modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) CLI 命令或 [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API 操作修改现有 MySQL 数据库实例。
有关说明，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
+ 使用控制台、[restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) CLI 命令或 [RestoreDBInstanceFromDBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) RDS API 操作，从数据库快照还原 MySQL 数据库实例。
有关说明，请参阅[还原到数据库实例](USER_RestoreFromSnapshot.md)。
+ 使用控制台、[restore-db-instance-to-point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) CLI 命令或 [RestoreDBInstanceToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API 操作，将 MySQL 数据库实例还原到某个时间点。
有关说明，请参阅[将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)。
只有 VPC 中的 MySQL 数据库实例才支持 Kerberos 身份验证。数据库实例可以与目录在同一 VPC 中或在不同 VPC 中。数据库实例必须使用允许在目录的 VPC 中传出的安全组，以便数据库实例可与目录通信。
在使用控制台创建、修改或还原数据库实例时，请选择**数据库身份验证**部分中的**密码和 Kerberos 身份验证**。选择 **Browse Directory (浏览目录)**，然后选择目录或选择 **Create a new directory (创建新目录)**。
![\[Amazon RDS 控制台中选中了密码和 Kerberos 身份验证的数据库身份验证部分。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/kerberos-authentication.png)
使用 AWS CLI 或 RDS API 时，将数据库实例与目录关联。数据库实例需要以下参数才能使用您创建的域目录：
+ 对于 `--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 身份验证，请在进行更改之后重启数据库实例。
### 步骤 5：创建 Kerberos 身份验证 MySQL 登录名
使用 Amazon RDS 主用户凭证连接到 MySQL 数据库实例，就像连接到任何其他数据库实例一样。数据库实例加入到 AWS Managed Microsoft AD 域。这样，您可以从您域中的 Active Directory 用户预配置 MySQL 登录名和用户。数据库权限是通过授予这些登录名并从这些登录名撤消的标准 MySQL 权限来管理的。
您可以允许 Active Directory 用户使用 MySQL 进行身份验证。为此，首先使用 Amazon RDS 主用户凭证连接到 MySQL 数据库实例，就像连接到任何其他数据库实例一样。登录之后，通过运行以下命令，在 MySQL 中使用 PAM（可插入身份验证模块），创建在外部进行身份验证的用户。将 `testuser` 替换为用户名。
```
CREATE USER 'testuser'@'%' IDENTIFIED WITH 'auth_pam';
```
域中用户（人和应用程序）现在均可从联接域的客户端计算机使用 Kerberos 身份验证连接到数据库实例。
**重要**
我们强烈建议客户端在使用 PAM 身份验证时使用 SSL/TLS 连接。如果不使用 SSL/TLS 连接，在某些情况下密码可能会以明文形式发送。要为您的 AD 用户要求 SSL/TLS 加密的连接，请运行以下命令，并将 `testuser` 替换为用户名：
```
ALTER USER 'testuser'@'%' REQUIRE SSL;
```
有关更多信息，请参阅 [Amazon RDS 上 MySQL 数据库实例的 SSL/TLS 支持](MySQL.Concepts.SSLSupport.md)。
## 在域中管理数据库实例
您可以使用 CLI 或 RDS API 来管理您的数据库实例及其与托管的 Active Directory 的关系。例如，您可以关联一个 Active Directory 以进行 Kerberos 身份验证，并取消关联一个 Active Directory 以禁用 Kerberos 身份验证。您也可以将由一个 Active Directory 在外部进行身份验证的数据库实例移到另一个 Active Directory。
例如，使用 Amazon RDS API，您可以执行下列操作：
+ 要重新尝试为失败的成员启用 Kerberos 身份验证，请使用 `ModifyDBInstance` API 操作并指定当前成员的目录 ID。
+ 要为成员资格更新 IAM 角色名称，请使用 `ModifyDBInstance` API 操作并指定当前成员资格的目录 ID 和新的 IAM 角色。
+ 要在数据库实例上禁用 Kerberos 身份验证，请使用 `ModifyDBInstance` API 操作并指定 `none` 作为域参数。
+ 要将数据库实例从一个域移至另一个域，请使用 `ModifyDBInstance` API 操作并指定新域的域标识符作为域参数。
+ 要列出每个数据库实例的成员资格，请使用 `DescribeDBInstances` API 操作。
### 了解域成员资格
在创建或修改数据库实例后，它将成为域的成员。您可以通过运行 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) CLI 命令来查看数据库实例的域成员身份状态。数据库实例的状态可以是以下状态之一：
+ `kerberos-enabled` – 数据库实例已启用 Kerberos 身份验证。
+ `enabling-kerberos` – AWS 正在此数据库实例上启用 Kerberos 身份验证。
+ `pending-enable-kerberos` – 启用 Kerberos 身份验证正在此数据库实例上等待处理。
+ `pending-maintenance-enable-kerberos` – AWS将尝试在下一个计划的维护时段在数据库实例上启用 Kerberos 身份验证。
+ `pending-disable-kerberos` – 禁用 Kerberos 身份验证正在此数据库实例上等待处理。
+ `pending-maintenance-disable-kerberos` – AWS将尝试在下一个计划的维护时段在数据库实例上禁用 Kerberos 身份验证。
+ `enable-kerberos-failed` – 出现一个配置问题，导致AWS无法在数据库实例上启用 Kerberos 身份验证。在重新发出数据库实例修改命令之前检查并修复配置。
+ `disabling-kerberos` – AWS 正在此数据库实例上禁用 Kerberos 身份验证。
启用 Kerberos 身份验证的请求可能因网络连接问题或不正确的 IAM 角色而失败。例如，假设您创建数据库实例或修改现有数据库实例，但启用 Kerberos 身份验证的尝试失败。如果发生这种情况，请重新发出修改命令或修改新创建的数据库实例以加入域。
## 使用 Kerberos 身份验证连接到 MySQL
要使用 Kerberos 身份验证连接到 MySQL，您必须使用 Kerberos 身份验证类型进行登录。
要创建可以使用 Kerberos 身份验证连接到的数据库用户，请在 `IDENTIFIED WITH` 语句上使用 `CREATE USER` 子句。有关说明，请参阅[步骤 5：创建 Kerberos 身份验证 MySQL 登录名](#mysql-kerberos-setting-up.create-logins)。
为避免发生错误，请使用 MariaDB `mysql` 客户端。您可以在 [https://downloads.mariadb.org/](https://downloads.mariadb.org/) 下载 MariaDB 软件。
在命令提示符下，连接到其中一个与 MySQL 数据库实例关联的端点。按照 [连接到 MySQL 数据库实例](USER_ConnectToInstance.md)中的常规过程进行操作。当系统提示您输入密码时，请输入与该用户名关联的 Kerberos 密码。
## 还原 MySQL 数据库实例并将其添加到域中
您可还原数据库快照或为 MySQL 数据库实例完成时间点还原，然后将其添加到域中。数据库实例还原后，使用 [步骤 4：创建或修改 MySQL 数据库实例](#mysql-kerberos-setting-up.create-modify) 中介绍的过程修改此实例以将数据库实例添加到域中。
## Kerberos 身份验证 MySQL 限制
以下限制适用于 MySQL 的 Kerberos 身份验证：
+ 仅支持 AWS Managed Microsoft AD。但是，您可以将 RDS for MySQL 数据库实例加入到同一 AWS 区域中不同账户拥有的共享托管式 Microsoft AD 域。
+ 启用该功能后，您必须重启数据库实例。
+ 域名长度不能超过 61 个字符。
+ 您无法同时启用 Kerberos 身份验证和 IAM 身份验证。为 MySQL 数据库实例选择一种或另一种身份验证方法。
+ 启用该功能后，请勿修改数据库实例端口。
+ 请勿将 Kerberos 身份验证与只读副本一起使用。
+ 如果您为使用 Kerberos 身份验证的 MySQL 数据库实例启用了自动次要版本升级，则必须关闭 Kerberos 身份验证，然后在自动升级结束后将该功能重新打开。有关自动升级次要版本的更多信息，请参阅 [RDS for MySQL 的自动次要版本升级](USER_UpgradeDBInstance.MySQL.Minor.md)。
+ 要删除启用此功能的数据库实例，请先禁用该功能。为此，请对数据库实例运行 `modify-db-instance` CLI 命令并为 `--domain` 参数指定 `none`。
如果您使用 CLI 或 RDS API 删除启用此功能的数据库实例，则预期会发生延迟。
+ RDS for MySQL 不支持跨本地或自托管 AD 与 AWS Managed Microsoft AD 之间的林信任进行 Kerberos 身份验证。
# 使用 Amazon RDS 优化读取提高 RDS for MySQL 的查询性能
使用 Amazon RDS 优化读取，您可以更快地处理 RDS for MySQL 查询。与不使用 RDS 优化型读取功能的数据库实例或集群相比，使用此功能的 RDS for MySQL 数据库实例或多可用区数据库集群可以实现最多快 2 倍的查询处理速度。
**Topics**
+ [
## RDS 优化读取概述
](#rds-optimized-reads-overview)
+ [
## RDS 优化读取的使用案例
](#rds-optimized-reads-use-cases)
+ [
## RDS 优化读取的最佳实践
](#rds-optimized-reads-best-practices)
+ [
## 使用 RDS 优化读取
](#rds-optimized-reads-using)
+ [
## 监控使用 RDS 优化读取的数据库实例
](#rds-optimized-reads-monitoring)
+ [
## RDS 优化读取的限制
](#rds-optimized-reads-limitations)
## RDS 优化读取概述
当您使用开启了 RDS 优化型读取功能的 RDS for MySQL 数据库实例或多可用区数据库集群时，该实例或集群会通过使用实例存储实现更快的查询性能。*实例存储*为数据库实例或多可用区数据库集群提供临时性块级存储。存储位于物理上附加到主机服务器的非易失性存储规范（NVMe）固态硬盘（SSD）上。此存储针对低延迟、高随机输入/输出性能和高速连续读取吞吐量进行了优化。
默认情况下，当数据库实例或多可用区数据库集群使用带有实例存储的数据库实例类（例如 db.m5d 或 db.m6gd）时，RDS 优化型读取功能处于开启状态。使用 RDS 优化读取，一些临时对象存储在实例存储中。这些临时对象包括内部临时文件、内部磁盘上的临时表、内存映射文件和二进制日志（binlog）缓存文件。有关实例存储的更多信息，请参阅《适用于 Linux 实例的 Amazon Elastic Compute Cloud 用户指南》**中的 [Amazon EC2 实例存储](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html)。
在 MySQL 中生成用于查询处理的临时对象的工作负载可以利用实例存储来加快查询处理速度。此类工作负载包括涉及排序、哈希聚合、高负载联接、公用表表达式（CTE）的查询以及对未索引列的查询。无论用于持久 Amazon EBS 存储的存储配置如何，这些实例存储卷都能提供更高的 IOPS 和性能。由于 RDS 优化读取将对临时对象的操作分载到实例存储，因此永久存储（Amazon EBS）的每秒进行读写操作的次数（IOPS）或吞吐量现在可用于对永久对象进行的操作。这些操作包括常规数据文件读取和写入以及后台引擎操作，例如刷新和插入缓冲区合并。
**注意**
手动和自动 RDS 快照仅包含用于永久对象的引擎文件。在实例存储中创建的临时对象不包含在 RDS 快照中。
## RDS 优化读取的使用案例
如果您的工作负载严重依赖于临时对象（例如内部表或文件）来执行查询，那么启用 RDS 优化读取会给您带来好处。以下使用案例是 RDS 优化读取的候选使用案例：
+ 使用复杂的公用表表达式（CTE）、派生表和分组操作运行分析查询的应用程序
+ 通过未优化的查询提供大量读取流量的只读副本
+ 运行涉及复杂操作（例如，带 `GROUP BY` 和 `ORDER BY` 子句的查询）的按需或动态报告查询的应用程序
+ 使用内部临时表进行查询处理的工作负载
您可以监控引擎状态变量 `created_tmp_disk_tables`，以确定在数据库实例上创建的基于磁盘的临时表的数量。
+ 直接或在过程中创建大型临时表以存储中间结果的应用程序
+ 对非索引列执行分组或排序的数据库查询
## RDS 优化读取的最佳实践
对于 RDS 优化读取使用以下最佳实践：
+ 为只读查询添加重试逻辑，以防它们在执行过程中由于实例存储已满而失败。
+ 使用 CloudWatch 指标 `FreeLocalStorage` 监控实例存储上的可用存储空间。如果由于数据库实例上的工作负载导致实例存储达到其极限，请修改数据库实例以使用更大的数据库实例类。
+ 当您的数据库实例或多可用区数据库集群有足够的内存，但仍达到实例存储上的存储限制时，请增加 `binlog_cache_size` 值以将特定于会话的二进制日志条目保留在内存中。此配置可防止将二进制日志条目写入磁盘上的临时二进制日志缓存文件。
`binlog_cache_size` 参数是特定于会话的。您可以更改每个新会话的值。此参数的设置可以提高高峰工作负载期间数据库实例的内存利用率。因此，请考虑根据应用程序的工作负载模式和数据库实例上的可用内存增加参数值。
+ 对于 MySQL 8.0 及更低版本，`binlog_format` 参数的默认值为 `MIXED`。根据事务的大小，将 `binlog_format` 设置为 `ROW` 可能会导致实例存储上的二进制日志缓存文件很大。对于 MySQL 8.4 及更高版本，`binlog_format` 参数的默认值为 `ROW`。
+ 将 [internal\$1tmp\$1mem\$1storage\$1engine](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_internal_tmp_mem_storage_engine) 参数设置为 `TempTable`，然后将 [temptable\$1max\$1mmap](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_temptable_max_mmap) 参数设置为与实例存储上的可用存储大小相匹配。
+ 避免在单个事务中进行批量更改。这些类型的事务会在实例存储上生成大型二进制日志缓存文件，并在实例存储已满时导致问题。考虑将写入分成多个小事务，以显著减少二进制日志缓存文件的存储使用量。
+ 对 `binlog_error_action` 参数使用 `ABORT_SERVER` 的默认值。这样做可以避免在启用备份的数据库实例上进行二进制日志记录时出现问题。
## 使用 RDS 优化读取
当您在单可用区数据库实例部署、多可用区数据库实例部署或多可用区数据库集群部署中预调配具有以下数据库实例类之一的 RDS for MySQL 数据库实例时，该数据库实例会自动使用 RDS 优化型读取功能。
要启用 RDS 优化读取，请执行以下操作之一：
+ 使用其中一个数据库实例类创建 RDS for MySQL 数据库实例或多可用区数据库集群。有关更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 修改现有 RDS for MySQL 数据库实例或多可用区数据库集群以使用其中一个数据库实例类。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
在支持其中一个或多个数据库实例类（具有本地 NVMe SSD 存储）的所有 AWS 区域 RDS 中，均可使用 RDS 优化型读取功能。有关数据库实例类的信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。
数据库实例类可用性因 AWS 区域而异。要确定特定 AWS 区域中是否支持数据库实例类，请参阅[确定 AWS 区域 中的数据库实例类支持](Concepts.DBInstanceClass.RegionSupport.md)。
如果您不想使用 RDS 优化型读取特征，请修改您的数据库实例或多可用区数据库集群，使其不使用支持该特征的数据库实例类。
## 监控使用 RDS 优化读取的数据库实例
您可以使用以下 CloudWatch 指标监控使用 RDS 优化读取的数据库实例：
+ `FreeLocalStorage`
+ `ReadIOPSLocalStorage`
+ `ReadLatencyLocalStorage`
+ `ReadThroughputLocalStorage`
+ `WriteIOPSLocalStorage`
+ `WriteLatencyLocalStorage`
+ `WriteThroughputLocalStorage`
这些指标提供有关可用实例存储的存储空间、IOPS 和吞吐量的数据。有关这些指标的更多信息，请参阅 [Amazon RDS 的 Amazon CloudWatch 实例级指标](rds-metrics.md#rds-cw-metrics-instance)。
## RDS 优化读取的限制
以下限制适用于 RDS 优化读取：
+ 以下版本支持 RDS 优化读取：
+ RDS for MySQL 8.0.28 版本以及更高的主要和次要版本
有关 RDS for MySQL 版本的信息，请参阅 [Amazon RDS 上的 MySQL 版本](MySQL.Concepts.VersionMgmt.md)。
+ 您无法在支持 RDS 优化读取的数据库实例类上将临时对象的位置更改为永久存储（Amazon EBS）。
+ 在数据库实例上启用二进制日志记录时，最大事务大小受实例存储大小的限制。在 MySQL 中，任何需要的存储空间比 `binlog_cache_size` 值更多的会话都会将事务更改写入临时二进制日志缓存文件，这些文件是在实例存储上创建的。
+ 实例存储已满时，事务可能会失败。
# 使用适用于 MySQL 的 RDS 优化型写入功能提高写入性能
您可以使用适用于 MySQL 的 RDS 优化写入功能来提高写入事务的性能。当您的 RDS for MySQL 数据库使用 RDS 优化写入时，它最多可以实现高两倍的写入事务吞吐量。
**Topics**
+ [
## RDS 优化写入概述
](#rds-optimized-writes-overview)
+ [
## 使用 RDS 优化写入
](#rds-optimized-writes-using)
+ [
## 在现有数据库上启用 RDS 优化写入
](#rds-optimized-writes-modify-enable)
+ [
## RDS 优化写入的限制
](#rds-optimized-writes-limitations)
## RDS 优化写入概述
当您启用 RDS 优化写入时，您的 RDS for MySQL 数据库在将数据刷新到持久存储时仅写入一次，无需双写缓冲区。数据库继续为可靠的数据库事务提供 ACID 属性保护，同时提高性能。
关系数据库（如 MySQL）为可靠的数据库事务提供原子性、一致性、隔离性和持久性的 ACID *属性*。为了帮助提供这些属性，MySQL 使用一个名为*双写缓冲区*的数据存储区域，以防止出现不完整页面写入错误。这些错误发生在数据库更新页面时出现硬件故障的情况下，例如停电时。MySQL 数据库可以检测不完整页面写入，并使用双写缓冲区中的页面副本进行恢复。虽然这种技术提供了保护，但也会导致额外的写入操作。有关 MySQL 双写缓冲区的更多信息，请参阅 MySQL 文档中的[双写缓冲区](https://dev.mysql.com/doc/refman/8.0/en/innodb-doublewrite-buffer.html)。
开启 RDS 优化写入后，RDS for MySQL 数据库将在数据刷新到持久存储时仅写入一次，而不使用双写缓冲区。如果您在 RDS for MySQL 数据库上运行写入密集型工作负载，RDS 优化写入非常有用。具有写入密集型工作负载的数据库示例包括支持数字支付、金融交易和游戏应用程序的数据库。
这些数据库在使用 AWS Nitro 系统的数据库实例类上运行。由于这些系统中的硬件配置，数据库可以在一个步骤中可靠而持久地将 16KiB 页直接写入数据文件。AWS Nitro 系统使 RDS 优化写入成为可能。
您可以设置新的数据库参数 `rds.optimized_writes` 来控制适用于 RDS for MySQL 数据库的 RDS 优化写入功能。可在 RDS for MySQL 版本 8.0 和 RDS for MySQL 版本 8.4 的数据库参数组中访问此参数。使用以下值设置参数：
+ `AUTO` – 如果数据库支持 RDS 优化写入，则开启此功能。如果数据库不支持 RDS 优化写入，请将其关闭。此设置是默认设置。
+ `OFF` – 关闭 RDS 优化写入，即使数据库支持此功能也不例外。
如果您的现有数据库的引擎版本、数据库实例类和/或文件系统格式不支持 RDS 优化写入，则可以通过创建蓝绿部署来启用该功能。有关更多信息，请参阅 [在现有数据库上启用 RDS 优化写入](#rds-optimized-writes-modify-enable)。
如果您将配置为使用 RDS 优化写入的 RDS for MySQL 数据库迁移到不支持该特征的数据库实例类，RDS 会自动对该数据库关闭 RDS 优化写入。
关闭 RDS 优化写入时，数据库使用 MySQL 双写缓冲区。
要确定 RDS for MySQL 数据库是否使用 RDS 优化写入，请查看数据库的 `innodb_doublewrite` 参数的当前值。如果数据库使用 RDS 优化写入，则此参数设置为 `FALSE`（`0`）。
## 使用 RDS 优化写入
使用 RDS 控制台、AWS CLI 或 RDS API 创建 RDS for MySQL 数据库时，可以开启 RDS 优化写入。在数据库创建过程中，当以下两个条件都适用时，RDS 优化写入功能会自动开启：
+ 您可以指定支持 RDS 优化写入的数据库引擎版本和数据库实例类。
+ RDS for MySQL 版本 8.0.30 及更高版本支持 RDS 优化写入。有关 RDS for MySQL 版本的信息，请参阅 [Amazon RDS 上的 MySQL 版本](MySQL.Concepts.VersionMgmt.md)。
+ 使用以下数据库实例类的 RDS for MySQL 数据库支持 RDS 优化写入：
+ db.m7i
+ db.m7g
+ db.m6g
+ db.m6gd
+ db.m6i
+ db.m5
+ db.m5d
+ db.r7i
+ db.r7g
+ db.r6g
+ db.r6gd
+ db.r6i
+ db.r5
+ db.r5b
+ db.r5d
+ db.x2idn
+ db.x2iedn
有关数据库实例类的信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。
数据库实例类可用性因 AWS 区域而异。要确定特定 AWS 区域中是否支持数据库实例类，请参阅[确定 AWS 区域 中的数据库实例类支持](Concepts.DBInstanceClass.RegionSupport.md)。
要将数据库升级为支持 RDS 优化写入的数据库实例类，您可以创建蓝绿部署。有关更多信息，请参阅 [在现有数据库上启用 RDS 优化写入](#rds-optimized-writes-modify-enable)。
+ 在与数据库关联的参数组中，`rds.optimized_writes` 参数设置为 `AUTO`。在默认参数组中，此参数始终设置为 `AUTO`。
如果您需要使用支持 RDS 优化型写入特征的数据库引擎版本和数据库实例类，但您不想使用此特征，则在创建数据库时指定一个自定义参数组。在此参数组中，将 `rds.optimized_writes` 参数设置为 `OFF`。如果您希望数据库稍后使用 RDS 优化写入，可以将此参数设置为 `AUTO` 以将其开启。有关创建自定义参数组和设置参数的信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
有关创建数据库实例的信息，请参阅[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
### 控制台
当您使用 RDS 控制台创建 RDS for MySQL 数据库时，您可以筛选支持 RDS 优化写入的数据库引擎版本和数据库实例类。开启筛选条件后，您可以从可用的数据库引擎版本和数据库实例类中进行选择。
要选择支持 RDS 优化写入的数据库引擎版本，请在 **Engine version**（引擎版本）中筛选支持该功能的 RDS for MySQL 数据库引擎版本，然后选择版本。
![\[引擎选项部分，针对引擎版本开启了 Amazon RDS 优化型写入功能筛选条件。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-version-filter.png)
在 **Instance configuration**（实例配置）部分中，筛选支持 RDS 优化写入的数据库实例类，然后选择数据库实例类。
![\[实例配置部分，针对数据库实例类开启了 Amazon RDS 优化型写入功能筛选条件。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-class-filter.png)
做出这些选择后，您可以选择符合要求的其他设置，并使用控制台完成创建 RDS for MySQL 数据库。
### AWS CLI
要使用 AWS CLI 创建数据库实例，请运行 [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) 命令。确保 `--engine-version` 和 `--db-instance-class` 值支持 RDS 优化写入。此外，确保与数据库实例关联的参数组将 `rds.optimized_writes` 参数设置为 `AUTO`。以下示例将默认参数组与数据库实例关联。
**Example 创建使用 RDS 优化写入的数据库实例**
对于 Linux、macOS 或 Unix：
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --engine mysql \
4. --engine-version 8.0.30 \
5. --db-instance-class db.r5b.large \
6. --manage-master-user-password \
7. --master-username admin \
8. --allocated-storage 200
```
对于：Windows
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --engine mysql ^
4. --engine-version 8.0.30 ^
5. --db-instance-class db.r5b.large ^
6. --manage-master-user-password ^
7. --master-username admin ^
8. --allocated-storage 200
```
### RDS API
您可以使用 [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) 操作创建数据库实例。使用此操作时，请确保 `EngineVersion` 和 `DBInstanceClass` 值支持 RDS 优化写入。此外，确保与数据库实例关联的参数组将 `rds.optimized_writes` 参数设置为 `AUTO`。
## 在现有数据库上启用 RDS 优化写入
要修改现有 RDS for MySQL 数据库以开启 RDS 优化写入功能，数据库必须使用支持的数据库引擎版本和数据库实例类创建。此外，数据库必须是在 2022 年 11 月 27 日发布 RDS 优化写入*之后*创建的，因为所需的底层文件系统配置与此次发布前创建的数据库的配置不兼容。如果满足上述条件，则可以通过将 `rds.optimized_writes` 参数设置为 `AUTO` 来开启 RDS 优化写入。
如果您的数据库*不是*使用支持的引擎版本、实例类或文件系统配置创建的，则可以使用 RDS 蓝绿部署来迁移到支持的配置。创建蓝绿部署时，请执行以下操作：
+ 选择**在绿色数据库上启用优化写入**，然后指定支持 RDS 优化写入的引擎版本和数据库实例类。有关支持的引擎版本和实例类的列表，请参阅[使用 RDS 优化写入](#rds-optimized-writes-using)。
+ 在**存储**下，选择**升级存储文件系统配置**。此选项将数据库升级到兼容的底层文件系统配置。
创建蓝绿部署时，如果将 `rds.optimized_writes` 参数设置为 `AUTO`，则在绿色环境中将自动启用 RDS 优化写入。然后，您可以切换蓝绿部署，以将绿色环境升级为新的生产环境。
有关更多信息，请参阅 [在 Amazon RDS 中创建蓝绿部署](blue-green-deployments-creating.md)。
## RDS 优化写入的限制
当您从快照中还原 RDS for MySQL 数据库时，仅当满足以下所有条件时，才能为数据库开启 RDS 优化写入：
+ 快照是从支持 RDS 优化写入的数据库创建的。
+ 快照是从发布 RDS 优化型写入功能*之后*创建的数据库中创建的。
+ 快照还原为支持 RDS 优化写入的数据库。
+ 还原的数据库与一个参数组相关联，该参数组的 `rds.optimized_writes` 参数设置为 `AUTO`。
# 升级 RDS for MySQL 数据库引擎
如果 Amazon RDS 支持数据库引擎的新版本，您可以将您的数据库实例升级到新版本。MySQL 数据库有两种升级方式：主要版本升级和次要版本升级。
**主要版本升级。**
*主要版本升级*会包含不与现有应用程序向后兼容的数据库更改。因此，您必须手动为数据库实例执行主要版本升级。您可以通过修改数据库实例来启动主要版本升级。在执行主要版本升级之前，建议您按照[RDS for MySQL 的主要版本升级](USER_UpgradeDBInstance.MySQL.Major.md)中的说明操作。
对于多可用区数据库实例部署的主要版本升级，Amazon RDS 会同时升级主要副本和备用副本。在升级完成之前，数据库实例将不可用。对于多可用区数据库集群部署的主要版本升级，Amazon RDS 一次升级一个集群成员实例。
您可以使用蓝绿部署，最大限度地减少主要版本升级所需的停机时间。有关更多信息，请参阅 [使用 Amazon RDS 蓝绿部署进行数据库更新](blue-green-deployments.md)。
**次要版本升级**
*次要版本升级* 仅包含与现有应用程序向后兼容的更改。您可以通过修改数据库实例来手动启动次要版本升级。您也可以在创建或修改数据库实例时启用**自动次要版本升级**选项。这样做意味着 Amazon RDS 会在测试并批准新版本后自动升级您的数据库实例。有关执行升级的信息，请参阅 [升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)。
当您对多可用区数据库集群执行次要版本升级时，Amazon RDS 将一次升级一个读取器数据库实例。然后，其中一个读取器数据库实例将切换为新的写入器数据库实例。然后，Amazon RDS 升级旧的写入器实例（现在是读取器实例）。
多可用区数据库*实例*部署的次要版本升级的停机时间可能会持续几分钟。多可用区数据库集群通常可将次要版本升级的停机时间缩短至大约 35 秒。与 RDS 代理一起使用时，您可以将停机时间进一步缩短到一秒或更短。有关更多信息，请参阅 [Amazon RDS 代理](rds-proxy.md)。或者，您可以使用开源数据库代理，例如 [ProxySQL](https://aws.amazon.com/blogs/database/achieve-one-second-or-less-of-downtime-with-proxysql-when-upgrading-amazon-rds-multi-az-deployments-with-two-readable-standbys/)、[PgBouncer](https://aws.amazon.com/blogs/database/fast-switchovers-with-pgbouncer-on-amazon-rds-multi-az-deployments-with-two-readable-standbys-for-postgresql/) 或 [AWS Advanced JDBC Wrapper Driver](https://aws.amazon.com/blogs/database/achieve-one-second-or-less-downtime-with-the-advanced-jdbc-wrapper-driver-when-upgrading-amazon-rds-multi-az-db-clusters/)。
Amazon RDS 还支持升级推出策略，以管理跨多个数据库资源和 AWS 账户的自动次要版本升级。有关更多信息，请参阅 [使用 AWS Organizations 升级推出策略自动升级次要版本](RDS.Maintenance.AMVU.UpgradeRollout.md)。
如果 MySQL 数据库实例使用只读副本，则必须在升级源实例之前升级所有只读副本。
**Topics**
+ [
## MySQL 升级的注意事项
](#USER_UpgradeDBInstance.MySQL.Considerations)
+ [
## 查找有效的升级目标
](#USER_UpgradeDBInstance.MySQL.FindingTargets)
+ [
# MySQL 版本号
](USER_UpgradeDBInstance.MySQL.VersionID.md)
+ [
# RDS for MySQL 中的 RDS 版本号
](USER_UpgradeDBInstance.MySQL.rds.version.md)
+ [
# RDS for MySQL 的主要版本升级
](USER_UpgradeDBInstance.MySQL.Major.md)
+ [
# 测试 RDS for MySQL 升级
](USER_UpgradeDBInstance.MySQL.UpgradeTesting.md)
+ [
## 升级 MySQL 数据库实例
](#USER_UpgradeDBInstance.MySQL.Upgrading)
+ [
# RDS for MySQL 的自动次要版本升级
](USER_UpgradeDBInstance.MySQL.Minor.md)
+ [
# 使用只读副本在升级 RDS for MySQL 数据库时减少停机时间
](USER_UpgradeDBInstance.MySQL.ReducedDowntime.md)
+ [
# 使用事件监控 RDS for MySQL 引擎升级
](USER_UpgradeDBInstance.MySQL.Monitoring.md)
## MySQL 升级的注意事项
在升级流程期间，Amazon RDS 会创建两个或更多数据库快照。在进行任何升级更改*之前*，Amazon RDS 最多会拍摄两个数据库实例快照。如果无法完成数据库的升级，那么，就可以还原这些快照之一，来创建一个运行旧版本的数据库实例。升级完成后，Amazon RDS 会为数据库实例拍摄另一个快照。无论 AWS Backup 是否管理数据库实例的备份，Amazon RDS 都会拍摄这些快照。
**注意**
如果您将数据库实例的备份保留期设置为大于 0 的数字，则 Amazon RDS 只需创建数据库快照。要更改您的备份保留期，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
升级完成后，您无法恢复为数据库引擎的以前版本。如果要返回以前版本，则还原创建的第一个数据库快照以新建数据库实例。
您可以控制何时将数据库实例升级到 Amazon RDS 支持的新版本。此级别的控制可帮助您保留与特定数据库版本的兼容性，并在生产中部署前使用应用程序测试新版本。在您准备好后，可在与时间表最搭配的时间执行版本升级。
如果数据库实例使用只读复制，则必须在升级源实例之前升级所有只读副本。
## 查找有效的升级目标
使用 AWS 管理控制台 升级数据库实例时，它会显示数据库实例的有效升级目标。您还可以运行以下 AWS CLI 命令来标识数据库实例的有效升级目标：
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-engine-versions \
--engine mysql \
--engine-version version_number \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
对于：Windows
```
aws rds describe-db-engine-versions ^
--engine mysql ^
--engine-version version_number ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
例如，要标识 MySQL 版本 8.0.28 数据库实例的有效升级目标，请运行以下 AWS CLI 命令：
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-engine-versions \
--engine mysql \
--engine-version 8.0.28 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
对于：Windows
```
aws rds describe-db-engine-versions ^
--engine mysql ^
--engine-version 8.0.28 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
# MySQL 版本号
RDS for MySQL 数据库引擎的版本编号序列采用 *major.minor.patch.YYYYMMDD* 或 *major.minor.patch* 形式，例如 8.0.33.R2.20231201 或 5.7.44。使用的格式取决于 MySQL 引擎版本。有关 RDS 扩展支持版本号的信息，请参阅[Amazon RDS Extended Support 版本命名](extended-support-versions.md#extended-support-naming)。
**major**
主要版本号是版本号的整数和第一个小数点后的部分，例如 8.0。主要版本升级会增加版本号的主要版本部分。例如，从 *5.7*.44 升级到 8.0.33 是主要版本升级，其中 *5.7* 和 *8.0* 为主要版本号。
**minor**
次要版本号是版本号的第三部分，例如 8.0.33 中的 33。
**patch**
补丁是版本号的第四部分，例如 8.0.33.R2 中的 R2。RDS 补丁版本包括在发布后添加到次要版本的重要错误修复。
**YYYYMMDD**
日期是版本号的第五部分，例如 8.0.33.R2.20231201 中的 20231201。RDS 日期版本是一个安全补丁，它包括在发布后添加到次要版本的重要安全修复程序。它不包括任何可能更改引擎行为的修复程序。
下表说明了 RDS for MySQL 版本 8.4 的命名方案。
| 8.4 次要版本 | 命名模式 |
| --- | --- |
| ≥ 3 | 新的数据库实例使用 *major.minor.patch.YYMMDD*，例如 8.4.3.R2.20241201。 在下一次主要版本或次要版本升级之前，现有数据库实例可能使用 *major.minor.patch*，例如 8.4.3.R2。 |
下表说明了 RDS for MySQL 版本 8.0 的命名方案。
| 8.0 次要版本 | 命名模式 |
| --- | --- |
| ≥ 33 | 新的数据库实例使用 *major.minor.patch.YYMMDD*，例如 8.0.33.R2.20231201。 在下一次主要版本或次要版本升级之前，现有数据库实例可能使用 *major.minor.patch*，例如 8.0.33.R2。 |
| < 33 | 现有数据库实例使用 *major.minor.patch*，例如 8.0.32.R2。 |
下表说明了 RDS for MySQL 版本 5.7 的命名方案。
| 5.7 次要版本 | 命名模式 |
| --- | --- |
| ≥ 42 | 新的数据库实例使用 *major.minor.patch.YYMMDD*，例如 5.7.42.R2.20231201。 在下一次主要版本或次要版本升级之前，现有数据库实例可能使用 *major.minor.patch*，例如 5.7.42.R2。 |
# RDS for MySQL 中的 RDS 版本号
RDS 版本号使用 `major.minor.patch` 或 `major.minor.patch.YYYYMMDD` 命名方案。Amazon RDS 扩展支持版本使用 *minor-RDS.YYYYMMDD* 次要版本命名方案。
RDS 补丁版本包括在发布后添加到次要版本的重要错误修复。RDS 日期版本（*YYYYMMDD*）是一个安全补丁。安全补丁不包括任何可能更改引擎行为的修复程序。有关 RDS 扩展支持版本号的信息，请参阅[Amazon RDS Extended Support 版本命名](extended-support-versions.md#extended-support-naming)。
您可以通过以下 SQL 查询找出 RDS for MySQL 数据库的 RDS 版本号：
```
mysql> select mysql.rds_version();
```
例如，查询 RDS for MySQL 8.0.34 数据库将返回以下输出：
```
+---------------------+
| mysql.rds_version() |
+---------------------+
| 8.0.34.R2.20231201 |
+---------------------+
1 row in set (0.01 sec)
```
# RDS for MySQL 的主要版本升级
Amazon RDS 支持 MySQL 数据库引擎的以下主要版本就地升级：
+ MySQL 5.7 到 MySQL 8.0
+ MySQL 8.0 到 MySQL 8.4
**注意**
您只能使用最新一代和当前一代数据库实例类创建 MySQL 版本 5.7、8.0 和 8.4 数据库实例。
在某些情况下，您希望将在上一代数据库实例类上运行的数据库实例升级到具有更高 MySQL 引擎版本的数据库实例。在这些情况下，先修改数据库实例以使用最新一代或当前一代数据库实例类。执行此操作之后，您可以修改数据库实例以使用更高的 MySQL 数据库引擎版本。有关 Amazon RDS 数据库实例类的信息，请参阅[数据库实例类](Concepts.DBInstanceClass.md)。
**Topics**
+ [
## MySQL 主要版本升级概述
](#USER_UpgradeDBInstance.MySQL.Major.Overview)
+ [
## 升级预检查
](#USER_UpgradeDBInstance.MySQL.Prechecks)
+ [
## 升级失败后回滚
](#USER_UpgradeDBInstance.MySQL.Major.RollbackAfterFailure)
## MySQL 主要版本升级概述
主要版本升级会包含不与现有应用程序向后兼容的数据库更改。因此，Amazon RDS 不会自动应用主要版本升级；您必须手动修改数据库实例。建议您在将任何升级应用于生产实例前全面测试这些升级。
要执行主要版本升级，请首先执行任何可用的操作系统更新。操作系统更新完成后，请升级到各个主要版本，例如从 5.7 升级到 8.0，然后再升级到 8.0 到 8.4。有关升级 RDS for MySQL 多可用区数据库集群的信息，请参阅[升级 Amazon RDS 的多可用区数据库集群的引擎版本](multi-az-db-clusters-upgrading.md)。在 2014 年 4 月 24 日之前创建的 MySQL 数据库实例会显示可用的操作系统更新，直到更新安装完成。有关操作系统升级的更多信息，请参阅 [对数据库实例应用更新](USER_UpgradeDBInstance.Maintenance.md#USER_UpgradeDBInstance.OSUpgrades)。
在 MySQL 的主要版本升级期间，如有必要，Amazon RDS 会运行 MySQL 二进制文件 `mysql_upgrade` 以便升级表。此外，Amazon RDS 会在主要版本升级期间清空 `slow_log` 和 `general_log` 表。要保留日志信息，请在升级主要版本之前保存日志内容。
MySQL 主要版本升级通常在大约 10 分钟内完成。由于数据库实例类大小不同或由于实例未遵循[Amazon RDS 的最佳实践](CHAP_BestPractices.md)中的特定操作指南，某些升级过程可能需要更长时间。如果您从 Amazon RDS 控制台升级数据库实例，则数据库实例的状态会标明升级完成的时间。如果您使用 AWS Command Line Interface (AWS CLI) 进行升级，请使用 [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令并选中 `Status` 值。
## 升级预检查
Amazon RDS 在升级之前会运行预检查以检查是否有不兼容问题。这些不兼容问题因要升级到的 MySQL 版本不同而异。
预检查包括 MySQL 内的一些预检查和 Amazon RDS 团队专门创建的一些预检查。有关 MySQL 提供的预检查的信息，请参阅[升级检查程序实用工具](https://dev.mysql.com/doc/mysql-shell/8.4/en/mysql-shell-utilities-upgrade.html)。
在为了升级而停止数据库实例之前先运行预检查，这意味着它们在运行时不会造成任何停机。如果预检查发现不兼容问题，Amazon RDS 会在停止数据库实例之前自动取消升级。Amazon RDS 还会针对不兼容问题生成事件。有关 Amazon RDS 事件的更多信息，请参阅 [使用 Amazon RDS 事件通知](USER_Events.md)。
Amazon RDS 在日志文件 `PrePatchCompatibility.log` 中记录有关每项不兼容性的详细信息。在大部分情况下，日志条目包括用于纠正不兼容性的 MySQL 文档的链接。有关查看日志文件的更多信息，请参阅 [查看和列出数据库日志文件](USER_LogAccess.Procedural.Viewing.md)。
由于预检查的性质，它们会分析数据库中的对象。此分析会导致资源消耗并增加完成升级的时间。
**Topics**
+ [
### 从 MySQL 8.0 升级到 8.4 的预检查
](#USER_UpgradeDBInstance.MySQL.80to84Prechecks)
+ [
### 从 MySQL 5.7 升级到 8.0 的预检查
](#USER_UpgradeDBInstance.MySQL.57to80Prechecks)
### 从 MySQL 8.0 升级到 8.4 的预检查
MySQL 8.4 与 MySQL 8.0 存在一定的不兼容性。在从 MySQL 8.0 升级到 MySQL 8.4 时，这些不兼容性会引起问题。因此，为了让升级成功，可能需要对数据库做一些准备。以下是这些不一致项的一般列表：
+ 不得有使用过时的数据类型或函数的表。
+ 触发器不得具有缺失的或空的定义程序或无效的创建上下文。
+ 不得出现关键字或保留关键字违规情况。MySQL 8.4 中可能会保留一些以前未保留的关键字。
有关更多信息，请参阅 MySQL 文档中的[关键字和保留关键字](https://dev.mysql.com/doc/refman/8.4/en/keywords.html)。
+ MySQL 8.0 `mysql` 系统数据库中不得有与 MySQL 8.4 数据字典使用的表同名的表。
+ `sql_mode` 系统变量设置中不得定义过时的 SQL 模式。
+ 不得有包含超过 255 个字符或 1020 个字节的单个 `ENUM` 或 `SET` 列元素的表或存储过程。
+ 您的 MySQL 8.0 安装不得使用 MySQL 8.4 不支持的功能。
有关更多信息，请参阅 MySQL 文档中的 [Features removed in MySQL 8.4](https://dev.mysql.com/doc/refman/8.4/en/mysql-nutshell.html#mysql-nutshell-removals)。
+ 不得有超过 64 个字符的外键约束名称。
+ 对于改进的 Unicode 支持，请查看以下信息：
+ 请考虑将使用 `utf8mb3` 字符集的对象转换为使用 `utf8mb4` 字符集。`utf8mb3` 字符集已弃用。
+ 请考虑对字符集引用使用 `utf8mb4` 而不是 `utf8`，因为 `utf8` 当前是 `utf8mb3` 字符集的别名。如果可能，请先将 `utf8` 更改为 `utf8mb4`，然后再升级数据库。
+ 对于 `utf8mb3`，由于较旧的客户端可能会收到未知字符集错误，因此请在升级数据库之前升级数据库客户端。
有关更多信息，请参阅 MySQL 文档中的 [utf8mb3 字符集（3 字节 UTF-8 Unicode 编码）](https://dev.mysql.com/doc/refman/8.4/en/charset-unicode-utf8mb3.html)。
要更改字符集，您可以手动对数据库执行备份、还原和复制。您也可以使用 Amazon RDS 蓝绿部署。有关更多信息，请参阅 [使用 Amazon RDS 蓝绿部署进行数据库更新](blue-green-deployments.md)。
当您开始从 MySQL 8.0 更新到 8.4 时，Amazon RDS 会自动运行预检查，以便检测这些不兼容性。有关升级到 MySQL 8.4 的信息，请参阅 MySQL 文档中的 [Upgrading MySQL](https://dev.mysql.com/doc/refman/8.4/en/upgrading.html)。
这些预检查是必需的。您不能选择跳过它们。预检查提供以下好处：
+ 它们让您可以在升级期间避免出现计划外停机。
+ 如果存在不一致项，Amazon RDS 将阻止升级并提供日志以供您参阅。然后，您可以使用日志，通过减少不一致性来准备数据库以升级到 MySQL 8.4。有关消除不兼容情况的详细信息，请参阅 MySQL 文档中的 [Preparing your installation for upgrade](https://dev.mysql.com/doc/refman/8.4/en/upgrade-prerequisites.html)。
### 从 MySQL 5.7 升级到 8.0 的预检查
MySQL 8.0 与 MySQL 5.7 存在一定的不兼容性。在从 MySQL 5.7 升级到 MySQL 8.0 时，这些不兼容性会引起问题。因此，为了让升级成功，可能需要对数据库做一些准备。以下是这些不一致项的一般列表：
+ 不得有使用过时的数据类型或函数的表。
+ 不得有孤立的 \$1.frm 文件。
+ 触发器不得具有缺失的或空的定义程序或无效的创建上下文。
+ 不得有使用不支持本机分区的存储引擎的分区表。
+ 不得出现关键字或保留关键字违规情况。MySQL 8.0 中可能会保留一些以前未保留的关键字。
有关更多信息，请参阅 MySQL 文档中的[关键字和保留关键字](https://dev.mysql.com/doc/refman/8.0/en/keywords.html)。
+ MySQL 5.7 `mysql` 系统数据库中不得有与 MySQL 8.0 数据字典使用的表同名的表。
+ `sql_mode` 系统变量设置中不得定义过时的 SQL 模式。
+ 不得有包含超过 255 个字符或 1020 个字节的单个 `ENUM` 或 `SET` 列元素的表或存储过程。
+ 在升级到 MySQL 8.0.13 或更高版本之前，不得有驻留在共享 InnoDB 表空间中的表分区。
+ MySQL 8.0.12 或更低版本中不得有对 `ASC` 子句使用 `DESC` 或 `GROUP BY` 限定符的查询和存储程序定义。
+ 您的 MySQL 5.7 安装不得使用 MySQL 8.0 不支持的功能。
有关更多信息，请参阅 MySQL 文档中的 [MySQL 8.0 中删除的功能](https://dev.mysql.com/doc/refman/8.0/en/mysql-nutshell.html#mysql-nutshell-removals)。
+ 不得有超过 64 个字符的外键约束名称。
+ 对于改进的 Unicode 支持，请查看以下信息：
+ 请考虑将使用 `utf8mb3` 字符集的对象转换为使用 `utf8mb4` 字符集。`utf8mb3` 字符集已弃用。
+ 请考虑对字符集引用使用 `utf8mb4` 而不是 `utf8`，因为 `utf8` 当前是 `utf8mb3` 字符集的别名。如果可能，请先将 `utf8` 更改为 `utf8mb4`，然后再升级数据库。
+ 对于 `utf8mb3`，由于较旧的客户端可能会收到未知字符集错误，因此请在升级数据库之前升级数据库客户端。
有关更多信息，请参阅 MySQL 文档中的 [utf8mb3 字符集（3 字节 UTF-8 Unicode 编码）](https://dev.mysql.com/doc/refman/8.4/en/charset-unicode-utf8mb3.html)。
要更改字符集，您可以手动对数据库执行备份、还原和复制。您也可以使用 Amazon RDS 蓝绿部署。有关更多信息，请参阅 [使用 Amazon RDS 蓝绿部署进行数据库更新](blue-green-deployments.md)。
当您开始从 MySQL 5.7 更新到 8.0 时，Amazon RDS 会自动运行预检查，以便检测这些不兼容性。有关升级到 MySQL 8.0 的信息，请参阅 MySQL 文档中的[升级 MySQL](https://dev.mysql.com/doc/refman/8.0/en/upgrading.html)。
这些预检查是必需的。您不能选择跳过它们。预检查提供以下好处：
+ 它们让您可以在升级期间避免出现计划外停机。
+ 如果存在不一致项，Amazon RDS 将阻止升级并提供日志以供您参阅。然后，您可以使用日志，通过减少不一致性来准备数据库以升级到 MySQL 8.0。有关消除不兼容性的详细信息，请参阅 MySQL 文档中的[准备安装以进行升级](https://dev.mysql.com/doc/refman/8.0/en/upgrade-prerequisites.html)和 MySQL Server 博客上的[升级到 MySQL 8.0？ 以下是您需要了解的内容…](https://dev.mysql.com/blog-archive/upgrading-to-mysql-8-0-here-is-what-you-need-to-know/)。
## 升级失败后回滚
当将数据库实例从 MySQL 版本 5.7 升级到 MySQL 版本 8.0 或从 MySQL 版本 8.0 升级到 8.4 时，升级可能会失败。尤其是，如果数据字典中包含预检查未发现的不兼容性，则可能会失败。在这种情况下，数据库无法在新的 MySQL 8.0 或 8.4 版本中成功启动。此时，升级所进行的更改就会 Amazon RDS 回滚。回滚后，MySQL 数据库实例将运行原始版本：
+ MySQL 版本 8.0（用于从 MySQL 8.4 回滚）
+ MySQL 版本 5.7（用于从 MySQL 8.0 回滚）
当升级失败并回滚时，Amazon RDS 生成一个 ID 为 RDS-EVENT-0188 的事件。
通常，升级失败是因为数据库实例中的数据库与目标 MySQL 版本之间的元数据存在不兼容性。升级失败时，您可以在 `upgradeFailure.log` 文件中查看有关这些不兼容性的详细信息。在尝试再次升级之前，请先解决不兼容问题。
尝试升级和回滚失败时，您的数据库实例会重新启动。任何待处理的参数更改都将在重新启动期间应用，并在回滚后保留。
有关升级到 MySQL 8.0 的更多信息，请参阅 MySQL 文档中的以下主题：
+ [准备安装以进行升级](https://dev.mysql.com/doc/refman/8.0/en/upgrade-prerequisites.html)
+ [升级到 MySQL 8.0？ 您需要知道这些.](https://dev.mysql.com/blog-archive/upgrading-to-mysql-8-0-here-is-what-you-need-to-know/)..
有关升级到 MySQL 8.4 的更多信息，请参阅 MySQL 文档中的 [Preparing Your Installation for Upgrade](https://dev.mysql.com/doc/refman/8.4/en/upgrade-prerequisites.html)。
# 测试 RDS for MySQL 升级
在数据库实例上执行主要版本升级前，彻底地测试数据库，了解是否与新版本兼容。此外，彻底地测试访问数据库的所有应用程序，了解是否与新版本兼容。建议您使用以下过程。
**测试主要版本升级**
1. 检查新版数据库引擎的升级文档以了解是否存在可能会影响数据库或应用程序的兼容性问题：
+ [MySQL 5.7 中的变化](http://dev.mysql.com/doc/refman/5.7/en/upgrading-from-previous-series.html)
+ [MySQL 8.0 中的变化](http://dev.mysql.com/doc/refman/8.0/en/upgrading-from-previous-series.html)
+ [MySQL 8.4 中的变化](http://dev.mysql.com/doc/refman/8.4/en/upgrading-from-previous-series.html)
1. 如果数据库实例是自定义数据库参数组的成员，就必须使用兼容新主要版本的现有设置创建一个新的数据库参数组。在升级测试实例时，应指定新的数据库参数组，以便升级测试可确保其运行正常。有关创建数据库参数组的详细信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 为要升级的数据库实例创建数据库快照。有关更多信息，请参阅“[为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)”。
1. 恢复数据库快照，以便创建一个新的测试数据库实例。有关更多信息，请参阅“[还原到数据库实例](USER_RestoreFromSnapshot.md)”。
1. 使用下方详细介绍的某种方法，修改此新测试数据库实例以将其升级到新版本。如果您在步骤 2 中创建了一个新的参数组，则指定该参数组。
1. 计算升级的实例使用的存储容量以决定升级是否需要额外的存储容量。
1. 对升级的数据库实例运行所需次数的质量保证测试以确保数据库和应用程序可正常使用新版本。实施任何必需的新测试，评估您在步骤 1 中发现的任何兼容性问题的影响。测试所有的存储过程和功能。将应用程序的测试版本指向所升级的数据库实例。
1. 如果所有测试通过，那么请在生产数据库实例上执行升级。建议您直到确认一切正常后，再允许对数据库实例执行写入操作。
## 升级 MySQL 数据库实例
有关手动或自动升级 MySQL 数据库实例的信息，请参阅[升级数据库实例 引擎版本](USER_UpgradeDBInstance.Upgrading.md)。
# RDS for MySQL 的自动次要版本升级
如果在创建或修改数据库实例时指定以下设置，则可以让数据库实例自动升级。
+ **自动次要版本升级**设置已启用。
+ **备份保留期**设置需大于 0。
在 AWS 管理控制台 中，这些设置位于 **Additional configuration**（其他配置）下。下图显示了 **Auto minor version upgrade**（自动次要版本升级）设置。
![\[Amazon RDS 控制台中选择了允许自动次要版本升级的维护部分。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/amvu.png)
有关这些设置的更多信息，请参阅 [数据库实例的设置](USER_ModifyInstance.Settings.md)。
对于某些 AWS 区域中的某些 RDS for MySQL 主要版本，RDS 将一个次要版本指定为自动升级版本。在 Amazon RDS 测试并批准次要版本后，将在维护时段内自动进行次要版本升级。RDS 不会自动将发布的较新次要版本设置为自动升级版本。在 RDS 指定较新的自动升级版本之前，将会考虑一些条件，例如：
+ 已知的安全问题
+ MySQL 社区版本中的错误
+ 发布次要版本后的整体队列稳定性
您可以运行以下 AWS CLI 命令，以确定特定 AWS 区域中指定 MySQL 次要版本的当前自动次要升级目标版本。
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-engine-versions \
--engine mysql \
--engine-version minor_version \
--region region \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output text
```
对于 Windows：
```
aws rds describe-db-engine-versions ^
--engine mysql ^
--engine-version minor_version ^
--region region ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output text
```
例如，以下 AWS CLI 命令可确定美国东部（俄亥俄州）AWS 区域 (us-east-2) 中 MySQL 次要版本 8.0.11 的自动次要升级目标。
对于 Linux、macOS 或 Unix：
```
aws rds describe-db-engine-versions \
--engine mysql \
--engine-version 8.0.11 \
--region us-east-2 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output table
```
对于 Windows：
```
aws rds describe-db-engine-versions ^
--engine mysql ^
--engine-version 8.0.11 ^
--region us-east-2 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output table
```
输出类似于以下内容。
```
----------------------------------
| DescribeDBEngineVersions |
+--------------+-----------------+
| AutoUpgrade | EngineVersion |
+--------------+-----------------+
| False | 8.0.15 |
| False | 8.0.16 |
| False | 8.0.17 |
| False | 8.0.19 |
| False | 8.0.20 |
| False | 8.0.21 |
| True | 8.0.23 |
| False | 8.0.25 |
+--------------+-----------------+
```
在此示例中，`AutoUpgrade` 值对于 MySQL 版本 8.0.23 为 `True`。因此，自动次要升级目标是 MySQL 版本 8.0.23，它在输出中突出显示。
如果满足以下条件，则会在维护时段内自动升级 MySQL 数据库实例：
+ **自动次要版本升级**设置已启用。
+ **备份保留期**设置需大于 0。
+ 数据库实例运行的次要数据库引擎版本低于当前的自动升级次要版本。
有关更多信息，请参阅“[自动升级次要引擎版本](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades)”。
# 使用只读副本在升级 RDS for MySQL 数据库时减少停机时间
在大多数情况下，蓝绿部署是升级 MySQL 数据库实例时减少停机时间的最佳选项。有关更多信息，请参阅 [使用 Amazon RDS 蓝绿部署进行数据库更新](blue-green-deployments.md)。
如果您无法使用蓝绿部署，并且 MySQL 数据库实例当前与生产应用程序结合使用，则可使用以下过程来升级数据库实例的数据库版本。此过程可以减少应用程序的停机时间。
使用只读副本，您可以提前执行大多数维护步骤，并在实际停机期间尽量减少必要的更改。利用此技巧，您可以在不对现有数据库实例进行任何更改的情况下测试和准备新的数据库实例。
以下过程显示了从 MySQL 5.7 版升级到 MySQL 8.0 版的示例。您可以使用相同的常规步骤升级到其他主要版本。您可以使用相同的常规步骤升级到其他主要版本。
**注意**
当您从 MySQL 版本 5.7 升级到 MySQL 版本 8.0 或从 MySQL 版本 8.0 升级到 MySQL 版本 8.4 时，请在执行升级之前完成预检查。有关更多信息，请参阅[从 MySQL 5.7 升级到 8.0 的预检查](USER_UpgradeDBInstance.MySQL.Major.md#USER_UpgradeDBInstance.MySQL.57to80Prechecks) 和[从 MySQL 8.0 升级到 8.4 的预检查](USER_UpgradeDBInstance.MySQL.Major.md#USER_UpgradeDBInstance.MySQL.80to84Prechecks)。
**在使用数据库实例时升级 MySQL 数据库**
1. 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 创建 MySQL 5.7 数据库实例的只读副本。该过程可创建数据库的可升级副本。可能还存在数据库实例的其他只读副本。
1. 在控制台上，选择**数据库**，然后选择您要升级的数据库实例。
1. 对于 **Actions (操作)**，选择 **Create read replica (创建只读副本)**。
1. 为只读副本提供**数据库实例标识符**的值，并确保**数据库实例类**和其他设置与您的 MySQL 5.7 数据库实例匹配。
1. 选择 **Create read replica (创建只读副本)**。
1. （可选）创建只读副本且**状态**显示为**可用**之后，将只读副本转换为多可用区部署并启用备份。
默认情况下，创建的只读副本禁用了备份。由于只读副本最终成为生产数据库实例，因此最佳实践是配置多可用区部署并启用备份。
1. 在控制台上，选择**数据库**，然后选择您刚创建的只读副本。
1. 选择**修改**。
1. 对于**多可用区部署**，请选择**创建备用实例**。
1. 对于 **Backup Retention Period**（备份保留期），请选择正的非零值（如 3 天），然后选择 **Continue**（继续）。
1. 对于**修改计划**，选择**立即应用**。
1. 选择**修改数据库实例**。
1. 只读副本**状态**显示**可用**后，请将只读副本升级到 MySQL 8.0：
1. 在控制台上，选择**数据库**，然后选择您刚创建的只读副本。
1. 选择**修改**。
1. 对于**数据库引擎版本**，选择升级目标版本 MySQL 8.0 版，然后选择**继续**。
1. 对于**修改计划**，选择**立即应用**。
1. 选择 **Modify DB instance (修改数据库实例)**开始升级。
1. 升级完成并且**状态**显示为**可用**之后，验证升级的只读副本是否与源 MySQL 5.7 数据库实例保持同步。要进行验证，请连接到只读副本并运行 `SHOW REPLICA STATUS` 命令。如果 `Seconds_Behind_Master` 字段为 `0`，则复制保持最新。
**注意**
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS`，而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
1. （可选）创建只读副本的只读副本。
如果您希望数据库实例在提升为独立数据库实例后拥有只读副本，则可以立即创建只读副本。
1. 在控制台上，选择**数据库**，然后选择您刚刚升级的只读副本。
1. 对于 **Actions (操作)**，选择 **Create read replica (创建只读副本)**。
1. 为只读副本提供**数据库实例标识符**的值，并确保**数据库实例类**和其他设置与您的 MySQL 5.7 数据库实例匹配。
1. 选择 **Create read replica (创建只读副本)**。
1. （可选）为只读副本配置自定义数据库参数组。
如果您希望数据库实例在提升为独立数据库实例后使用自定义参数组，则可以立即创建数据库参数组，并将其与只读副本相关联。
1. 为 MySQL 8.0 创建自定义数据库参数组。有关说明，请参阅[在 Amazon RDS 中创建数据库参数组](USER_WorkingWithParamGroups.Creating.md)。
1. 修改要在刚创建的数据库参数组中更改的参数。有关说明，请参阅[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 在控制台中，选择**数据库**，然后选择只读副本。
1. 选择**修改**。
1. 对于**数据库参数组**，请选择刚创建的 MySQL 8.0 数据库参数组，然后选择**继续**。
1. 对于**修改计划**，选择**立即应用**。
1. 选择 **Modify DB instance (修改数据库实例)**开始升级。
1. 使您的 MySQL 8.0 只读副本成为独立的数据库实例。
**重要**
将 MySQL 8.0 只读副本提升为独立的数据库实例后，它不再是 MySQL 5.7 数据库实例的副本。建议您在源 MySQL 8.0 数据库实例处于只读模式并且所有写入操作都暂停的维护时段期间，提升 MySQL 5.7 只读副本。提升完成之后，您可以将写入操作定向到已升级的 MySQL 8.0 数据库实例，以确保不会丢失写入操作。
此外，建议您在提升 MySQL 8.0 只读副本之前，对 MySQL 8.0 只读副本执行所有必需的数据定义语言 (DDL) 操作。例如，创建索引。此方法可避免在 MySQL 8.0 只读副本提升之后对其性能造成任何负面影响。要提升只读副本，请使用以下过程。
1. 在控制台上，选择**数据库**，然后选择您刚刚升级的只读副本。
1. 对于**操作**，请选择**提升**。
1. 选择**是**，为只读副本实例启用自动备份。有关更多信息，请参阅“[备份简介](USER_WorkingWithAutomatedBackups.md)”。
1. 选择 **Continue (继续)**。
1. 选择 **Promote Read Replica**。
1. 您现在有了 MySQL 数据库的升级版本。此时，您可以将应用程序定向到新的 MySQL 8.0 数据库实例。
# 使用事件监控 RDS for MySQL 引擎升级
在升级 RDS for MySQL 数据库的引擎版本时，Amazon RDS 在流程的每个阶段都会发出一个特定的事件。要跟踪升级进度，您可以查看或订阅这些事件。
有关 RDS 事件的更多信息，请参阅[监控 Amazon RDS 事件](working-with-events.md)。
有关引擎升级期间发生的特定 Amazon RDS 事件的详细信息，请参阅[Amazon RDS 事件类别和事件消息](USER_Events.Messages.md)。
# 升级 MySQL 数据库快照引擎版本
借助 Amazon RDS，您可以为 MySQL 数据库实例创建存储卷数据库快照。创建数据库快照时，快照基于数据库实例使用的引擎版本。您可以升级数据库快照的引擎版本。
对于 RDS for MySQL，可以将版本 5.7 快照升级到版本 8.0，或将版本 8.0 快照升级到版本 8.4。您可以升级加密或未加密的数据库快照。
要查看 RDS for MySQL 数据库快照的可用引擎版本，请使用以下 AWS CLI 示例。
```
aws rds describe-db-engine-versions --engine mysql --include-all --engine-version example-engine-version --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
如果您看不到快照的结果，表明您的引擎版本可能已被弃用。如果您的引擎版本被弃用，我们建议您升级到最新的主要版本升级目标或该版本的其它可用升级目标之一。有关更多信息，请参阅 [使用 RDS for MySQL 不支持的引擎版本的数据库快照的升级选项](mysql-upgrade-snapshot.upgrade-options.md)。
将升级到新引擎版本的数据库快照还原后，请确保测试升级是否成功。有关主要版本升级的更多信息，请参阅[升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。要了解如何还原数据库快照，请参阅 [还原到数据库实例](USER_RestoreFromSnapshot.md)。
**注意**
您无法升级在自动备份过程中创建的自动数据库快照。
您可以使用 AWS 管理控制台、AWS CLI 或 RDS API 升级数据库快照。
------
#### [ Console ]
要使用 AWS 管理控制台升级数据库快照引擎版本，请使用以下过程。
**升级数据库快照**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在导航窗格中，选择**快照**。
1. 选择要升级的快照。
1. 对于 **Actions (操作)**，选择 **Upgrade snapshot (升级快照)**。此时会显示 **Upgrade snapshot (升级快照)** 页面。
1. 选择要升级到的 **New engine version (新引擎版本)**。
1. 选择 **Save changes (保存更改)** 以升级快照。
在升级过程中，将为此数据库快照禁用所有快照操作。此外，数据库快照状态由**可用**变为**正在升级**，完成后变为**活动**。如果由于快照损坏问题导致无法升级数据库快照，状态将变为**不可用**。此状态的快照无法恢复。
**注意**
如果数据库快照升级失败，则快照将回滚到具有原始版本的原始状态。
------
#### [ AWS CLI ]
要将数据库快照升级到新的数据库引擎版本，请运行 AWS CLI [modify-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-snapshot.html) 命令。
**选项**
+ `--db-snapshot-identifier` – 要升级的数据库快照的标识符。标识符必须是唯一的 Amazon 资源名称 (ARN)。有关更多信息，请参阅“[Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)”。
+ `--engine-version` – 升级后的数据库快照的引擎版本。
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds modify-db-snapshot \
2.
3. --db-snapshot-identifier my_db_snapshot \
4. --engine-version new_version
```
对于：Windows
```
1. aws rds modify-db-snapshot ^
2. --db-snapshot-identifier my_db_snapshot ^
3. --engine-version new_version
```
------
#### [ Amazon RDS API ]
要将数据库快照升级到新的数据库引擎版本，请调用 RDS API [ModifyDBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshot.html) 操作。
**参数**
+ `DBSnapshotIdentifier` – 要升级的数据库快照的标识符。标识符必须是唯一的 Amazon 资源名称 (ARN)。有关更多信息，请参阅“[Amazon RDS 中的 Amazon 资源名称（ARN）](USER_Tagging.ARN.md)”。
+ `EngineVersion` – 升级后的数据库快照的引擎版本。
------
# 使用 RDS for MySQL 不支持的引擎版本的数据库快照的升级选项
下表显示了可以从 RDS for MySQL 数据库快照不支持的引擎版本升级到哪些引擎版本。
**注意**
您可能需要多次升级数据库快照，才能升级到所选的引擎版本。
| 数据库快照引擎版本 | 可供升级的引擎版本 |
| --- | --- |
| 5.5.8 | 5.5.62、5.6.51 |
| 5.5.12 | 5.5.62、5.6.51 |
| 5.5.20 | 5.5.62、5.6.51 |
| 5.5.23 | 5.5.62、5.6.51 |
| 5.5.25a | 5.5.62、5.6.51 |
| 5.5.27 | 5.5.62、5.6.51 |
| 5.5.31 | 5.5.62、5.6.51 |
| 5.5.33 | 5.5.62、5.6.51 |
| 5.5.37 | 5.5.62、5.6.51 |
| 5.5.38 | 5.5.62、5.6.51 |
| 5.5.40 | 5.5.62、5.6.51 |
| 5.5.40a | 5.5.62、5.6.51 |
| 5.5.40b | 5.5.62、5.6.51 |
| 5.5.41 | 5.5.62、5.6.51 |
| 5.5.42 | 5.5.62、5.6.51 |
| 5.5.59 | 5.5.62、5.6.51 |
| 5.6.12 | 5.6.51、5.7.44 |
| 5.6.13 | 5.6.51、5.7.44 |
| 5.6.17 | 5.6.51、5.7.44 |
| 5.6.19 | 5.6.51、5.7.44 |
| 5.6.19a | 5.6.51、5.7.44 |
| 5.6.19b | 5.6.51、5.7.44 |
| 5.6.21 | 5.6.51、5.7.44 |
| 5.6.21b | 5.6.51、5.7.44 |
| 5.6.22 | 5.6.51、5.7.44 |
| 5.6.23 | 5.6.51、5.7.44 |
| 5.6.27 | 5.6.51、5.7.44 |
| 5.6.27a | 5.6.51、5.7.44 |
| 5.7.10 | 5.7.44、5.7.44-rds.20240408、5.7.44-rds.20240529、5.7.44-rds.20250103、5.7.44-rds.20250213、8.0.32、8.0.33、8.0.34、8.0.35、8.0.36、8.0.37、8.0.39、8.0.40、8.0.41 |
| 5.7.11 | 5.7.44、5.7.44-rds.20240408、5.7.44-rds.20240529、5.7.44-rds.20250103、5.7.44-rds.20250213、8.0.32、8.0.33、8.0.34、8.0.35、8.0.36、8.0.37、8.0.39、8.0.40、8.0.41 |
| 5.7.12 | 5.7.44、5.7.44-rds.20240408、5.7.44-rds.20240529、5.7.44-rds.20250103、5.7.44-rds.20250213、8.0.32、8.0.33、8.0.34、8.0.35、8.0.36、8.0.37、8.0.39、8.0.40、8.0.41 |
# 将数据导入到 Amazon RDS for MySQL 数据库实例
您可以使用多种不同的技术将数据导入到 RDS for MySQL 数据库实例。最佳方法取决于多种因素：
+ 数据的来源
+ 数据量
+ 一次性导入，还是持续导出
+ 停机时间量
如果还要随数据一起迁移应用程序，则务必考虑停机时间量。
下表中列出了将数据导入到 RDS for MySQL 数据库实例的技巧：
| 来源 | 数据量 | 一次性或持续 | 应用程序停机时间 | 方法 | 更多信息 |
| --- | --- | --- | --- | --- | --- |
| 本地或 Amazon EC2 上的现有 MySQL 数据库 | 任何 | 一次性 | 一段时间 | 创建本地数据库的备份，将其存储在 Amazon S3 上，然后将该备份文件还原到运行 MySQL 的新 Amazon RDS 数据库实例上。 | [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md) |
| 本地或 Amazon EC2 上的现有 MySQL 数据库 | 任何 | 持续 | 最低 | 配置复制，使用现有 MySQL 数据库作为复制源。 | [配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md) [将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间](mysql-importing-data-reduced-downtime.md) |
| 任何现有数据库 | 任何 | 一次性或持续 | 最低 | 使用 AWS Database Migration Service 可在最少停机时间下迁移数据库，对于很多数据库引擎，将继续进行持续复制。 | *AWS Database Migration Service 用户指南*中的[什么是 AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) 和[将与 MySQL 兼容的数据库作为 AWS DMS 的目标](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) |
| 现有 MySQL 数据库实例 | 任何 | 一次性或持续 | 最低 | 为正在进行的复制创建只读副本。提升只读副本用于一次性创建新数据库实例。 | [使用数据库实例只读副本](USER_ReadRepl.md) |
| 现有 MySQL 数据库 | 小型 | 一次性 | 一段时间 | 使用命令行实用程序，将数据直接复制到您的 MySQL 数据库实例。 | [将数据从外部 MySQL 数据库导入到 Amazon RDS for MySQL 数据库实例](mysql-importing-data-external-database.md) |
| 未存储在现有数据库中的数据 | 中 | 一次性 | 一段时间 | 使用 MySQL LOAD DATA LOCAL INFILE 语句创建平面文件并导入这些文件。 | [从任意源将数据导入 Amazon RDS for MySQL 数据库实例](mysql-importing-data-any-source.md) |
**注意**
`mysql` 系统数据库包含登录到数据库实例并访问数据所需的身份验证和授权信息。在数据库实例中删掉、改动、重命名或截取 `mysql` 数据库中的表、数据或其他内容可能会导致错误，并可能导致无法访问数据库实例和数据。如果发生此情况，您可以使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) 命令从快照中还原数据库实例。您可以使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) 命令恢复数据库实例。
# 为 MySQL 导入数据的注意事项
以下内容包含与将数据加载到 MySQL 中相关的技术信息。此内容面向熟悉 MySQL 服务器架构的用户。
## 二进制日志记录
与禁用日志记录相比，启用二进制日志记录会降低数据加载性能，并且需要多达四倍的额外磁盘空间。用于加载数据的事务大小直接影响系统性能和磁盘空间需求，也即，事务越大，需要的资源越多。
## 事务大小
事务大小会影响 MySQL 数据加载的以下方面：
+ 资源消耗
+ 磁盘空间利用率
+ 恢复进程
+ 恢复时间
+ 输入格式（平面文件或 SQL）
本部分介绍了事务大小如何影响二进制日志记录以及让案例在大数据加载过程中禁用二进制日志记录。可以通过设置 Amazon RDS 自动备份保留期来启用和禁用二进制日志记录。非零值会启用二进制日志记录，零会将其禁用。有关更多信息，请参阅 [备份保留期](USER_WorkingWithAutomatedBackups.BackupRetention.md)。
本节还介绍大型事务对 InnoDB 的影响以及将事务大小保持为较小的重要性。
### 小型事务
对于小型事务，二进制日志记录会使加载数据所需的磁盘写入次数翻倍。这种影响会严重降低其他数据库会话的性能，并增加数据加载所需的时间。所经历的降级在一定程度上取决于以下因素：
+ 上传速率
+ 在加载期间发生的其它数据库活动
+ Amazon RDS 数据库实例的容量
此外，二进制日志占用的磁盘空间大致等于加载的数据量，直至备份和移除日志。Amazon RDS 通过频繁备份和移除二进制日志来尽量减少占用的磁盘空间量。
### 大型事务
对于大型事务，二进制日志记录会使 IOPS 和磁盘使用量增加两倍，原因如下：
+ 二进制日志缓存将事务数据临时存储在磁盘上。
+ 此缓存会随着事务大小而增长，这会占用磁盘空间。
+ 当事务（提交或回滚）完成时，系统会将缓存复制到二进制日志。
此过程会创建数据的三个副本：
+ 原始数据
+ 磁盘上的缓存
+ 最终二进制日志条目
每个写入操作都会产生额外的 IO，从而进一步影响性能。
因此，与禁用日志记录相比，二进制日志记录需要三倍的磁盘空间。例如，在单个事务中加载 10 GiB 的数据会创建三个副本：
+ 表数据为 10 GiB
+ 二进制日志缓存为 10 GiB
+ 二进制日志文件为 10 GiB
所需的临时磁盘空间总量为 30 GiB。
磁盘空间重要注意事项：
+ 缓存文件会一直存在，直到会话结束或新事务创建另一个缓存。
+ 二进制日志会保留直至对其进行备份，可能会在很长一段时间内占用 20 GiB（缓存和日志）。
如果您使用 `LOAD DATA LOCAL INFILE` 来加载数据，数据恢复会创建第四个副本，以防数据库必须从加载前进行的备份中恢复。在恢复期间，MySQL 将二进制日志中的数据提取到平面文件中。然后，MySQL 运行 `LOAD DATA LOCAL INFILE`。在前一个示例的基础上，此恢复需要的临时磁盘空间总量为 40 GiB，也即表、缓存、日志和本地文件各为 10 GiB。如果没有至少 40 GiB 的可用磁盘空间，则恢复将失败。
### 优化大数据加载
对于大数据加载，请禁用二进制日志记录，以减少开销和磁盘空间要求。可以通过将备份保留期设置为 0 来禁用二进制日志记录。完成加载后，将备份保留期还原为适当的非零值。有关更多信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)和设置表中的[备份保留期](USER_ModifyInstance.Settings.md)。
**注意**
如果数据库实例是只读副本的源数据库实例，则您无法将备份保留期设置为 0。
在加载数据之前，我们建议您创建数据库快照。有关更多信息，请参阅 [管理手动备份](USER_ManagingManualBackups.md)。
## InnoDB
以下有关撤消日志记录和恢复选项的信息支持将 InnoDB 事务保持为较小，以优化数据库性能。
### 了解 InnoDB 撤消日志记录
撤消是一种日志记录机制，可启用事务回滚并支持多版本并发控制（MVCC）。
对于 MySQL 5.7 及更低版本，撤消日志存储在 InnoDB 系统表空间（通常为 ibdata1）中，并保留至清除线程移除它们为止。因此，大数据加载事务可能会导致系统表空间变得相当大，并占用磁盘空间，除非重新创建数据库，否则无法回收这些磁盘空间。
对于所有 MySQL 版本，清除线程必须等待以移除所有撤消日志，直到最旧的活动事务提交或回滚。如果数据库在加载过程中正在处理其它事务，则其撤消日志也会累积并且无法移除，即使事务提交并且没有其它事务需要 MVCC 的撤消日志，也是如此。在这种情况下，所有事务（包括只读事务）都会变慢。之所以发生这种变慢过程，是因为所有事务都访问任何事务（而不仅仅是加载事务）更改的所有行。实际上，事务必须扫描一些撤消日志，在撤消日志清理期间，长时间运行的加载事务已阻止清除这些撤消日志。这会影响访问已修改行的任何操作的性能。
### InnoDB 事务恢复选项
尽管 InnoDB 优化了提交操作，但大型事务回滚速度很慢。为了加快恢复速度，请执行时间点故障恢复或还原数据库快照。有关更多信息，请参阅[时间点故障恢复](USER_PIT.md)和[还原到数据库实例](USER_RestoreFromSnapshot.md)。
## 数据导入格式
MySQL 支持两种数据导入格式：平面文件和 SQL。查看有关每种格式的信息，以确定最适合您需求的选项。
### 平面文件
对于小型事务，请使用 `LOAD DATA LOCAL INFILE` 加载平面文件。与使用 SQL 相比，这种数据导入格式具有以下优势：
+ 减少网络流量
+ 降低数据传输成本
+ 减少了数据库处理开销
+ 处理速度更快
`LOAD DATA LOCAL INFILE` 会将整个平面文件作为一个事务进行加载。将各个文件的大小保持为较小可获得以下优势：
+ **恢复功能**：可以保持跟踪哪些文件已加载。如果在加载期间出现问题，可以从停止处继续加载。可能需要将一些数据重新传输到 Amazon RDS，但使用小文件，就可以将重新传输的量减少至最低水平。
+ **并行数据加载**：如果 IOPS 和网络带宽足以支持单个文件加载，那么并行加载就可以节省时间。
+ **加载速率控制**：如果数据加载对其它进程产生负面影响，则可以通过增加文件之间的间隔来控制加载速率。
大型事务会降低使用 `LOAD DATA LOCAL INFILE` 导入数据的优势。当您无法将大量数据分解成较小的文件时，可以考虑使用 SQL。
### SQL
与平面文件相比，SQL 的一个主要优势为：您可以轻松地将事务大小保持为较小。但是，SQL 的加载时间可能比平面文件长得多。此外，在发生故障后，可能难以确定从哪里恢复，而您无法重新启动 mysqldump 文件。如果加载 mysqldump 文件时出现故障，您必须修改或替换该文件，然后才能恢复加载。或者，在纠正故障的原因后，您可以恢复到加载前的时间点，并重新发送该文件。有关更多信息，请参阅 [时间点故障恢复](USER_PIT.md)。
## 使用 Amazon RDS 数据库快照提供数据库检查点
如果您在没有二进制日志记录的情况下长时间（如数小时或数天）加载数据，请使用数据库快照提供定期检查点来实现数据安全。每个数据库快照都会创建数据库实例的一致副本，该副本在系统故障或数据损坏事件期间用作恢复点。由于数据库快照速度很快，因此频繁的检查点对加载性能的影响微乎其微。您可以在不影响数据库持久性或恢复能力的情况下，删除以前的数据库快照。有关数据库快照的更多信息，请参阅[管理手动备份](USER_ManagingManualBackups.md)。
## 减少数据库加载时间
以下各项是减少加载时间的其它技巧：
+ 在将数据加载到 MySQL 数据库之前，请创建所有二级索引。与其它数据库系统不同，MySQL 在添加或修改二级索引时会重建整个表。此过程会创建一个包含索引更改的新表，复制所有数据，然后删除原始表。
+ 按主键顺序加载数据。对于 InnoDB 表，这可以将加载时间缩短 75% 至 80%，并将数据文件大小减少 50%。
+ 通过将 `foreign_key_checks` 设置为 `0` 来禁用外键约束。对于使用 `LOAD DATA LOCAL INFILE` 加载的平面文件，这通常是必需的。对于任何加载，禁用外键检查会加快数据加载速度。加载完成后，通过将 `foreign_key_checks` 设置为 `1` 来重新启用约束并验证数据。
+ 并行加载数据，除非接近资源限制。要实现跨多个表段的并行加载，请在适当时使用分区表。
+ 要减少 SQL 执行开销，请将多条 `INSERT` 语句合并为单个多值 `INSERT` 操作。`mysqldump` 自动实现此优化。
+ 通过将 `innodb_flush_log_at_trx_commit` 设置为 `0` 来减少 InnoDB 日志 IO 操作。加载完成后，将 `innodb_flush_log_at_trx_commit` 还原为 `1`。
**警告**
将 `innodb_flush_log_at_trx_commit` 设置为 `0` 会导致 InnoDB 每秒都刷新其日志，而不是在每次提交时刷新。此设置可以提高性能，但在系统故障期间可能会有事务丢失的风险。
+ 如果您要将数据加载到没有只读副本的数据库实例，请将 `sync_binlog` 设置为 `0`。加载完成后，将 `sync_binlog parameter` 还原为 `1`。
+ 在将数据库实例转换为多可用区部署之前，将数据加载到单可用区实例中。如果数据库实例已经使用多可用区部署，我们建议您不要切换为单可用区部署来加载数据。这样做所带来的改进微不足道。
# 将备份还原到 Amazon RDS for MySQL 数据库实例
Amazon RDS 支持使用备份文件导入 MySQL 数据库。您可以创建数据库的备份，将备份文件存储在 Amazon S3 上，然后将该备份文件还原到运行 MySQL 的新 Amazon RDS 数据库实例上。Amazon RDS 支持在所有 AWS 区域中从 Amazon S3 导入备份文件。
本节中介绍的方案将还原本地数据库的备份。只要数据库可供访问，您就可以将此技术用于其它位置（例如 Amazon EC2 或其它云服务）中的数据库。
下图显示了支持的方案。
![\[MySQL 从 S3 中导入备份文件。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MySQL-bak-file.png)
如果在创建、复制和还原备份文件时，您的本地数据库可能处于脱机状态，则我们建议您使用备份文件将数据库导入到 Amazon RDS。如果数据库无法脱机，则可以使用以下方法之一：
+ **二进制日志** – 首先，将备份文件从 Amazon S3 导入到 Amazon RDS，如本主题所述。然后，使用二进制日志（binlog）复制来更新数据库。有关更多信息，请参阅 [配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)。
+ **AWS Database Migration Service** – 使用 AWS Database Migration Service 将数据库迁移到 Amazon RDS。有关更多信息，请参阅[什么是 AWS Database Migration Service？](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
## 将备份文件从 Amazon S3 导入到 Amazon RDS 的设置概述
要将备份文件从 Amazon S3 导入到 Amazon RDS，您需要以下组件：
+ 用于存储备份文件的 Amazon S3 存储桶。
如果您已有一个 Amazon S3 存储桶，则可以使用该存储桶。如果没有 Amazon S3 存储桶，请创建一个新的存储桶。有关更多信息，请参阅[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html)。
+ Percona XtraBackup 创建的本地数据库备份。
有关更多信息，请参阅 [创建数据库备份](#MySQL.Procedural.Importing.Backup)。
+ AWS Identity and Access Management（IAM）角色，支持 Amazon RDS 访问 S3 存储桶。
如果您已有 IAM 角色，则可以使用该角色并向其附加信任和权限策略。有关更多信息，请参阅 [手动创建 IAM 角色](#MySQL.Procedural.Importing.Enabling.IAM)。
如果您没有 IAM 角色，则有两个选项：
+ 您可以手动创建新的 IAM 角色。有关更多信息，请参阅 [手动创建 IAM 角色](#MySQL.Procedural.Importing.Enabling.IAM)。
+ 您可以选择让 Amazon RDS 为您创建新的 IAM 角色。如果您希望 Amazon RDS 为您创建新的 IAM 角色，请按照[将数据从 Amazon S3 导入到新的 MySQL 数据库实例](#MySQL.Procedural.Importing.PerformingImport)一节中使用 AWS 管理控制台的过程进行操作。
## 创建数据库备份
可以使用 Percona XtraBackup 软件创建备份。建议您使用最新的 Percona XtraBackup 版本。您可以通过 Percona 网站上的 [Software Downloads](https://www.percona.com/downloads/) 安装 Percona XtraBackup。
**警告**
创建数据库备份时，XtraBackup 可能会将凭证保存在 xtrabackup\$1info 文件中。务必确认 xtrabackup\$1info 文件中的 `tool_command` 设置不包含任何敏感信息。
您使用的 Percona XtraBackup 版本取决于您要备份的 MySQL 版本。
+ **MySQL 8.4** – 使用 Percona XtraBackup 版本 8.4。
+ **MySQL 8.0** – 使用 Percona XtraBackup 版本 8.0。
**注意**
Percona XtraBackup 8.0.12 及更高版本支持迁移所有 MySQL 8.0 版本。如果要迁移到 RDS for MySQL 8.0.32 或更高版本，则必须使用 Percona XtraBackup 8.0.12 或更高版本。
+ **MySQL 5.7** – 使用 Percona XtraBackup 版本 2.4。
您可以使用 Percona XtraBackup 来创建 MySQL 数据库文件的完整备份。或者，如果已使用 Percona XtraBackup 备份 MySQL 数据库文件，您可以上传现有的完整和增量备份目录和文件。
有关使用 Percona XtraBackup 备份数据库的更多信息，请参阅 Percona 网站上的 [Percona XtraBackup - Documentation](https://www.percona.com/doc/percona-xtrabackup/LATEST/index.html)。
### 使用 Percona XtraBackup 创建完整备份
要为 Amazon RDS 可从 Amazon S3 中还原的 MySQL 数据库文件创建完整备份，请使用 Percona XtraBackup 实用程序 (`xtrabackup`)。
例如，以下命令创建 MySQL 数据库备份，并将这些文件存储在 `/on-premises/s3-restore/backup` 文件夹中。
```
xtrabackup --backup --user=myuser --password=password --target-dir=/on-premises/s3-restore/backup
```
如果您想将备份压缩到单个文件中（如果需要，您可以稍后将其拆分为多个文件），可以根据 MySQL 版本将备份保存为以下格式之一：
+ **Gzip (.gz)**：适用于 MySQL 5.7 及更低版本
+ **tar (.tar)**：适用于 MySQL 5.7 及更低版本
+ **Percona xbstream (.xbstream)**：适用于所有 MySQL 版本
**注意**
Percona XtraBackup 8.0 及更高版本仅支持使用 Percona xbstream 进行压缩。
**MySQL 5.7 及更低版本**
以下命令为您的 MySQL 数据库创建一个拆分成多个 Gzip 文件的备份。将值替换为您自己的信息。
```
xtrabackup --backup --user=my_user --password=password --stream=tar \
--target-dir=/on-premises/s3-restore/backup | gzip - | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.tar.gz
```
**MySQL 5.7 及更低版本**
以下命令为您的 MySQL 数据库创建一个拆分成多个 tar 文件的备份。将值替换为您自己的信息。
```
xtrabackup --backup --user=my_user --password=password --stream=tar \
--target-dir=/on-premises/s3-restore/backup | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.tar
```
**所有 MySQL 版本**
以下命令为您的 MySQL 数据库创建一个拆分成多个 xbstream 文件的备份。将值替换为您自己的信息。
```
xtrabackup --backup --user=myuser --password=password --stream=xbstream \
--target-dir=/on-premises/s3-restore/backup | split -d --bytes=500MB \
- /on-premises/s3-restore/backup/backup.xbstream
```
**注意**
如果您看到以下错误，则可能是由于命令中混用了文件格式所致：
```
ERROR:/bin/tar: This does not look like a tar archive
```
### 通过 Percona XtraBackup 使用增量备份
如果您已使用 Percona XtraBackup 对 MySQL 数据库文件进行完整备份和增量备份，则无需创建完整备份和将备份文件上传到 Amazon S3。相反，为了节省时间，请将现有的备份目录和文件复制到 Amazon S3 存储桶中。有关使用 Percona XtraBackup 创建增量备份的更多信息，请参阅 Percona 网站上的 [Create an incremental backup](https://docs.percona.com/percona-xtrabackup/LATEST/create-incremental-backup.html)。
在将现有的完整备份和增量备份文件复制到 Amazon S3 存储桶时，您必须以递归方式复制基目录的内容。这些内容同时包括完整备份以及所有增量备份目录和文件。此副本必须在 Amazon S3 存储桶中保留目录结构。Amazon RDS 将循环访问所有文件和目录。Amazon RDS 使用每个增量备份中包含的 `xtrabackup-checkpoints` 文件来标识基本目录，并按日志序列号（LSN）范围对增量备份进行排序。
### Percona XtraBackup 的备份注意事项
Amazon RDS 根据文件名使用您的备份文件。根据文件格式使用相应的文件扩展名来命名备份文件。例如，使用 `.xbstream` 来表示使用 Percona xbstream 格式存储的文件。
Amazon RDS 按照字母顺序以及自然数字顺序使用您的备份文件。为确保按正确的顺序写入和命名备份文件，请在发出 `xtrabackup` 命令时使用 `split` 选项。
Amazon RDS 不支持使用 Percona XtraBackup 创建的部分备份。在备份数据库的源文件时，不能使用以下选项创建部分备份：
+ `--tables`
+ `--tables-exclude`
+ `--tables-file`
+ `--databases`
+ `--databases-exclude`
+ `--databases-file`
## 手动创建 IAM 角色
如果您没有 IAM 角色，则可以手动创建一个新的角色。但是，如果您使用 AWS 管理控制台还原数据库，我们建议您选择让 Amazon RDS 为您创建这个新的 IAM 角色。要让 Amazon RDS 为您创建此角色，请按照[将数据从 Amazon S3 导入到新的 MySQL 数据库实例](#MySQL.Procedural.Importing.PerformingImport)一节中的过程进行操作。
要手动创建新的 IAM 角色以从 Amazon S3 导入数据库，请创建一个角色，以便将权限从 Amazon RDS 委托给 Amazon S3 存储桶。在创建 IAM 角色时，可附加信任和权限策略。要从 Amazon S3 中导入备份文件，请使用类似于以下示例的信任和权限策略。有关创建角色的更多信息，请参阅[创建将权限委派给 AWS 服务的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html)。
信任和权限策略要求您提供 Amazon Resource Name (ARN)。有关 ARN 格式的更多信息，请参阅 [Amazon Resource Name (ARN) 和 AWS 服务命名空间](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)。
**Example 用于从 Amazon S3 导入的信任策略**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AssumeRoleForBackup",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
**Example 用于从 Amazon S3 导入的权限策略 – IAM 用户权限**
在以下示例中，将 *iam\$1user\$1id* 替换为您自己的值。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowS3AccessRole",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/S3Access"
}
]
}
```
**Example 用于从 Amazon S3 导入的权限策略 – 角色权限**
在以下示例中，将 *amzn-s3-demo-bucket* 和 *prefix* 替换为您自己的值。
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix*"
},
{
"Effect": "Allow",
"Action":
[
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/key_id*"
]
}
]
}
```
如果包含文件名前缀，请在前缀后面包含星号 (\$1)。如果您不想指定前缀，请仅指定星号。
## 将数据从 Amazon S3 导入到新的 MySQL 数据库实例
您可以使用AWS 管理控制台、AWS CLI 或 RDS API 将数据从 Amazon S3 导入到新的 MySQL 数据库实例。
### 控制台
**将数据从 Amazon S3 导入到新的 MySQL 数据库实例**
1. 登录 AWS 管理控制台 并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在 Amazon RDS 控制台的右上角，选择要在其中创建数据库实例的 AWS 区域。选择与包含数据库备份的 Amazon S3 桶相同的 AWS 区域。
1. 在导航窗格中，选择**数据库**。
1. 选择**从 S3 还原**。
此时将显示**通过从 S3 还原创建数据库**页面。
![\[通过从 S3 还原创建数据库页面，可在其中指定从 S3 还原数据库实例的详细信息。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/mys-s3-ingestion.png)
1. 在 **S3 源**下：
1. 选择包含备份的 **S3 桶**。
1. （可选）对于 **S3 前缀**，输入存储在 Amazon S3 存储桶中的文件的文件路径前缀。
如果未指定前缀，则 Amazon RDS 使用 S3 存储桶的根文件夹中的所有文件和文件夹创建数据库实例。如果的确指定了前缀，则 Amazon RDS 使用 S3 存储桶中文件路径以指定前缀开头的文件和文件夹来创建数据库实例。
例如，您将备份文件存储在 S3 上名为 backups 的子文件夹中，并且具有多组备份文件，每个文件位于其自己的目录（gzip\$1backup1、gzip\$1backup2，依此类推）中。在这种情况下，要从 gzip\$1backup1 文件夹中的文件进行还原，请指定前缀 backups/gzip\$1backup1。
1. 在**引擎选项**下：
1. 对于**引擎类型**，选择 **MySQL**。
1. 对于**源引擎版本**，请选择源数据库的 MySQL 主版本。
1. 对于**引擎版本**，选择您所在AWS 区域中 MySQL 主要版本的默认次要版本。
在AWS 管理控制台中，仅默认的次要版本可用。完成导入后，您可以升级数据库实例。
1. 对于 **IAM 角色**，创建或选择具有所需信任策略和权限策略的 IAM 角色，即允许 Amazon RDS 访问您的 Amazon S3 存储桶。执行以下操作之一：
+ （推荐）选择**创建新角色**，然后输入 **IAM 角色名称**。选择此选项后，Amazon RDS 会自动为您创建具有信任策略和权限策略的角色。
+ 选择现有 IAM 角色。确保此角色符合[手动创建 IAM 角色](#MySQL.Procedural.Importing.Enabling.IAM)中的所有条件。
1. 指定数据库实例信息。有关每项设置的信息，请参阅 [数据库实例的设置](USER_CreateDBInstance.Settings.md)。
**注意**
确保为新的数据库实例分配足够的存储空间，以便成功进行还原操作。
要支持未来自动增长，请在**其他存储配置**下选择**启用存储自动扩缩**。
1. 根据需要选择其他设置。
1. 选择**创建数据库**。
### AWS CLI
要使用 AWS CLI 将数据从 Amazon S3 导入新的 MySQL 数据库实例，请使用以下选项运行 [restore-db-instance-from-s3](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html) 命令。有关每项设置的信息，请参阅[数据库实例的设置](USER_CreateDBInstance.Settings.md)。
**注意**
确保为新的数据库实例分配足够的存储空间，以便成功进行还原操作。
要启用存储自动扩缩并支持未来自动增长，请使用 `--max-allocated-storage` 选项。
+ `--allocated-storage`
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine`
+ `--master-username`
+ `--manage-master-user-password`
+ `--s3-bucket-name`
+ `--s3-ingestion-role-arn`
+ `--s3-prefix`
+ `--source-engine`
+ `--source-engine-version`
**Example**
对于 Linux、macOS 或 Unix：
```
1. aws rds restore-db-instance-from-s3 \
2. --allocated-storage 250 \
3. --db-instance-identifier my_identifier \
4. --db-instance-class db.m5.large \
5. --engine mysql \
6. --master-username admin \
7. --manage-master-user-password \
8. --s3-bucket-name amzn-s3-demo-bucket \
9. --s3-ingestion-role-arn arn:aws:iam::account-number:role/rolename \
10. --s3-prefix bucket_prefix \
11. --source-engine my_sql \
12. --source-engine-version 8.0.32 \
13. --max-allocated-storage 1000
```
对于：Windows
```
1. aws rds restore-db-instance-from-s3 ^
2. --allocated-storage 250 ^
3. --db-instance-identifier my_identifier ^
4. --db-instance-class db.m5.large ^
5. --engine mysql ^
6. --master-username admin ^
7. --manage-master-user-password ^
8. --s3-bucket-name amzn-s3-demo-bucket ^
9. --s3-ingestion-role-arn arn:aws:iam::account-number:role/rolename ^
10. --s3-prefix bucket_prefix ^
11. --source-engine mysql ^
12. --source-engine-version 8.0.32 ^
13. --max-allocated-storage 1000
```
### RDS API
要使用 Amazon RDS API 将数据从 Amazon S3 导入新的 MySQL 数据库实例，请调用 [RestoreDBInstanceFromS3](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html) 操作。
## 将备份文件从 Amazon S3 导入到 Amazon RDS 的限制和注意事项
以下限制和注意事项适用于将备份文件从 Amazon S3 导入到 RDS for MySQL 数据库实例：
+ 您只能将数据迁移到新的数据库实例，而不能迁移到现有的数据库实例。
+ 您必须使用 Percona XtraBackup 将数据备份到 Amazon S3。有关更多信息，请参阅 [创建数据库备份](#MySQL.Procedural.Importing.Backup)。
+ Amazon S3 存储桶和 RDS for MySQL 数据库实例必须在同一个 AWS 区域中。
+ 您无法从以下来源进行还原：
+ 到 Amazon S3 的数据库实例快照导出。您也无法将数据从数据库实例快照导出迁移到 Amazon S3 存储桶。
+ 加密的源数据库。但是，您可以加密正在迁移的数据。您也可以在迁移过程中不加密数据。
+ MySQL 5.5 或 5.6 数据库。
+ RDS for MySQL 不支持将 Percona Server for MySQL 用作源数据库，因为它可能在 `mysql schema` 中包含 `compression_dictionary*` 表。
+ RDS for MySQL 不支持主要版本或次要版本的反向迁移。例如，您无法从 MySQL 版本 8.0 迁移到 RDS for MySQL 5.7，也无法从 MySQL 版本 8.0.32 迁移到 RDS for MySQL 版本 8.0.26。
+ Amazon RDS 不支持从 Amazon S3 中的 db.t2.micro 数据库实例类上进行导入。不过，您可以还原到不同的数据库实例类，然后更改该数据库实例类。有关实例类的更多信息，请参阅[数据库实例类的硬件规格](Concepts.DBInstanceClass.Summary.md)。
+ Amazon S3 将上传到 Amazon S3 存储桶的文件大小限制为 5 TB。如果备份文件超过 5 TB，则必须将备份文件拆分为较小的文件。
+ Amazon RDS 将上传到 Amazon S3 存储桶的文件数限制为一百万个。如果数据库的备份数据 (包括所有完整和增量备份) 超过 100 万个文件，请使用 Gzip (.gz)、tar (.tar.gz) 或 Percona xbstream (.xbstream) 文件将完整和增量备份文件存储在 Amazon S3 存储桶中。Percona XtraBackup 8.0 仅支持使用 Percona xbstream 进行压缩。
+ 要为每个数据库实例提供管理服务，Amazon RDS 会在创建数据库实例时创建 `rdsadmin` 用户。由于 `rdsamin` 是 Amazon RDS 中的保留用户，因此以下限制适用：
+ Amazon RDS 不导入以 `'rdsadmin'@'localhost'` 作为定义者的函数、过程、视图、事件和触发器。有关更多信息，请参阅[以 'rdsamin'@'localhost' 作为定义者的存储对象](#MySQL.Procedural.Importing.StoredObjects)和[主用户账户权限](UsingWithRDS.MasterAccounts.md)。
+ 创建数据库实例时，Amazon RDS 会创建一个具有最大受支持权限的主用户。从备份还原时，Amazon RDS 会自动移除分配给正在导入的用户的任何不受支持的权限。
要识别可能受此影响的用户，请参阅[具有不支持的权限的用户账户](#MySQL.Migrating.ExtMySQL.Prechecks.Users)。有关 RDS for MySQL 中支持的权限的更多信息，请参阅 [RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)。
+ Amazon RDS 不会迁移 `mysql` 架构中用户创建的表。
+ 您必须仅通过一个使用默认数据文件名 `ibdata1:12M:autoextend` 的数据文件来配置 `innodb_data_file_path` 参数。可以使用此方法迁移具有两个数据文件或具有不同名称的数据文件的数据库。
以下示例是 Amazon RDS 不支持的文件名：
+ `innodb_data_file_path=ibdata1:50M`
+ `ibdata2:50M:autoextend`
+ `innodb_data_file_path=ibdata01:50M:autoextend`
+ 您无法从在默认 MySQL 数据目录外部定义表的源数据库中迁移。
+ 使用此方法的未压缩备份支持的最大大小限制为 64 TiB。对于压缩的备份，考虑到解压缩空间的需求，此限制会降低。在此类情况下，支持的最大备份大小为 `64 TiB - compressed backup size`。
有关 RDS for MySQL 支持的最大数据库大小的信息，请参阅[通用型 SSD 存储](CHAP_Storage.md#Concepts.Storage.GeneralSSD)和[预置 IOPS SSD 存储](CHAP_Storage.md#USER_PIOPS)。
+ Amazon RDS 不支持导入 MySQL 以及其它外部组件和插件。
+ Amazon RDS 不会从您的数据库中还原所有内容。我们建议您从源 MySQL 系统数据库保存数据库架构以及以下项目的值，然后将这些内容添加到已还原的 RDS for MySQL 数据库实例（在创建该实例后）：
+ 用户账户
+ 函数
+ 存储过程
+ 时区信息。从 RDS for MySQL 数据库实例的本地操作系统中加载时区信息。有关更多信息，请参阅 [MySQL 数据库实例的本地时区](MySQL.Concepts.LocalTimeZone.md)。
### 以 'rdsamin'@'localhost' 作为定义者的存储对象
Amazon RDS 不导入以 `'rdsadmin'@'localhost'` 作为定义者的函数、过程、视图、事件和触发器。
您可以在源 MySQL 数据库上使用以下 SQL 脚本来列出具有不受支持的定义程序的存储对象。
```
-- This SQL query lists routines with `rdsadmin`@`localhost` as the definer.
SELECT
ROUTINE_SCHEMA,
ROUTINE_NAME
FROM
information_schema.routines
WHERE
definer = 'rdsadmin@localhost';
-- This SQL query lists triggers with `rdsadmin`@`localhost` as the definer.
SELECT
TRIGGER_SCHEMA,
TRIGGER_NAME,
DEFINER
FROM
information_schema.triggers
WHERE
DEFINER = 'rdsadmin@localhost';
-- This SQL query lists events with `rdsadmin`@`localhost` as the definer.
SELECT
EVENT_SCHEMA,
EVENT_NAME
FROM
information_schema.events
WHERE
DEFINER = 'rdsadmin@localhost';
-- This SQL query lists views with `rdsadmin`@`localhost` as the definer.
SELECT
TABLE_SCHEMA,
TABLE_NAME
FROM
information_schema.views
WHERE
DEFINER = 'rdsadmin@localhost';
```
### 具有不支持的权限的用户账户
如果用户账户的权限不受 RDS for MySQL 支持，则在导入这些账户时将不包含这些不受支持的权限。有关支持的权限列表，请参阅[RDS for MySQL 的基于角色的权限模型](Appendix.MySQL.CommonDBATasks.privilege-model.md)。
可以在源数据库上运行以下 SQL 查询，以列出具有不受支持的权限的用户账户。
```
SELECT
user,
host
FROM
mysql.user
WHERE
Shutdown_priv = 'y'
OR File_priv = 'y'
OR Super_priv = 'y'
OR Create_tablespace_priv = 'y';
```
# 将数据从外部 MySQL 数据库导入到 Amazon RDS for MySQL 数据库实例
您可以将数据从现有 MySQL 数据库导入到 RDS for MySQL 数据库实例。为此，请使用 [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) 复制数据库，然后通过管道将其直接传输到 RDS for MySQL 数据库实例。`mysqldump` 命令行实用程序通常用于创建备份以及在 MySQL 服务器之间传输数据。该实用程序包含在 MySQL 客户端软件中。
**注意**
如果您使用 MySQL 数据库实例导入或导出大量数据，则可以使用 `xtrabackup` 备份文件和 Amazon S3 更可靠、更块地将数据移入和移出 Amazon RDS。有关更多信息，请参阅 [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md)。
将数据从外部数据库移动到 Amazon RDS 数据库实例的典型 `mysqldump` 命令类似以下示例。将值替换为您自己的信息。
```
mysqldump -u local_user \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mysql -u RDS_user \
--port=port_number \
--host=host_name \
-pRDS_password
```
**重要**
确保 `-p` 选项和输入的密码之间不留空格。
作为安全最佳实践，请指定此示例中显示的提示以外的凭证。
确保您了解以下建议和注意事项：
+ 从转储文件中排除以下架构：
+ `sys`
+ `performance_schema`
+ `information_schema`
默认情况下，`mysqldump` 实用工程序包括这些架构。
+ 如果您需要迁移用户和权限，请考虑使用生成数据控制语言 (DCL) 的工具 (如 [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html) 实用程序) 来重新创建用户和权限。
+ 要执行导入，请确保执行此操作的用户有权访问数据库实例。有关更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
所用参数如下所示：
+ `-u local_user` – 用于指定用户名。在第一次使用该参数时，请指定您使用 `--databases` 参数确定的本地 MySQL 数据库中的用户账户名称。
+ `--databases database_name`：用于指定本地 MySQL 实例上您要导入 Amazon RDS 的数据库的名称。
+ `--single-transaction` – 用于确保从本地数据库加载的所有数据都与单一时间点保持一致。如果在 `mysqldump` 读取数据期间有其他进程更改数据，使用该参数有助于保持数据完整性。
+ `--compress` – 用于降低网络带宽消耗，方式为将数据从本地数据库发送到 Amazon RDS 之前压缩数据。
+ `--order-by-primary` – 用于减少加载时间，方式为根据主键对每个表中的数据进行排序。
+ `--routines`：如果您要复制的数据库中存在诸如存储过程或函数之类的例程，则使用此参数。将此参数设置为 `0`，这将在导入过程中排除例程。稍后在 Amazon RDS 数据库中手动重新创建例程。
+ `--triggers`：如果要复制的数据库中存在触发器，则使用此参数。将此参数设置为 `0`，这将在导入过程中排除触发器。稍后在 Amazon RDS 数据库中手动重新创建触发器。
+ `--events`：如果要复制的数据库中存在事件，则使用此参数。将此参数设置为 `0`，这将在导入过程中排除事件。稍后在 Amazon RDS 数据库中手动重新创建事件。
+ `-plocal_password` – 用于指定密码。在第一次使用该参数时，请为您使用第一个 `-u` 参数标识的用户账户指定密码。
+ `-u RDS_user` – 用于指定用户名。在第二次使用该参数时，请为您使用 `--host` 参数标识的 MySQL 数据库实例指定默认数据库上的用户账户的名称。
+ `--port port_number`：用于为您的 MySQL 数据库实例指定端口。默认情况下该值为 3306，除非您在创建数据库实例时更改了该值。
+ `--host host_name` – 用于从 Amazon RDS 数据库实例端点指定域名系统 (DNS) 名称，例如，`myinstance.123456789012.us-east-1.rds.amazonaws.com`。您可以在 Amazon RDS 控制台上的数据库实例详细信息中找到端点值。
+ `-pRDS_password` – 用于指定密码。在第二次使用该参数时，您为第二个 `-u` 参数确定的用户账户指定密码。
确保在 Amazon RDS 数据库中手动创建任何存储过程、触发器、函数或事件。如果您所复制的数据库中有上述任一对象，则在运行 `mysqldump` 时排除这些对象。为此，使用 `mysqldump` 命令时请包含以下参数：
+ `--routines=0`
+ `--triggers=0`
+ `--events=0`
**示例**
以下示例将本地主机上的 `world` 示例数据库复制到 RDS for MySQL 数据库实例中。将值替换为您自己的信息。
对于 Linux、macOS 或 Unix：
```
sudo mysqldump -u local_user \
--databases world \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mysql -u rds_user \
--port=3306 \
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com \
-pRDS_password
```
对于：Windows
在已通过右键单击 Windows 程序菜单上的**命令提示符**并选择**以管理员身份运行**打开的命令提示符中，运行以下命令：将值替换为您自己的信息。
```
mysqldump -u local_user ^
--databases world ^
--single-transaction ^
--compress ^
--order-by-primary ^
--routines=0 ^
--triggers=0 ^
--events=0 ^
-plocal_password | mysql -u RDS_user ^
--port=3306 ^
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com ^
-pRDS_password
```
**注意**
作为安全最佳实践，请指定示例中显示的提示以外的凭证。
# 将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间
有时，您可能需要将数据从支持活动应用程序的外部 MySQL 数据库导入到 RDS for MySQL 数据库实例或 RDS for MySQL 多可用区数据库集群。使用以下过程可最大程度地减小对应用程序可用性产生的影响。如果使用非常大的数据库，该步骤也很有用。使用该过程，您可以通过减少跨网络传送到 AWS 的数据量以降低导入成本。
在该过程中，您将数据库数据的副本传输到 Amazon EC2 实例，并将数据导入到新的 Amazon RDS 数据库中。然后，使用复制功能使 Amazon RDS 数据库与活动的外部实例保持同步，再将应用程序重新导向到 Amazon RDS 数据库。基于二进制日志坐标配置复制。
**注意**
如果您想要将数据导入到 RDS for MySQL 数据库实例中且您的方案支持此操作，则建议使用备份文件和 Amazon S3 将数据移入和移出 Amazon RDS。有关更多信息，请参阅 [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md)。
下图显示将外部 MySQL 数据库导入到 Amazon RDS 上的 MySQL 数据库。
![\[显示将外部 MySQL 数据库导入到 Amazon RDS 上的 MySQL 数据库的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_1.png)
## 任务 1：创建现有数据库的副本
要以尽可能少的停机时间将大量数据迁移到 RDS for MySQL 数据库，第一步是创建源数据的副本。
下图显示了创建 MySQL 数据库的备份。
![\[显示创建 MySQL 数据库的备份的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_2.png)
您可以使用 `mysqldump` 实用程序创建 SQL 或分隔的文本格式的数据库备份。建议您在非生产环境中对每种格式运行测试，以便了解哪种方法能最大程度地减少 `mysqldump` 运行的时间。
我们还建议您对照将分隔文本格式用于加载所获得的好处来权衡 `mysqldump` 性能。使用分隔的文本格式的备份将为所转储的每个表创建制表符分隔的文本文件。为减少导入数据库所需的时间，您可以使用 `LOAD DATA LOCAL INFILE` 命令并行加载这些文件。有关更多信息，请参阅“从任意来源导入数据”过程中的[步骤 5：加载数据](mysql-importing-data-any-source.md#mysql-importing-data-any-source-load-data)。
在开始备份操作之前，确保对将复制到 Amazon RDS 的 MySQL 数据库设置复制选项。复制选项包括开启二进制日志记录和设置唯一的服务器 ID。设置这些选项将促使您的服务器开始记录数据库事务，并做好在该过程的后面充当源复制实例的准备。
确保您了解以下建议和注意事项：
+ 将 `--single-transaction` 选项与 `mysqldump` 结合使用，因为它会转储数据库的一致状态。为确保转储文件有效，请勿在 `mysqldump` 运行时运行数据定义语言 (DDL) 语句。您可以为这些操作计划维护时段。
+ 从转储文件中排除以下架构：
+ `sys`
+ `performance_schema`
+ `information_schema`
默认情况下，`mysqldump` 实用工程序包括这些架构。
+ 如果您需要迁移用户和权限，请考虑使用生成数据控制语言 (DCL) 的工具 (如 [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html) 实用程序) 来重新创建用户和权限。
### 设置复制选项
1. 编辑 `my.cnf` 文件。此文件通常位于 `/etc` 下。
```
sudo vi /etc/my.cnf
```
将 `log_bin` 和 `server_id` 选项添加到 `[mysqld]` 节。`log_bin` 选项为二进制日志文件提供文件名标识符。`server_id` 选项为源-副本关系中的服务器提供唯一标识符。
以下示例显示 `my.cnf` 文件已更新的 `[mysqld]` 部分：
```
[mysqld]
log-bin=mysql-bin
server-id=1
```
有关更多信息，请参阅 MySQL 文档中的 [Setting the Replication Source Configuration](https://dev.mysql.com/doc/refman/8.4/en/replication-howto-masterbaseconfig.html)。
1. 要使用多可用区数据库集群进行复制，请将 `ENFORCE_GTID_CONSISTENCY` 和 `GTID_MODE` 参数设置为 `ON`。
```
mysql> SET @@GLOBAL.ENFORCE_GTID_CONSISTENCY = ON;
```
```
mysql> SET @@GLOBAL.GTID_MODE = ON;
```
使用数据库实例进行复制不需要这些设置。
1. 重新启动 `mysql` 服务。
```
sudo service mysqld restart
```
### 创建现有数据库的备份副本
1. 使用 `mysqldump` 实用程序创建数据备份，并指定 SQL 或分隔的文本格式。
对于 MySQL 8.0.25 及更低版本，指定 `--master-data=2` 以创建可用于启动服务器间复制的备份文件。对于 MySQL 8.0.26 及更高版本，指定 `--source-data=2` 以创建可用于启动服务器间复制的备份文件。有关更多信息，请参阅 MySQL 文档中的 [mysqldump — A Database Backup Program](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html)。
要提高性能和确保数据完整性，请对于 `mysqldump` 使用 `--order-by-primary` 和 `--single-transaction` 选项。
要避免在备份中包括 MySQL 系统数据库，请不要将 `--all-databases` 选项与 `mysqldump` 结合使用。有关更多信息，请参阅 MySQL 文档中的 [Creating a Data Snapshot Using mysqldump](https://dev.mysql.com/doc/mysql-replication-excerpt/8.0/en/replication-howto-mysqldump.html)。
如有必要，可使用 `chmod` 来确保要在其中创建备份文件的目录是可写的。
**重要**
在 Windows 中，以管理员身份运行命令窗口。
+ 要生成 SQL 输出，请使用以下命令：
对于 Linux、macOS 或 Unix：
```
sudo mysqldump \
--databases database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-r backup.sql \
-u local_user \
-ppassword
```
**注意**
作为安全最佳实践，请指定示例中显示的提示以外的凭证。
对于：Windows
```
mysqldump ^
--databases database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-r backup.sql ^
-u local_user ^
-ppassword
```
**注意**
作为安全最佳实践，请指定示例中显示的提示以外的凭证。
+ 要生成分隔文本输出，请使用以下命令：
对于 Linux、macOS 或 Unix：
```
sudo mysqldump \
--tab=target_directory \
--fields-terminated-by ',' \
--fields-enclosed-by '"' \
--lines-terminated-by 0x0d0a \
database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-ppassword
```
对于：Windows
```
mysqldump ^
--tab=target_directory ^
--fields-terminated-by "," ^
--fields-enclosed-by """ ^
--lines-terminated-by 0x0d0a ^
database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-ppassword
```
**注意**
作为安全最佳实践，请指定示例中显示的提示以外的凭证。
确保在 Amazon RDS 数据库中手动创建任何存储过程、触发器、函数或事件。如果您所复制的数据库中有上述任一对象，则在运行 `mysqldump` 时排除这些对象。为此，请在 `mysqldump` 命令中包含以下参数：
`--routines=0`
`--triggers=0`
`--events=0`
对于 MySQL 8.0.22 及更低版本，当您运行 `mysqldump` 并指定分隔文本格式时，将返回 `CHANGE MASTER TO` 注释。此注释包含主日志文件名称和位置。对于 MySQL 8.0.23 及更高版本，如果您使用分隔文本格式运行 `mysqldump`，将返回 `CHANGE REPLICATION SOURCE TO` 注释。此注释包含源日志文件名称和位置。如果外部实例是 MySQL 8.0.23 及更高版本，请注意 `MASTER_LOG_FILE` 和 `MASTER_LOG_POS` 的值。设置复制时需要这些值。
对于 MySQL 8.0.22 及更低版本，将返回以下输出：
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
对于 MySQL 8.0.23 及更高版本，将返回以下输出：
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE SOURCE TO SOURCE_LOG_FILE='mysql-bin-changelog.000031', SOURCE_LOG_POS=107;
```
对于 MySQL 8.0.22 及更低版本，如果您使用的是 SQL 格式，则可以在备份文件的 `CHANGE MASTER TO` 注释中获得主日志文件名称和位置。对于 MySQL 8.0.23 及更高版本，如果您使用的是 SQL 格式，则可以在备份文件的 `CHANGE REPLICATION SOURCE TO` 注释中获得源日志文件名称和位置。
1. 压缩复制后的数据可减少将数据复制到 Amazon RDS 数据库所需的网络资源量。记下备份文件的大小。您在确定要创建的 Amazon EC2 实例的大小时需要此信息。完成操作后，请使用 GZIP 或您的首选压缩实用程序来压缩备份文件。
+ 要压缩 SQL 输出，请使用以下命令：
```
gzip backup.sql
```
+ 要压缩分隔文本输出，请使用以下命令：
```
tar -zcvf backup.tar.gz target_directory
```
## 任务 2：创建 Amazon EC2 实例和复制压缩的数据库
将压缩的数据库备份文件复制到 Amazon EC2 实例所占用的网络资源少于直接在数据库实例之间复制未压缩的数据所占用的网络资源。当您的数据位于 Amazon EC2 中后，可以直接从中将数据复制到 MySQL 数据库。要节省网络资源成本，您的 Amazon EC2 实例必须与 Amazon RDS 数据库实例位于同一 AWS 区域内。使 Amazon EC2 实例位于 Amazon RDS 数据库所在的相同 AWS 区域内，还可以减少导入期间的网络延迟。
下图显示了将数据库备份复制到 Amazon EC2 实例。
![\[显示将数据库备份复制到 Amazon EC2 实例的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_3.png)
### 创建 Amazon EC2 实例并复制数据
1. 在您打算在其中创建 Amazon RDS 数据库的 AWS 区域中，创建虚拟私有云（VPC）、VPC 安全组和 VPC 子网。确保您的 VPC 安全组的入站规则允许应用程序连接到 AWS 所需的 IP 地址。您可以指定一系列 IP 地址（例如 `203.0.113.0/24`）或另一个 VPC 安全组。可以使用 [Amazon VPC 控制台](https://console.aws.amazon.com/vpc)来创建和管理 VPC、子网和安全组。有关更多信息，请参阅《Amazon Virtual Private Cloud 用户指南》**中的 [Amazon VPC 入门](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html#getting-started)。
1. 打开 [Amazon EC2 控制台](https://console.aws.amazon.com/ec2)，并选择将包含 Amazon EC2 实例和 Amazon RDS 数据库的 AWS 区域。使用您在步骤 1 中创建的 VPC、子网和安全组来启动 Amazon EC2 实例。在数据库备份文件未压缩的情况下，确保为该文件选择具有足够存储空间的实例类型。有关 Amazon EC2 实例的详细信息，请参阅《Amazon Elastic Compute Cloud 用户指南》**中的[开始使用 Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html)。
1. 要从 Amazon EC2 实例连接到 Amazon RDS 数据库，请编辑 VPC 安全组。添加指定 EC2 实例的私有 IP 地址的入站规则。您可以在 EC2 控制台窗口中的 **Instance** 窗格的 **Details** 选项卡上找到私有 IP 地址。要编辑 VPC 安全组并添加入站规则，请在 EC2 控制台导航窗格中选择 **Security Groups**（安全组），然后为 MySQL 或 Aurora 添加指定 EC2 实例的私有 IP 地址的入站规则。要了解如何向 VPC 安全组添加入站规则，请参阅《Amazon Virtual Private Cloud 用户指南》**中的[安全组规则](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html)。
1. 将压缩后的数据库备份文件从本地系统复制到 Amazon EC2 实例中。如有必要，可使用 `chmod` 来确保您具有 Amazon EC2 实例目标目录的写入权限。您可以使用 `scp` 或 Secure Shell (SSH) 客户端复制文件。以下命令是一个示例 `scp` 命令：
```
scp -r -i key pair.pem backup.sql.gz ec2-user@EC2 DNS:/target_directory/backup.sql.gz
```
**重要**
复制敏感数据时，务必使用安全网络传输协议。
1. 连接到 Amazon EC2 实例，并使用以下命令安装最新更新和 MySQL 客户端工具：
```
sudo yum update -y
sudo yum install mysql -y
```
有关更多信息，请参阅《Amazon Elastic Compute Cloud 用户指南》**中的[连接到您的实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux)（适用于 Linux 实例）。
**重要**
此示例介绍了如何在适用于 Amazon Linux 发行版的 Amazon Machine Image (AMI) 上安装 MySQL 客户端。此示例不在其它发行版（例如 Ubuntu 或 Red Hat Enterprise Linux）上安装 MySQL 客户端。有关安装 MySQL 的信息，请参阅 MySQL 文档中的 [Installing MySQL](https://dev.mysql.com/doc/refman/8.4/en/installing.html)。
1. 在连接到 Amazon EC2 实例时，请解压缩数据库备份文件。下面是一些命令示例。
+ 要解压缩 SQL 输出，请使用以下命令：
```
gzip backup.sql.gz -d
```
+ 要解压缩分隔的文本输出，请使用以下命令：
```
tar xzvf backup.tar.gz
```
## 任务 3：创建 MySQL 数据库，并从 Amazon EC2 实例导入数据
通过在 Amazon EC2 实例所在的同一 AWS 区域中创建 RDS for MySQL 数据库实例或 RDS for MySQL 多可用区数据库集群，与通过互联网相比，可以更快地从 Amazon EC2 导入数据库备份文件。
下图显示了将备份从 Amazon EC2 实例导入到 MySQL 数据库。
![\[显示将备份从 EC2 实例导入到 MySQL 数据库的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_4.png)
### 创建 MySQL 数据库并导入数据
1. 确定支持此 Amazon RDS 数据库的预期工作负载所需的数据库实例类和存储空间量。作为过程的一部分，确定数据加载过程所需的足够空间量和处理能力。此外，确定处理生产工作负载所需的项目。您可以根据源 MySQL 数据库的大小和资源来进行估计。有关更多信息，请参阅 [数据库实例类](Concepts.DBInstanceClass.md)。
1. 在包含您的 Amazon EC2 实例的 AWS 区域中创建数据库实例或多可用区数据库集群。
要创建 RDS for MySQL 多可用区数据库集群，请按[创建 Amazon RDS 的多可用区数据库集群](create-multi-az-db-cluster.md)中的说明操作。
要创建 RDS for MySQL 数据库实例，请按照[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)中的说明操作并使用以下准则：
+ 指定与源数据库实例兼容的数据库引擎版本。
+ 指定用于 Amazon EC2 实例的相同虚拟私有云（VPC）和 VPC 安全组。此方式将确保 Amazon EC2 实例和 Amazon RDS 实例通过网络相互可见。确保您的数据库实例可公开访问。要按下一节所述设置源数据库的复制，您的数据库实例必须可公开访问。
+ 在导入数据库备份之前，不要配置多个可用区、备份保留或只读副本。在完成该导入操作后，您可以为生产实例配置多可用区和备份保留期。
1. 检查 Amazon RDS 数据库的默认配置选项。如果数据库的默认参数组没有所需的配置选项，请查找具有这些选项的参数组，或创建新的参数组。有关创建参数组的详细信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 以主用户身份连接到新 Amazon RDS 数据库。创建为需要访问数据库实例的管理员、应用程序和服务提供支持所需的用户。Amazon RDS 数据库的主机名为此数据库实例的**端点**值（不包含端口号），例如 `mysampledb.123456789012.us-west-2.rds.amazonaws.com`。您可以在 Amazon RDS 控制台上的数据库详细信息中找到端点值。
1. 连接到 Amazon EC2 实例。有关更多信息，请参阅《Amazon Elastic Compute Cloud 用户指南》**中的[连接到您的实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux)（适用于 Linux 实例）。
1. 使用 `mysql` 命令以远程主机身份从 Amazon EC2 实例连接到 Amazon RDS 数据库。以下命令是一个示例：
```
mysql -h host_name -P 3306 -u db_master_user -p
```
*host\$1name* 是 Amazon RDS 数据库端点。
1. 在 `mysql` 提示符下，运行 `source` 命令并向它传递您的数据库转储文件名。此命令将数据加载到 Amazon RDS 数据库实例。
+ 对于 SQL 格式，请使用以下命令：
```
mysql> source backup.sql;
```
+ 对于分隔文本格式，请先创建数据库（如果它不是您在设置 Amazon RDS 数据库时创建的默认数据库）。
```
mysql> create database database_name;
mysql> use database_name;
```
然后，创建表。
```
mysql> source table1.sql
mysql> source table2.sql
etc...
```
然后，导入数据。
```
mysql> LOAD DATA LOCAL INFILE 'table1.txt' INTO TABLE table1 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
mysql> LOAD DATA LOCAL INFILE 'table2.txt' INTO TABLE table2 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
etc...
```
要提高性能，您可以从多个连接并行执行这些操作，以便同时创建并加载所有表。
**注意**
如果您在最初转储表时已将任何数据格式化选项与 `mysqldump` 结合使用，则务必将相同的选项与 `LOAD DATA LOCAL INFILE` 结合使用，来确保正确地解读数据文件内容。
1. 对导入的数据库中的一个或两个表运行简单 `SELECT` 查询，来验证导入是否成功。
如果您不再需要该过程中使用的 Amazon EC2 实例，请终止 EC2 实例以减少AWS资源使用。要终止 EC2 实例，请参阅《Amazon Elastic Compute Cloud 用户指南》**中的[终止实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#terminating-instances-console)。
## 任务 4：将数据从外部数据库复制到新的 Amazon RDS 数据库
在将数据复制并传输到 MySQL 数据库期间，您的源数据库可能已更新。这样，您可以使用复制功能使复制的数据库与源数据库保持同步。
![\[显示将数据从外部 MySQL 数据库复制到 Amazon RDS 上的数据库的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_5.png)
对 Amazon RDS 数据库启动复制功能所需的权限受到限制且对 Amazon RDS 主用户不可用。因此，请使用适用于您的主要引擎版本的 Amazon RDS 存储过程：
+ [mysql\$1rds\$1set\$1external\$1master（RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md)（配置复制）和 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication)（开始复制）
### 启动复制
在任务 1 中，[当您设置复制选项时](#mysql-importing-data-reduced-downtime-set-replication-options)，您开启了二进制日志记录，并为源数据库设置了唯一服务器 ID。现在您可以将 Amazon RDS 数据库设置为副本，并将活动数据库作为源数据库实例。
1. 在 Amazon RDS 控制台中，将托管源数据库的服务器的 IP 地址添加到 Amazon RDS 数据库的 VPC 安全组。有关配置 VPC 安全组的更多信息，请参阅《Amazon Virtual Private Cloud 用户指南》**中的[配置安全组规则](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html)。
您可能还需要配置本地网络，以允许来自 Amazon RDS 数据库的 IP 地址的连接，以便它能与源实例进行通信。要查找 Amazon RDS 数据库的 IP 地址，请使用 `host` 命令：
```
host host_name
```
*host\$1name* 是 Amazon RDS 数据库端点中的 DNS 名称，例如 `myinstance.123456789012.us-east-1.rds.amazonaws.com`。您可以在 Amazon RDS 控制台上的数据库实例详细信息中找到端点值。
1. 通过使用所选的客户端，连接到源实例并创建将用于复制的用户。此账户仅用于复制，并且必须仅供您的域使用以增强安全性。以下命令是一个示例：
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的凭证。
1. 对于源 实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。例如，要为您的域的“`REPLICATION CLIENT`”用户授予对所有数据库的 `REPLICATION SLAVE` 和 `repl_user` 权限，请发出以下命令。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. 将 Amazon RDS 数据库设置为副本。使用适当的 Amazon RDS 存储过程，以主用户身份连接到 Amazon RDS 数据库，并将源数据库标识为源复制实例。
+ [mysql\$1rds\$1set\$1external\$1master（RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source)
如果您具有 SQL 格式的备份文件，则使用您在步骤 4 中确定的主日志文件名和主日志位置。如果您使用的是分隔文本格式，则使用您在创建备份文件时确定的名称和位置。下面是一些命令示例：
**MySQL 8.4 及更高版本**
```
CALL mysql.rds_set_external_source ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MySQL 8.0 及更低版本**
```
CALL mysql.rds_set_external_master ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的凭证。
1. 在 Amazon RDS 数据库上，要开始复制，请运行以下使用 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) 存储过程的命令：
```
CALL mysql.rds_start_replication;
```
1. 在 Amazon RDS 数据库上，要确定副本何时与源复制实例实现同步，请运行 [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) 命令。`SHOW REPLICA STATUS` 命令的结果包括 `Seconds_Behind_Master` 字段。当 `Seconds_Behind_Master` 字段返回 0 时，副本将与源复制实例保持同步。
**注意**
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS`，而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
1. 在 Amazon RDS 数据库同步后，开启自动备份以便您可以在需要时还原该数据库。您可以使用 [Amazon RDS 控制台](https://console.aws.amazon.com/rds/)开启或修改 Amazon RDS 数据库的自动备份。有关更多信息，请参阅 [备份简介](USER_WorkingWithAutomatedBackups.md)。
## 任务 5：将您的活动应用程序重定向到 Amazon RDS 实例
在 MySQL 数据库与源复制实例保持同步后，您现在可以更新活动的应用程序以使用 Amazon RDS 实例。
![\[显示停止复制并将活动应用程序定向到 Amazon RDS 上的数据库的工作流程。\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/images/MigrateMySQLToRDS_6.png)
### 将活动应用程序重新导向到 MySQL 数据库并停止复制
1. 要添加 Amazon RDS 数据库的 VPC 安全组，请添加托管应用程序的服务器的 IP 地址。有关修改 VPC 安全组的更多信息，请参阅《Amazon Virtual Private Cloud 用户指南》**中的[配置安全组规则](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html)。
1. 验证 [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) 命令结果中的 `Seconds_Behind_Master` 字段是否为 0，这表示副本与源复制实例保持同步。
```
SHOW REPLICA STATUS;
```
**注意**
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS`，而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
1. 在事务完成后关闭与源的所有连接。
1. 更新应用程序以使用 Amazon RDS 数据库。此更新通常涉及更改连接设置以标识 Amazon RDS 数据库的主机名和端口、用于进行连接的用户账户和密码以及要使用的数据库。
1. 连接到数据库实例。
对于多可用区数据库集群，连接至写入器数据库实例。
1. 通过运行使用以下使用 [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) 存储过程的命令来停止 Amazon RDS 实例的复制：
```
CALL mysql.rds_stop_replication;
```
1. 通过在 Amazon RDS 数据库上使用相应的 Amazon RDS 存储过程，重置复制配置，使该实例不再被识别为副本：
+ [mysql\$1rds\$1reset\$1external\$1master（RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master)
+ [mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_reset_external_source)
**MySQL 8.4 及更高版本**
```
CALL mysql.rds_reset_external_source;
```
**MySQL 8.0 及更低版本**
```
CALL mysql.rds_reset_external_master;
```
1. 开启其他 Amazon RDS 特征，例如多可用区支持和只读副本。有关更多信息，请参阅[配置和管理 Amazon RDS 的多可用区部署](Concepts.MultiAZ.md)和[使用数据库实例只读副本](USER_ReadRepl.md)。
# 从任意源将数据导入 Amazon RDS for MySQL 数据库实例
使用 Amazon RDS，您可以将任意来源的现有 MySQL 数据迁移到 RDS for MySQL 数据库实例。您可以将数据从本地数据库、其他云提供商或现有 RDS for MySQL 数据库实例传输到目标 RDS for MySQL 数据库实例。借助此功能，您可以整合数据库、实施灾难恢复解决方案或从自管理数据库过渡。常见场景包括从自托管 MySQL 服务器迁移到完全托管的 Amazon RDS 数据库实例、将多个 MySQL 数据库整合为单个数据库实例，或者使用生产数据创建测试环境。以下几部分提供有关使用 `mysqldump`、备份文件或复制等方法导入 MySQL 数据的分步说明。
## 步骤 1：创建包含待加载数据的平面文件
使用通用格式存储待加载的数据，如逗号分隔值 (CSV)。每个表都必须拥有其自己的文件，您不能将多个表的数据合并到同一文件。每个文件的名称都必须与对应的表相同。可以根据个人喜好设置文件扩展名。例如，如果表名称为 `sales`，文件名可能为 `sales.csv` 或 `sales.txt`。
如果可能，请按照正在加载的表的主键对数据进行排序。这样做可以显著优化加载时间并尽可能减少磁盘存储要求。
该过程的速度和效率取决于能否将文件的大小保持在较小状态。如果在未压缩状态下单个文件的大小超过 1 GiB，则需将此文件分割为多个文件，然后分别加载各个文件。
在类 Unix 的系统（包括 Linux）中，请使用 `split` 命令。例如，以下命令会将 `sales.csv` 文件分割为多个小于 1 GiB 的文件，且只在换行符处进行分割 (-C 1024m)。新文件的名称包括升序数字后缀。以下命令生成名称如 `sales.part_00` 和 `sales.part_01` 的文件。
```
split -C 1024m -d sales.csv sales.part_
```
其他操作系统也具有类似的实用程序。
您可以将平面文件存储在任何地方。但是，当在[步骤 5](#mysql-importing-data-any-source-load-data) 中加载数据时，必须从文件存在的相同位置调用 `mysql` Shell，或者在运行 `LOAD DATA LOCAL INFILE` 时使用文件的绝对路径。
## 步骤 2：阻止任何应用程序访问目标数据库实例
开始大量加载前，阻止所有应用程序活动访问您打算加载到的目标数据库实例。建议您这样做，特别是当其他会话将要修改正在加载的表或引用的表时。这可以降低加载过程中发生约束冲突的风险并提高加载性能。它还可以将数据库实例还原到加载前的某一时间点，而不会丢失未参与加载的进程所做的更改。
当然，这可能并不可行或不现实。如果您无法在加载前阻止应用程序访问数据库实例，应采取步骤以确保数据的可用性和完整性。所需的具体步骤在很大程度上根据特定的使用案例和现场要求而有所不同。
## 步骤 3：创建数据库快照
如果您计划将数据加载到不包含数据的新数据库实例，可以跳过此步骤。否则，我们建议您在加载数据之前和之后创建目标 Amazon RDS 数据库实例的数据库快照。Amazon RDS 数据库快照是数据库实例的完整备份，可用于将数据库实例还原到已知状态。在启动数据库快照时，针对数据库实例的 I/O 操作将在备份数据库过程中暂停。
通过在即将开始加载前创建数据库快照，您可以在需要时将数据库还原到加载前的状态。通过使用在加载后立即创建的数据库快照，您可以在遇到问题时不必再次加载数据。还可以在加载后使用数据库快照将数据导入到新的数据库实例中。
以下示例运行 AWS CLI [create-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html) 命令来创建 `AcmeRDS` 实例的数据库快照，并为该数据库快照指定标识符 `"preload"`。
对于 Linux、macOS 或 Unix：
```
aws rds create-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
对于：Windows
```
aws rds create-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
也可以使用从数据库快照还原功能，以创建用于试运行的测试数据库实例或撤消在加载期间进行的更改。
请务必注意，从数据库快照还原数据库将创建新的数据库实例，与所有数据库实例一样，该数据库实例具有唯一的标识符和端点。要还原数据库实例但不改变端点，请先删除该数据库实例，以使您能够重新使用此端点。
例如，要创建一个适用于试运行或其他测试的数据库实例，您可为数据库实例指定它自己的标识符。在示例中，标识符为 `AcmeRDS-2`"。该示例使用与 `AcmeRDS-2` 关联的端点连接到数据库实例。有关更多信息，请参阅 [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)。
对于 Linux、macOS 或 Unix：
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS-2 \
--db-snapshot-identifier preload
```
对于：Windows
```
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS-2 ^
--db-snapshot-identifier preload
```
要重新使用现有的端点，请首先删除该数据库实例，然后为还原的数据库指定相同的标识符。有关更多信息，请参阅 [delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance.html)。
以下示例还在删除数据库实例之前为其制作最终的数据库快照。您可以自由选择，但建议您这样做。
对于 Linux、macOS 或 Unix：
```
aws rds delete-db-instance \
--db-instance-identifier AcmeRDS \
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
对于：Windows
```
aws rds delete-db-instance ^
--db-instance-identifier AcmeRDS ^
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
## 步骤 4（可选）：关闭 Amazon RDS 自动备份
**警告**
如果需要执行时间点故障恢复，请勿关闭自动备份。
关闭自动备份是一种性能优化，加载数据时不需要这样做。关闭自动备份会清除所有现有备份。因此，在关闭自动备份后，将无法使用时间点故障恢复功能。关闭自动备份不会影响手动数据库快照。仍然可以还原所有现有的手动数据库快照。
关闭自动备份可减少约 25% 的加载时间，并减少加载期间所需的存储空间。如果您计划将数据加载到不包含任何数据的新数据库实例，关闭备份就可轻松加速加载并避免使用备份所需的额外存储空间。但是，在某些情况下，您可能会计划将数据加载到已包含数据的数据库实例。如果是这样，请权衡关闭备份的优势与无法执行时间点恢复功能的影响。
数据库实例默认开启自动备份 (保留期为一天)。要关闭自动备份，请将备份保留期设置为零。加载后，可以将备份保留期设置为非零值，重新开启自动备份。要开启或关闭备份，Amazon RDS 将关闭并重新启动数据库实例，以开启或关闭 MySQL 日志记录。
运行 AWS CLI `modify-db-instance` 命令，将备份保留期设置为零并立即应用更改。要将保留期设置为零，需要重新启动数据库实例，因此，等到重新启动完成后再继续操作。有关更多信息，请参阅 [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--apply-immediately \
--backup-retention-period 0
```
对于：Windows
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--apply-immediately ^
--backup-retention-period 0
```
您可以使用 AWS CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) 命令检查数据库实例的状态。以下示例显示 `AcmeRDS` 数据库实例的数据库实例状态：
```
aws rds describe-db-instances --db-instance-identifier AcmeRDS --query "*[].{DBInstanceStatus:DBInstanceStatus}"
```
当数据库实例状态为 `available` 时，您已准备好进行下一步。
## 步骤 5：加载数据
要将平面文件中的行读取到数据库表中，请使用 MySQL `LOAD DATA LOCAL INFILE` 语句。
**注意**
必须从平面文件存在的相同位置调用 `mysql` Shell，或者在运行 `LOAD DATA LOCAL INFILE` 时使用文件的绝对路径。
以下示例说明如何将数据从名为 `sales.txt` 的文件加载到数据库中名为 `Sales` 的表中：
```
mysql> LOAD DATA LOCAL INFILE 'sales.txt' INTO TABLE Sales FIELDS TERMINATED BY ' ' ENCLOSED BY '' ESCAPED BY '\\';
Query OK, 1 row affected (0.01 sec)
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
```
有关 `LOAD DATA` 语句的更多信息，请参阅 MySQL 文档中的 [LOAD DATA Statement](https://dev.mysql.com/doc/refman/8.4/en/load-data.html)。
## 步骤 6：重新开启 Amazon RDS 自动备份
如果您在[步骤 4](#mysql-importing-data-any-source-turn-off-automated-backups) 中关闭了 Amazon RDS 自动备份，则在加载完成后，请通过将备份保留期重新设置为其预加载值来开启自动备份。如步骤 4 中所述，Amazon RDS 会重新启动数据库实例，因此，请为短暂中断做好准备。
以下示例运行 AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) 命令来开启 `AcmeRDS` 数据库实例的自动备份，并将保留期设置为一天：
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--backup-retention-period 1 \
--apply-immediately
```
对于：Windows
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--backup-retention-period 1 ^
--apply-immediately
```
# 在 Amazon RDS 中使用 MySQL 复制
一般使用只读副本配置 Amazon RDS 数据库实例之间的复制。有关只读副本的一般信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。有关使用 Amazon RDS for MySQL 上的只读副本的特定信息，请参阅 [使用 MySQL 只读副本](USER_MySQL.Replication.ReadReplicas.md)。
您可以使用全局事务标识符 (GTID) 与 RDS for MySQL 之间进行复制。有关更多信息，请参阅 [使用基于 GTID 的复制](mysql-replication-gtid.md)。
还可以设置 RDS for MySQL 数据库实例与 Amazon RDS 外部的 MariaDB 或 MySQL 实例之间的复制。有关配置外部源复制的信息，请参阅[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)。
对于其中任何复制选项，您可以使用基于行的复制、基于语句的复制或混合复制。基于行的复制仅复制因 SQL 语句而导致更改的行。基于语句的复制将复制整个 SQL 语句。混合复制尽可能使用基于语句的复制，但当运行对于基于语句的复制不安全的 SQL 语句时切换到基于行的复制。在大多数情况下，建议使用混合复制。数据库实例的二进制日志格式确定复制是基于行、基于语句还是混合的。有关设置二进制日志格式的信息，请参阅[为单可用区数据库配置 RDS for MySQL 二进制日志记录](USER_LogAccess.MySQL.BinaryFormat.md)。
**注意**
您可以配置复制以导入来自 Amazon RDS 外部的 MariaDB 或 MySQL 实例的数据库，或将数据库导出至此类实例。有关更多信息，请参阅[将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间](mysql-importing-data-reduced-downtime.md)和[使用复制从 MySQL 数据库实例中导出数据](MySQL.Procedural.Exporting.NonRDSRepl.md)。
从快照还原数据库实例或执行时间点恢复后，您可以在 RDS 控制台中查看上次从源数据库恢复的二进制日志位置。在**日志和事件**下，输入 **binlog**。二进制日志位置显示在**系统注释**下。
**Topics**
+ [
# 使用 MySQL 只读副本
](USER_MySQL.Replication.ReadReplicas.md)
+ [
# 使用基于 GTID 的复制
](mysql-replication-gtid.md)
+ [
# 配置与外部源实例之间的二进制日志文件位置复制
](MySQL.Procedural.Importing.External.Repl.md)
+ [
# 为 Amazon RDS for MySQL 配置多源复制
](mysql-multi-source-replication.md)
# 使用 MySQL 只读副本
接下来，您可以找到有关使用 RDS for MySQL 上的只读副本的特定信息。有关只读副本及其使用说明的一般信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
有关 MySQL 只读副本的更多信息，请参阅以下主题。
+ [使用 MySQL 配置复制筛选条件](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)
+ [使用 MySQL 配置延迟复制](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)
+ [使用 MySQL 更新只读副本](USER_MySQL.Replication.ReadReplicas.Updates.md)
+ [使用 MySQL 处理多可用区只读副本部署](USER_MySQL.Replication.ReadReplicas.MultiAZ.md)
+ [将级联只读副本用于 RDS for MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)
+ [监控 MySQL 只读副本的复制滞后](USER_MySQL.Replication.ReadReplicas.Monitor.md)
+ [开始和停止 MySQL 只读副本复制](USER_MySQL.Replication.ReadReplicas.StartStop.md)
+ [排查 MySQL 只读副本问题](USER_ReadRepl.Troubleshooting.md)
## 使用 MySQL 配置只读副本
请确保在源数据库实例上启用自动备份，然后 MySQL DB 实例才能用作复制源。为此，请将备份保留期设定为非 0 值。此要求也适用于作为一个只读副本的源数据库实例的另一个只读副本。运行任何版本的 MySQL 的只读副本都支持自动备份。可以为 MySQL 数据库实例配置基于二进制日志坐标的复制。
可以在以下版本上使用全局事务标识符（GTIDS）配置复制：
+ RDS for MySQL 5.7.44 版本及更高的 5.7 版本
+ RDS for MySQL 8.0.28 版本及更高的 8.0 版本
+ RDS for MySQL 8.4.3 版本及更高的 8.4 版本
有关更多信息，请参阅 [使用基于 GTID 的复制](mysql-replication-gtid.md)。
您可以从同一区域内的一个数据库实例创建最多 15 个只读副本。为了有效地进行复制，每个只读副本具有的计算和存储资源的量应与源数据库实例的一样多。如果扩展源数据库实例，则还应扩展只读副本。
RDS for MySQL 支持级联只读副本。要了解如何配置级联只读副本，请参阅 [将级联只读副本用于 RDS for MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)。
您可以在引用相同源数据库实例的同时，运行多个只读副本创建和删除操作。当您执行这些操作时，应将每个源实例的只读副本数限制在 15 个以内。
MySQL 数据库实例的只读副本不能使用比其源数据库实例低的数据库引擎版本。
### 准备使用 MyISAM 的 MySQL 数据库实例
如果 MySQL 数据库实例使用的是 MyISAM 等非事务性引擎，则将需要执行以下步骤才能成功地设置只读副本。需要执行这些步骤，以确保只读副本具有一致的数据副本。如果您的所有表使用的都是事务性引擎 (如 InnoDB)，则无需执行这些步骤。
1. 停止源数据库实例中的非事务性表上的所有数据操作语言 (DML) 和数据定义语言 (DDL) 操作，然后等待它们完成。SELECT 语句可以继续运行。
1. 刷新并锁定源数据库实例中的表。
1. 使用以下各节中的某种方法创建只读副本。
1. 使用如 `DescribeDBInstances` API 操作检查只读副本创建的进度。有只读副本可用后，即解除对源数据库实例的表的锁定，然后继续进行正常的数据库操作。
# 使用 MySQL 配置复制筛选条件
您可以使用复制筛选条件来指定使用只读副本的数据库和表。复制筛选条件可以将数据库和表包含在复制之中或排除在复制之外。
以下是复制筛选条件的一些使用案例：
+ 缩减只读副本的大小。使用复制筛选，您可以排除只读副本上不需要的数据库和表。
+ 出于安全原因，将数据库和表从只读副本中排除。
+ 在不同只读副本中为特定使用案例复制不同的数据库和表。例如，您可以使用特定的只读副本进行分析或分片。
+ 对于在不同 AWS 区域中具有只读副本的数据库实例，要在不同的 AWS 区域中复制不同的数据库或表。
**注意**
您还可以使用复制筛选条件来指定使用入站复制拓扑中裴志伟副本的主 MySQL 数据库实例的数据库和表。有关此配置的更多信息，请参阅[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)。
**Topics**
+ [
## 设置 RDS for MySQL 的复制筛选参数
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [
## RDS for MySQL 的复制筛选限制
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [
## RDS for MySQL 的复制筛选示例
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [
## 查看只读副本的复制筛选条件
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Viewing)
## 设置 RDS for MySQL 的复制筛选参数
要配置复制筛选条件，请在只读副本上设置以下复制筛选参数：
+ `replicate-do-db` –将更改复制到指定的数据库。为只读副本设置此参数时，仅复制参数中指定的数据库。
+ `replicate-ignore-db` –不将更改复制到指定的数据库。为只读副本设置 `replicate-do-db` 参数时，不会评估此参数。
+ `replicate-do-table` –将更改复制到指定的表。为只读副本设置此参数时，仅复制参数中指定的表。此外，设置 `replicate-do-db` 或 `replicate-ignore-db` 参数时，请确保包含指定表的数据库包含在使用只读副本的复制中。
+ `replicate-ignore-table` –不将更改复制到指定的表。为只读副本设置 `replicate-do-table` 参数时，不会评估此参数。
+ `replicate-wild-do-table` – 根据指定的数据库和表名模式复制表。支持 `%` 和 `_` 通配符。设置 `replicate-do-db` 或 `replicate-ignore-db` 参数时，请确保包含指定表的数据库包含在使用只读副本的复制中。
+ `replicate-wild-ignore-table` –不基于指定的数据库和表名模式复制表。支持 `%` 和 `_` 通配符。为只读副本设置 `replicate-do-table` 或 `replicate-wild-do-table` 参数时，不会评估此参数。
将按这些参数列出的顺序对其进行评估。有关这些参数如何运行的更多信息，请参阅 MySQL 文档：
+ 有关一般信息，请参阅[副本服务器选项和变量](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html)。
+ 有关如何评估数据库复制筛选参数的信息，请参阅[评估数据库级复制和二进制日志记录选项](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-db-options.html)。
+ 有关如何评估表复制筛选参数的信息，请参阅[评估表级复制选项](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-table-options.html)。
默认情况下，这些参数中的每个参数都具有一个空值。在每个只读副本上，您可以使用这些参数来设置、更改和删除复制筛选条件。设置其中一个参数时，请用逗号将各筛选条件分开。
您可以在 `%` 和 `_` 参数中使用 `replicate-wild-do-table` 和 `replicate-wild-ignore-table` 通配符。`%` 通配符可以匹配任意数量的字符，而 `_` 通配符只能匹配一个字符。
源数据库实例的二进制日志记录格式对于复制非常重要，因为它决定了数据更改的记录。`binlog_format` 参数的设置将决定复制是基于行还是基于语句的复制。有关更多信息，请参阅“[为单可用区数据库配置 RDS for MySQL 二进制日志记录](USER_LogAccess.MySQL.BinaryFormat.md)”。
**注意**
无论源数据库实例上的 `binlog_format` 设置如何，所有数据定义语言 (DDL) 语句都将作为语句进行复制。
## RDS for MySQL 的复制筛选限制
以下限制适用于对 RDS for MySQL 进行复制筛选：
+ 每个复制筛选参数不得超过 2000 个字符。
+ 参数值的复制筛选条件中不支持逗号。在参数列表中，逗号只能用作值分隔符。例如，不支持 `ParameterValue='`a,b`'`，但支持 `ParameterValue='a,b'`。
+ 不支持用于二进制日志筛选的 MySQL `--binlog-do-db` 和 `--binlog-ignore-db` 选项。
+ 复制筛选不支持 XA 事务。
有关更多信息，请参阅 MySQL 文档中的[XA 事务限制](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html)。
## RDS for MySQL 的复制筛选示例
要为只读副本配置复制筛选，请修改与只读副本关联的参数组中的复制筛选参数。
**注意**
您无法修改默认参数组。如果只读副本使用默认参数组，请创建新的参数组并将其与只读副本关联。有关数据库参数组的更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
您可以使用 AWS 管理控制台、AWS CLI 或 RDS API 在参数组中设置参数。有关设置参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。在参数组中设置参数时，与参数组关联的所有数据库实例都使用参数设置。如果在参数组中设置复制筛选参数，请确保参数组仅与只读副本关联。将源数据库实例的复制筛选参数留空。
以下示例使用 AWS CLI 设置参数。这些示例将 `ApplyMethod` 设置为 `immediate`，以便在 CLI 命令完成后立即发生参数更改。如果希望在只读副本重新启动后应用待处理的更改，请将 `ApplyMethod` 设置为 `pending-reboot`。
以下示例设置了复制筛选条件：
+ [Including databases in replication](#rep-filter-in-dbs-mysql)
+ [Including tables in replication](#rep-filter-in-tables-mysql)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mysql)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mysql)
+ [Excluding tables from replication](#rep-filter-ex-tables-mysql)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mysql)
**Example 将数据库包含在复制之中**
以下示例将 `mydb1` 和 `mydb2` 数据库包含在复制之内。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
**Example 将表包含在复制之中**
以下示例将数据库 `table1` 中的 `table2` 和 `mydb1` 表包含在复制之中。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
**Example 使用通配符将表包含在复制之中**
以下示例将数据库 `order` 中名称以 `return` 和 `mydb` 开头的表包含在复制之中。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
**Example 将数据库排除在复制之外**
以下示例将 `mydb5` 和 `mydb6` 数据库排除在复制之外。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
**Example 将表排除在复制之外**
以下示例将数据库 `mydb5` 中的表 `table1` 和数据库 `mydb6` 中的表 `table2` 排除在复制之外。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
**Example 使用通配符将表排除在复制之外**
以下示例将数据库 `order` 中名称以 `return` 和 `mydb7` 开头的表排除在复制之外。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
## 查看只读副本的复制筛选条件
您可以通过以下方式查看只读副本的复制筛选条件：
+ 检查与只读副本关联的参数组中复制筛选参数的设置。
有关说明，请参阅[在 Amazon RDS 中查看数据库参数组的参数值](USER_WorkingWithParamGroups.Viewing.md)。
+ 在 MySQL 客户端中，连接到只读副本并运行 `SHOW REPLICA STATUS` 语句。
在输出中，以下字段显示了只读副本的复制筛选条件：
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
有关这些字段的更多信息，请参阅 MySQL 文档中的[检查复制状态](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html)。
# 使用 MySQL 配置延迟复制
可以使用延迟复制作为灾难恢复策略。使用延迟复制，可指定最短的时间（以秒为单位）以延迟从源到只读副本的复制。如果出现灾难（如意外删除了表），可完成以下步骤以快速从灾难恢复：
+ 在导致灾难的更改发送到它之前停止复制到只读副本。
使用 [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) 存储过程停止复制。
+ 开始复制并指定复制在日志文件位置处自动停止。
使用 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 存储过程指定就位于灾难恢复之前的位置。
+ 按照[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明，将只读副本提升为新的源数据库实例。
**注意**
在 RDS for MySQL 8.4 上，支持针对 MySQL 8.4.3 及更高版本进行延迟复制。在 RDS for MySQL 8.0 上，支持针对 MySQL 8.0.28 及更高版本进行延迟复制。在 RDS for MySQL 5.7 上，支持针对 MySQL 5.7.44 及更高版本进行延迟复制。
使用存储过程配置延迟复制。无法使用AWS 管理控制台、AWS CLI 或 Amazon RDS API 配置延迟复制。
您可以在以下版本的延迟复制配置中使用基于全局事务标识符（GTID）的复制。
RDS for MySQL 5.7.44 版本及更高的 5.7 版本
RDS for MySQL 8.0.28 版本及更高的 8.0 版本
RDS for MySQL 8.4.3 版本及更高的 8.4 版本
如果使用基于 GTID 的复制，请使用 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程而不是 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 存储过程。有关基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
**Topics**
+ [
## 在创建只读副本时配置延迟复制
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [
## 修改现有只读副本的延迟复制
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [
## 设置停止复制到只读副本的位置
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.StartUntil)
+ [
## 提升只读副本
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.Promote)
## 在创建只读副本时配置延迟复制
要为未来通过数据库实例创建的任何只读副本配置延迟复制，请使用 [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) 参数运行 `target delay` 存储过程。
**在创建只读副本时配置延迟复制**
1. 通过使用 MySQL 客户端，以主用户身份连接到作为只读副本源的 MySQL 数据库实例。
1. 使用 [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) 参数运行 `target delay` 存储过程。
例如，运行以下存储过程，针对从当前数据库实例创建的任何只读副本，指定将复制延迟至少一小时（3600 秒）。
```
call mysql.rds_set_configuration('target delay', 3600);
```
**注意**
运行此存储过程之后，将为使用 AWS CLI 或 Amazon RDS API 创建的任何只读副本配置延迟指定秒数的复制。
## 修改现有只读副本的延迟复制
要修改现有只读副本的延迟复制，请运行 [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) 存储过程。
**修改现有只读副本的延迟复制**
1. 使用 MySQL 客户端，以主用户的身份连接到只读副本。
1. 使用 [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) 存储过程停止复制。
1. 运行 [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) 存储过程。
例如，运行以下存储过程，指定复制到只读副本延迟至少一小时（3600 秒）。
```
call mysql.rds_set_source_delay(3600);
```
1. 使用 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) 存储过程开始复制。
## 设置停止复制到只读副本的位置
停止复制到只读副本之后，可使用 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 存储过程开始复制，然后在指定二进制日志文件位置处停止复制。
**开始复制到只读副本并在特定位置处停止复制**
1. 通过使用 MySQL 客户端，以主用户的身份连接到源 MySQL 数据库实例。
1. 运行 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 存储过程。
以下示例将启动复制并复制更改，直到它到达 `120` 二进制日志文件中的 `mysql-bin-changelog.000777` 位置。在灾难恢复方案中，假定位置 `120` 刚好位于灾难之前。
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
当到达停止点时，复制将自动停止。将生成以下 RDS 事件：`Replication has been stopped since the replica reached the stop point specified by the rds_start_replication_until stored procedure`。
## 提升只读副本
在灾难恢复方案中，当复制停止后，您可以将只读副本提升为新的源数据库实例。有关提升只读副本的信息，请参阅 [将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)。
# 使用 MySQL 更新只读副本
只读副本旨在支持读取查询，但您可能需要偶尔进行更新。例如，您可能需要添加索引，以优化访问副本的特定类型的查询。
尽管您可以通过将只读副本的数据库参数组中的 `read_only` 参数设置为 `0` 来启用更新，但我们建议您不要这样做，因为如果读取副本与源数据库实例不兼容，则这可能会导致问题。对于维护操作，我们建议您使用蓝绿部署。有关更多信息，请参阅 [使用蓝绿部署进行数据库更新](blue-green-deployments.md)。
如果您在只读副本上禁用只读，请尽快将 `read_only` 参数的值改回为 `1`。
# 使用 MySQL 处理多可用区只读副本部署
您可从单可用区或多可用区数据库实例部署中创建只读副本。您可以使用多可用区部署提高关键数据的持久性和可用性，但无法使用多可用区为只读查询提供辅助服务。您可以改为从大流量、多可用区数据库实例创建只读副本以分载只读查询。如果多可用区部署的源实例故障转移到辅助可用区，则任何关联的只读副本都将自动切换为使用辅助可用区（现在为主可用区）作为其复制源。有关更多信息，请参阅“[配置和管理 Amazon RDS 的多可用区部署](Concepts.MultiAZ.md)”。
您可以将只读副本创建为多可用区数据库实例。Amazon RDS 会在另一个可用区中创建您的副本的备用，用于支持副本的故障转移。创建您的只读副本作为多可用区数据库实例与源数据库是否为多可用区数据库实例无关。
# 将级联只读副本用于 RDS for MySQL
RDS for MySQL 支持级联只读副本。使用*级联只读副本*，您可以扩展读取操作，而不会增加源 RDS for MySQL 数据库实例的开销。
使用级联只读副本，您的 RDS for MySQL 数据库实例会将数据发送到链中的第一个只读副本。然后，该只读副本将数据发送到链中的第二个副本，依此类推。最终结果是，链中的所有只读副本都具有来自 RDS for MySQL 数据库实例的更改，但不会只在源数据库实例上产生开销。
您可以从源 RDS for MySQL 数据库实例在链中创建一系列最多三个只读副本。例如，假设您具有 RDS for MySQL 数据库实例 `mysql-main`。您可执行以下操作：
+ 从 `mysql-main` 开始，创建链中的第一个只读副本 `read-replica-1`。
+ 接下来，从 `read-replica-1`，创建链中的下一个只读副本 `read-replica-2`。
+ 最后，从 `read-replica-2`，创建链中的第三个只读副本 `read-replica-3`。
除了 `mysql-main` 系列中的第三个级联只读副本之外，您无法创建另一个只读副本。从 RDS for MySQL 源数据库实例到一系列级联只读副本末尾的完整实例系列最多可以包含四个数据库实例。
为了使级联只读副本正常工作，每个源 RDS for MySQL 数据库实例必须开启自动备份。要对只读副本开启自动备份，请先创建只读副本，然后修改只读副本以开启自动备份。有关更多信息，请参阅 [创建只读副本](USER_ReadRepl.Create.md)。
与任何只读副本一样，您可以升级属于级联一部分的只读副本。从只读副本链中升级只读副本将从链中移除该副本。例如，假设您希望将一些工作负载从 `mysql-main` 数据库实例转移到新实例，以仅供会计部门使用。假设该示例中的链有三个只读副本，您决定升级 `read-replica-2`。该链受到如下影响：
+ 升级 `read-replica-2` 会将其从复制链中移除。
+ 现在它是一个完全读/写数据库实例。
+ 它继续复制到 `read-replica-3`，就像在升级之前那样。
+ 您的 `mysql-main` 继续复制到 `read-replica-1`。
有关升级只读副本的更多信息，请参阅[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)。
# 监控 MySQL 只读副本的复制滞后
对于 MySQL 只读副本，可以在 Amazon CloudWatch 中通过查看 Amazon RDS `ReplicaLag` 指标来监控复制滞后。`ReplicaLag` 指标报告 `Seconds_Behind_Master` 命令的 `SHOW REPLICA STATUS` 字段的值。
MySQL 复制滞后的常见原因如下所示：
+ 网络中断。
+ 对只读副本上有不同索引的表进行写入操作。如果在只读副本上将 `read_only` 参数设置为 `0`，则在只读副本变得与源数据库实例不兼容时，复制会中断。对只读副本执行维护任务之后，我们建议您将 `read_only` 参数调整回 `1`。
+ 使用 MyISAM 等非事务性存储引擎。仅 MySQL 上的 InnoDB 存储引擎支持复制。
当 `ReplicaLag` 指标达到 0 时，即表示副本已赶上源数据库实例进度。如果 `ReplicaLag` 指标返回 -1，则当前未激活复制。`ReplicaLag` = -1 等效于 `Seconds_Behind_Master` = `NULL`。
# 开始和停止 MySQL 只读副本复制
可通过调用系统存储过程 [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) 和 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication)，在 Amazon RDS 数据库实例上停止再重新开始复制过程。对于长时间运行的操作 (如创建大型索引)，在两个 Amazon RDS 实例之间进行复制时可以这样做。在导入或导出数据库时，也需要停止再开始复制。有关更多信息，请参阅[将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间](mysql-importing-data-reduced-downtime.md)和[使用复制从 MySQL 数据库实例中导出数据](MySQL.Procedural.Exporting.NonRDSRepl.md)。
如果复制连续 30 天停止，不论是手动还是由于复制错误，Amazon RDS 将终止源数据库实例与所有只读副本之间的复制。这样做是为了防止源数据库实例上的存储需求增长以及长故障转移时间。只读副本数据库实例仍可用。但是无法恢复复制，因为在终止复制后，已从源数据库实例中删除只读副本所需的二进制日志。您可为源数据库实例创建新的只读副本来重新建立复制。
# 排查 MySQL 只读副本问题
对于 MySQL 数据库实例，在某些情况下，只读副本将显示只读副本与其源数据库实例之间的复制错误或数据不一致项（或两者）。如果在只读副本或源数据库实例失败期间未刷新某些二进制日志 (binlog) 事件或 InnoDB 重做日志，则会出现此问题。在这些情况下，请手动删除并重新创建只读副本。您可通过设置以下参数值来降低发生这种情况的可能性：`sync_binlog=1` 和 `innodb_flush_log_at_trx_commit=1`。这些设置可能降低性能，因此，请先测试其影响，然后在生产环境中实施更改。
**警告**
建议在与源数据库实例关联的参数组中保留以下参数值：`sync_binlog=1` 和 `innodb_flush_log_at_trx_commit=1`。这些是动态参数。如果不想使用这些设置，建议在对源数据库实例执行可能导致其重启的任何操作之前，临时设置这些值。这些操作包括但不限于重启、使用故障转移重启、升级数据库版本以及更改数据库实例类或其存储。同样的建议也适用于创建源数据库实例的新只读副本。
如果不遵循此指示，则将增加只读副本显示只读副本与其源数据库实例之间的复制错误或数据不一致项（或两者）的风险。
MySQL 的复制技术是异步的。由于它们是异步的，因此，源数据库实例上偶发的 `BinLogDiskUsage` 会增多，而只读副本上应有 `ReplicaLag`。例如，对源数据库实例的大量写入操作可以并行进行。与之对比的是，对只读副本的写入操作使用单个 I/O 线程串行进行，这会导致源实例与只读副本之间存在滞后。有关 MySQL 文档中只读副本的更多信息，请参阅[复制实施详细信息](https://dev.mysql.com/doc/refman/8.0/en/replication-implementation-details.html)。
您可通过多种方式来减少对源数据库实例的更新与对只读副本的后续更新之间的滞后，例如：
+ 将只读副本的存储大小和数据库实例类调整到与源数据库实例类似。
+ 确保源数据库实例和只读副本使用的数据库参数组中的参数设置相兼容。有关更多信息和示例，请参阅本部分后面的有关 `max_allowed_packet` 参数的讨论。
Amazon RDS 监控只读副本的复制状态，如果由于任何原因停止复制，则将只读副本实例的 `Replication State` 字段更新为 `Error`。可能会有这样的例子，在您的只读副本上运行的 DML 查询与对源数据库实例的更新冲突。
可通过查看 `Replication Error` 字段，检查 MySQL 引擎引发的关联错误的详细信息。还生成指示只读副本状态的事件，包括 [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045)、[RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) 和 [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047)。有关这些事件和事件订阅的详细信息，请参阅 [使用 Amazon RDS 事件通知](USER_Events.md)。如果返回 MySQL 错误消息，则检查 [MySQL 错误消息文档](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html)中的错误编号。
一个可导致复制出错的常见问题是只读副本的 `max_allowed_packet` 参数的值小于源数据库实例的 `max_allowed_packet` 参数的值。`max_allowed_packet` 参数是您可以在数据库参数组中设置的自定义参数。您可以使用 `max_allowed_packet` 指定可在数据库上运行的 DML 代码的最大大小。有时候，与只读副本关联的数据库参数组中的 `max_allowed_packet` 值，要小于与源数据库实例关联的数据库参数组中的 `max_allowed_packet` 值。在这些情况下，复制过程可能会引发错误 `Packet bigger than 'max_allowed_packet' bytes` 并停止复制。如需修复错误，请让源数据库实例和只读副本使用具有相同 `max_allowed_packet` 参数值的数据库参数组。
其他可导致复制错误的常见情况包括：
+ 对只读副本上的表进行写入操作。在某些情况下，您可能会在只读副本上创建索引，而该索引不同于源数据库实例上的索引。如果执行此操作，请将 `read_only` 参数设置为 `0` 以创建索引。如果您要写入到只读副本上的表，则在只读副本变得与源数据库实例不兼容时，复制会中断。对只读副本执行维护任务之后，我们建议您将 `read_only` 参数调整回 `1`。
+ 使用非事务性存储引擎，如 MyISAM。只读副本需要使用事务性存储引擎。仅 MySQL 上的 InnoDB 存储引擎支持复制。
+ 使用不安全的不确定性查询，如 `SYSDATE()`。有关更多信息，请参阅[确定二进制日志记录中的安全和不安全语句](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html)。
如果您确定可安全跳过错误，那么可以按照[跳过 RDS for MySQL 的当前复制错误](Appendix.MySQL.CommonDBATasks.SkipError.md)部分中描述的步骤操作。否则，您可以先删除只读副本。然后，您可以使用相同的数据库实例标识符创建实例，以使终端节点保持与旧只读副本的终端节点相同。如果复制错误得到纠正，则 `Replication State` 将更改为 *replicating*。
# 使用基于 GTID 的复制
以下内容说明了如何在 Amazon RDS for MySQL 数据库实例间使用采用二进制日志（binlog）复制的全局事务标识符（GTID）。
如果您使用的是二进制日志复制，不熟悉 MySQL 的基于 GTID 的复制，请参阅 MySQL 文档中的 [Replication with global transaction identifiers](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html)。
以下版本支持基于 GTID 的复制：
+ 所有 RDS for MySQL 8.4 版本
+ 所有 RDS for MySQL 8.0 版本
+ 所有 RDS for MySQL 5.7 版本
复制配置中的所有 MySQL 数据库实例均必须满足该版本要求。
**Topics**
+ [
## 全局事务标识符 (GTID) 概述
](#mysql-replication-gtid.overview)
+ [
## 基于 GTID 的复制的参数
](#mysql-replication-gtid.parameters)
+ [
# 为 RDS for MySQL 的新只读副本启用基于 GTID 的复制
](mysql-replication-gtid.configuring-new-read-replicas.md)
+ [
# 为 RDS for MySQL 的现有只读副本启用基于 GTID 的复制
](mysql-replication-gtid.configuring-existing-read-replicas.md)
+ [
# 为具有只读副本的 MySQL 数据库实例禁用基于 GTID 的复制
](mysql-replication-gtid.disabling.md)
## 全局事务标识符 (GTID) 概述
*全局事务标识符 (GTID)* 是为提交的 MySQL 事务生成的唯一标识符。您可以使用 GTID 让二进制日志复制的故障排除更加简单便捷。
MySQL 使用两种不同类型的事务进行二进制日志复制：
+ *GTID 事务* – 由 GTID 标识的事务。
+ *匿名事务* – 未分配 GTID 的事务。
在复制配置中，GTID 在所有数据库实例中是唯一的。GTID 简化了复制配置，因为在使用它们时，您不必引用日志文件位置。通过使用 GTID，还可以更轻松地跟踪复制的事务并确定源实例和副本是否一致。
您可以使用基于 GTID 的复制，通过 RDS for MySQL 只读副本复制数据。您可以在创建新的只读副本时配置基于 GTID 的复制，也可以转换现有的只读副本以使用基于 GTID 的复制。
您还可以在与 RDS for MySQL 之间的延迟复制配置中使用基于 GTID 的复制。有关更多信息，请参阅 [使用 MySQL 配置延迟复制](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)。
## 基于 GTID 的复制的参数
可以使用以下参数配置基于 GTID 的复制。
| 参数 | 有效值 | 描述 |
| --- | --- | --- |
| `gtid_mode` | `OFF`, `OFF_PERMISSIVE`, `ON_PERMISSIVE`, `ON` | `OFF` 指定新事务是匿名事务（即，没有 GTID），并且事务必须是匿名事务才能复制。 `OFF_PERMISSIVE` 指定新事务是匿名事务，但可以复制所有事务。 `ON_PERMISSIVE` 指定新事务是 GTID 事务，但可以复制所有事务。 `ON` 指定新事务是 GTID 事务，并且事务必须是 GTID 事务才能复制。 |
| `enforce_gtid_consistency` | `OFF`, `ON`, `WARN` | `OFF` 允许事务违反 GTID 一致性。 `ON` 禁止事务违反 GTID 一致性。 `WARN` 允许事务违反 GTID 一致性，但在违反一致性时生成警告。 |
**注意**
在 AWS 管理控制台中，`gtid_mode` 参数显示为 `gtid-mode`。
对于基于 GTID 的复制，请为数据库实例或只读副本的参数组使用这些设置：
+ `ON` 和 `ON_PERMISSIVE` 仅适用于从 RDS 数据库实例的传出复制。这两个值都可以让 RDS 数据库实例为复制的事务使用 GTID。`ON` 要求目标数据库也使用基于 GTID 的复制。`ON_PERMISSIVE` 让基于 GTID 的复制成为目标数据库上的可选项。
+ `OFF_PERMISSIVE`（如果设置）表明您的 RDS 数据库实例可以接受来自源数据库的传入复制。无论源数据库是否使用基于 GTID 的复制，它们都可以这样做。
+ `OFF`（如果设置）表明您的 RDS 数据库实例只接受来自不使用基于 GTID 的复制的源数据库的传入复制。
有关参数组的更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
# 为 RDS for MySQL 的新只读副本启用基于 GTID 的复制
在为 RDS for MySQL 数据库实例启用基于 GTID 的复制时，将自动为数据库实例的只读副本配置基于 GTID 的复制。
**为新的只读副本启用基于 GTID 的复制**
1. 确保与数据库实例关联的参数组具有以下参数设置：
+ `gtid_mode` – `ON` 或 `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
有关使用参数组设置配置参数的更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 如果更改了数据库实例的参数组，请重新引导数据库实例。有关执行该操作的更多信息，请参阅[重启数据库实例](USER_RebootInstance.md)。
1. 创建数据库实例的一个或多个只读副本。有关执行该操作的更多信息，请参阅[创建只读副本](USER_ReadRepl.Create.md)。
Amazon RDS 尝试使用 `MASTER_AUTO_POSITION` 在 MySQL 数据库实例和只读副本之间配置基于 GTID 的复制。如果尝试失败，Amazon RDS 将使用日志文件位置与只读副本之间进行复制。有关 `MASTER_AUTO_POSITION` 的更多信息，请参阅 MySQL 文档中的 [GTID 自动定位](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-auto-positioning.html)。
# 为 RDS for MySQL 的现有只读副本启用基于 GTID 的复制
对于具有不使用基于 GTID 的复制的只读副本的现有 MySQL 数据库实例，您可以在数据库实例和只读副本之间配置基于 GTID 的复制。
**为现有的只读副本启用基于 GTID 的复制**
1. 如果数据库实例或任何只读副本使用了低于 8.0.26 的 RDS for MySQL 8.0.x 版本，请将数据库实例或只读副本升级为 8.0.26 或更高的 MySQL 8.0 版本。所有 RDS for MySQL 8.4 版本和 5.7 版本均支持基于 GTID 的复制。
有关更多信息，请参阅 [升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。
1. （可选）重置 GTID 参数并测试数据库实例和只读副本的行为：
1. 确保与数据库实例和每个只读副本关联的参数组将 `enforce_gtid_consistency` 参数设置为 `WARN`。
有关使用参数组设置配置参数的更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 如果更改了数据库实例的参数组，请重新引导数据库实例。如果更改了只读副本的参数组，请重新引导只读副本。
有关更多信息，请参阅“[重启数据库实例](USER_RebootInstance.md)”。
1. 运行具有正常工作负载的数据库实例和只读副本并监控日志文件。
如果看到有关与 GTID 不兼容的事务的警告，请调整您的应用程序，以使其仅使用与 GTID 兼容的功能。在继续执行下一步之前，请确保数据库实例未生成有关与 GTID 不兼容的事务的任何警告。
1. 为允许匿名事务的基于 GTID 的复制重置 GTID 参数，直到只读副本已处理所有这些事务。
1. 确保与数据库实例和每个只读副本关联的参数组具有以下参数设置：
+ `gtid_mode` – `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
1. 如果更改了数据库实例的参数组，请重新引导数据库实例。如果更改了只读副本的参数组，请重新引导只读副本。
1. 等待复制所有匿名事务。要检查是否复制了这些事务，请执行以下操作：
1. 在源数据库实例上运行以下语句。
**MySQL 8.4**
```
SHOW BINARY LOG STATUS;
```
**MySQL 5.7 和 8.0**
```
SHOW MASTER STATUS;
```
记下 `File` 和 `Position` 列中的值。
1. 在每个只读副本上，使用上一步中的源实例上的文件和位置信息运行以下查询。
```
SELECT MASTER_POS_WAIT('file', position);
```
例如，如果文件名是 `mysql-bin-changelog.000031` 并且位置是 `107`，请运行以下语句。
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
如果只读副本超过指定的位置，查询将立即返回。否则，该函数将等待一段时间。在查询返回所有只读副本的结果时，请继续执行下一步。
1. 仅重置基于 GTID 的复制的 GTID 参数。
1. 确保与数据库实例和每个只读副本关联的参数组具有以下参数设置：
+ `gtid_mode` – `ON`
+ `enforce_gtid_consistency` – `ON`
1. 重新引导数据库实例和每个只读副本。
1. 在每个只读副本上，运行以下过程。
**MySQL 8.4 及更高的主要版本**
```
CALL mysql.rds_set_source_auto_position(1);
```
**MySQL 8.0 及更低的主要版本**
```
CALL mysql.rds_set_master_auto_position(1);
```
# 为具有只读副本的 MySQL 数据库实例禁用基于 GTID 的复制
您可以为 一个具有只读副本的 MySQL 数据库实例。
**为 具有只读副本的 MySQL 数据库实例禁用基于 GTID 的复制**
1. 在每个只读副本上，运行以下过程：
**MySQL 8.4 及更高的主要版本**
```
CALL mysql.rds_set_source_auto_position(0);
```
**MySQL 8.0 及更低的主要版本**
```
CALL mysql.rds_set_master_auto_position(0);
```
1. 将 `gtid_mode` 重置为 `ON_PERMISSIVE`。
1. 确保与 MySQL 数据库实例和每个只读副本关联的参数组将 `gtid_mode` 设置为 `ON_PERMISSIVE`。
有关使用参数组设置配置参数的更多信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
1. 重新引导 MySQL 数据库实例和每个只读副本。有关重新引导的更多信息，请参阅[重启数据库实例](USER_RebootInstance.md)。
1. 将 `gtid_mode` 重置为 `OFF_PERMISSIVE`。
1. 确保与 MySQL 数据库实例和每个只读副本关联的参数组将 `gtid_mode` 设置为 `OFF_PERMISSIVE`。
1. 重新引导 MySQL 数据库实例和每个只读副本。
1. 等待在所有只读副本上应用所有 GTID 事务。要检查是否应用了这些事务，请按以下步骤操作：
1. 在 MySQL 数据库实例上，运行以下命令：
**MySQL 8.4**
```
SHOW BINARY LOG STATUS
```
**MySQL 5.7 和 8.0**
```
SHOW MASTER STATUS
```
您的输出应类似于以下输出。
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
记下输出中的文件和位置。
1. 在每个只读副本上，使用上一步中的源实例上的文件和位置信息运行以下查询：
**MySQL 8.4 和 MySQL 8.0.26 及更高的 MySQL 8.0 版本**
```
SELECT SOURCE_POS_WAIT('file', position);
```
**MySQL 5.7**\$1
```
SELECT MASTER_POS_WAIT('file', position);
```
例如，如果文件名是 `mysql-bin-changelog.000031` 并且位置是 `107`，请运行以下语句：
**MySQL 8.4 和 MySQL 8.0.26 及更高的 MySQL 8.0 版本**
```
SELECT SOURCE_POS_WAIT('mysql-bin-changelog.000031', 107);
```
**MySQL 5.7**\$1
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
1. 重置 GTID 参数以禁用基于 GTID 的复制。
1. 确保与 MySQL 数据库实例和每个只读副本关联的参数组具有以下参数设置：
+ `gtid_mode` – `OFF`
+ `enforce_gtid_consistency` – `OFF`
1. 重新引导 MySQL 数据库实例和每个只读副本。
# 配置与外部源实例之间的二进制日志文件位置复制
您可以使用二进制日志文件复制来设置 RDS for MySQL 或 MariaDB 数据库实例与 Amazon RDS 外部的 MySQL 或 MariaDB 实例之间的复制。
**Topics**
+ [
## 开始前的准备工作
](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [
## 配置与外部源实例之间的二进制日志文件位置复制
](#MySQL.Procedural.Importing.External.Repl.Procedure)
## 开始前的准备工作
您可以使用复制的事务的二进制日志文件位置配置复制。
对 Amazon RDS 数据库实例启动复制功能所需的权限受到限制且对 Amazon RDS 主用户不可用。因此，请确保使用 Amazon RDS [mysql.rds\$1set\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) 或 [mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) 以及 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) 命令来设置活动数据库和 Amazon RDS 数据库之间的复制。
要为 MySQL 或 MariaDB 数据库设置二进制日志记录格式，请更新 `binlog_format` 参数。如果您的数据库实例使用默认数据库实例参数组，请创建一个新的数据库参数组来修改 `binlog_format` 参数。在 MariaDB 和 MySQL 8.0 及更低版本中，`binlog_format` 默认设置为 `MIXED`。不过，如果您需要特定的二进制日志 (binlog) 格式，也可以将 `binlog_format` 设置为 `ROW` 或 `STATEMENT`。重启您的数据库实例以使更改生效。在 MySQL 8.4 及更高版本中，`binlog_format` 默认设置为 `ROW`。
有关设置 `binlog_format` 参数的信息，请参阅[为单可用区数据库配置 RDS for MySQL 二进制日志记录](USER_LogAccess.MySQL.BinaryFormat.md)。有关不同 MySQL 复制类型的含义的信息，请参阅 MySQL 文档中的[基于语句和基于行的复制的优点和缺点](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html)。
## 配置与外部源实例之间的二进制日志文件位置复制
对 Amazon RDS 设置外部源实例和副本时，请遵循以下准则：
+ 监控作为副本的 Amazon RDS 数据库实例的失效转移事件。如果发生失效转移，则可能会在具有不同的网络地址的新主机上重新创建作为副本的数据库实例。有关如何监控失效转移事件的信息，请参阅[使用 Amazon RDS 事件通知](USER_Events.md)。
+ 在您的源实例上维护二进制日志，直至您确认其已应用于副本。该维护确保在发生故障时可以还原源实例。
+ 对 Amazon RDS 数据库实例启用自动备份。通过启用自动备份，可以确保在需要重新同步源实例和副本时能够将副本还原到特定时间点。有关备份和时间点还原的信息，请参阅[备份、还原和导出数据](CHAP_CommonTasks.BackupRestore.md)。
**配置与外部源实例之间的二进制日志文件复制**
1. 将源 MySQL 或 MariaDB 实例设置为只读。
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. 对源 MySQL 或 MariaDB 实例运行 `SHOW MASTER STATUS` 命令以确定二进制日志位置。
您将收到类似于以下示例的输出。
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. 使用 `mysqldump` 将数据库从外部实例复制到 Amazon RDS 数据库实例。对于非常大的数据库，您可能需要使用[将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间](mysql-importing-data-reduced-downtime.md)中的过程。
对于 Linux、macOS 或 Unix：
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
对于：Windows
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**注意**
确保 `-p` 选项和输入的密码之间没有空格。
要指定主机名、用户名、端口和密码以连接到 Amazon RDS 数据库实例，请在 `--host` 命令中使用 `--user (-u)`、`--port`、`-p` 和 `mysql` 选项。主机名是 Amazon RDS 数据库实例端点中的域名服务 (DNS) 名称，例如 `myinstance.123456789012.us-east-1.rds.amazonaws.com`。您可以在 AWS 管理控制台上的实例详细信息中找到端点值。
1. 再次将源 MySQL 或 MariaDB 实例设置为可写。
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
有关生成备份以用于复制的更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html)。
1. 在 AWS 管理控制台 中，将托管外部数据库的服务器的 IP 地址添加到 Amazon RDS 数据库实例的 Virtual Private Cloud (VPC) 安全组中。有关修改 VPC 安全组的更多信息，请参阅 *Amazon Virtual Private Cloud 用户指南* 中的[您的 VPC 的安全组](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)。
在满足以下条件时，IP 地址可能会发生更改：
+ 您正在使用公有 IP 地址在外部源实例和数据库实例之间进行通信。
+ 外部源实例已停止并重新启动。
如果满足这些条件，请在添加 IP 地址之前先对其进行验证。
您可能还需要配置本地网络，以允许来自 Amazon RDS 数据库实例的 IP 地址的连接。通过执行此操作，您的本地网络可以与外部 MySQL 或 MariaDB 实例进行通信。要查找 Amazon RDS 数据库实例的 IP 地址，请使用 `host` 命令。
```
host db_instance_endpoint
```
主机名是 Amazon RDS 数据库实例端点中的 DNS 名称。
1. 通过使用所选的客户端，连接到外部实例并创建要用于复制的用户。请仅将该账户用于复制，并将其限制为您的域以提高安全性。示例如下：
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 对于外部 实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。例如，要为您的域的“`REPLICATION CLIENT`”用户授予对所有数据库的 `REPLICATION SLAVE` 和 `repl_user` 权限，请发出以下命令。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. 将 Amazon RDS 数据库实例设置为副本。为此，请先以主用户身份连接到 Amazon RDS 数据库实例。然后使用 [mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) 或 [mysql.rds\$1set\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) 命令，将外部 MySQL 或 MariaDB 数据库标识为源实例。使用在步骤 2 中确定的主日志文件名和主日志位置。下面是一些命令示例。
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB 以及 MySQL 8.0 和 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**注意**
在 RDS for MySQL 上，可以选择通过运行 [mysql.rds\$1set\$1external\$1source\$1with\$1delay（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay) 或 [mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay) 存储过程来使用延迟复制。在 RDS for MySQL 中，使用延迟复制的一个原因是，使用 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 存储过程打开灾难恢复。目前，RDS for MariaDB 支持延迟复制，但不支持 `mysql.rds_start_replication_until` 过程。
1. 在 Amazon RDS 数据库实例上，发出 [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) 命令以启动复制。
```
CALL mysql.rds_start_replication;
```
# 为 Amazon RDS for MySQL 配置多源复制
通过多源复制，您可以将 Amazon RDS for MySQL 数据库实例设置为一个副本，该副本接收来自多个 RDS for MySQL 源数据库实例的二进制日志事件。运行以下引擎版本的 RDS for MySQL 数据库实例支持多源复制：
+ 所有 MySQL 8.4 版本
+ 8.0.35 及更高的次要版本
+ 5.7.44 及更高的次要版本
有关 MySQL 多源复制的信息，请参阅 MySQL 文档中的 [MySQL Multi-Source Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-multi-source.html)。MySQL 文档包含有关此功能的详细信息，而本主题则介绍如何在 RDS for MySQL 数据库实例上配置和管理多源复制通道。
## 多源复制的使用案例
以下情况很适合在 RDS for MySQL 上使用多源复制：
+ 需要将不同数据库实例上的多个分片合并或组合成单个分片的应用程序。
+ 需要根据从多个来源整合的数据生成报告的应用程序。
+ 要求为分布在多个 RDS for MySQL 数据库实例中的数据创建长期合并备份。
## 多源复制的先决条件
在配置多源复制之前，请完成以下先决条件。
+ 确保每个源 RDS for MySQL 数据库实例都启用了自动备份。启用自动备份可启用二进制日志记录。要了解如何启用自动备份，请参阅[启用自动备份](USER_WorkingWithAutomatedBackups.Enabling.md)。
+ 为避免复制错误，建议您阻止对源数据库实例的写入操作。为此，您可以在附加到 RDS for MySQL 源数据库实例的自定义参数组中将 `read-only` 参数设置为 `ON`。您可以使用 AWS 管理控制台或 AWS CLI 来创建新的自定义参数组或修改现有的自定义参数组。有关更多信息，请参阅[在 Amazon RDS 中创建数据库参数组](USER_WorkingWithParamGroups.Creating.md)和[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
+ 对于每个源数据库实例，将实例的 IP 地址添加到多源数据库实例的 Amazon Virtual Private Cloud（VPC）安全组中。要确定源数据库实例的 IP 地址，可以运行命令 `dig RDS Endpoint`。在与目标多源数据库实例相同的 Amazon EC2 实例中运行命令。
+ 对于每个源数据库实例，使用客户端连接到数据库实例，并创建一个具有复制所需权限的数据库用户，如下例所示。
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user';
```
**注意**
从 MySQL 8.4 开始，`REPLICATION SLAVE` 权限已弃用并替换为 `REPLICATION REPLICA`。对于 8.4 及更高版本，请改用以下语法：
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION REPLICA ON *.* TO 'repl_user';
```
## 在 RDS for MySQL 数据库实例上配置多源复制通道
配置多源复制通道与配置单源复制类似。对于多源复制，首先在源实例上开启二进制日志记录。然后，将数据从源导入到多源副本。然后，您可以使用二进制日志坐标或使用 GTID 自动定位从每个源开始复制。
要将 RDS for MySQL 数据库实例配置为两个或更多 RDS for MySQL 数据库实例的多源副本，请执行以下步骤。
**Topics**
+ [
### 步骤 1：将数据从源数据库实例导入到多源副本
](#mysql-multi-source-replication-import)
+ [
### 步骤 2：开始从源数据库实例复制到多源副本
](#mysql-multi-source-replication-setting-up-start-replication-other)
### 步骤 1：将数据从源数据库实例导入到多源副本
在每个源数据库实例上执行以下步骤。
在将数据从源导入到多源副本之前，请通过运行 `SHOW MASTER STATUS` 命令来确定当前的二进制日志文件和位置。请记下这些详细信息，以便在下一个步骤中使用。在此示例输出中，文件为 `mysql-bin-changelog.000031`，位置为 `107`。
**注意**
从 MySQL 8.4 开始，`SHOW MASTER STATUS` 命令已弃用并替换为 `SHOW BINARY LOG STATUS`。对于 8.4 及更高版本，请改用 `SHOW BINARY LOG STATUS`。
```
File Position
-----------------------------------
mysql-bin-changelog.000031 107
-----------------------------------
```
现在，使用 `mysqldump` 将数据库从源数据库实例复制到多源副本，如下例所示。
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u RDS_user_name \
-p RDS_password \
--host=RDS Endpoint | mysql \
--host=RDS Endpoint \
--port=3306 \
-u RDS_user_name \
-p RDS_password
```
复制数据库后，可以在源数据库实例上将只读参数设置为 `OFF`。
### 步骤 2：开始从源数据库实例复制到多源副本
对于每个源数据库实例，使用管理用户凭证连接到实例，然后运行以下两个存储过程。这些存储过程在通道上配置复制并开始复制。此示例会使用上一步的示例输出中的二进制日志文件名和位置。
```
CALL mysql.rds_set_external_source_for_channel('mysourcehost.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1, 'channel_1');
CALL mysql.rds_start_replication_for_channel('channel_1');
```
有关使用这些存储过程和其它存储过程来设置和管理复制通道的更多信息，请参阅[管理多源复制](mysql-stored-proc-multi-source-replication.md)。
## 将筛选条件与多源复制结合使用
您可以使用复制筛选条件来指定在多源副本中使用哪些数据库和表进行复制。复制筛选条件可以将数据库和表包含在复制之中或排除在复制之外。有关复制筛选条件的更多信息，请参阅[使用 MySQL 配置复制筛选条件](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)。
使用多源复制，您可以全局或在通道级配置复制筛选条件。通道级筛选仅适用于运行 8.0 或 8.4 版本的受支持数据库实例。以下各示例介绍如何全局或在通道级配置筛选条件。
请注意多源复制中筛选的以下要求和行为：
+ 通道名称前后需要使用反引号（``）。
+ 如果您在参数组中更改复制筛选条件，则会对所有带有更新的通道重启多源副本的 `sql_thread` 以动态应用更改。如果更新涉及全局筛选条件，则所有处于运行状态的复制通道都将重启。
+ 所有全局筛选条件都在任何通道特定的筛选条件之前应用。
+ 如果在全局和通道级应用筛选条件，则仅应用通道级筛选条件。例如，如果筛选条件为 `replicate_ignore_db="db1,`channel_22`:db2"`，则 `replicate_ignore_db`（设置为 `db1`）将应用于除 `channel_22` 之外的所有通道，并且 `channel_22` 仅忽略来自 `db2` 的更改。
示例 1：设置全局筛选条件
在以下示例中，将 `temp_data` 数据库排除在每个通道的复制之外。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='temp_data',ApplyMethod=immediate"
```
示例 2：设置通道级筛选条件
在以下示例中，来自 `sample22` 数据库的更改仅包含在通道 `channel_22` 中。同样，来自 `sample99` 数据库的更改仅包含在通道 `channel_99` 中。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='\`channel_22\`:sample22,\`channel_99\`:sample99',ApplyMethod=immediate"
```
## 监控多源复制通道
您可以使用以下方法监控多源副本中的各个通道：
+ 要监控所有通道或特定通道的状态，请连接到多源副本并运行 `SHOW REPLICA STATUS` 或 `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` 命令。有关更多信息，请参阅 MySQL 文档中的[检查复制状态](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html)。
+ 要在启动、停止或移除复制通道时接收通知，请使用 RDS 事件通知。有关更多信息，请参阅 [使用 Amazon RDS 事件通知](USER_Events.md)。
+ 要监控特定通道的滞后，请检查它的 `ReplicationChannelLag` 指标。此指标的数据点的期间为 60 秒（1分钟），可使用 15 天。要查找通道的复制通道滞后，请使用实例标识符和复制通道名称。要在此滞后超过特定阈值时收到通知，您可以设置 CloudWatch 警报。有关更多信息，请参阅 [使用 Amazon CloudWatch 监控 Amazon RDS 指标](monitoring-cloudwatch.md)。
## 多源复制的注意事项和最佳实践
在 RDS for MySQL 上使用多源复制之前，请查看以下注意事项和最佳实践：
+ 确保配置为多源副本的数据库实例具有足够的资源，例如吞吐量、内存、CPU 和 IOPS，以处理来自多个源实例的工作负载。
+ 定期监控多源副本的资源利用率，调整存储或实例配置，以便在不造成资源紧张的情况下处理工作负载。
+ 通过将系统变量 `replica_parallel_workers` 设置为大于 `0` 的值，可以在多源副本上配置多线程复制。在这种情况下，分配给每个通道的线程数就是此变量的值，再加上一个用于管理应用程序线程的协调器线程。
+ 适当配置复制筛选条件以避免冲突。要将整个数据库复制到副本上的另一个数据库，可以使用 `--replicate-rewrite-db` 选项。例如，您可以将数据库 A 中的所有表复制到副本实例上的数据库 B。当所有源实例都使用相同的架构命名约定时，这种方法会很有用。有关 `--replicate-rewrite-db` 选项的信息，请参阅 MySQL 文档中的 [Replica Server Options and Variables](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html)。
+ 为避免复制错误，请避免写入副本。建议您在多源副本上启用 `read_only` 参数以阻止写入操作。这样做有助于消除由于写入操作冲突而导致的复制问题。
+ 要提高在多源副本上执行的读取操作（例如排序和高负载联接）的性能，请考虑使用 RDS 优化型读取功能。此功能有助于处理依赖大型临时表或排序文件的查询。有关更多信息，请参阅 [使用 Amazon RDS 优化读取提高 RDS for MySQL 的查询性能](rds-optimized-reads.md)。
+ 为了显著减少复制滞后并提高多源副本的性能，请考虑启用优化型写入功能。有关更多信息，请参阅 [使用适用于 MySQL 的 RDS 优化型写入功能提高写入性能](rds-optimized-writes.md)。
+ 一次对一个通道执行管理操作（例如更改配置），并避免从多个连接对多个通道执行更改。这些做法可能会导致复制操作发生冲突。例如，通过多个连接同时执行 `rds_skip_repl_error_for_channel` 和 `rds_start_replication_for_channel` 过程可能会导致跳过与预期不同的通道上的事件。
+ 您可以在多源复制实例上启用备份，并将数据从该实例导出到 Amazon S3 存储桶，以便长期存储。但是，还要在各个源实例上配置具有适当保留期的备份，这一点很重要。有关将快照数据导出到 Amazon S3 的信息，请参阅[将 Amazon RDS 的数据库快照数据导出到 Amazon S3](USER_ExportSnapshot.md)。
+ 要在多源副本上分配读取工作负载，您可以从多源副本创建只读副本。您可以根据应用程序的要求将这些只读副本放在不同的 AWS 区域中。有关只读副本的更多信息，请参阅 [使用 MySQL 只读副本](USER_MySQL.Replication.ReadReplicas.md)。
## RDS for MySQL 上多源复制的限制
以下限制适用于 RDS for MySQL 上的多源复制：
+ 目前，RDS for MySQL 支持为多源副本配置最多 15 个通道。
+ 只读副本实例不能配置为多源副本。
+ 要在运行引擎版本 5.7 的 RDS for MySQL 上配置多源复制，必须在副本实例上启用 Performance Schema。对于运行 8.0 或 8.4 版引擎的 RDS for MySQL，可选择是否启用 Performance Schema。
+ 对于运行 5.7 版引擎的 RDS for MySQL，复制筛选条件适用于所有复制通道。对于运行 8.0 或 8.4 版引擎的 RDS for MySQL，可以配置适用于所有复制通道或单个通道的筛选条件。
+ 还原 RDS 快照或执行时间点恢复（PITR）并不会还原多源副本通道配置。
+ 创建多源副本的只读副本时，它只会复制多源实例中的数据。它不会还原任何通道配置。
+ MySQL 不支持为每个通道设置不同数量的并行工作线程。每个通道根据 `replica_parallel_workers` 值获得相同数量的并行工作线程。
如果您的多源复制目标为多可用区数据库集群，则以下其它限制适用：
+ 在对源 RDS for MySQL 实例进行任何写入之前，必须为该实例配置通道。
+ 每个源 RDS for MySQL 实例都必须启用基于 GTID 的复制。
+ 数据库集群上的失效转移事件会移除多源复制配置。还原该配置需要重复配置步骤。
# 为 RDS for MySQL 配置主动-主动集群
Amazon RDS 中的主动-主动集群是一种数据库配置，其中多个节点主动处理读取和写入操作，同时在实例之间分配工作负载来提高可用性和可扩展性。集群中的每个节点都经过同步以保持数据一致性，从而在节点出现故障时实现高可用性和更快的失效转移
您可以使用 MySQL 组复制插件为 RDS for MySQL 设置主动-主动集群。运行以下引擎版本的 RDS for MySQL 数据库实例支持组复制插件：
+ 所有 MySQL 8.4 版本
+ MySQL 8.0.35 及更高的次要版本
有关 MySQL 组复制的信息，请参阅 MySQL 文档中的 [Group Replication](https://dev.mysql.com/doc/refman/8.0/en/group-replication.html)。MySQL 文档包含有关此功能的详细信息，而本主题则介绍如何在 RDS for MySQL 数据库实例上配置和管理插件。
**注意**
为简洁起见，本主题中所有提及的“主动-主动”集群均指使用 MySQL 组复制插件的主动-主动集群。
## 主动-主动集群的用例
以下情况很适合使用主动-主动集群：
+ 需要集群中所有数据库实例才能支持写入操作的应用程序。组复制插件可使主动-主动集群中每个数据库实例的数据保持一致。有关这一点的工作原理的更多信息，请参阅 MySQL 文档中的 [Group Replication](https://dev.mysql.com/doc/refman/8.0/en/group-replication-summary.html)。
+ 需要数据库持续可用性的应用程序。对于主动-主动集群，数据将保留在集群中的所有数据库实例上。如果一个数据库实例出现故障，应用程序可以将流量重新路由到集群中的另一个数据库实例。
+ 出于负载均衡的目的，可能需要在集群中的不同数据库实例之间拆分读取和写入操作的应用程序。使用主动-主动集群，您的应用程序可以将读取流量发送到特定的数据库实例，而将写入流量发送到其它数据库实例。您也可以随时切换要向哪些数据库实例发送读取或写入。
**Topics**
+ [
## 主动-主动集群的用例
](#mysql-active-active-clusters-benefits)
+ [
# 主动-主动集群的限制和注意事项
](mysql-active-active-clusters-considerations-limitations.md)
+ [
# 跨 VPC 主动-主动集群的准备工作
](mysql-active-active-clusters-cross-vpc-prerequisites.md)
+ [
# 主动-主动集群所需的参数设置
](mysql-active-active-clusters-parameters.md)
+ [
# 将现有数据库实例转换为主动-主动集群
](mysql-active-active-clusters-converting.md)
+ [
# 使用新的数据库实例设置主动-主动集群
](mysql-active-active-clusters-setting-up.md)
+ [
# 将数据库实例添加到主动-主动集群
](mysql-active-active-clusters-adding.md)
+ [
# 监控主动-主动集群
](mysql-active-active-clusters-monitoring.md)
+ [
# 在主动-主动集群中的数据库实例上停止组复制
](mysql-active-active-clusters-stopping.md)
+ [
# 重命名主动-主动集群中的数据库实例
](mysql-active-active-clusters-renaming.md)
+ [
# 从主动-主动集群中移除数据库实例
](mysql-active-active-clusters-remove.md)
# 主动-主动集群的限制和注意事项
Amazon RDS 中的主动-主动集群通过将工作负载分配到多个实例来增强可用性和可扩展性。但是，在使用此架构时，需要记住一些重要的限制和注意事项。
以下各节概述了诸如复制延迟、冲突解决、资源分配和失效转移行为等关键因素。了解这些注意事项有助于确保主动-主动集群部署实现理想的性能和可靠性。
**Topics**
+ [
## RDS for MySQL 主动-主动集群的限制
](#mysql-active-active-clusters-limitations)
+ [
## RDS for MySQL 主动-主动集群的注意事项和最佳实践
](#mysql-active-active-clusters-considerations)
## RDS for MySQL 主动-主动集群的限制
以下限制适用于 RDS for MySQL 的主动-主动集群。
+ 对于主动-主动集群中的数据库实例，主用户名不能为 `rdsgrprepladmin`。此用户名保留用于组复制连接。
+ 对于在主动-主动集群中具有只读副本的数据库实例，除 `Replicating` 之外的长时间复制状态可能会导致日志文件超出存储限制。有关只读副本的状态的信息，请参阅[监控只读复制](USER_ReadRepl.Monitoring.md)。
+ 主动-主动集群中的数据库实例不支持蓝绿部署。有关更多信息，请参阅 [使用 Amazon RDS 蓝绿部署进行数据库更新](blue-green-deployments.md)。
+ 主动-主动集群中的数据库实例不支持 Kerberos 身份验证。有关更多信息，请参阅 [对 Amazon RDS for MySQL 进行 Kerberos 身份验证](mysql-kerberos.md)。
+ 无法将多可用区数据库集群中的数据库实例添加到主动-主动集群。但是，可以将多可用区数据库实例部署中的数据库实例添加到主动-主动集群。有关更多信息，请参阅 [配置和管理 Amazon RDS 的多可用区部署](Concepts.MultiAZ.md)。
+ 由于组复制插件拒绝写入，因此不会在主动-主动集群中复制没有主键的表。
+ 不会在主动-主动集群中复制非 InnoDB 表。
+ 主动-主动集群不支持集群中不同数据库实例上的并发 DML 和 DDL 语句。
+ 您无法将主动-主动集群配置为使用单主模式作为该组的复制模式。对于此配置，我们建议改用多可用区数据库集群。有关更多信息，请参阅 [Amazon RDS 的多可用区数据库集群部署](multi-az-db-clusters-concepts.md)。
+ 主动-主动集群中的数据库实例不支持多源复制。
+ 跨区域主动-主动集群无法对组复制连接强制执行证书颁发机构（CA）验证。
## RDS for MySQL 主动-主动集群的注意事项和最佳实践
在使用 RDS for MySQL 主动-主动集群之前，请查看以下注意事项和最佳实践：
+ 主动-主动集群的数据库实例不能超过 9 个。
+ 使用组复制插件，您可以控制主动-主动集群的事务一致性保证。有关更多信息，请参阅 MySQL 文档中的 [Transaction Consistency Guarantees](https://dev.mysql.com/doc/refman/8.0/en/group-replication-consistency-guarantees.html)。
+ 当不同的数据库实例更新主动-主动集群中的同一行时，可能会发生冲突。有关冲突和冲突解决的信息，请参阅 MySQL 文档中的 [Group Replication](https://dev.mysql.com/doc/refman/8.0/en/group-replication-summary.html)。
+ 为了实现容错，请在您的主动-主动集群中至少包含三个数据库实例。可以配置只具有一个或两个数据库实例的主动-主动集群，但该集群不具备容错能力。有关容错的信息，请参阅 MySQL 文档中的 [Fault-tolerance](https://dev.mysql.com/doc/refman/8.0/en/group-replication-fault-tolerance.html)。
+ 当数据库实例加入现有的主动-主动集群并且运行的引擎版本与集群中的最低引擎版本相同时，该数据库实例将以读写模式加入。
+ 当数据库实例加入现有的主动-主动集群并且运行的引擎版本高于集群中的最低引擎版本时，该数据库实例必须保持只读模式。
+ 如果您通过在数据库参数组中将数据库实例的 `rds.group_replication_enabled` 参数设置为 `1` 来为它启用组复制，但复制尚未启动或未能启动，则该数据库实例将置于超级只读模式以防止数据不一致。有关超级只读模式的信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_super_read_only)。
+ 您可以升级主动-主动集群中的数据库实例，但在主动-主动集群中的所有其它数据库实例都升级到相同的引擎版本或更高的引擎版本之前，该数据库实例是只读的。升级数据库实例时，升级完成后，数据库实例会自动加入同一个主动-主动集群。为避免数据库实例意外切换到只读模式，请对其禁用自动次要版本升级。有关升级 MySQL 数据库实例的信息，请参阅[升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。
+ 您可以将多可用区数据库实例部署中的数据库实例添加到现有的主动-主动集群中。您还可以将主动-主动集群中的单可用区数据库实例转换为多可用区数据库实例部署。如果多可用区部署中的主数据库实例出现故障，则该主实例会失效转移到备用实例。失效转移完成后，新的主数据库实例会自动加入同一个集群。有关多可用区数据库实例部署的更多信息，请参阅[Amazon RDS 的多可用区数据库实例部署](Concepts.MultiAZSingleStandby.md)。
+ 我们建议主动-主动集群中的数据库实例为其维护时段使用不同的时间范围。这种做法可以避免集群中的多个数据库实例同时脱机来进行维护。有关更多信息，请参阅 [Amazon RDS 维护时段](USER_UpgradeDBInstance.Maintenance.md#Concepts.DBMaintenance)。
+ 主动-主动集群可以使用 SSL 在数据库实例之间建立连接。要配置 SSL 连接，请设置 [ group\$1replication\$1recovery\$1use\$1ssl](https://dev.mysql.com/doc/refman/8.0/en/group-replication-system-variables.html#sysvar_group_replication_recovery_use_ssl) 和 [group\$1replication\$1ssl\$1mode](https://dev.mysql.com/doc/refman/8.0/en/group-replication-system-variables.html#sysvar_group_replication_ssl_mode) 参数。对于主动-主动集群中的所有数据库实例，这些参数的值必须匹配。
目前，主动-主动集群不支持对 AWS 区域之间的连接进行证书颁发机构（CA）验证。因此，对于跨区域集群，必须将 [group\$1replication\$1ssl\$1mode](https://dev.mysql.com/doc/refman/8.0/en/group-replication-system-variables.html#sysvar_group_replication_ssl_mode) 参数设置为 `DISABLED`（默认）或 `REQUIRED`。
+ RDS for MySQL 主动-主动集群在多主模式下运行。[group\$1replication\$1enforce\$1update\$1everywhere\$1checks](https://dev.mysql.com/doc/refman/8.0/en/group-replication-system-variables.html#sysvar_group_replication_enforce_update_everywhere_checks) 的默认值为 `ON`，参数是静态的。当此参数设置为 `ON` 时，应用程序无法插入到具有级联外键约束的表中。
+ RDS for MySQL 主动-主动集群使用 MySQL 通信堆栈来保护连接安全，而不是 XCOM。有关更多信息，请参阅 MySQL 文档中的 [Communication Stack for Connection Security Management](https://dev.mysql.com/doc/refman/8.0/en/group-replication-connection-security.html)。
+ 当数据库参数组与主动-主动集群中的数据库实例关联时，我们建议仅将此数据库参数组与集群中的其它数据库实例相关联。
+ 主动-主动集群仅支持 RDS for MySQL 数据库实例。这些数据库实例必须运行受支持的数据库引擎版本。
+ 当主动-主动集群中的数据库实例出现意外故障时，RDS 会自动开始恢复该数据库实例。如果数据库实例无法恢复，我们建议将其替换为新的数据库实例，方法是使用集群中运行状况良好的数据库实例执行时间点恢复。有关说明，请参阅[使用时间点恢复将数据库实例添加到主动-主动集群](mysql-active-active-clusters-adding.md#mysql-active-active-clusters-adding-pitr)。
+ 您可以删除主动-主动集群中的数据库实例，而不会影响集群中的其它数据库实例。有关删除数据库实例的信息，请参阅[删除数据库实例](USER_DeleteInstance.md)。
+ 当数据库实例无意中离开主动-主动集群时，`group_replication_exit_state_action` 参数会更改为 `OFFLINE_MODE`。在此状态下，无法访问数据库实例，您必须重启数据库实例才能使其恢复在线状态并重新加入集群。可以通过修改自定义参数组中的 `group_replication_exit_state_action` 参数来更改此行为。通过将参数设置为 `READ_ONLY`，当数据库实例无意中离开集群时，它会进入超级只读状态而不是离线状态。
# 跨 VPC 主动-主动集群的准备工作
可以在多个 VPC 中配置包含 Amazon RDS for MySQL 数据库实例的主动-主动集群。VPC 可以位于相同的 AWS 区域或不同的 AWS 区域中。
**注意**
在多个 AWS 区域之间发送流量可能会产生额外费用。有关更多信息，请参阅[常见架构的数据传输成本概览](https://aws.amazon.com/blogs/architecture/overview-of-data-transfer-costs-for-common-architectures/)。
如果您要在单个 VPC 中配置主动-主动集群，可以跳过这些步骤并转入[使用新的数据库实例设置主动-主动集群](mysql-active-active-clusters-setting-up.md)。
**为在多个 VPC 中具有数据库实例的主动-主动集群做准备**
1. 确保 CIDR 块中的 IPv4 地址范围满足以下要求：
+ VPC 的 CIDR 块中的 IPv4 地址范围不能重叠。
+ CIDR 块中的所有 IPv4 地址范围必须小于 `128.0.0.0/subnet_mask` 或高于 128.0.0.0/*subnet\$1mask*。
以下范围说明了这些要求：
+ 支持在一个 VPC 中使用 `10.1.0.0/16`，而在另一个 VPC 中使用 `10.2.0.0/16`。
+ 支持在一个 VPC 中使用 `172.1.0.0/16`，而在另一个 VPC 中使用 `172.2.0.0/16`。
+ *不* 支持在一个 VPC 中使用 `10.1.0.0/16`，而在另一个 VPC 中使用 `10.1.0.0/16`，因为范围重叠。
+ *不* 支持在一个 VPC 中使用 `10.1.0.0/16`，而在另一个 VPC 中使用 `172.1.0.0/16`，因为一个低于 `128.0.0.0/subnet_mask`，另一个高于 `128.0.0.0/subnet_mask`。
有关 CIDR 块的信息，请参阅《Amazon VPC 用户指南》**中的 [VPC CIDR 块](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html)。
1. 在每个 VPC 中，请确保 DNS 解析和 DNS 主机名都已启用。
有关说明，请参阅《Amazon VPC 用户指南》**中的[查看和更新 VPC 的 DNS 属性](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating)。
1. 配置 VPC，以便您可以通过以下方式之一在它们之间路由流量：
+ 在 VPC 之间创建 VPC 对等连接。
有关说明，请参阅《Amazon VPC Peering Guide》**中的 [Create a VPC peering connection](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html)。在每个 VPC 中，确保您的安全组都有引用对等 VPC 中的安全组的入站规则。此操作将允许流量流入和流出与对等的 VPC 中的已引用安全组关联的实例。有关说明，请参阅《Amazon VPC 对等连接指南》**中的[更新安全组以引用对等安全组](https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-security-groups.html)。
+ 在 VPC 之间创建一个中转网关。
有关说明，请参阅《Amazon VPC Transit Gateway》**中的[开始使用中转网关](https://docs.aws.amazon.com/vpc/latest/tgw/tgw-getting-started.html)。在每个 VPC 中，确保您的安全组都有允许来自其它 VPC 的流量的入站规则，例如指定另一个 VPC 的 CIDR 的入站规则。此操作允许流量流入和流出与主动-主动集群中的已引用安全组关联的实例。有关更多信息，请参阅《Amazon VPC 用户指南》**中的[使用安全组控制到 AWS 资源的流量](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html#working-with-security-groups)。
# 主动-主动集群所需的参数设置
在 Amazon RDS for MySQL 中为主动-主动集群配置参数，对于保持一致的性能和运行稳定性至关重要。此表详细说明了控制复制、冲突解决和工作负载分配的关键参数。正确的配置可确保节点之间的高效同步，更大限度地减少复制滞后，并优化分布式或高流量环境中的资源利用率。
| 参数 | 描述 | 所需的设置 |
| --- | --- | --- |
| `binlog_format` | 设置二进制日志记录格式。RDS for MySQL 8.0 及更低版本的默认值为 `MIXED`。RDS for MySQL 8.4 版的默认值为 `ROW`。有关更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_format)。 | `ROW` |
| `enforce_gtid_consistency` | 强制语句执行的 GTID 一致性。RDS for MySQL 的默认值为 `OFF`。有关更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_enforce_gtid_consistency)。 | `ON` |
| `group_replication_group_name` | 将组复制名称设置为 UUID。UUID 格式为 `11111111-2222-3333-4444-555555555555`。您可以通过连接到 MySQL 数据库实例并运行 `SELECT UUID()` 生成 MySQL UUID。对于主动-主动集群中的所有数据库实例，该值必须相同。有关更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/miscellaneous-functions.html#function_uuid)。 | MySQL UUID |
| `gtid-mode` | 控制基于 GTID 的日志记录。RDS for MySQL 的默认值为 `OFF_PERMISSIVE`。有关更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_mode)。 | `ON` |
| `rds.custom_dns_resolution` | 指定是否允许从 VPC 中的 Amazon DNS 服务器进行 DNS 解析。当使用 `rds.group_replication_enabled` 参数启用组复制时，必须启用 DNS 解析。如果使用 `rds.group_replication_enabled` 参数禁用组复制，则无法启用 DNS 解析。有关更多信息，请参阅《Amazon VPC 用户指南》**中的 [Amazon DNS 服务器](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#AmazonDNS)。 | `1` |
| `rds.group_replication_enabled` | 指定是否为数据库实例启用组复制。必须在主动-主动集群中的数据库实例上启用组复制。 | `1` |
| `replica_preserve_commit_order`（RDS for MySQL 8.4 及更高版本）或 `slave_preserve_commit_order`（RDS for MySQL 8.0 版本） | 控制在副本上提交事务的顺序。RDS for MySQL 的默认值为 `ON`。有关更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html#sysvar_slave_preserve_commit_order)。 | `ON` |
# 将现有数据库实例转换为主动-主动集群
要迁移到主动-主动集群的数据库实例的数据库引擎版本必须为以下版本之一：
+ 所有 MySQL 8.4 版本
+ MySQL 8.0.35 及更高的次要版本
如果您需要升级引擎版本，请参阅[升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。
如果您要在多个 VPC 中设置具有数据库实例的主动-主动集群，请务必完成[跨 VPC 主动-主动集群的准备工作](mysql-active-active-clusters-cross-vpc-prerequisites.md)中的先决条件。
完成以下步骤，以将现有数据库实例迁移到 RDS for MySQL 的主动-主动集群。
**Topics**
+ [
## 步骤 1：在一个或多个自定义参数组中设置主动-主动集群参数
](#mysql-active-active-clusters-converting-parameter-group)
+ [
## 步骤 2：将数据库实例与设置了所需组复制参数的数据库参数组相关联
](#mysql-active-active-clusters-converting-associate-parameter-group)
+ [
## 步骤 3：创建主动-主动集群
](#mysql-active-active-clusters-converting-associate-parameter-groups)
+ [
## 步骤 4：为主动-主动集群创建其它 RDS for MySQL 数据库实例
](#mysql-active-active-clusters-converting-add-db-instances)
+ [
## 步骤 5：在要转换的数据库实例上初始化组
](#mysql-active-active-clusters-converting-start-replication-first)
+ [
## 步骤 6：在主动-主动集群中的其它数据库实例上开始复制
](#mysql-active-active-clusters-converting-start-replication-other)
+ [
## 步骤 7：（建议）检查主动-主动集群的状态
](#mysql-active-active-clusters-converting-view)
## 步骤 1：在一个或多个自定义参数组中设置主动-主动集群参数
主动-主动集群中的 RDS for MySQL 数据库实例必须与一个自定义参数组相关联，该参数组对于所需参数具有正确的设置。有关参数和每个参数所需设置的信息，请参阅[主动-主动集群所需的参数设置](mysql-active-active-clusters-parameters.md)。
您可以在新的参数组或现有参数组中设置这些参数。但是，为避免意外影响不属于主动-主动集群的数据库实例，我们强烈建议您创建一个新的自定义参数组。主动-主动集群中的数据库实例可以与相同的数据库参数组或不同的数据库参数组相关联。
您可以使用 AWS 管理控制台或 AWS CLI 创建新的自定义参数组。有关更多信息，请参阅 [在 Amazon RDS 中创建数据库参数组](USER_WorkingWithParamGroups.Creating.md)。以下示例运行 [create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) AWS CLI 命令来为 RDS for MySQL 8.0 创建名为 `myactivepg` 的自定义数据库参数组：
对于 Linux、macOS 或 Unix：
```
aws rds create-db-parameter-group \
--db-parameter-group-name myactivepg \
--db-parameter-group-family mysql8.0 \
--description "Parameter group for active-active clusters"
```
对于：Windows
```
aws rds create-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--db-parameter-group-family mysql8.0 ^
--description "Parameter group for active-active clusters"
```
还可以使用 AWS 管理控制台或 AWS CLI 设置自定义参数组中的参数。有关更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
以下示例运行 [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI 命令来为 RDS for MySQL 8.0 设置参数。要将此示例与 RDS for MySQL 8.4 结合使用，请将 `slave_preserve_commit_order` 更改为 `replica_preserve_commit_order`。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myactivepg \
--parameters "ParameterName='rds.group_replication_enabled',ParameterValue='1',ApplyMethod=pending-reboot" \
"ParameterName='rds.custom_dns_resolution',ParameterValue='1',ApplyMethod=pending-reboot" \
"ParameterName='enforce_gtid_consistency',ParameterValue='ON',ApplyMethod=pending-reboot" \
"ParameterName='gtid-mode',ParameterValue='ON',ApplyMethod=pending-reboot" \
"ParameterName='binlog_format',ParameterValue='ROW',ApplyMethod=immediate" \
"ParameterName='slave_preserve_commit_order',ParameterValue='ON',ApplyMethod=immediate" \
"ParameterName='group_replication_group_name',ParameterValue='11111111-2222-3333-4444-555555555555',ApplyMethod=pending-reboot"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--parameters "ParameterName='rds.group_replication_enabled',ParameterValue='1',ApplyMethod=pending-reboot" ^
"ParameterName='rds.custom_dns_resolution',ParameterValue='1',ApplyMethod=pending-reboot" ^
"ParameterName='enforce_gtid_consistency',ParameterValue='ON',ApplyMethod=pending-reboot" ^
"ParameterName='gtid-mode',ParameterValue='ON',ApplyMethod=pending-reboot" ^
"ParameterName='binlog_format',ParameterValue='ROW',ApplyMethod=immediate" ^
"ParameterName='slave_preserve_commit_order',ParameterValue='ON',ApplyMethod=immediate" ^
"ParameterName='group_replication_group_name',ParameterValue='11111111-2222-3333-4444-555555555555',ApplyMethod=pending-reboot"
```
## 步骤 2：将数据库实例与设置了所需组复制参数的数据库参数组相关联
将数据库实例与您在上一步中创建或修改的参数组相关联。有关说明，请参阅[在 Amazon RDS 中将数据库参数组与数据库实例关联](USER_WorkingWithParamGroups.Associating.md)。
重启数据库实例以使新的参数设置生效。有关说明，请参阅[重启数据库实例](USER_RebootInstance.md)。
## 步骤 3：创建主动-主动集群
在与数据库实例关联的数据库参数组中，将 `group_replication_group_seeds` 参数设置为要转换的数据库实例的端点。
可以使用 AWS 管理控制台或 AWS CLI 来设置参数。设置此参数后，您无需重启数据库实例。有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
以下示例运行 [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI 命令来设置参数：
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myactivepg \
--parameters "ParameterName='group_replication_group_seeds',ParameterValue='myactivedb1.123456789012.us-east-1.rds.amazonaws.com:3306',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--parameters "ParameterName='group_replication_group_seeds',ParameterValue='myactivedb1.123456789012.us-east-1.rds.amazonaws.com:3306',ApplyMethod=immediate"
```
## 步骤 4：为主动-主动集群创建其它 RDS for MySQL 数据库实例
要为主动-主动集群创建其它数据库实例，请对要转换的数据库实例执行时间点恢复。有关说明，请参阅[使用时间点恢复将数据库实例添加到主动-主动集群](mysql-active-active-clusters-adding.md#mysql-active-active-clusters-adding-pitr)。
一个主动-主动集群最多可以有九个数据库实例。在数据库实例上执行时间点恢复，直到集群拥有所需的数据库实例数量。执行恢复点恢复时，请确保将您要添加的数据库实例与将 `rds.group_replication_enabled` 设置为 `1` 的数据库参数组相关联。否则，组复制将无法在新添加的数据库实例上启动。
## 步骤 5：在要转换的数据库实例上初始化组
初始化组并开始复制：
1. 在 SQL 客户端中连接到您要转换的该数据库实例。有关连接到 RDS for MySQL 数据库实例的更多信息，请参阅[连接到 MySQL 数据库实例](USER_ConnectToInstance.md)。
1. 在 SQL 客户端中，运行以下存储过程并将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。在主动-主动集群中，`rdsgrprepladmin` 用户保留用于组复制连接。在主动-主动集群中的所有数据库实例上，该用户的密码必须相同。
```
call mysql.rds_set_configuration('binlog retention hours', 168); -- 7 days binlog
call mysql.rds_group_replication_create_user('group_replication_user_password');
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
call mysql.rds_group_replication_start(1);
```
此示例将 `binlog retention hours` 值设置为 `168`，这意味着二进制日志文件在数据库实例上保留七天。您可以根据要求调整该值。
此示例在 `mysql.rds_group_replication_start` 存储过程中指定 `1`，以使用当前数据库实例初始化新组。
有关此示例中调用的存储过程的更多信息，请参阅[管理主动-主动集群](mysql-stored-proc-active-active-clusters.md)。
## 步骤 6：在主动-主动集群中的其它数据库实例上开始复制
对于主动-主动集群中的每个数据库实例，使用 SQL 客户端连接到该实例，然后运行以下存储过程。将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。
```
call mysql.rds_set_configuration('binlog retention hours', 168); -- 7 days binlog
call mysql.rds_group_replication_create_user('group_replication_user_password');
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
call mysql.rds_group_replication_start(0);
```
此示例将 `binlog retention hours` 值设置为 `168`，这意味着二进制日志文件在每个数据库实例上保留七天。您可以根据要求调整该值。
此示例在 `mysql.rds_group_replication_start` 存储过程中指定 `0`，以将当前数据库实例加入现有组。
**提示**
确保在主动-主动集群中的所有其它数据库实例上运行这些存储过程。
## 步骤 7：（建议）检查主动-主动集群的状态
要确保集群的每个成员都配置正确，请通过连接到主动-主动集群中的数据库实例并运行以下 SQL 命令来检查集群的状态：
```
SELECT * FROM performance_schema.replication_group_members;
```
输出应针对每个数据库实例的 `MEMBER_STATE` 显示 `ONLINE`，如以下示例输出所示：
```
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| CHANNEL_NAME | MEMBER_ID | MEMBER_HOST | MEMBER_PORT | MEMBER_STATE | MEMBER_ROLE | MEMBER_VERSION | MEMBER_COMMUNICATION_STACK |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| group_replication_applier | 9854d4a2-5d7f-11ee-b8ec-0ec88c43c251 | ip-10-15-3-137 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | 9e2e9c28-5d7f-11ee-8039-0e5d58f05fef | ip-10-15-3-225 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | a6ba332d-5d7f-11ee-a025-0a5c6971197d | ip-10-15-1-83 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
3 rows in set (0.00 sec)
```
有关可能的 `MEMBER_STATE` 值的信息，请参阅 MySQL 文档中的 [Group Replication Server States](https://dev.mysql.com/doc/refman/8.0/en/group-replication-server-states.html)。
# 使用新的数据库实例设置主动-主动集群
完成以下步骤，使用新的 Amazon RDS for MySQL 数据库实例设置主动-主动集群。
如果您要在多个 VPC 中设置具有数据库实例的主动-主动集群，请务必完成[跨 VPC 主动-主动集群的准备工作](mysql-active-active-clusters-cross-vpc-prerequisites.md)中的先决条件。
**Topics**
+ [
## 步骤 1：在一个或多个自定义参数组中设置主动-主动集群参数
](#mysql-active-active-clusters-setting-up-parameter-group)
+ [
## 步骤 2：为主动-主动集群创建新的 RDS for MySQL 数据库实例
](#mysql-active-active-clusters-setting-up-db-instances)
+ [
## 步骤 3：指定主动-主动集群中的数据库实例
](#mysql-active-active-clusters-setting-up-associate-parameter-groups)
+ [
## 步骤 4：在数据库实例上初始化组并开始复制
](#mysql-active-active-clusters-setting-up-start-replication-first)
+ [
## 步骤 5：在主动-主动集群中的其它数据库实例上开始复制
](#mysql-active-active-clusters-setting-up-start-replication-other)
+ [
## 步骤 6：（建议）检查主动-主动集群的状态
](#mysql-active-active-clusters-setting-up-view)
+ [
## 步骤 7：（可选）将数据导入到主动-主动集群中的数据库实例
](#mysql-active-active-clusters-import)
## 步骤 1：在一个或多个自定义参数组中设置主动-主动集群参数
主动-主动集群中的 RDS for MySQL 数据库实例必须与一个自定义参数组相关联，该参数组对于所需参数具有正确的设置。有关参数和每个参数所需设置的信息，请参阅[主动-主动集群所需的参数设置](mysql-active-active-clusters-parameters.md)。
您可以在新的参数组或现有参数组中设置这些参数。但是，为避免意外影响不属于主动-主动集群的数据库实例，我们强烈建议您创建一个新的自定义参数组。主动-主动集群中的数据库实例可以与相同的数据库参数组或不同的数据库参数组相关联。
您可以使用 AWS 管理控制台或 AWS CLI 创建新的自定义参数组。有关更多信息，请参阅 [在 Amazon RDS 中创建数据库参数组](USER_WorkingWithParamGroups.Creating.md)。以下示例运行 [create-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-parameter-group.html) AWS CLI 命令来为 RDS for MySQL 8.0 创建名为 `myactivepg` 的自定义数据库参数组：
对于 Linux、macOS 或 Unix：
```
aws rds create-db-parameter-group \
--db-parameter-group-name myactivepg \
--db-parameter-group-family mysql8.0 \
--description "Parameter group for active-active clusters"
```
对于：Windows
```
aws rds create-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--db-parameter-group-family mysql8.0 ^
--description "Parameter group for active-active clusters"
```
还可以使用 AWS 管理控制台或 AWS CLI 设置自定义参数组中的参数。有关更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
以下示例运行 [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI 命令来为 RDS for MySQL 8.0 设置参数。要将此示例与 RDS for MySQL 8.4 结合使用，请将 `slave_preserve_commit_order` 更改为 `replica_preserve_commit_order`。
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myactivepg \
--parameters "ParameterName='rds.group_replication_enabled',ParameterValue='1',ApplyMethod=pending-reboot" \
"ParameterName='rds.custom_dns_resolution',ParameterValue='1',ApplyMethod=pending-reboot" \
"ParameterName='enforce_gtid_consistency',ParameterValue='ON',ApplyMethod=pending-reboot" \
"ParameterName='gtid-mode',ParameterValue='ON',ApplyMethod=pending-reboot" \
"ParameterName='binlog_format',ParameterValue='ROW',ApplyMethod=immediate" \
"ParameterName='slave_preserve_commit_order',ParameterValue='ON',ApplyMethod=immediate" \
"ParameterName='group_replication_group_name',ParameterValue='11111111-2222-3333-4444-555555555555',ApplyMethod=pending-reboot"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--parameters "ParameterName='rds.group_replication_enabled',ParameterValue='1',ApplyMethod=pending-reboot" ^
"ParameterName='rds.custom_dns_resolution',ParameterValue='1',ApplyMethod=pending-reboot" ^
"ParameterName='enforce_gtid_consistency',ParameterValue='ON',ApplyMethod=pending-reboot" ^
"ParameterName='gtid-mode',ParameterValue='ON',ApplyMethod=pending-reboot" ^
"ParameterName='binlog_format',ParameterValue='ROW',ApplyMethod=immediate" ^
"ParameterName='slave_preserve_commit_order',ParameterValue='ON',ApplyMethod=immediate" ^
"ParameterName='group_replication_group_name',ParameterValue='11111111-2222-3333-4444-555555555555',ApplyMethod=pending-reboot"
```
## 步骤 2：为主动-主动集群创建新的 RDS for MySQL 数据库实例
以下 RDS for MySQL 数据库实例版本支持主动-主动集群。
+ 所有 MySQL 8.4 版本
+ MySQL version 8.0.35 及更高的次要版本
您可为集群创建最多九个新的数据库实例。
您可以使用 AWS 管理控制台或 AWS CLI 来创建新的数据库实例。有关创建数据库实例的更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。创建数据库实例时，将其与您在上一步中创建或修改的数据库参数组相关联。
## 步骤 3：指定主动-主动集群中的数据库实例
在与每个数据库实例关联的数据库参数组中，将 `group_replication_group_seeds` 参数设置为要包含在集群中的数据库实例的端点。
可以使用 AWS 管理控制台或 AWS CLI 来设置参数。设置此参数后，您无需重启数据库实例。有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
以下示例运行 [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI 命令来设置参数：
对于 Linux、macOS 或 Unix：
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myactivepg \
--parameters "ParameterName='group_replication_group_seeds',ParameterValue='myactivedb1.123456789012.us-east-1.rds.amazonaws.com:3306,myactivedb2.123456789012.us-east-1.rds.amazonaws.com:3306,myactivedb3.123456789012.us-east-1.rds.amazonaws.com:3306',ApplyMethod=immediate"
```
对于：Windows
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myactivepg ^
--parameters "ParameterName='group_replication_group_seeds',ParameterValue='myactivedb1.123456789012.us-east-1.rds.amazonaws.com:3306,myactivedb2.123456789012.us-east-1.rds.amazonaws.com:3306,myactivedb3.123456789012.us-east-1.rds.amazonaws.com:3306',ApplyMethod=immediate"
```
**提示**
确保在每个与主动-主动集群中的数据库实例关联的数据库参数组中设置 `group_replication_group_seeds` 参数。
## 步骤 4：在数据库实例上初始化组并开始复制
您可以选择任何新数据库来初始化组并开始复制。为此，请完成以下步骤：
1. 在主动-主动集群中选择一个数据库实例，然后在 SQL 客户端中连接到该数据库实例。有关连接到 RDS for MySQL 数据库实例的更多信息，请参阅[连接到 MySQL 数据库实例](USER_ConnectToInstance.md)。
1. 在 SQL 客户端中，运行以下存储过程并将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。在主动-主动集群中，`rdsgrprepladmin` 用户保留用于组复制连接。在主动-主动集群中的所有数据库实例上，该用户的密码必须相同。
```
call mysql.rds_set_configuration('binlog retention hours', 168); -- 7 days binlog
call mysql.rds_group_replication_create_user('group_replication_user_password');
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
call mysql.rds_group_replication_start(1);
```
此示例将 `binlog retention hours` 值设置为 `168`，这意味着二进制日志文件在数据库实例上保留七天。您可以根据要求调整该值。
此示例在 `mysql.rds_group_replication_start` 存储过程中指定 `1`，以使用当前数据库实例初始化新组。
有关此示例中调用的存储过程的更多信息，请参阅[管理主动-主动集群](mysql-stored-proc-active-active-clusters.md)。
## 步骤 5：在主动-主动集群中的其它数据库实例上开始复制
对于主动-主动集群中的每个数据库实例，使用 SQL 客户端连接到该实例，然后运行以下存储过程。将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。
```
call mysql.rds_set_configuration('binlog retention hours', 168); -- 7 days binlog
call mysql.rds_group_replication_create_user('group_replication_user_password');
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
call mysql.rds_group_replication_start(0);
```
此示例将 `binlog retention hours` 值设置为 `168`，这意味着二进制日志文件在每个数据库实例上保留七天。您可以根据要求调整该值。
此示例在 `mysql.rds_group_replication_start` 存储过程中指定 `0`，以将当前数据库实例加入现有组。
**提示**
确保在主动-主动集群中的所有其它数据库实例上运行这些存储过程。
## 步骤 6：（建议）检查主动-主动集群的状态
要确保集群的每个成员都配置正确，请通过连接到主动-主动集群中的数据库实例并运行以下 SQL 命令来检查集群的状态：
```
SELECT * FROM performance_schema.replication_group_members;
```
输出应针对每个数据库实例的 `MEMBER_STATE` 显示 `ONLINE`，如以下示例输出所示：
```
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| CHANNEL_NAME | MEMBER_ID | MEMBER_HOST | MEMBER_PORT | MEMBER_STATE | MEMBER_ROLE | MEMBER_VERSION | MEMBER_COMMUNICATION_STACK |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| group_replication_applier | 9854d4a2-5d7f-11ee-b8ec-0ec88c43c251 | ip-10-15-3-137 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | 9e2e9c28-5d7f-11ee-8039-0e5d58f05fef | ip-10-15-3-225 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | a6ba332d-5d7f-11ee-a025-0a5c6971197d | ip-10-15-1-83 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
3 rows in set (0.00 sec)
```
有关可能的 `MEMBER_STATE` 值的信息，请参阅 MySQL 文档中的 [Group Replication Server States](https://dev.mysql.com/doc/refman/8.0/en/group-replication-server-states.html)。
## 步骤 7：（可选）将数据导入到主动-主动集群中的数据库实例
您可以将数据从 MySQL 数据库导入到主动-主动集群中的数据库实例。导入数据后，组复制会将其复制到集群中的其它数据库实例。
有关导入用户的信息，请参阅[将数据导入 Amazon RDS for MySQL 数据库实例并减少停机时间](mysql-importing-data-reduced-downtime.md)。
# 将数据库实例添加到主动-主动集群
可以通过还原数据库快照或将数据库实例还原到某个时间点，将数据库实例添加到 Amazon RDS for MySQL 主动-主动集群。一个主动-主动集群最多可以包含九个数据库实例。
将数据库实例恢复到某个时间点时，它通常包含比从数据库快照还原的数据库实例较新的事务。当数据库实例具有较新的事务时，启动复制时需要应用的事务会较少。因此，使用时间点恢复将数据库实例添加到集群通常比从数据库快照还原更快。
**Topics**
+ [
## 使用时间点恢复将数据库实例添加到主动-主动集群
](#mysql-active-active-clusters-adding-pitr)
+ [
## 使用数据库快照将数据库实例添加到主动-主动集群
](#mysql-active-active-clusters-adding-snapshot)
## 使用时间点恢复将数据库实例添加到主动-主动集群
您可以通过对集群中的数据库实例执行时间点恢复，将数据库实例添加到主动-主动集群中。
有关在不同的 AWS 区域将数据库实例恢复到某个时间点的信息，请参阅[将自动备份复制到其他 AWS 区域](USER_ReplicateBackups.md)。
**使用时间点恢复将数据库实例添加到主动-主动集群**
1. 通过对主动-主动集群中的数据库实例执行时间点恢复，创建新的数据库实例。
您可以对集群中的任何数据库实例执行时间点恢复以创建新的数据库实例。有关说明，请参阅 [将 Amazon RDS 的数据库实例还原到指定时间](USER_PIT.md)。
**重要**
在时间点恢复期间，将新的数据库实例与设置了主动-主动集群参数的数据库参数组相关联。否则，组复制将无法在新的数据库实例上启动。有关参数和每个参数所需设置的信息，请参阅[主动-主动集群所需的参数设置](mysql-active-active-clusters-parameters.md)。
**提示**
如果您在开始时间点恢复之前拍摄数据库实例的快照，则可以减少在新数据库实例上应用事务所需的时间量。
1. 将数据库实例添加到与主动-主动集群中的一个数据库实例相关联的每个数据库参数组中的 `group_replication_group_seeds` 参数，包括与新数据库实例关联的数据库参数组。
有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 在 SQL 客户端中，连接到新的数据库实例，然后调用 [mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_set_recovery_channel) 存储过程。将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。
```
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
```
1. 使用 SQL 客户端，调用 [mysql.rds\$1group\$1replication\$1start](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_start) 存储过程以开始复制：
```
call mysql.rds_group_replication_start(0);
```
## 使用数据库快照将数据库实例添加到主动-主动集群
通过在集群中创建数据库实例的数据库快照，然后还原数据库快照，可以将数据库实例添加到主动-主动集群。
有关将快照复制到不同 AWS 区域的信息，请参阅[跨区域快照复制的注意事项](USER_CopySnapshot.md#USER_CopySnapshot.AcrossRegions)。
**使用数据库快照将数据库实例添加到主动-主动集群**
1. 创建主动-主动集群中数据库实例的数据库快照。
您可以创建集群中任何数据库实例的数据库快照。有关说明，请参阅 [为 Amazon RDS 的单可用区数据库实例创建数据库快照](USER_CreateSnapshot.md)。
1. 从数据库快照还原数据库实例。
在快照还原操作期间，将新的数据库实例与设置了主动-主动集群参数的数据库参数组相关联。有关参数和每个参数所需设置的信息，请参阅[主动-主动集群所需的参数设置](mysql-active-active-clusters-parameters.md)。
有关从数据库快照还原数据库实例的信息，请参阅[还原到数据库实例](USER_RestoreFromSnapshot.md)。
1. 将数据库实例添加到与主动-主动集群中的一个数据库实例相关联的每个数据库参数组中的 `group_replication_group_seeds` 参数，包括与新数据库实例关联的数据库参数组。
有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 在 SQL 客户端中，连接到新的数据库实例，然后调用 [mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_set_recovery_channel) 存储过程。将 *group\$1replication\$1user\$1password* 替换为 `rdsgrprepladmin` 用户的密码。
```
call mysql.rds_group_replication_set_recovery_channel('group_replication_user_password');
```
1. 使用 SQL 客户端，调用 [mysql.rds\$1group\$1replication\$1start](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_start) 存储过程以开始复制：
```
call mysql.rds_group_replication_start(0);
```
# 监控主动-主动集群
在 Amazon RDS for MySQL 中监控主动-主动集群，对于跟踪性能、复制完整性和节点同步至关重要。您可以通过连接到集群中的数据库实例并运行以下 SQL 命令来监控您的主动-主动集群：
```
SELECT * FROM performance_schema.replication_group_members;
```
输出应针对每个数据库实例的 `MEMBER_STATE` 显示 `ONLINE`，如以下示例输出所示：
```
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| CHANNEL_NAME | MEMBER_ID | MEMBER_HOST | MEMBER_PORT | MEMBER_STATE | MEMBER_ROLE | MEMBER_VERSION | MEMBER_COMMUNICATION_STACK |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
| group_replication_applier | 9854d4a2-5d7f-11ee-b8ec-0ec88c43c251 | ip-10-15-3-137 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | 9e2e9c28-5d7f-11ee-8039-0e5d58f05fef | ip-10-15-3-225 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
| group_replication_applier | a6ba332d-5d7f-11ee-a025-0a5c6971197d | ip-10-15-1-83 | 3306 | ONLINE | PRIMARY | 8.0.35 | MySQL |
+---------------------------+--------------------------------------+----------------+-------------+--------------+-------------+----------------+----------------------------+
3 rows in set (0.00 sec)
```
有关可能的 `MEMBER_STATE` 值的信息，请参阅 MySQL 文档中的 [Group Replication Server States](https://dev.mysql.com/doc/refman/8.0/en/group-replication-server-states.html)。
# 在主动-主动集群中的数据库实例上停止组复制
您可以在主动-主动集群中的数据库实例上停止组复制。停止组复制后，数据库实例将处于超级只读模式，直到重启复制或从主动-主动集群中移除该数据库实例。有关超级只读模式的信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_super_read_only)。
**暂时停止主动-主动集群的组复制**
1. 使用 SQL 客户端连接到主动-主动集群中的数据库实例。
有关连接到 RDS for MySQL 数据库实例的更多信息，请参阅[连接到 MySQL 数据库实例](USER_ConnectToInstance.md)。
1. 在 SQL 客户端中，调用 [mysql.rds\$1group\$1replication\$1stop](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_stop) 存储过程：
```
call mysql.rds_group_replication_stop();
```
# 重命名主动-主动集群中的数据库实例
您可以更改主动-主动集群中数据库实例的名称。要重命名主动-主动集群中的多个数据库实例，请一次重命名一个数据库实例。因此，先重命名一个数据库实例并将其重新加入集群，然后重命名下一个数据库实例。
**重命名主动-主动集群中的数据库实例**
1. 在 SQL 客户端中连接到数据库实例，然后调用 [mysql.rds\$1group\$1replication\$1stop](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_stop) 存储过程：
```
call mysql.rds_group_replication_stop();
```
1. 按照[重命名数据库实例](USER_RenameInstance.md)中的说明重命名数据库实例。
1. 在每个与主动-主动集群中的数据库实例关联的数据库参数组中修改 `group_replication_group_seeds` 参数。
在参数设置中，将旧的数据库实例端点替换为新的数据库实例端点。有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 在 SQL 客户端中连接到数据库实例，然后调用 [mysql.rds\$1group\$1replication\$1start](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_start) 存储过程：
```
call mysql.rds_group_replication_start(0);
```
# 从主动-主动集群中移除数据库实例
当您从主动-主动集群中移除数据库实例时，它会恢复为独立的数据库实例。
**从主动-主动集群中移除数据库实例**
1. 在 SQL 客户端中连接到数据库实例，然后调用 [mysql.rds\$1group\$1replication\$1stop](mysql-stored-proc-active-active-clusters.md#mysql_rds_group_replication_stop) 存储过程：
```
call mysql.rds_group_replication_stop();
```
1. 修改将保留在主动-主动集群中的数据库实例的 `group_replication_group_seeds` 参数。
在 `group_replication_group_seeds` 参数中，删除要从主动-主动集群中移除的数据库实例。有关设置参数的更多信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
1. 修改要从主动-主动集群中移除的数据库实例的参数，使其不再是集群的一部分。
您可以将数据库实例与其它参数组关联，也可以修改与数据库实例关联的数据库参数组中的参数。要修改的参数包括 `group_replication_group_name`、`rds.group_replication_enabled` 和 `group_replication_group_seeds`。有关主动-主动集群参数的更多信息，请参阅[主动-主动集群所需的参数设置](mysql-active-active-clusters-parameters.md)。
如果您修改数据库参数组中的参数，请确保该数据库参数组未与主动-主动集群中的其它数据库实例相关联。
1. 重启您从主动-主动集群中移除的数据库实例，以使新的参数设置生效。
有关说明，请参阅[重启数据库实例](USER_RebootInstance.md)。
# 使用复制从 MySQL 数据库实例中导出数据
可以使用复制功能，将数据从 RDS for MySQL 数据库实例导出到在 Amazon RDS 外部运行的 MySQL 实例。在这种情况下，MySQL 数据库实例是*源 MySQL 数据库实例*，而在 Amazon RDS 外部运行的 MySQL 实例则是*外部 MySQL 数据库*。
外部 MySQL 数据库可以在数据中心本地运行，也可以在 Amazon EC2 实例上运行。外部 MySQL 数据库必须运行与源 MySQL 数据库实例相同的版本或更高版本。
只有在从源 MySQL 数据库实例导出数据库期间，才支持复制到外部 MySQL 数据库。导出数据后，应终止复制，而应用程序可开始访问该外部 MySQL 实例。
下面列表显示了需要采取的步骤。每个步骤在后续的几节中有详述。
1. 准备外部 MySQL 数据库实例。
1. 准备用于复制的源 MySQL 数据库实例。
1. 使用 mysqldump 实用程序将数据库从源 MySQL 数据库实例传输到外部 MySQL 数据库。
1. 开始复制到外部 MySQL 数据库。
1. 导出完毕后，停止复制。
## 准备外部 MySQL 数据库
执行以下步骤来准备外部 MySQL 数据库。
**准备外部 MySQL 数据库**
1. 安装外部 MySQL 数据库。
1. 以主用户身份连接到外部 MySQL 数据库。然后创建支持访问数据库的管理员、应用程序和服务所需的用户。
1. 按照 MySQL 文档中的说明以副本的形式准备外部 MySQL 数据库。有关更多信息，请参阅 MySQL 文档中的 [Setting the Replica Configuration](https://dev.mysql.com/doc/refman/8.0/en/replication-howto-slavebaseconfig.html)。
1. 配置一条传出规则，使外部 MySQL 数据库在导出过程中作为只读副本运行。该传出规则将允许外部 MySQL 数据库在复制期间连接到源 MySQL 数据库实例。指定传出规则以允许通过传输控制协议 (TCP) 连接到源 MySQL 数据库实例的端口和 IP 地址。
为您的环境指定适当的传出规则：
+ 如果外部 MySQL 数据库在基于 Amazon VPC 服务的 Virtual Private Cloud (VPC) 中的 Amazon EC2 实例中运行，请在 VPC 安全组中指定传出规则。有关更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
+ 如果外部 MySQL 数据库安装在本地，请在防火墙中指定传出规则。
1. 如果外部 MySQL 数据库在 VPC 中运行，则除了安全组传出规则外，还应配置 VPC 访问控制列表 (ACL) 规则：
+ 配置允许将 TCP 流量从源 MySQL 数据库实例的 IP 地址传入到端口 1024–65535 的 ACL 传入规则。
+ 配置允许将 TCP 流量传出到源 MySQL 数据库实例的端口 和 IP 地址的 ACL 传出规则。
有关 Amazon VPC 网络 ACL 的更多信息，请参阅 *Amazon VPC 用户指南*中的[网络 ACL](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)。
1. （可选）将 `max_allowed_packet` 参数设置为最大大小，以避免复制错误。建议使用此设置。
## 准备源 MySQL 数据库实例
执行以下步骤以复制源的形式准备源 MySQL 数据库实例。
**准备源 MySQL 数据库实例**
1. 确保设置复制时您的客户端计算机有足够的磁盘空间来保存二进制日志。
1. 连接到源 MySQL 数据库实例，并按照 MySQL 文档中 [Creating a User for Replication](http://dev.mysql.com/doc/refman/8.0/en/replication-howto-repuser.html) 的说明创建复制账户。
1. 在运行源 MySQL 数据库实例的系统上配置传入规则，以允许外部 MySQL 数据库在复制期间连接。指定一条传入规则，以允许从外部 MySQL 数据库的 IP 地址通过 TCP 连接到源 MySQL 数据库实例使用的端口。
1. 指定传出规则：
+ 如果源 MySQL 数据库实例在 VPC 中运行，请在 VPC 安全组中指定传入规则。有关更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
1. 如果源 MySQL 数据库实例在 VPC 中运行，则除了安全组传入规则外，还要配置 VPC ACL 规则。
+ 配置 ACL 传入规则，以允许从外部 MySQL 数据库的 IP 地址通过 TCP 连接到 Amazon RDS 实例使用的端口。
+ 配置 ACL 出口规则，以允许从端口 1024-65535 通过 TCP 连接到外部 MySQL 数据库的 IP 地址。
有关 Amazon VPC 网络 ACL 的更多信息，请参阅 *Amazon VPC 用户指南*中的[网络 ACL](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)。
1. 确保设置的备份保留期足够长，以便在导出期间不会清除任何二进制日志。如果在导出完成前清除了所有日志，您必须从头重新启动复制进程。有关设置备份保留期的更多信息，请参阅 [备份简介](USER_WorkingWithAutomatedBackups.md)。
1. 使用 `mysql.rds_set_configuration` 存储过程将二进制日志文件保留期设置得足够长，以便在导出期间不会清除二进制日志文件。有关更多信息，请参阅 [访问 MySQL 二进制日志](USER_LogAccess.MySQL.Binarylog.md)。
1. 从源 MySQL 数据库实例创建 Amazon RDS 只读副本，以进一步确保不会清除源 MySQL 数据库实例的二进制日志文件。有关更多信息，请参阅 [创建只读副本](USER_ReadRepl.Create.md)。
1. 在创建 Amazon RDS 只读副本后，调用 `mysql.rds_stop_replication` 存储过程以停止复制过程。源 MySQL 数据库实例不会再清除其二进制日志文件，以便这些文件可用于复制过程。
1. （可选）将 `max_allowed_packet` 和 `slave_max_allowed_packet` 参数都设置为最大大小，以避免复制错误。两个参数的最大大小为 1 GB。建议对两个参数都使用此设置。有关设置参数的信息，请参阅[在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
## 复制数据库
执行以下步骤以复制数据库。
**复制数据库**
1. 连接到源 MySQL 数据库实例的 RDS 只读副本，然后运行 MySQL `SHOW REPLICA STATUS\G` 语句。请记录下以下值：
+ `Master_Host`
+ `Master_Port`
+ `Master_Log_File`
+ `Exec_Master_Log_Pos`
**注意**
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS`，而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
1. 使用 mysqldump 实用程序创建快照，此过程会将数据从 Amazon RDS 复制到本地客户端计算机。确保您的客户端计算机有足够的空间容纳要复制的数据库中的 `mysqldump` 文件。为大量数据库完成此过程可能需要数小时的时间。按照 MySQL 文档中 [Creating a Data Snapshot Using mysqldump](https://dev.mysql.com/doc/mysql-replication-excerpt/8.0/en/replication-howto-mysqldump.html) 的说明进行操作。
以下示例在客户端上运行 `mysqldump`，并将转储写入文件。
对于 Linux、macOS 或 Unix：
```
mysqldump -h source_MySQL_DB_instance_endpoint \
-u user \
-ppassword \
--port=3306 \
--single-transaction \
--routines \
--triggers \
--databases database database2 > path/rds-dump.sql
```
对于：Windows
```
mysqldump -h source_MySQL_DB_instance_endpoint ^
-u user ^
-ppassword ^
--port=3306 ^
--single-transaction ^
--routines ^
--triggers ^
--databases database database2 > path\rds-dump.sql
```
您可以将备份文件加载到外部 MySQL 数据库中。有关更多信息，请参阅 MySQL 文档中的[重新加载 SQL 格式备份](https://dev.mysql.com/doc/refman/8.0/en/reloading-sql-format-dumps.html)。您可以运行另一个实用程序以将数据加载到外部 MySQL 数据库中。
## 完成导出
执行以下步骤以完成导出。
**完成导出**
1. 使用 MySQL `CHANGE MASTER` 语句配置外部 MySQL 数据库。指定授予 `REPLICATION SLAVE` 权限的用户的 ID 和密码。指定您对 RDS 只读副本运行的 MySQL `Master_Host` 语句所返回的 `Master_Port`、`Relay_Master_Log_File`、`Exec_Master_Log_Pos` 和 `SHOW REPLICA STATUS\G` 值。有关更多信息，请参阅 MySQL 文档中的 [CHANGE MASTER TO Statement](https://dev.mysql.com/doc/refman/8.0/en/change-master-to.html)。
**注意**
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS`，而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
1. 使用 MySQL `START REPLICA` 命令启动从源 MySQL 数据库实例到外部 MySQL 数据库的复制。
执行此操作将启动从源 MySQL 数据库实例进行复制的过程，并会导出在停止从 Amazon RDS 只读副本进行复制后发生的所有源更改。
**注意**
以前的 MySQL 版本使用的是 `START SLAVE`，而不是 `START REPLICA`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `START SLAVE`。
1. 对外部 MySQL 数据库运行 MySQL `SHOW REPLICA STATUS\G` 命令，以验证它是否作为只读副本运行。有关解释结果的更多信息，请参阅 MySQL 文档中的 [SHOW SLAVE \$1 REPLICA STATUS Statement](https://dev.mysql.com/doc/refman/8.0/en/show-slave-status.html)。
1. 在外部 MySQL 数据库上的复制跟上源 MySQL 数据库实例后，使用 MySQL `STOP REPLICA` 命令停止从源 MySQL 数据库实例的复制。
**注意**
以前的 MySQL 版本使用的是 `STOP SLAVE`，而不是 `STOP REPLICA`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `STOP SLAVE`。
1. 在 Amazon RDS 只读副本上，调用 `mysql.rds_start_replication` 存储过程。这样，Amazon RDS 就能开始从源 MySQL 数据库实例清除二进制日志文件。
# 适用于 MySQL 数据库实例的选项
在下文中，您可以找到适用于运行 MySQL 数据库引擎的 Amazon RDS 实例的选项或其他功能的说明。要启用这些选项，您可以将它们添加到自定义选项组中，然后将选项组关联到数据库实例。有关使用选项组的详细信息，请参阅[使用选项组](USER_WorkingWithOptionGroups.md)。
Amazon RDS 支持 MySQL 的以下选项：
****
| 选项 | 选项 ID | 引擎版本 |
| --- | --- | --- |
| [MySQL 的 MariaDB 审计插件支持](Appendix.MySQL.Options.AuditPlugin.md) | `MARIADB_AUDIT_PLUGIN` | 所有 MySQL 8.4 版本MySQL 8.0.28 及更高的 8.0 版本所有 MySQL 5.7 版本 |
| [MySQL memcached 支持](Appendix.MySQL.Options.memcached.md) | `MEMCACHED` | 所有 MySQL 5.7 和 8.0 版本 |
# MySQL 的 MariaDB 审计插件支持
Amazon RDS 基于开源 MariaDB 审计插件为 MySQL 数据库实例提供审计插件。有关更多信息，请参阅 [MySQL Server GitHub 存储库的审计插件](https://github.com/aws/audit-plugin-for-mysql)。
**注意**
MySQL 的审计插件基于 MariaDB 审计插件。在本文中，我们将其称为 MariaDB 审计插件。
MariaDB 审计插件记录数据库活动，包括用户登录数据库和针对数据库运行的查询等。数据库活动记录存储在日志文件中。
## 审计插件选项设置
Amazon RDS 支持 MariaDB 审计插件选项的以下设置。
| 选项设置 | 有效值 | 默认值 | 描述 |
| --- | --- | --- | --- |
| `SERVER_AUDIT_FILE_PATH` | `/rdsdbdata/log/audit/` | `/rdsdbdata/log/audit/` | 日志文件的位置。日志文件包含 `SERVER_AUDIT_EVENTS` 中指定的活动记录。有关更多信息，请参阅“[查看和列出数据库日志文件](USER_LogAccess.Procedural.Viewing.md)”和“[MySQL 数据库日志文件](USER_LogAccess.Concepts.MySQL.md)”。 |
| `SERVER_AUDIT_FILE_ROTATE_SIZE` | 1–1000000000 | 1000000 | 达到该字节大小时，会导致文件轮换。有关更多信息，请参阅“[RDS for MySQL 数据库日志概览](USER_LogAccess.MySQL.LogFileSize.md)”。 |
| `SERVER_AUDIT_FILE_ROTATIONS` | 0–100 | 9 | 当 `server_audit_output_type=file` 时要保存的日志轮换数量。如果设置为 0，则日志文件从不轮换。有关更多信息，请参阅“[RDS for MySQL 数据库日志概览](USER_LogAccess.MySQL.LogFileSize.md)”和“[下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)”。 |
| `SERVER_AUDIT_EVENTS` | `CONNECT`, `QUERY`, `QUERY_DDL`, `QUERY_DML`, `QUERY_DML_NO_SELECT`, `QUERY_DCL` | `CONNECT`, `QUERY` | 要在日志中记录的活动类型。安装 MariaDB 审核插件可自行登录。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/Appendix.MySQL.Options.AuditPlugin.html) MySQL 不支持 `TABLE`。 |
| `SERVER_AUDIT_INCL_USERS` | 多个逗号分隔值 | 无 | 仅包括指定用户的活动。默认情况下，会记录所有用户的活动。`SERVER_AUDIT_INCL_USERS` 和 `SERVER_AUDIT_EXCL_USERS` 是相互排斥的。如果将值添加到 `SERVER_AUDIT_INCL_USERS`，请确保未向 `SERVER_AUDIT_EXCL_USERS` 中添加任何值。 |
| `SERVER_AUDIT_EXCL_USERS` | 多个逗号分隔值 | 无 | 排除指定用户的活动。默认情况下，会记录所有用户的活动。`SERVER_AUDIT_INCL_USERS` 和 `SERVER_AUDIT_EXCL_USERS` 是相互排斥的。如果将值添加到 `SERVER_AUDIT_EXCL_USERS`，请确保未向 `SERVER_AUDIT_INCL_USERS` 中添加任何值。 `rdsadmin` 用户会每秒查询一次数据库，以检查数据库的运行状况。根据您的其他设置，此活动可能导致您的日志文件大小非常快速地增长。如果您不需要记录此活动，请将 `rdsadmin` 用户添加到 `SERVER_AUDIT_EXCL_USERS` 列表。 `CONNECT`会始终为所有用户记录 活动，即使是该选项设置指定的用户。 |
| `SERVER_AUDIT_LOGGING` | `ON` | `ON` | 日志记录处于活动状态。唯一有效值为 `ON`。Amazon RDS 不支持停用日志记录。如果您要停用日志记录，请删除 MariaDB 审核插件。有关更多信息，请参阅“[删除 MariaDB 审核插件](#Appendix.MySQL.Options.AuditPlugin.Remove)”。 |
| `SERVER_AUDIT_QUERY_LOG_LIMIT` | 0–2147483647 | 1024 | 记录中查询字符串的长度限制。 |
## 添加 MariaDB 审核插件
向数据库实例添加 MariaDB 审核插件的一般过程如下：
+ 创建新的选项组，或者复制或修改现有选项组
+ 向选项组添加选项
+ 将选项组与数据库实例相关联
添加 MariaDB 审核插件后，您无需重新启动数据库实例。一旦选项组处于活动状态，审核便会立即开始。
**重要**
将 MariaDB 审计插件添加到数据库实例可能会导致中断。我们建议在维护时段或数据库工作负载较低时添加 MariaDB 审计插件。
**添加 MariaDB 审核插件**
1. 确定您想要使用的选项组。您可以创建新的选项组，或使用现有选项组。如果您想使用现有选项组，请跳到下一步。否则，请创建自定义数据库选项组。为**引擎**选择 **mysql**，并为**主引擎版本**选择 **5.7**、**8.0** 或 **8.4**。有关更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 **MARIADB\$1AUDIT\$1PLUGIN** 选项添加到选项组中，然后配置选项设置。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。有关各项设置的更多信息，请参阅[审计插件选项设置](#Appendix.MySQL.Options.AuditPlugin.Options)。
1. 将选项组应用到新的或现有的数据库实例。
+ 对于新数据库实例，您可以在启动实例时应用选项组。有关更多信息，请参阅“[创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)”。
+ 对于现有数据库实例，您可以通过修改实例并附加新的选项组来应用选项组。有关更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## 审计日志格式
日志文件表示为 UTF-8 格式的逗号分隔变量 (CSV) 文件。
**提示**
日志文件条目不按先后顺序排列。要对条目进行排序，请使用时间戳值。要查看最新事件，您可能需要查看所有日志文件。为了更加灵活地对日志数据进行排序和搜索，请启用设置将审计日志上传到 CloudWatch，再使用 CloudWatch 界面进行查看。
若要查看包含更多字段类型和 JSON 格式输出的审计数据，还可以使用数据库活动流功能。有关更多信息，请参阅 [使用数据库活动流监控 Amazon RDS](DBActivityStreams.md)。
审核日志文件的各行按照指定顺序包含以下逗号分隔的信息：
| 字段 | 描述 |
| --- | --- |
| timestamp | 所记录的事件的 `YYYYMMDD` 后跟 `HH:MI:SS`（24 小时制）。 |
| serverhost | 记录了其事件的实例的名称。 |
| username | 已连接用户的用户名。 |
| host | 用户发起连接时所在的主机。 |
| connectionid | 所记录操作的连接 ID 号。 |
| queryid | 查询 ID 号，可用于查找关系表事件和相关查询。对于 `TABLE` 事件，添加多行。 |
| operation | 记录的操作类型。可能值为：`CONNECT`、`QUERY`、`READ`、`WRITE`、`CREATE`、`ALTER`、`RENAME` 和 `DROP`。 |
| database | 活动数据库，由 `USE` 命令设置。 |
| object | 对于 `QUERY` 事件，此值指示数据库执行的查询。对于 `TABLE` 事件，它指示表名。 |
| retcode | 所记录操作的返回代码。 |
| connection\$1type | 与服务器的连接的安全状态。可能的值有： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/AmazonRDS/latest/UserGuide/Appendix.MySQL.Options.AuditPlugin.html) |
## 查看和下载 MariaDB 审计插件日志
启用 MariaDB 审计插件后，您将以访问其他任何基于文本的日志文件的相同方式来访问日志文件中的结果。审计日志文件位于 `/rdsdbdata/log/audit/`。有关在控制台中查看日志文件的信息，请参阅 [查看和列出数据库日志文件](USER_LogAccess.Procedural.Viewing.md)。有关下载日志文件的信息，请参阅 [下载数据库日志文件](USER_LogAccess.Procedural.Downloading.md)。
## 修改 MariaDB 审计插件设置
启用 MariaDB 审计插件后，您可以修改各项设置。有关如何修改选项设置的更多信息，请参阅 [修改选项设置](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption)。有关各项设置的更多信息，请参阅[审计插件选项设置](#Appendix.MySQL.Options.AuditPlugin.Options)。
## 删除 MariaDB 审核插件
Amazon RDS 不支持关闭 MariaDB 审核插件中的日志记录。不过，您可以从数据库实例删除插件。在删除 MariaDB 审核插件时，将自动重新启动数据库实例以停止审核。
要从数据库实例中删除 MariaDB 审核插件，请执行以下操作之一：
+ 从 MariaDB 审核插件选项所属的选项组中删除 MariaDB 审核插件选项。此更改会影响使用该选项组的所有数据库实例。有关更多信息，请参阅“[从选项组中删除选项](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)”
+ 修改数据库实例，并指定不包含插件的其他选项组。此更改会影响单个数据库实例。您可以指定默认 (空) 选项组，或指定其他自定义选项组。有关更多信息，请参阅“[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)”。
# MySQL memcached 支持
Amazon RDS 支持对 InnoDB 表使用 `memcached` 接口，该接口已在 MySQL 5.6 中引入。通过 `memcached` API，应用程序可以按照 NoSQL 密钥值数据存储的类似使用方式来使用 InnoDB 表。
**注意**
Memcached 接口在 MySQL 8.4 上不再可用。当您将数据库实例升级到 MySQL 8.4 时，必须在现有选项组中禁用 `memcached`。
`memcached` 接口是基于键的简单缓存。应用程序使用 `memcached` 插入、操作和检索缓存中的“键-值”数据对。MySQL 5.6 引入了一个插件来实现一个守护进程服务，该服务通过 `memcached` 协议公开 InnoDB 表中的数据。有关 MySQL `memcached` 插件的更多信息，请参阅 [InnoDB 与 memcached 的集成](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached.html)。
**实现对 RDS for MySQL 数据库实例的 memcached 支持**
1. 确定用于控制对 `memcached` 接口的访问的安全组。如果已在使用 SQL 接口的应用程序集与访问 `memcached` 接口的应用程序集相同，则可使用 SQL 接口所用的现有 VPC 安全组。如果访问 `memcached` 接口的系列应用程序与之不同，则请定义新的 VPC 或数据库安全组。有关管理安全组的更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
1. 创建自定义数据库选项组，引擎类型选择 MySQL 并选择版本。有关创建选项组的更多信息，请参阅 [创建选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create)。
1. 将 `MEMCACHED` 选项添加到该选项组。指定 `memcached` 接口将使用的端口以及用于控制对接口的访问的安全组。有关添加选项的更多信息，请参阅 [将选项添加到选项组](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption)。
1. 如有必要，修改选项设置以配置 `memcached` 参数。有关如何修改选项设置的更多信息，请参阅 [修改选项设置](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption)。
1. 将选项组应用于实例。在应用选项组时，Amazon RDS 会为该实例启用 `memcached` 支持：
+ 您可以通过在启动实例时指定自定义选项组来启用新实例的 `memcached` 支持。有关启动 MySQL 实例的更多信息，请参阅 [创建 Amazon RDS 数据库实例](USER_CreateDBInstance.md)。
+ 您可以通过在修改实例时指定自定义选项组来启用现有实例的 `memcached` 支持。有关修改 数据库实例的更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
1. 指定 MySQL 表中哪些列可以通过 `memcached` 接口进行访问。`memcached` 插件会在名为 `containers` 的专用数据库中创建名为 `innodb_memcache` 的目录表。在 `containers` 表中插入行，使之映射通过 `memcached` 访问的 InnoDB 表。在 InnoDB 表中指定用于存储 `memcached` 键值的列，并指定一个或多个用于存储与该键关联的数据值的列。您还指定一个 `memcached` 应用程序用于引用列集的名称。有关在 `containers` 表中插入行的详细信息，请参阅 [InnoDB memcached 插件内部信息](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-internals.html)。有关映射 InnoDB 表并通过 `memcached` 访问该表的示例，请参阅[为 InnoDB memcached 插件编写应用程序](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-developing.html)。
1. 如果访问 `memcached` 接口的应用程序与使用 SQL 接口的应用程序位于不同的计算机或 EC2 实例上，请将这些计算机的连接信息添加到与 MySQL 实例关联的 VPC 安全组。有关管理安全组的更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
您通过修改该实例并指定 MySQL 版本的默认选项组来关闭实例的 `memcached` 支持。有关修改 数据库实例的更多信息，请参阅 [修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## MySQL memcached 安全注意事项
`memcached` 协议不支持用户身份验证。有关 MySQL `memcached` 安全注意事项的更多信息，请参阅 MySQL 文档中的 [InnoDB memcached 插件的安全注意事项](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-security.html)。
您可以采取下列操作来帮助提高 `memcached` 接口的安全性：
+ 在向选项组添加 `MEMCACHED` 选项时，指定一个与默认 11211 不同的端口。
+ 确保将 `memcached` 接口与用于限制对巳知的可信客户端地址和 EC2 实例的访问的 VPC 安全组关联。有关管理安全组的更多信息，请参阅 [使用安全组控制访问权限](Overview.RDSSecurityGroups.md)。
## MySQL memcached 连接信息
要访问 `memcached` 接口，应用程序必须同时指定 Amazon RDS 实例的 DNS 名称和 `memcached` 端口号。例如，如果实例的 DNS 名称为 `my-cache-instance.cg034hpkmmjt.region.rds.amazonaws.com`，并且内存缓存接口使用端口 11212，PHP 中指定的连接信息将为：
```
1. connect('my-cache-instance.cg034hpkmmjt.region.rds.amazonaws.com',11212);
5. ?>
```
**要查找 MySQL DB 实例的 DNS 名称和 memcached 端口，请执行以下操作：**
1. 登录AWS 管理控制台并通过以下网址打开 Amazon RDS 控制台：[https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)。
1. 在 AWS 管理控制台中的右上角，选择包含该数据库实例的地区。
1. 在导航窗格中，选择 **Databases (数据库)**。
1. 选择 MySQL 数据库实例名称以显示其详细信息。
1. 在**连接**部分，记下**终端节点**字段的值。DNS 名称与终端节点相同。另请注意，**连接**部分中的端口未用于访问 `memcached` 接口。
1. 在**详细信息**部分，记下**选项组**字段中列出的名称。
1. 在导航窗格中，选择**选项组**。
1. 选择 MySQL 数据库实例所用的选项组名称以显示该选项组的详细信息。在**选项**部分，记下 **MEMCACHED** 选项的**端口**设置值。
## MySQL memcached 选项设置
Amazon RDS 将 MySQL `memcached` 参数公开为 Amazon RDS `MEMCACHED` 选项中的选项设置。
### MySQL memcached 参数
+ `DAEMON_MEMCACHED_R_BATCH_SIZE` – 一个整数，用于指定在执行 COMMIT 操作启动新的事务前应执行多少个 `memcached` 读取操作（获取）。允许的值是 1 到 4294967295；默认值为 1。此选项在重新启动实例后生效。
+ `DAEMON_MEMCACHED_W_BATCH_SIZE` – 一个整数，用于指定在执行 COMMIT 操作启动新的事务前应执行多少个 `memcached` 写入操作，如添加、设置或者 incr。允许的值是 1 到 4294967295；默认值为 1。此选项在重新启动实例后生效。
+ `INNODB_API_BK_COMMIT_INTERVAL` – 一个整数，用于指定多长时间自动提交一次使用 InnoDB `memcached` 接口的闲置连接。允许的值是 1 到 1073741824；默认值为 5。该选项会立即生效，无需重新启动实例。
+ `INNODB_API_DISABLE_ROWLOCK` – 一个布尔值，该值在使用 InnoDB `memcached` 接口时禁用 (1 (true)) 或启用 (0 (false)) 行锁。默认为 0 (false)。此选项在重新启动实例后生效。
+ `INNODB_API_ENABLE_MDL` –一个布尔值，设置为 0(false) 会锁定 InnoDB `memcached` 插件使用的表，以便 DDL 无法通过 SQL 接口删除或者更改该表。默认为 0 (false)。此选项在重新启动实例后生效。
+ `INNODB_API_TRX_LEVEL` – 一个整数，用于指定 `memcached` 接口处理的查询的事务隔离级别。容许值是 0 到 3。默认值为 0。此选项在重新启动实例后生效。
Amazon RDS 配置以下 MySQL `memcached` 参数，这些参数无法修改：`DAEMON_MEMCACHED_LIB_NAME`、`DAEMON_MEMCACHED_LIB_PATH` 和 `INNODB_API_ENABLE_BINLOG`。在 Amazon RDS 中，也以单个 `daemon_memcached_options` 选项设置是形式提供 MySQL 管理员使用 `MEMCACHED` 设置的参数。
### MySQL daemon\$1memcached\$1options 参数
+ `BINDING_PROTOCOL` – 一个字符串，用于指定要使用的绑定协议。允许的值是 `auto`、`ascii` 或 `binary`。默认值为 `auto`，这意味着服务器与客户端自动协商协议。此选项在重新启动实例后生效。
+ `BACKLOG_QUEUE_LIMIT` 一个整数，用于指定可等待 处理的网络连接的数目。`memcached`增大此限值会减少无法连接到 `memcached` 实例的客户端所收到的错误，但不会提高服务器性能。允许的值是 1 到 2048；默认值为 1024。此选项在重新启动实例后生效。
+ `CAS_DISABLED` – 一个布尔值，该值启用 (1 (true)) 或禁用 (0 (false)) 比较和交换 (CAS)，它可使每个项大小减少 8 个字节。默认为 0 (false)。此选项在重新启动实例后生效。
+ `CHUNK_SIZE` – 一个整数，用于指定为最小项的键、值和标志所分配的最小区块大小（计算单位：字节）。容许值是 1 到 48。默认为 48，且可以使用较低的值显著地提高内存效率。此选项在重新启动实例后生效。
+ `CHUNK_SIZE_GROWTH_FACTOR` – 一个浮点数，用于控制新区块的大小。新区块的大小是前一区块时间的大小 `CHUNK_SIZE_GROWTH_FACTOR`。允许的值是 1 到 2；默认值为 1.25。此选项在重新启动实例后生效。
+ `ERROR_ON_MEMORY_EXHAUSTED` – 一个布尔值，当该值设置为 1 (true) 时，将指定在没有更多内存来存储项时 `memcached` 将返回错误，而不会返回逐出项。如果设置为 0(false)，当没有更多内存时，`memcached` 将移出项目。默认为 0 (false)。此选项在重新启动实例后生效。
+ `MAX_SIMULTANEOUS_CONNECTIONS` – 一个整数，用于指定最大并发连接数。将这个值设置为低于 10 的任何数值可防止 MySQL 启动。允许的值是 10 到 1024；默认值为 1024。此选项在重新启动实例后生效。
+ `VERBOSITY` – 一个字符串，用于指定 `memcached` 服务在 MySQL 错误日志中记录的信息级别。默认值为 v。此选项在重新启动实例后生效。允许的许值为：
+ `v` – 记录运行主事件循环时出现的错误和警告。
+ `vv` – 除了 v 选项记录的信息之外，还会记录每个客户端命令和响应。
+ `vvv` – 除了 vv 选项记录的信息之外，还会记录内部状态转换。
Amazon RDS 配置这些 MySQL `DAEMON_MEMCACHED_OPTIONS` 参数，且无法进行修改：`DAEMON_PROCESS`、`LARGE_MEMORY_PAGES`、`MAXIMUM_CORE_FILE_LIMIT`、`MAX_ITEM_SIZE`、`LOCK_DOWN_PAGE_MEMORY`、`MASK`、`IDFILE`、`REQUESTS_PER_EVENT`、`SOCKET` 和 `USER`。
# MySQL 的参数
默认情况下，MySQL 数据库实例使用特定于 MySQL 数据库的数据库参数组。此参数组包含 MySQL 数据库引擎的参数。有关使用参数组和设置参数的信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
RDS for MySQL 参数设置为您已选择的存储引擎的默认值。有关 MySQL 参数的更多信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html)。有关 MySQL 存储引擎的更多信息，请参阅 [支持的 RDS for MySQL 存储引擎](MySQL.Concepts.FeatureSupport.md#MySQL.Concepts.Storage)。
您可以使用 RDS 控制台或 AWS CLI 查看特定 RDS for MySQL 版本的可用参数。有关在 RDS 控制台中查看 MySQL 参数组中参数的信息，请参阅 [在 Amazon RDS 中查看数据库参数组的参数值](USER_WorkingWithParamGroups.Viewing.md)。
使用 AWS CLI，您可以通过运行 [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html) 命令查看 RDS for MySQL 版本的参数。为 `--db-parameter-group-family` 选项指定下列值之一：
+ `mysql8.4`
+ `mysql8.0`
+ `mysql5.7`
例如，要查看 RDS for MySQL 版本 8.0 的参数，请运行以下命令。
```
aws rds describe-engine-default-parameters --db-parameter-group-family mysql8.0
```
输出看上去类似于以下内容。
```
{
"EngineDefaults": {
"Parameters": [
{
"ParameterName": "activate_all_roles_on_login",
"ParameterValue": "0",
"Description": "Automatically set all granted roles as active after the user has authenticated successfully.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": true
},
{
"ParameterName": "allow-suspicious-udfs",
"Description": "Controls whether user-defined functions that have only an xxx symbol for the main function can be loaded",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false
},
{
"ParameterName": "auto_generate_certs",
"Description": "Controls whether the server autogenerates SSL key and certificate files in the data directory, if they do not already exist.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "boolean",
"AllowedValues": "0,1",
"IsModifiable": false
},
...
```
要仅列出 RDS for MySQL 版本 8.0 的可修改参数，请运行以下命令。
对于 Linux、macOS 或 Unix：
```
aws rds describe-engine-default-parameters --db-parameter-group-family mysql8.0 \
--query 'EngineDefaults.Parameters[?IsModifiable==`true`]'
```
对于 Windows：
```
aws rds describe-engine-default-parameters --db-parameter-group-family mysql8.0 ^
--query "EngineDefaults.Parameters[?IsModifiable==`true`]"
```
# MySQL 数据库实例的数据库管理员常见任务
您可以在下面的内容中找到一些常见数据管理员任务的 Amazon RDS 特定实施描述，这些任务适用于运行 MySQL 数据库引擎的数据库实例。为了提供托管服务体验，Amazon RDS 未提供数据库实例的 Shell 访问权限。并且它还限制了对需要高级权限的某些系统程序和表的访问。
有关在 Amazon RDS 上使用 MySQL 日志文件的信息，请参阅 [MySQL 数据库日志文件](USER_LogAccess.Concepts.MySQL.md)。
## 了解预定义用户
Amazon RDS 使用新的 RDS for MySQL 数据库实例自动创建若干预定义用户。无法更改预定义用户及其权限。无法删除、重命名或修改这些预定义用户的权限。此类尝试会导致错误。
+ **rdsadmin** – 具有 `superuser` 权限的管理员将对独立的 PostgreSQL 数据库执行许多管理任务，此用户专为处理这些管理任务而创建。此用户供 RDS for MySQL 在内部执行许多管理任务。
+ **rdsrepladmin** - Amazon RDS 在内部使用的用户，用于支持 RDS for MySQL 数据库实例和集群上的复制活动。
有关其它常见 DBA 任务的信息，请参阅以下主题。
**Topics**
+ [
## 了解预定义用户
](#Appendix.MySQL.CommonDBATasks.users)
+ [
# RDS for MySQL 的基于角色的权限模型
](Appendix.MySQL.CommonDBATasks.privilege-model.md)
+ [
# 适用于 RDS for MySQL 的动态权限
](Appendix.MySQL.CommonDBATasks.dynamic-privileges.md)
+ [
# 结束 RDS for MySQL 的会话或查询
](Appendix.MySQL.CommonDBATasks.End.md)
+ [
# 跳过 RDS for MySQL 的当前复制错误
](Appendix.MySQL.CommonDBATasks.SkipError.md)
+ [
# 使用 InnoDB 表空间改善 RDS for MySQL 的崩溃恢复时间
](Appendix.MySQL.CommonDBATasks.Tables.md)
+ [
# 管理 RDS for MySQL 的全局状态历史记录
](Appendix.MySQL.CommonDBATasks.GoSH.md)
+ [
# 在 MySQL 8.4 中配置缓冲池大小和重做日志容量
](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md)
# RDS for MySQL 的基于角色的权限模型
从 RDS for MySQL 版本 8.0.36 开始，您无法直接修改 `mysql` 数据库中的表。特别是，您不能通过对 `grant` 表执行数据操作语言（DML）操作来创建数据库用户。相反，您可以使用 MySQL 账户管理语句（例如 `CREATE USER`、`GRANT`、和 `REVOKE`）向用户授予基于角色的权限。您也无法创建其他类型的对象，例如 `mysql` 数据库中的存储过程。您仍然可以查询 `mysql` 表。如果您使用二进制日志复制，则直接对源数据库实例上的 `mysql` 表进行的更改不会复制到目标集群中。
在某些情况下，您的应用程序可能会使用快捷方式通过插入到 `mysql` 表来创建用户或其他对象。如果是这样，请更改应用程序代码以使用相应的语句，例如 `CREATE USER`。
要在从外部 MySQL 数据库迁移期间导出数据库用户的元数据，请使用以下方法之一：
+ 将 MySQL Shell 的实例转储实用程序与筛选条件一起使用，来排除用户、角色和授权。以下示例显示了要使用的命令语法。确保 `outputUrl` 为空。
```
mysqlsh user@host -- util.dumpInstance(outputUrl,{excludeSchemas:['mysql'],users: true})
```
有关更多信息，请参阅《MySQL 参考手册》中的 [Instance Dump Utility, Schema Dump Utility, and Table Dump Utility](https://dev.mysql.com/doc/mysql-shell/8.0/en/mysql-shell-utilities-dump-instance-schema.html)。
+ 使用 `mysqlpump` 客户端实用程序。此示例包括除 `mysql` 系统数据库中的表之外的所有表。它还包括用于重现迁移数据库中的所有 MySQL 用户的 `CREATE USER` 和 `GRANT` 语句。
```
mysqlpump --exclude-databases=mysql --users
```
MySQL 8.4 中不再提供 `mysqlpump` 客户端实用工具。请改用`mysqldump`。
为了简化对许多用户或应用程序的权限管理，您可以使用 `CREATE ROLE` 语句来创建具有一组权限的角色。然后，您可以使用 `GRANT` 和 `SET ROLE` 语句以及 `current_role` 函数将角色分配给用户或应用程序、切换当前角色以及检查哪些角色有效。有关 MySQL 8.0 中基于角色的权限系统的更多信息，请参阅 MySQL 参考手册中的[使用角色](https://dev.mysql.com/doc/refman/8.0/en/roles.html)。
**重要**
我们强烈建议不要直接在应用程序中使用主用户。请遵守使用数据库用户的最佳实践，按照您的应用程序所需的最少权限创建用户。
从版本 8.0.36 开始，RDS for MySQL 包括一个具有以下所有权限的特殊角色。该角色命名为 `rds_superuser_role`。每个数据库实例的主管理用户已经获得了此角色。`rds_superuser_role` 角色包括所有数据库对象的以下权限：
+ `ALTER`
+ `APPLICATION_PASSWORD_ADMIN`
+ `ALTER ROUTINE`
+ `CREATE`
+ `CREATE ROLE`
+ `CREATE ROUTINE`
+ `CREATE TEMPORARY TABLES`
+ `CREATE USER`
+ `CREATE VIEW`
+ `DELETE`
+ `DROP`
+ `DROP ROLE`
+ `EVENT`
+ `EXECUTE`
+ `INDEX`
+ `INSERT`
+ `LOCK TABLES`
+ `PROCESS`
+ `REFERENCES`
+ `RELOAD`
+ `REPLICATION CLIENT`
+ `REPLICATION SLAVE`
+ `ROLE_ADMIN`
+ `SET_USER_ID`
+ `SELECT`
+ `SHOW DATABASES`
+ `SHOW VIEW`
+ `TRIGGER`
+ `UPDATE`
+ `XA_RECOVER_ADMIN`
角色定义还包括 `WITH GRANT OPTION`，以便管理用户可以将该角色授予其他用户。特别是，管理员必须授予以 MySQL 集群作为目标执行二进制日志复制所需的任何权限。
**提示**
要查看权限的完整详细信息，请使用以下语句。
```
SHOW GRANTS FOR rds_superuser_role@'%';
```
当您使用 RDS for MySQL 版本 8.0.36 和更高版本中的角色授予访问权限时，还可以通过使用 `SET ROLE role_name` 或 `SET ROLE ALL` 语句来激活角色。下面的示例演示如何操作。将适当的角色名称替换为 `CUSTOM_ROLE`。
```
# Grant role to user
mysql> GRANT CUSTOM_ROLE TO 'user'@'domain-or-ip-address'
# Check the current roles for your user. In this case, the CUSTOM_ROLE role has not been activated.
# Only the rds_superuser_role is currently in effect.
mysql> SELECT CURRENT_ROLE();
+--------------------------+
| CURRENT_ROLE() |
+--------------------------+
| `rds_superuser_role`@`%` |
+--------------------------+
1 row in set (0.00 sec)
# Activate all roles associated with this user using SET ROLE.
# You can activate specific roles or all roles.
# In this case, the user only has 2 roles, so we specify ALL.
mysql> SET ROLE ALL;
Query OK, 0 rows affected (0.00 sec)
# Verify role is now active
mysql> SELECT CURRENT_ROLE();
+--------------------------------------------------+
| CURRENT_ROLE() |
+--------------------------------------------------+
| `CUSTOM_ROLE`@`%`,`rds_superuser_role`@`%` |
+--------------------------------------------------+
```
# 适用于 RDS for MySQL 的动态权限
动态权限是可以使用 `GRANT` 语句显式授予的 MySQL 权限。根据 RDS for MySQL 版本，RDS 支持您仅授予特定的动态权限。RDS 不支持使用其中某些权限，因为这些权限可能会干扰特定的数据库操作，例如复制和备份。
下表显示了可以针对不同的 MySQL 版本授予其中哪些权限。如果要从低于 8.0.36 的 MySQL 版本升级到 8.0.36 或更高版本，则当不再支持授予特定权限时，可能需要更新应用程序代码。
| 特权 | MySQL 8.0.35 及更低版本 | MySQL 8.0.36 及更高的次要版本 | MySQL 8.4.3 及更高版本 |
| --- | --- | --- | --- |
| [ALLOW\$1NONEXISTENT\$1DEFINER](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_allow-nonexistent-definer) | 不可用 | 不可用 | 不允许 |
| [APPLICATION\$1PASSWORD\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_application-password-admin) | 已允许 | 已允许 | 已允许 |
| [AUDIT\$1ABORT\$1EXEMPT](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_audit-abort-exempt) | 已允许 | 不允许 | 不允许 |
| [AUDIT\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_audit-admin) | 不允许 | 不允许 | 不允许 |
| [AUTHENTICATION\$1POLICY\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_authentication-policy-admin) | 已允许 | 不允许 | 不允许 |
| [BACKUP\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_backup-admin) | 已允许 | 不允许 | 不允许 |
| [BINLOG\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_binlog-admin) | 已允许 | 不允许 | 不允许 |
| [BINLOG\$1ENCRYPTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_binlog-encryption-admin) | 不允许 | 不允许 | 不允许 |
| [CLONE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_clone-admin) | 不允许 | 不允许 | 不允许 |
| [CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_connection-admin) | 已允许 | 不允许 | 不允许 |
| [ENCRYPTION\$1KEY\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_encryption-key-admin) | 不允许 | 不允许 | 不允许 |
| [FIREWALL\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-admin) | 不允许 | 不允许 | 不允许 |
| [FIREWALL\$1EXEMPT](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-exempt) | 已允许 | 不允许 | 不允许 |
| [FIREWALL\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_firewall-user) | 不允许 | 不允许 | 不允许 |
| [FLUSH\$1OPTIMIZER\$1COSTS](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-optimizer-costs) | 已允许 | 已允许 | 已允许 |
| [FLUSH\$1PRIVILEGES](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_flush-privileges) | 不可用 | 不可用 | 已允许 |
| [FLUSH\$1STATUS](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-status) | 已允许 | 已允许 | 已允许 |
| [FLUSH\$1TABLES](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-tables) | 已允许 | 已允许 | 已允许 |
| [FLUSH\$1USER\$1RESOURCES](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_flush-user-resources) | 已允许 | 已允许 | 已允许 |
| [GROUP\$1REPLICATION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_group-replication-admin) | 不允许 | 不允许 | 不允许 |
| [GROUP\$1REPLICATION\$1STREAM](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_group-replication-stream) | 不允许 | 不允许 | 不允许 |
| [INNODB\$1REDO\$1LOG\$1ARCHIVE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_innodb-redo-log-archive) | 不允许 | 不允许 | 不允许 |
| [INNODB\$1REDO\$1LOG\$1ENABLE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_innodb-redo-log-enable) | 不允许 | 不允许 | 不允许 |
| [MASKING\$1DICTIONARIES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_masking-dictionaries-admin) | 不允许 | 不允许 | 不允许 |
| [NDB\$1STORED\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_ndb-stored-user) | 不允许 | 不允许 | 不允许 |
| [OPTIMIZE\$1LOCAL\$1TABLE](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_optimize-local-table) | 不可用 | 不可用 | 不允许 |
| [PASSWORDLESS\$1USER\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_passwordless-user-admin) | 不允许 | 不允许 | 不允许 |
| [PERSIST\$1RO\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_persist-ro-variables-admin) | 不允许 | 不允许 | 不允许 |
| [REPLICATION\$1APPLIER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_replication-applier) | 已允许 | 不允许 | 不允许 |
| [REPLICATION\$1SLAVE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_replication-slave-admin) | 不允许 | 不允许 | 不允许 |
| [RESOURCE\$1GROUP\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_resource-group-admin) | 已允许 | 不允许 | 不允许 |
| [RESOURCE\$1GROUP\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_resource-group-user) | 已允许 | 不允许 | 不允许 |
| [ROLE\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_role-admin) | 已允许 | 已允许 | 已允许 |
| [SENSITIVE\$1VARIABLES\$1OBSERVER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_sensitive-variables-observer) | 已允许 | 已允许 | 已允许 |
| [SERVICE\$1CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_service-connection-admin) | 已允许 | 不允许 | 不允许 |
| [SESSION\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_session-variables-admin) | 已允许 | 已允许 | 已允许 |
| [SET\$1ANY\$1DEFINER](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_set-any-definer) | 不可用 | 不可用 | 已允许 |
| [SET\$1USER\$1ID](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_set-user-id) | 已允许 | 已允许 | 不可用 |
| [SHOW\$1ROUTINE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_show-routine) | 已允许 | 已允许 | 已允许 |
| [SKIP\$1QUERY\$1REWRITE](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_skip-query-rewrite) | 不允许 | 不允许 | 不允许 |
| [SYSTEM\$1USER](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_system-user) | 不允许 | 不允许 | 不允许 |
| [SYSTEM\$1VARIABLES\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_system-variables-admin) | 不允许 | 不允许 | 不允许 |
| [TABLE\$1ENCRYPTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_table-encryption-admin) | 不允许 | 不允许 | 不允许 |
| [TELEMETRY\$1LOG\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_telemetry-log-admin) | 已允许 | 不允许 | 不允许 |
| [TP\$1CONNECTION\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_tp-connection-admin) | 不允许 | 不允许 | 不允许 |
| [TRANSACTION\$1GTID\$1TAG](https://dev.mysql.com/doc/refman/8.4/en/privileges-provided.html#priv_transaction-gtid-tag) | 不可用 | 不可用 | 不允许 |
| [VERSION\$1TOKEN\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_version-token-admin) | 不允许 | 不允许 | 不允许 |
| [XA\$1RECOVER\$1ADMIN](https://dev.mysql.com/doc/refman/8.0/en/privileges-provided.html#priv_xa-recover-admin) | 已允许 | 已允许 | 已允许 |
# 结束 RDS for MySQL 的会话或查询
您可使用 `rds_kill` 和 `rds_kill_query` 命令结束数据库实例上的用户会话或查询。首先连接到 MySQL 数据库实例，然后发出正确的命令，如下所示。有关更多信息，请参阅“[连接到 MySQL 数据库实例](USER_ConnectToInstance.md)”。
```
CALL mysql.rds_kill(thread-ID)
CALL mysql.rds_kill_query(thread-ID)
```
例如，要结束线程 99 上运行的会话，可以键入以下内容：
```
CALL mysql.rds_kill(99);
```
要结束线程 99 上运行的查询，可以键入以下内容：
```
CALL mysql.rds_kill_query(99);
```
# 跳过 RDS for MySQL 的当前复制错误
如果错误导致只读副本停止响应但不影响数据的完整性，您可以跳过只读副本错误。
**注意**
请先验证是否可以安全地跳过错误。在 MySQL 实用工具中，连接到只读副本并运行以下 MySQL 命令。
```
SHOW REPLICA STATUS\G
```
有关返回值的信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html)。
以前的 MySQL 版本使用的是 `SHOW SLAVE STATUS` 而不是 `SHOW REPLICA STATUS`。如果您使用的 MySQL 版本低于 8.0.23，那么请使用 `SHOW SLAVE STATUS`。
您可以通过以下方式跳过只读副本上的错误。
**Topics**
+ [
## 调用 mysql.rds\$1skip\$1repl\$1error 过程
](#Appendix.MySQL.CommonDBATasks.SkipError.procedure)
+ [
## 设置 slave\$1skip\$1errors 参数
](#Appendix.MySQL.CommonDBATasks.SkipError.parameter)
## 调用 mysql.rds\$1skip\$1repl\$1error 过程
Amazon RDS 提供了一个存储过程，您可以调用该过程以跳过只读副本上的错误。首先连接到您的只读副本，然后发出正确的命令，如下所示。有关更多信息，请参阅 [连接到 MySQL 数据库实例](USER_ConnectToInstance.md)。
要跳过错误，请发出以下命令。
```
CALL mysql.rds_skip_repl_error;
```
如果您在未遇到复制错误的源数据库实例或只读副本上运行此命令，则此命令不会产生任何影响。
有关更多信息 (如支持 `mysql.rds_skip_repl_error` 的 MySQL 版本)，请参阅 [mysql.rds\$1skip\$1repl\$1error](mysql-stored-proc-replicating.md#mysql_rds_skip_repl_error)。
**重要**
如果您尝试调用 `mysql.rds_skip_repl_error` 并遇到以下错误：`ERROR 1305 (42000): PROCEDURE mysql.rds_skip_repl_error does not exist`，请将您的 MySQL 数据库实例升级到最新次要版本或是 [mysql.rds\$1skip\$1repl\$1error](mysql-stored-proc-replicating.md#mysql_rds_skip_repl_error) 中列出的最低次要版本之一。
## 设置 slave\$1skip\$1errors 参数
要跳过一个或多个错误，您可以设置在只读副本上设置 `slave_skip_errors` 静态参数。您可以将此参数设置为跳过一个或多个特定的复制错误代码。目前，您只能为适用于 MySQL 5.7 的 RDS 数据库实例设置此参数。更改此参数的设置后，确保重启数据库实例，以使新设置生效。有关设置此参数的信息，请参阅 [MySQL 文档](https://dev.mysql.com/doc/refman/5.7/en/replication-options-replica.html#sysvar_slave_skip_errors)。
我们建议在单独的数据库参数组中设置此参数。您只能将此数据库参数组与需要跳过错误的只读副本关联。遵循此最佳实践可以减少对其他数据库实例和只读副本的潜在影响。
**重要**
为此参数设置非默认值可能会导致复制不一致。只有在用尽其他选项来解决问题并且确定对只读副本数据的潜在影响时，才将此参数设置为非默认值。
# 使用 InnoDB 表空间改善 RDS for MySQL 的崩溃恢复时间
MySQL 中的所有表均由表定义、数据和索引组成。MySQL 存储引擎 InnoDB 将表数据和索引存储在*表空间*中。InnoDB 创建全局共享的表空间，其中包括数据字典和其他相关元数据，并且它可能包含表数据和索引。InnoDB 还可以为每张表创建单独的表空间和分区。这些单独的表空间存储在后缀名为 .ibd 的文件中，并且每个表空间的头部包含一个唯一识别编号。
`innodb_file_per_table` 提供一个属于 MySQL 参数组的参数，名称为 Amazon RDS。这些参数控制 InnoDB 是否（通过将参数值设置为 0）向共享表空间或（通过将参数值设置为 1）向单个表空间添加新的表数据和索引。Amazon RDS 将 `innodb_file_per_table` 参数的默认值设置为 1，以便删除单独的 InnoDB 表并回收数据库实例的表所占用的存储空间。在大多数使用案例中，推荐将 `innodb_file_per_table` 参数设置为 1。
当表特别多时 (例如，当使用标准 (磁性) 或通用 SSD 存储时，有超过 1000 张表，或当使用预置的 IOPS 存储时，有超过 10000 张表)，应将 `innodb_file_per_table` 参数设置为 0。当将该参数设置为 0 时，不会创建独立表空间，这样可以节省数据库崩溃恢复所需的时间。
MySQL 在崩溃恢复循环期间处理每个元数据文件 (包括表空间)。当有多个表空间时，与 MySQL 用于处理数以千计的表空间文件的时间相比，MySQL 用于处理共享表空间中的元数据信息的时间可以忽略不计。因为表空间编号存储在每个文件的头部，读取所有表空间文件的总时间可能需要长达数小时。例如，在崩溃恢复循环期间，标准存储空间上的一百万个 InnoDB 表空间可能需要 5 到 8 个小时的处理时间。在一些案例中，InnoDB 可能会在一个崩溃恢复循环后确定它需要额外清理，因此，它会开始另一个崩溃恢复循环，这会使恢复时间延长。请记住，崩溃恢复循环也会引起回滚事务、修复损坏页面和除表空间信息处理以外的其他操作。
因为 `innodb_file_per_table` 参数存储在参数组中，所以可通过编辑数据库实例所使用的参数组来更改该参数值，无需重新启动该数据库实例。更改该设置后，例如从 1 (创建独立的表) 改为 0 (使用共享的表空间)，新的 InnoDB 表将添加到共享的表空间，而现有的表继续使用独立的表空间。要将 InnoDB 表移动到共享的表空间，必须使用 `ALTER TABLE` 命令。
## 将多个表空间迁移到共享的表空间
您可将 InnoDB 表的元数据从其自己的表空间移至共享的表空间，这将按照 `innodb_file_per_table` 参数设置重建表的元数据。首先连接到 MySQL 数据库实例，然后发出正确的命令，如下所示。有关更多信息，请参阅“[连接到 MySQL 数据库实例](USER_ConnectToInstance.md)”。
```
ALTER TABLE table_name ENGINE = InnoDB, ALGORITHM=COPY;
```
例如，以下查询为不在共享表空间中的每个 InnoDB 表返回 `ALTER TABLE` 语句。
**对于 MySQL 5.7 数据库实例：**
```
SELECT CONCAT('ALTER TABLE `',
REPLACE(LEFT(NAME , INSTR((NAME), '/') - 1), '`', '``'), '`.`',
REPLACE(SUBSTR(NAME FROM INSTR(NAME, '/') + 1), '`', '``'), '` ENGINE=InnoDB, ALGORITHM=COPY;') AS Query
FROM INFORMATION_SCHEMA.INNODB_SYS_TABLES
WHERE SPACE <> 0 AND LEFT(NAME, INSTR((NAME), '/') - 1) NOT IN ('mysql','');
```
**对于 MySQL 8.4 和 8.0 数据库实例：**
```
SELECT CONCAT('ALTER TABLE `',
REPLACE(LEFT(NAME , INSTR((NAME), '/') - 1), '`', '``'), '`.`',
REPLACE(SUBSTR(NAME FROM INSTR(NAME, '/') + 1), '`', '``'), '` ENGINE=InnoDB, ALGORITHM=COPY;') AS Query
FROM INFORMATION_SCHEMA.INNODB_TABLES
WHERE SPACE <> 0 AND LEFT(NAME, INSTR((NAME), '/') - 1) NOT IN ('mysql','');
```
重建一个 MySQL 表以便将该表的元数据移动到共享的表空间，这需要额外的临时存储空间以重建该表，因此，该数据库实例必须有可用的存储空间。在重建期间，该表会被锁定，无法访问查询。对于不经常访问的小型表或普通表，这可能不是问题。对于在大量并发环境中经常访问的大型表或普通表，您可以在只读副本上重建表。
您可以创建只读副本，并将表元数据迁移到只读副本上的共享表空间。虽然 ALTER TABLE 语句会阻止访问只读副本，但源数据库实例不会受到影响。尽管只读副本会在表重建过程中滞后，但源数据库实例将继续生成其二进制日志。由于重建需要额外的存储空间，并且重放日志文件可能会变得很大，因此，您应该创建只读副本，并向其分配大于源数据库实例的存储空间。
要创建只读副本和重建 InnoDB 表以便使用共享表空间，请遵循以下步骤：
1. 确保在源数据库实例上启用备份保留，以便启用二进制日志记录。
1. 使用 AWS 管理控制台或 AWS CLI 创建源数据库实例的只读副本。由于创建只读副本涉及的流程与崩溃恢复一样多，因此，如果存在大量 InnoDB 表空间，创建过程可能会需要一些时间。在只读副本上分配的存储空间应大于源数据库实例上当前使用的空间。
1. 创建只读副本后，使用参数设置 `read_only = 0` 和 `innodb_file_per_table = 0` 创建参数组，然后将该参数组与只读副本关联。
1. 针对您要在副本中迁移的所有表发出以下 SQL 语句。
```
ALTER TABLE name ENGINE = InnoDB
```
1. 在只读副本中完成所有 `ALTER TABLE` 语句后，验证只读副本是否连接至源数据库实例，并且两个实例是否同步。
1. 使用控制台或 CLI 将只读副本提升为实例。确保用于新的独立数据库实例的参数组已将 `innodb_file_per_table` 参数设置为 0。更改新的独立数据库实例的名称，并将所有应用程序指向新的独立数据库实例。
# 管理 RDS for MySQL 的全局状态历史记录
**提示**
要分析数据库性能，您还可以在 Amazon RDS 上使用性能详情。有关更多信息，请参阅 [在 Amazon RDS 上使用性能详情监控数据库负载](USER_PerfInsights.md)。
MySQL 保存了很多状态变量，用于提供与操作相关的信息。状态变量值可以帮助您检测数据库实例上的锁定或内存问题。这些状态变量的值会从上次启动数据库实例时开始累积。可以使用 `FLUSH STATUS` 命令将大多数状态变量重置为 0。
Amazon RDS 提供了一套程序，这些程序会随着时间为这些状态变量的值创建快照，并将它们及上次创建快照后所做的任何更改写入一个表中，从而可以随时间监控这些值。此基础设施名为 Global Status History (GoSH)，安装在从版本 5.5.23 开始的所有 MySQL 数据库实例上。默认情况下 GoSH 处于禁用状态。
要启用 GoSH，请首先在数据库参数组中通过将参数 `event_scheduler` 设置为 `ON`，启用事件调度器。对于运行 MySQL 5.7 的 MySQL 数据库实例，还要将参数 `show_compatibility_56` 设置为 `1`。有关创建和修改数据库参数组的信息，请参阅 [Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。有关启用此参数的副作用的信息，请参阅《MySQL 5.7 参考手册》**中的 [show\$1compatibility\$156](https://dev.mysql.com/doc/refman/5.7/en/server-system-variables.html#sysvar_show_compatibility_56)。
然后可以使用下表中的程序启用和配置 GoSH。首先连接到 MySQL 数据库实例，然后发出正确的命令，如下所示。有关更多信息，请参阅 [连接到 MySQL 数据库实例](USER_ConnectToInstance.md)。对于每个过程，运行以下命令并替换 **procedure-name**：
```
CALL procedure-name;
```
下表列出了可用于上一个命令中 **procedure-name** 的所有过程。
| 程序 | 描述 |
| --- | --- |
| `mysql.rds_enable_gsh_collector` | 启用 GoSH，按照 `rds_set_gsh_collector` 指定的间隔创建默认快照。 |
| `mysql.rds_set_gsh_collector` | 指定快照之间的间隔，以分钟为单位。默认值是 5。 |
| `mysql.rds_disable_gsh_collector` | 禁用快照。 |
| `mysql.rds_collect_global_status_history` | 根据需求创建快照。 |
| `mysql.rds_enable_gsh_rotation` | 按照 `mysql.rds_global_status_history` 指定的间隔，使 `mysql.rds_global_status_history_old` 表的内容可交替到 `rds_set_gsh_rotation`。 |
| `mysql.rds_set_gsh_rotation` | 指定表交替之间的间隔，以天为单位。默认值是 7。 |
| `mysql.rds_disable_gsh_rotation` | 禁用表交替。 |
| `mysql.rds_rotate_global_status_history` | 根据需求将 `mysql.rds_global_status_history` 表的内容交替到 `mysql.rds_global_status_history_old`。 |
GoSH 运行时，您可以查询 GoSH 要写入的表。例如，要查询 Innodb 缓冲池的命中率，您可以发送以下查询请求：
```
select a.collection_end, a.collection_start, (( a.variable_Delta-b.variable_delta)/a.variable_delta)*100 as "HitRatio"
from mysql.rds_global_status_history as a join mysql.rds_global_status_history as b on a.collection_end = b.collection_end
where a. variable_name = 'Innodb_buffer_pool_read_requests' and b.variable_name = 'Innodb_buffer_pool_reads'
```
# 在 MySQL 8.4 中配置缓冲池大小和重做日志容量
在 MySQL 8.4 中，Amazon RDS 默认启用 `innodb_dedicated_server` 参数。使用 `innodb_dedicated_server` 参数，数据库引擎可计算 `innodb_buffer_pool_size` 和 `innodb_redo_log_capacity` 参数。有关如何计算这些参数的信息，请参阅 MySQL 文档中的 [Configuring InnoDB Buffer Pool Size](https://dev.mysql.com/doc/refman/8.4/en/innodb-buffer-pool-resize.html) 和 [Redo Log](https://dev.mysql.com/doc/refman/8.4/en/innodb-redo-log.html)。
启用 `innodb_dedicated_server` 后，将根据数据库实例类内存计算 `innodb_buffer_pool_size` 参数。下表显示了检测到的服务器内存和相应的缓冲池大小。
| 检测到的服务器内存 | 缓冲池大小 |
| --- | --- |
| < 1 GB | 默认值为 128 MB |
| 1 GB 到 4 GB | *检测到的服务器内存* \$1 0.5 |
| > 4 GB | *检测到的服务器内存* \$1 0.75 |
`innodb_redo_log_capacity` 参数会随实例类自动扩展到（vCPU 数量 / 2）GB，最大可达 16 GB。较大的实例类具有更大的重做日志容量，这样可以提高写入密集型工作负载的性能和弹性。
从 MySQL 8.0 升级到 MySQL 8.4 之前，请务必增加存储空间，以适应升级完成后可能出现的重做日志大小的增加。有关更多信息，请参阅 [增加数据库实例存储容量](USER_PIOPS.ModifyingExisting.md)。
如果您不希望 `innodb_dedicated_server` 参数计算 `innodb_buffer_pool_size` 和 `innodb_redo_log_capacity` 参数的值，则可以通过在自定义参数组中为这些值设置特定值来覆盖这些值。或者，您可以禁用 `innodb_dedicated_server` 参数，并在自定义参数组中设置 `innodb_buffer_pool_size` 和 `innodb_redo_log_capacity` 参数的值。有关更多信息，请参阅 [原定设置和自定义参数组](parameter-groups-overview.md#parameter-groups-overview.custom)。
如果您通过将 `innodb_dedicated_server` 参数设置为 `0` 来禁用该参数，并且未为 `innodb_buffer_pool_size` 和 `innodb_redo_log_capacity` 参数设置值，则 Amazon RDS 会将后两个参数分别设置为 128 MB 和 100 MB。这些默认值会导致在较大的实例类上性能不佳。
# MySQL 数据库实例的本地时区
默认情况下，MySQL 数据库实例的时区是协调世界时 (UTC)。您可以将数据库实例的时区设置为您的应用程序的本地时区。
要设置数据库实例的本地时区，请将数据库实例参数组中的 `time_zone` 参数设置为本节后面列出的受支持值之一。在设置参数组的 `time_zone` 参数时，所有使用该参数组的数据库实例和只读副本都会改用新的本地时区。有关如何设置参数组中的参数的信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
设置本地时区之后，所有新数据库连接都会反映更改。如果在更改本地时区时打开了任何数据库连接，则到关闭连接再打开新连接之后才会看到本地时区更新。
您可以为数据库实例及其一个或多个只读副本设置不同的本地时区。为此，请对数据库实例和副本使用不同的参数组，并将每个参数组中的 `time_zone` 参数设置为不同的本地时区。
如果要跨 AWS 区域复制，则源数据库实例和只读副本使用不同的参数组（参数组对于 AWS 区域是唯一的）。要对每个实例使用相同的本地时区，您必须在实例和只读副本的参数组中设置 `time_zone` 参数。
从数据库快照还原数据库实例时，本地时区设置为 UTC。还原完成之后，可以将时区更新为本地时区。如果将数据库实例还原到某个时间点，则还原的数据库实例的本地时区是来自还原的数据库实例的参数组的时区设置。
互联网编号分配机构（IANA）每年多次在 [https://www.iana.org/time-zones](https://www.iana.org/time-zones) 上发布新的时区。每当 RDS 发布 MySQL 的新次要维护版本时，RDS 都会附带发布时的最新时区数据。当您使用最新的 RDS for MySQL 版本时，您会获得来自 RDS 的最新时区数据。为确保您的数据库实例具有最新的时区数据，我们建议升级到更高的数据库引擎版本。或者，您可以手动修改 MariaDB 数据库实例中的时区表。为此，可以使用 SQL 命令或者在 SQL 客户端中运行 [mysql\$1tzinfo\$1to\$1sql 工具](https://dev.mysql.com/doc/refman/8.0/en/mysql-tzinfo-to-sql.html)。手动更新时区数据后，重启数据库实例以使更改生效。RDS 不会修改或重置正在运行的数据库实例的时区数据。只有在执行数据库引擎版本升级时，才会安装新的时区数据。
您可以将本地时区设置为以下值之一。
| 区 | 时区 |
| --- | --- |
| 非洲 | 非洲/开罗、非洲/卡萨布兰卡、非洲/哈拉雷、非洲/蒙罗维亚、非洲/内罗毕、非洲/的黎波里、非洲/温得和克 |
| 美洲 | 美洲/阿拉瓜尼亚、美洲/亚松森、美洲/波哥大、美洲/布宜诺斯艾利斯、美洲/加拉加斯、美洲/奇瓦瓦、美洲/库亚巴、美洲/丹佛、美洲/福塔莱萨、美洲/危地马拉、美洲/哈利法克斯、美洲/玛瑙斯、美洲/马塔莫罗斯、美洲/蒙特雷、美洲/蒙得维的亚、美洲/凤凰城、美洲/圣地亚哥、美洲/蒂华纳 |
| 亚洲 | 亚洲/阿曼、亚洲/阿什哈巴德、亚洲/巴格达、亚洲/巴库、亚洲/曼谷、亚洲/贝鲁特、亚洲/加尔各答、亚洲/大马士革、亚洲/达卡、亚洲/伊尔库茨克、亚洲/耶路撒冷、亚洲/喀布尔、亚洲/卡拉奇、亚洲/加德满都、亚洲/克拉斯诺雅茨克、亚洲/马加丹、亚洲/马斯喀特、亚洲/新西伯利亚、亚洲/利雅得、亚洲/首尔、亚洲/上海、亚洲/新加坡、亚洲/台北、亚洲/德黑兰、亚洲/东京、亚洲/乌兰巴托、亚洲/符拉迪沃斯托克、亚洲/雅库茨克、亚洲/埃里温 |
| 大西洋 | 大西洋州/亚速尔群岛 |
| 澳大利亚 | 澳大利亚/阿德莱德、澳大利亚/布里斯班、澳大利亚/达尔文、澳大利亚/霍巴特、澳大利亚/珀斯、澳大利亚/悉尼 |
| 巴西 | 巴西/迪诺罗尼亚、巴西/东部 |
| 加拿大 | 加拿大/纽芬兰、加拿大/萨斯喀彻温省、加拿大/育空地区 |
| 欧洲 | 欧洲/阿姆斯特丹、欧洲/雅典、欧洲/都柏林、欧洲/赫尔辛基、欧洲/伊斯坦布尔、欧洲/加里宁格勒、欧洲/莫斯科、欧洲/巴黎、欧洲/布拉格、欧洲/萨拉热窝 |
| 太平洋 | 太平洋/奥克兰、太平洋/斐济、太平洋/关岛、太平洋/檀香山、太平洋/萨摩亚群岛 |
| 美国 | 美国/阿拉斯加、美国/中部、美国/印第安纳东部、美国/东部、美国/太平洋地区 |
| UTC | UTC |
# Amazon RDS for MySQL 的已知问题和限制
下面给出了有关使用 Amazon RDS for MySQL 的已知问题和限制。
**Topics**
+ [
## InnoDB 保留字
](#MySQL.Concepts.KnownIssuesAndLimitations.InnodbDatabaseName)
+ [
## Amazon RDS for MySQL 存储已满行为
](#MySQL.Concepts.StorageFullBehavior)
+ [
## 不一致的 InnoDB 缓冲池大小
](#MySQL.Concepts.KnownIssuesAndLimitations.InnodbBufferPoolSize)
+ [
## 索引合并优化返回不正确的结果
](#MySQL.Concepts.KnownIssuesAndLimitations.IndexMergeOptimization)
+ [
## Amazon RDS 数据库实例的 MySQL 参数异常错误
](#MySQL.Concepts.ParameterNotes)
+ [
## Amazon RDS 中的 MySQL 文件大小限制
](#MySQL.Concepts.Limits.FileSize)
+ [
## 不支持 MySQL 密钥环插件
](#MySQL.Concepts.Limits.KeyRing)
+ [
## 自定义端口
](#MySQL.Concepts.KnownIssuesAndLimitations.CustomPorts)
+ [
## MySQL 存储过程限制
](#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures)
+ [
## 与外部源实例之间的基于 GTID 的复制
](#MySQL.Concepts.KnownIssuesAndLimitations.GTID)
+ [
## MySQL 默认身份验证插件
](#MySQL.Concepts.KnownIssuesAndLimitations.authentication-plugin)
+ [
## 覆盖 innodb\$1buffer\$1pool\$1size
](#MySQL.Concepts.KnownIssuesAndLimitations.innodb-bp-size)
+ [
## 从 MySQL 5.7 升级到 MySQL 8.4
](#MySQL.Concepts.KnownIssuesAndLimitations.upgrade-8-4)
+ [
## InnoDB 页面压缩
](#MySQL.Concepts.KnownIssuesAndLimitations.innodb-page-compression)
## InnoDB 保留字
`InnoDB` 是 RDS for MySQL 的保留字。您不能将此名称用于 MySQL 数据库。
## Amazon RDS for MySQL 存储已满行为
当 MySQL 数据库实例的存储空间已满时，可能存在元数据不一致、字典不匹配和孤立表。为防止出现这些问题，Amazon RDS 自动停止达到 `storage-full` 状态的数据库实例。
在以下情况下，MySQL 数据库实例达到 `storage-full` 状态：
+ 数据库实例的存储空间少于 20000 MiB，可用存储空间达到 200 MiB 或更少。
+ 数据库实例的存储空间多于 102400 MiB，可用存储空间达到 1024 MiB 或更少。
+ 数据库实例的存储空间介于 20000 MiB 到 102400 MiB 之间，可用存储空间不到 1％。
在由于数据库实例达到 `storage-full` 状态而 Amazon RDS 将其自动停止后，您仍然可以对其进行修改。要重新启动数据库实例，请至少完成以下操作之一：
+ 修改数据库实例以启用存储自动扩缩。
有关存储自动扩展的更多信息，请参阅 [使用 Amazon RDS 存储自动扩展功能自动管理容量](USER_PIOPS.Autoscaling.md)。
+ 修改数据库实例以增加其存储容量。
有关增加存储容量的更多信息，请参阅 [增加数据库实例存储容量](USER_PIOPS.ModifyingExisting.md)。
进行这些更改之一后，数据库实例将自动重新启动。有关修改 数据库实例的信息，请参阅[修改 Amazon RDS 数据库实例](Overview.DBInstance.Modifying.md)。
## 不一致的 InnoDB 缓冲池大小
对于 MySQL 5.7，管理 InnoDB 缓冲池的方式当前存在错误。MySQL 5.7 可能将 `innodb_buffer_pool_size` 参数的值调整为较大的值，这会导致 InnoDB 缓冲池增长得过大并占用过多内存。此效果会导致 MySQL 数据库引擎停止运行或阻止该引擎启动。可用内存较少的数据库实例类更易出现此问题。
要解决此问题，请将 `innodb_buffer_pool_size` 参数的值设置为 `innodb_buffer_pool_instances` 参数值和 `innodb_buffer_pool_chunk_size` 参数值的积的倍数。例如，您可以将 `innodb_buffer_pool_size` 参数值设置为 `innodb_buffer_pool_instances` 参数值和 `innodb_buffer_pool_chunk_size` 参数值的积的 8 倍，如以下示例所示。
```
innodb_buffer_pool_chunk_size = 536870912
innodb_buffer_pool_instances = 4
innodb_buffer_pool_size = (536870912 * 4) * 8 = 17179869184
```
有关此 MySQL 5.7 错误的详细信息，请参阅 MySQL 文档中的 [https://bugs.mysql.com/bug.php?id=79379](https://bugs.mysql.com/bug.php?id=79379)。
## 索引合并优化返回不正确的结果
使用索引合并优化功能的查询可能因 MySQL 5.5.37 中引入的 MySQL 查询优化程序中的错误而返回不正确的结果。当您针对一个带多条索引的表发出查询时，此优化器将基于多条索引扫描一系列行，但无法正确地合并这些结果。有关查询优化程序错误的详细信息，请参阅 MySQL 错误数据库中的 [http://bugs.mysql.com/bug.php?id=72745](https://bugs.mysql.com/bug.php?id=72745) 和 [http://bugs.mysql.com/bug.php?id=68194](https://bugs.mysql.com/bug.php?id=68194)。
例如，假设发出针对一个带两条索引的表的查询，其中搜索参数会引用索引列。
```
1. SELECT * FROM table1
2. WHERE indexed_col1 = 'value1' AND indexed_col2 = 'value2';
```
在此情况下，搜索引擎将搜索这两条索引。由于出现错误，导致合并结果不正确。
要解决此问题，您可以执行下列操作之一：
+ 在 MySQL 数据库实例的数据库参数组中将 `optimizer_switch` 参数设置为 `index_merge=off`。有关设置数据库参数组参数的信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
+ 将 MySQL 数据库实例升级到 MySQL 5.7 或 8.0 版。有关更多信息，请参阅 [升级 RDS for MySQL 数据库引擎](USER_UpgradeDBInstance.MySQL.md)。
+ 如果无法升级实例或更改 `optimizer_switch` 参数，您可以通过显式标识查询的索引来纠正错误，例如：
```
1. SELECT * FROM table1
2. USE INDEX covering_index
3. WHERE indexed_col1 = 'value1' AND indexed_col2 = 'value2';
```
有关更多信息，请参阅 MySQL 文档中的[索引合并优化](https://dev.mysql.com/doc/refman/8.0/en/index-merge-optimization.html)。
## Amazon RDS 数据库实例的 MySQL 参数异常错误
某些 MySQL 参数在与 Amazon RDS 数据库实例一起使用时需要考虑一些特殊的注意事项。
### lower\$1case\$1table\$1names
因为 Amazon RDS 使用区分大小写的文件系统，所以不支持将 `lower_case_table_names` 服务器参数的值设置为 2（名称存储为给定名称，但按小写字母进行比较）。以下是 Amazon RDS for MySQL 数据库实例支持的值：
+ 所有 RDS for MySQL 版本均支持 0（名称存储为给定名称，而比较区分大小写）。
+ RDS for MySQL 5.7、8.0.28 及更高的 8.0 和 8.4 版本支持 1（以小写字母形式存储名称，并且比较不区分大小写）。
创建数据库实例前，请在自定义数据库参数组中设置 `lower_case_table_names` 参数。然后，您可以在创建数据库实例时指定自定义数据库参数组。
当参数组与版本低于 8.0 的 MySQL 数据库实例相关联时，建议您避免在参数组中修改 `lower_case_table_names` 参数。更改它可能导致时间点恢复备份与只读副本数据库实例不一致。
当参数组与 8.0 或 8.4 版 MySQL 数据库实例相关联时，您将无法在参数组中修改 `lower_case_table_names` 参数。
只读副本应总是使用与源数据库实例相同的 `lower_case_table_names` 参数值。
### long\$1query\$1time
您可以将 `long_query_time` 参数设置为浮点值，这样，您可以将慢速查询以微秒分辨率记录到 MySQL 慢速查询日志中。您可以设置一个值（如 0.1 秒，也就是 100 毫秒），在调试时间不到一秒的慢事务时提供帮助。
## Amazon RDS 中的 MySQL 文件大小限制
对于 MySQL 8.0 及更高版本的数据库实例，最大文件大小为 16 TiB。使用 file-per-table 表空间时，最大文件大小将 InnoDB 表的大小限制为 16 TiB。默认情况下，为 MySQL 数据库实例设置 InnoDB file-per-table 表空间 (表各自位于自己的表空间中)。有关更多信息，请参阅 MySQL 文档中的 [InnoDB limits](https://dev.mysql.com/doc/refman/8.0/en/innodb-limits.html)。
**注意**
某些现有的数据库实例具有下限。例如，在 2014 年 4 月之前创建的 MySQL 数据库实例的文件和表大小限制为 2 TB。不管创建数据库实例的时间如何，此 2 TB 文件大小限制也适用于从 2014 年 4 月之前创建的数据库快照创建的数据库实例或只读副本。
根据您的应用程序，使用 InnoDB file-per-table 表空间有一些优缺点。要确定适用于您的应用程序的最佳方法，请参阅 MySQL 文档中的 [File-Per-Table 表空间](https://dev.mysql.com/doc/refman/8.0/en/innodb-file-per-table-tablespaces.html)。
建议不要允许表增长到最大文件大小。一般而言，更好的方法是将数据分区到较小的表中，这可以提高性能并缩短恢复时间。
可用于将大型表划分为多个较小表的一个选项是分区。分区可基于您指定的规则将大型表的各个部分分布到单独的文件中。例如，如果您按日期存储事务，则可以创建分区规则，以便使用分区将较旧的事务分布到单独的文件中。随后您可以定期存档无需随时可供应用程序使用的历史事务数据。有关更多信息，请参阅 MySQL 文档中的[分区](https://dev.mysql.com/doc/refman/8.0/en/partitioning.html)。
由于没有单个系统表或视图可以提供所有表和 InnoDB 系统表空间的大小，因此必须查询多个表才能确定表空间的大小。
**确定 InnoDB 系统表空间和数据字典表空间的大小**
+ 使用以下 SQL 命令可确定任何表空间是否过大以及是否适合进行分区。
**注意**
数据字典表空间特定于 MySQL 8.0 及更高版本。
```
1. select FILE_NAME,TABLESPACE_NAME, ROUND(((TOTAL_EXTENTS*EXTENT_SIZE)
2. /1024/1024/1024), 2) as "File Size (GB)" from information_schema.FILES
3. where tablespace_name in ('mysql','innodb_system');
```
**确定 InnoDB 系统表空间之外的 InnoDB 用户表的大小（针对 MySQL 5.7 版本）**
+ 使用以下 SQL 命令可确定任何表是否太大以及是否适合进行分区。
```
1. SELECT SPACE,NAME,ROUND((ALLOCATED_SIZE/1024/1024/1024), 2)
2. as "Tablespace Size (GB)"
3. FROM information_schema.INNODB_SYS_TABLESPACES ORDER BY 3 DESC;
```
**确定 InnoDB 系统表空间之外的 InnoDB 用户表的大小（对于 MySQL 8.0 及更高版本）**
+ 使用以下 SQL 命令可确定任何表是否太大以及是否适合进行分区。
```
1. SELECT SPACE,NAME,ROUND((ALLOCATED_SIZE/1024/1024/1024), 2)
2. as "Tablespace Size (GB)"
3. FROM information_schema.INNODB_TABLESPACES ORDER BY 3 DESC;
```
**确定非 InnoDB 用户表的大小**
+ 使用以下 SQL 命令来确定是否有任何非 InnoDB 用户表过大。
```
SELECT TABLE_SCHEMA, TABLE_NAME, round(((DATA_LENGTH + INDEX_LENGTH+DATA_FREE)
/ 1024 / 1024/ 1024), 2) As "Approximate size (GB)" FROM information_schema.TABLES
WHERE TABLE_SCHEMA NOT IN ('mysql', 'information_schema', 'performance_schema')
and ENGINE<>'InnoDB';
```
**启用 InnoDB file-per-table 表空间**
+ 请在数据库实例的参数组中将 *innodb\$1file\$1per\$1table* 参数设置为 `1`。
**禁用 InnoDB file-per-table 表空间**
+ 请在数据库实例的参数组中将 *innodb\$1file\$1per\$1table* 参数设置为 `0`。
有关更新参数组的信息，请参阅[Amazon RDS 的参数组](USER_WorkingWithParamGroups.md)。
启用或禁用 InnoDB file-per-table 表空间后，可以发出 `ALTER TABLE` 命令将一个表从全局表空间移至它自己的表空间，或从它自己的表空间移至全局表空间，如以下示例所示：
```
ALTER TABLE table_name TABLESPACE=innodb_file_per_table;
```
## 不支持 MySQL 密钥环插件
目前，Amazon RDS for MySQL 不支持 MySQL `keyring_aws` Amazon Web Services 密钥环插件。
## 自定义端口
Amazon RDS 禁止连接到 MySQL 引擎的自定义端口 33060。为您的 MySQL 引擎选择不同的端口。
## MySQL 存储过程限制
在以下 RDS for MySQL 版本上，[mysql.rds\$1kill](mysql-stored-proc-ending.md#mysql_rds_kill) 和 [mysql.rds\$1kill\$1query](mysql-stored-proc-ending.md#mysql_rds_kill_query) 存储过程无法终止由用户名多于 16 个字符的 MySQL 用户所拥有的会话或查询：
+ 8.0.32 及更低的 8 版本
+ 5.7.41 及更低的 5.7 版本
## 与外部源实例之间的基于 GTID 的复制
Amazon RDS 支持基于全局事务标识符（GTID），从外部 MySQL 实例复制到需要在配置过程中设置 GTID\$1PURGED 的 Amazon RDS for MySQL 数据库实例。但是，只有 RDS for MySQL 8.0.37 及更高版本才支持此功能。
## MySQL 默认身份验证插件
RDS for MySQL 8.0.34 及更高的 8.0 版本使用 `mysql_native_password` 插件。您将无法更改 `default_authentication_plugin` 设置。
RDS for MySQL 8.4 及更高版本使用 `caching_sha2_password` 插件作为默认身份验证插件。可以更改 MySQL 8.4 的默认身份验证插件。`mysql_native_password` 插件仍然适用于 MySQL 8.4，但对该插件的支持将在 MySQL 8.4 中终止。要更改默认身份验证插件，请创建自定义参数组并修改 `authentication_policy` 参数的值。有关更多信息，请参阅 [原定设置和自定义参数组](parameter-groups-overview.md#parameter-groups-overview.custom)。
## 覆盖 innodb\$1buffer\$1pool\$1size
对于微型或小型数据库实例类，`innodb_buffer_pool_size` 参数的默认值可能与运行以下命令时返回的值不同：
```
mysql> SELECT @@innodb_buffer_pool_size;
```
当 Amazon RDS 在管理数据库实例类时需要覆盖默认值时，可能会出现这种差异。如有必要，您可以覆盖默认值并将其设置为数据库实例类支持的值。要确定有效值，请将内存使用量和数据库实例上的可用内存总量相加。有关更多信息，请参阅 [Amazon RDS 实例类型](https://aws.amazon.com/rds/instance-types/)。
如果您的数据库实例只有 4 GB 的内存，则无法将 `innodb_buffer_pool_size` 设置为 8 GB，但可以将其设置为 3 GB，具体取决于您为其他参数分配的内存量。
如果您输入的值太大，Amazon RDS 会将该值降低到以下限制范围内：
+ 微型数据库实例类：256 MB
+ db.t4g.micro 数据库实例类：128 MB
## 从 MySQL 5.7 升级到 MySQL 8.4
您无法从 MySQL 5.7 直接升级到 MySQL 8.4。必须首先从 MySQL 5.7 升级到 MySQL 8.0，然后从 MySQL 8.0 升级到 MySQL 8.4。有关更多信息，请参阅 [RDS for MySQL 的主要版本升级](USER_UpgradeDBInstance.MySQL.Major.md)。
## InnoDB 页面压缩
InnoDB 页面压缩不适用于文件系统块大小为 16k 的 Amazon RDS 数据库实例，因为文件系统块大小必须小于 InnoDB 页面大小。从 2024 年 2 月开始，所有新创建的数据库实例的文件系统块大小均为 16k，这会增加吞吐量并减少页面刷新期间的 IOPS 消耗。
# RDS for MySQL 存储过程参考
这些主题介绍对于运行 MySQL 数据库引擎的 Amazon RDS 实例可用的系统存储过程。主用户必须运行这些过程。
**Topics**
+ [
# 收集和维护全局状态历史记录
](mysql-stored-proc-gsh.md)
+ [
# 配置、启动和停止二进制日志（binlog）复制
](mysql-stored-proc-replicating.md)
+ [
# 结束会话或查询
](mysql-stored-proc-ending.md)
+ [
# 管理主动-主动集群
](mysql-stored-proc-active-active-clusters.md)
+ [
# 管理多源复制
](mysql-stored-proc-multi-source-replication.md)
+ [
# 使用 GTID 复制事务
](mysql-stored-proc-gtid.md)
+ [
# 轮换查询日志
](mysql-stored-proc-logging.md)
+ [
# 设置和显示二进制日志配置
](mysql-stored-proc-configuring.md)
+ [
# 预热 InnoDB 缓存
](mysql-stored-proc-warming.md)
# 收集和维护全局状态历史记录
Amazon RDS 提供了一组过程，这些过程可以随时间推移对状态变量的值创建快照，并将它们及上次创建快照后所做的任何更改写入一个表中。该基础设施称为全局状态历史记录。有关更多信息，请参阅[管理 RDS for MySQL 的全局状态历史记录](Appendix.MySQL.CommonDBATasks.GoSH.md)。
以下存储过程管理全局状态历史记录的收集和维护方式。
**Topics**
+ [
## mysql.rds\$1collect\$1global\$1status\$1history
](#mysql_rds_collect_global_status_history)
+ [
## mysql.rds\$1disable\$1gsh\$1collector
](#mysql_rds_disable_gsh_collector)
+ [
## mysql.rds\$1disable\$1gsh\$1rotation
](#mysql_rds_disable_gsh_rotation)
+ [
## mysql.rds\$1enable\$1gsh\$1collector
](#mysql_rds_enable_gsh_collector)
+ [
## mysql.rds\$1enable\$1gsh\$1rotation
](#mysql_rds_enable_gsh_rotation)
+ [
## mysql.rds\$1rotate\$1global\$1status\$1history
](#mysql_rds_rotate_global_status_history)
+ [
## mysql.rds\$1set\$1gsh\$1collector
](#mysql_rds_set_gsh_collector)
+ [
## mysql.rds\$1set\$1gsh\$1rotation
](#mysql_rds_set_gsh_rotation)
## mysql.rds\$1collect\$1global\$1status\$1history
按需为全局状态历史记录创建快照。
### 语法
```
CALL mysql.rds_collect_global_status_history;
```
## mysql.rds\$1disable\$1gsh\$1collector
关闭全局状态历史记录创建的快照。
### 语法
```
CALL mysql.rds_disable_gsh_collector;
```
## mysql.rds\$1disable\$1gsh\$1rotation
关闭 `mysql.global_status_history` 表的交替。
### 语法
```
CALL mysql.rds_disable_gsh_rotation;
```
## mysql.rds\$1enable\$1gsh\$1collector
开启全局状态历史记录，以 `rds_set_gsh_collector` 指定的间隔创建原定设置快照。
### 语法
```
CALL mysql.rds_enable_gsh_collector;
```
## mysql.rds\$1enable\$1gsh\$1rotation
按照 `rds_set_gsh_rotation` 指定的间隔，开启将 `mysql.global_status_history` 表的内容交替到 `mysql.global_status_history_old`
### 语法
```
CALL mysql.rds_enable_gsh_rotation;
```
## mysql.rds\$1rotate\$1global\$1status\$1history
根据需求将 `mysql.global_status_history` 表的内容交替到 `mysql.global_status_history_old`。
### 语法
```
CALL mysql.rds_rotate_global_status_history;
```
## mysql.rds\$1set\$1gsh\$1collector
指定全局状态历史记录创建的快照之间的间隔，以分钟为单位。
### 语法
```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```
### 参数
*intervalPeriod*
快照之间的间隔，以分钟为单位。默认值为 `5`。
## mysql.rds\$1set\$1gsh\$1rotation
指定 `mysql.global_status_history` 表轮换之间的间隔，以天为单位。
### 语法
```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```
### 参数
*intervalPeriod*
表轮换之间的间隔，以天为单位。默认值为 `7`。
# 配置、启动和停止二进制日志（binlog）复制
以下存储过程控制事务如何从外部数据库复制到 RDS for MySQL，或从 RDS for MySQL 复制到外部数据库。
在使用这些存储过程管理复制时，如果其复制用户配置了 `caching_sha2_password`，则必须通过指定 `SOURCE_SSL=1` 来配置 TLS。`caching_sha2_password` 是 RDS for MySQL 8.4 的默认身份验证插件。有关更多信息，请参阅 [使用 SSL/TLS 进行加密](mysql-ssl-connections.md)。
有关配置、使用和管理只读副本的信息，请参阅 [使用 MySQL 只读副本](USER_MySQL.Replication.ReadReplicas.md)。
**Topics**
+ [
## mysql.rds\$1next\$1master\$1log（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_next_master_log)
+ [
## mysql.rds\$1next\$1source\$1log（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_next_source_log)
+ [
## mysql.rds\$1reset\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_reset_external_master)
+ [
## mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_reset_external_source)
+ [
## mysql.rds\$1set\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_set_external_master)
+ [
## mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_set_external_source)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_set_external_master_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_set_external_source_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_set_external_master_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_set_external_source_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
](#mysql_rds_set_external_source_gtid_purged)
+ [
## mysql.rds\$1set\$1master\$1auto\$1position（RDS for MySQL 主要版本 8.0 及更低版本）
](#mysql_rds_set_master_auto_position)
+ [
## mysql.rds\$1set\$1source\$1auto\$1position（RDS for MySQL 主要版本 8.4 及更高版本）
](#mysql_rds_set_source_auto_position)
+ [
## mysql.rds\$1set\$1source\$1delay
](#mysql_rds_set_source_delay)
+ [
## mysql.rds\$1skip\$1repl\$1error
](#mysql_rds_skip_repl_error)
+ [
## mysql.rds\$1start\$1replication
](#mysql_rds_start_replication)
+ [
## mysql.rds\$1start\$1replication\$1until
](#mysql_rds_start_replication_until)
+ [
## mysql.rds\$1stop\$1replication
](#mysql_rds_stop_replication)
## mysql.rds\$1next\$1master\$1log（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
将源数据库实例日志位置更改为源数据库实例上的下一个二进制日志的开始位置。只有在只读副本上收到复制 I/O 错误 1236 时，才能使用该过程。
### 语法
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### 参数
*curr\$1master\$1log*
当前主日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。若要确定当前主日志文件名，请运行 `SHOW REPLICA STATUS` 命令并查看 `Master_Log_File` 字段。
### 使用说明
主用户必须运行 `mysql.rds_next_master_log` 过程。
**警告**
仅在对作为复制源的多可用区数据库实例进行故障转移后复制失败，并且 `mysql.rds_next_master_log` 的 `Last_IO_Errno` 字段报告 I/O 错误 1236 时调用 `SHOW REPLICA STATUS`。
如果在发生失效转移事件之前，源实例中的事务未写入到磁盘上的二进制日志，调用 `mysql.rds_next_master_log` 可能会导致只读副本丢失数据。可以通过将源实例参数 `sync_binlog` 和 `innodb_support_xa` 设置为 `1` 来减少发生这种情况的几率，尽管这可能会降低性能。有关更多信息，请参阅 [排查 MySQL 只读副本问题](USER_ReadRepl.Troubleshooting.md)。
### 示例
假设复制在 RDS for MySQL 只读副本上失败。对只读副本运行 `SHOW REPLICA STATUS\G` 会返回以下结果：
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
`Last_IO_Errno` 字段显示该实例收到 I/O 错误 1236。`Master_Log_File` 字段显示文件名为 `mysql-bin-changelog.012345`，这意味着日志文件索引为 `12345`。要纠正该错误，您可以使用以下参数调用 `mysql.rds_next_master_log`：
```
CALL mysql.rds_next_master_log(12345);
```
## mysql.rds\$1next\$1source\$1log（RDS for MySQL 主要版本 8.4 及更高版本）
将源数据库实例日志位置更改为源数据库实例上的下一个二进制日志的开始位置。只有在只读副本上收到复制 I/O 错误 1236 时，才能使用该过程。
### 语法
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### 参数
*curr\$1source\$1log*
当前源日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。要确定当前源日志文件名，请运行 `SHOW REPLICA STATUS` 命令并查看 `Source_Log_File` 字段。
### 使用说明
管理用户必须运行 `mysql.rds_next_source_log` 过程。
**警告**
仅在对作为复制源的多可用区数据库实例进行故障转移后复制失败，并且 `mysql.rds_next_source_log` 的 `Last_IO_Errno` 字段报告 I/O 错误 1236 时调用 `SHOW REPLICA STATUS`。
如果在发生失效转移事件之前，源实例中的事务未写入到磁盘上的二进制日志，调用 `mysql.rds_next_source_log` 可能会导致只读副本丢失数据。可以通过将源实例参数 `sync_binlog` 和 `innodb_support_xa` 设置为 `1` 来减少发生这种情况的几率，尽管这可能会降低性能。有关更多信息，请参阅[排查 MySQL 只读副本问题](USER_ReadRepl.Troubleshooting.md)。
### 示例
假设复制在 RDS for MySQL 只读副本上失败。对只读副本运行 `SHOW REPLICA STATUS\G` 会返回以下结果：
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Source: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from source when reading data from binary log: 'Client requested source to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
`Last_IO_Errno` 字段显示该实例收到 I/O 错误 1236。`Source_Log_File` 字段显示文件名为 `mysql-bin-changelog.012345`，这意味着日志文件索引为 `12345`。要纠正该错误，您可以使用以下参数调用 `mysql.rds_next_source_log`：
```
CALL mysql.rds_next_source_log(12345);
```
## mysql.rds\$1reset\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
重新配置 RDS for MySQL 数据库实例，使其不再是在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_reset_external_master;
```
### 使用说明
主用户必须运行 `mysql.rds_reset_external_master` 过程。此过程必须运行于一个 MySQL 数据库实例上，后者要作为在 Amazon RDS 之外运行的 MySQL 实例的只读副本而被删除。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
想要了解更多有关使用复制从在 Amazon RDS 之外运行的 MySQL 实例导入数据的信息，请参阅 [配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)。
## mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）
重新配置 RDS for MySQL 数据库实例，使其不再是在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_reset_external_source;
```
### 使用说明
管理用户必须运行 `mysql.rds_reset_external_source` 过程。此过程必须运行于一个 MySQL 数据库实例上，后者要作为在 Amazon RDS 之外运行的 MySQL 实例的只读副本而被删除。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。
有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。想要了解更多有关使用复制从在 Amazon RDS 之外运行的 MySQL 实例导入数据的信息，请参阅 [配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)。
## mysql.rds\$1set\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
**注意**
您可以使用 [mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_set_external_master_with_delay) 存储过程配置外部源数据库实例和延迟复制。
### 语法
```
CALL mysql.rds_set_external_master (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行以变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW MASTER STATUS` 来确定二进制日志文件名和位置。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `MASTER_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
### 使用说明
主用户必须运行 `mysql.rds_set_external_master` 过程。必须在要配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本的 MySQL 数据库实例上运行该过程。
运行 `mysql.rds_set_external_master` 之前，您必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 之外运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值，这些值指示对 MySQL 的外部实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。示例如下：
**MySQL 5.7**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED WITH mysql_native_password BY 'password';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例向您所在域的“repl\$1user”用户授予对所有数据库的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。
**MySQL 5.7**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
要使用加密复制，请将源数据库实例配置为使用 SSL 连接。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_master` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_reset_external_master) 删除只读副本配置。
调用 `mysql.rds_set_external_master` 时，Amazon RDS 将时间、用户和 `set master` 的操作记录在 `mysql.rds_history` 和 `mysql.rds_replication_status` 表中。
### 示例
在 MySQL 数据库实例上运行时，下例将该数据库实例配置为在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。
```
call mysql.rds_set_external_master(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行以变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW MASTER STATUS` 来确定二进制日志文件名和位置。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值是 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
### 使用说明
管理用户必须运行 `mysql.rds_set_external_source` 过程。该过程必须在以下 RDS for MySQL 数据库实例上运行：也即，该实例将配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本。
运行 `mysql.rds_set_external_source` 之前，必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 之外运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值，这些值指示对 MySQL 的外部实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。示例如下：
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**注意**
作为安全最佳实践，请指定除此处所示提示以外的密码。
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例向您所在域的“repl\$1user”用户授予对所有数据库的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
要使用加密复制，请将源数据库实例配置为使用 SSL 连接。此外，使用 [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html) 过程，将证书颁发机构证书、客户端证书和客户端密钥导入到数据库实例或数据库集群中。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_source` 将 RDS for MySQL 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 以开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_reset_external_source) 来删除只读副本配置。
调用 `mysql.rds_set_external_source` 时，Amazon RDS 将时间、用户和 `set master` 的操作记录在 `mysql.rds_history` 和 `mysql.rds_replication_status` 表中。
### 示例
在 RDS for MySQL 数据库实例上运行时，以下示例将该数据库实例配置为在 Amazon RDS 外部运行的某个 MySQL 实例的只读副本。
```
call mysql.rds_set_external_source(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.0 及更低版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。该过程还会配置延迟复制和基于全局事务标识符 (GTID) 的复制。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行以变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `MASTER_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
### 使用说明
主用户必须运行 `mysql.rds_set_external_master_with_auto_position` 过程。必须在要配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本的 MySQL 数据库实例上运行该过程。
所有 RDS for MySQL 5.7 版本和 RDS for MySQL 8.0.26 及更高的 8.0 版本均支持此过程。
运行 `mysql.rds_set_external_master_with_auto_position` 之前，您必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 外部运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值。这些值必须指示具有外部 MySQL 实例的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。以下是示例。
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例为您的域的 `REPLICATION CLIENT` 用户授予所有数据库的 `REPLICATION SLAVE` 和 `'repl_user'` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
有关更多信息，请参阅“[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)”。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_master_with_auto_position` 之前，务必调用 [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged)，以便使用来自外部源的指定 GTID 范围设置 `gtid_purged` 系统变量。
在调用 `mysql.rds_set_external_master_with_auto_position` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_reset_external_master) 删除只读副本配置。
在调用 `mysql.rds_set_external_master_with_auto_position` 时，Amazon RDS 在 `set master` 和 `mysql.rds_history` 表中记录时间、用户和 `mysql.rds_replication_status` 操作。
对于灾难恢复，您可以将该过程与 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_external_master_with_auto_position` 过程。在 `mysql.rds_start_replication_until_gtid` 过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关使用基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
### 示例
在 MySQL 数据库实例上运行时，下例将该数据库实例配置为在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。它在 MySQL 数据库实例上将最短复制延迟时间设置为一小时（3600 秒）。在 Amazon RDS 外部运行的 MySQL 源数据库实例的更改在至少一个小时内不会在 MySQL 数据库实例只读副本上应用。
```
call mysql.rds_set_external_master_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.4 及更高版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。该过程还会配置延迟复制和基于全局事务标识符 (GTID) 的复制。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行以变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
### 使用说明
管理用户必须运行 `mysql.rds_set_external_source_with_auto_position` 过程。必须在要配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本的 MySQL 数据库实例上运行该过程。
运行 `mysql.rds_set_external_source_with_auto_position` 之前，您必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 外部运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值。这些值必须指示具有外部 MySQL 实例的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。以下是示例。
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例为您的域的 `REPLICATION CLIENT` 用户授予所有数据库的 `REPLICATION SLAVE` 和 `'repl_user'` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
有关更多信息，请参阅“[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)”。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_source_with_auto_position` 之前，务必调用 [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged)，以便使用来自外部源的指定 GTID 范围设置 `gtid_purged` 系统变量。
在调用 `mysql.rds_set_external_source_with_auto_position` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_reset_external_source) 删除只读副本配置。
在调用 `mysql.rds_set_external_source_with_auto_position` 时，Amazon RDS 在 `set master` 和 `mysql.rds_history` 表中记录时间、用户和 `mysql.rds_replication_status` 操作。
对于灾难恢复，您可以将该过程与 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_external_source_with_auto_position` 过程。在 `mysql.rds_start_replication_until_gtid` 过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关使用基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
### 示例
在 MySQL 数据库实例上运行时，下例将该数据库实例配置为在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。它在 MySQL 数据库实例上将最短复制延迟时间设置为一小时（3600 秒）。在 Amazon RDS 外部运行的 MySQL 源数据库实例的更改在至少一个小时内不会在 MySQL 数据库实例只读副本上应用。
```
call mysql.rds_set_external_source_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本并配置延迟复制。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_master_with_delay(
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行并将变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的 SSH 端口复制，则指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW MASTER STATUS` 来确定二进制日志文件名和位置。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `MASTER_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
### 使用说明
主用户必须运行 `mysql.rds_set_external_master_with_delay` 过程。必须在要配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本的 MySQL 数据库实例上运行该过程。
运行 `mysql.rds_set_external_master_with_delay` 之前，您必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 外部运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值。这些值必须指示具有外部 MySQL 实例的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。以下是示例。
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例为您的域的 `REPLICATION CLIENT` 用户授予所有数据库的 `REPLICATION SLAVE` 和 `'repl_user'` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
有关更多信息，请参阅“[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)”。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_master_with_delay` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_reset_external_master) 删除只读副本配置。
在调用 `mysql.rds_set_external_master_with_delay` 时，Amazon RDS 在 `set master` 和 `mysql.rds_history` 表中记录时间、用户和 `mysql.rds_replication_status` 操作。
对于灾难恢复，您可以将该过程与 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_external_master_with_delay` 过程。在 `mysql.rds_start_replication_until` 过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关使用基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
`mysql.rds_set_external_master_with_delay` 过程在以下版本的 RDS for MySQL 中可用：
+ MySQL 8.0.26 和更高的 8.0.x 版本
+ 所有 5.7 版本
### 示例
在 MySQL 数据库实例上运行时，下例将该数据库实例配置为在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。它在 MySQL 数据库实例上将最短复制延迟时间设置为一小时（3600 秒）。在 Amazon RDS 外部运行的 MySQL 源数据库实例的更改在至少一个小时内不会在 MySQL 数据库实例只读副本上应用。
```
call mysql.rds_set_external_master_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay（RDS for MySQL 主要版本 8.4 及更高版本）
将 RDS for MySQL 数据库实例配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本并配置延迟复制。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source_with_delay (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### 参数
*host\$1name*
在 Amazon RDS 之外运行并将变为源数据库实例的 MySQL 实例的主机名或 IP 地址。
*host\$1port*
在 Amazon RDS 之外运行的要配置为源数据库实例的 MySQL 实例使用的端口。如果网络配置包括转换端口号的 SSH 端口复制，则指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对在 Amazon RDS 外部运行的 MySQL 实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW MASTER STATUS` 来确定二进制日志文件名和位置。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
### 使用说明
管理用户必须运行 `mysql.rds_set_external_source_with_delay` 过程。必须在要配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本的 MySQL 数据库实例上运行该过程。
运行 `mysql.rds_set_external_source_with_delay` 之前，您必须先将在 Amazon RDS 之外运行的 MySQL 实例配置为源数据库实例。要连接到在 Amazon RDS 外部运行的 MySQL 实例，您必须指定 `replication_user_name` 和 `replication_user_password` 值。这些值必须指示具有外部 MySQL 实例的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户。
**将 MySQL 的外部实例配置为源数据库实例**
1. 通过使用所选的 MySQL 客户端，连接到 MySQL 的外部实例并创建要用于复制的用户账户。以下是示例。
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. 对于 MySQL 的外部实例，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例为您的域的 `REPLICATION CLIENT` 用户授予所有数据库的 `REPLICATION SLAVE` 和 `'repl_user'` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
有关更多信息，请参阅“[配置与外部源实例之间的二进制日志文件位置复制](MySQL.Procedural.Importing.External.Repl.md)”。
**注意**
建议您尽可能使用只读副本管理两个 Amazon RDS 数据库实例之间的复制。在执行该操作时，建议您仅使用该存储过程以及其他与复制相关的存储过程。这些做法可以在 Amazon RDS 数据库实例之间实现更复杂的复制拓扑。我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。有关管理 Amazon RDS 数据库实例之间的复制的信息，请参阅[使用数据库实例只读副本](USER_ReadRepl.md)。
在调用 `mysql.rds_set_external_source_with_delay` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_reset_external_source) 删除只读副本配置。
在调用 `mysql.rds_set_external_source_with_delay` 时，Amazon RDS 在 `set master` 和 `mysql.rds_history` 表中记录时间、用户和 `mysql.rds_replication_status` 操作。
对于灾难恢复，您可以将该过程与 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_external_source_with_delay` 过程。在 `mysql.rds_start_replication_until` 过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关使用基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
### 示例
在 MySQL 数据库实例上运行时，下例将该数据库实例配置为在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。它在 MySQL 数据库实例上将最短复制延迟时间设置为一小时（3600 秒）。在 Amazon RDS 外部运行的 MySQL 源数据库实例的更改在至少一个小时内不会在 MySQL 数据库实例只读副本上应用。
```
call mysql.rds_set_external_source_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
使用来自外部源的指定 GTID 范围设置 [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) 系统变量。配置基于 GTID 的复制以使用自动定位来恢复复制时，需要 `gtid_purged` 值。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### 参数
*server\$1uuid*
从中导入 GTID 范围的外部服务器的通用唯一标识符（UUID）。
*start\$1pos*
要设置的 GTID 范围的起始位置。
*end\$1pos*
要设置的 GTID 范围的结束位置。
### 使用说明
`mysql.rds_set_external_source_gtid_purged` 过程仅适用于 MySQL 8.0.37 及更高的 8.0 版本。
先调用 `mysql.rds_set_external_source_gtid_purged`，然后再调用 [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_set_external_master_with_auto_position)、[mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_set_external_source_with_auto_position) 或 [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_set_external_source_with_auto_position_for_channel)。
在调用 `mysql.rds_set_external_source_gtid_purged` 之前，请务必停止数据库的所有活动的复制通道。要检查通道的状态，请使用 `SHOW REPLICA STATUS` MySQL 语句。要停止通道上的复制，请调用 [mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel)。
您指定的 GTID 范围必须是现有 `GTID_PURGED` 值的超集。此存储过程在设置 `GTID_PURGED` 值之前会检查以下各值：
+ `server_uuid` 有效。
+ `start_pos` 的值大于 `0` 并小于 `end_pos` 的值。
+ `end_pos` 的值大于或等于 `start_pos` 的值。
如果在外部服务器上设置的 GTID 包含多个值范围，请考虑使用不同的 GTID 设置值多次调用该过程。
在调用 `mysql.rds_set_external_source_gtid_purged` 时，Amazon RDS 会在 `mysql.rds_history` 表中记录 `set gtid_purged` 的时间、用户和操作。
如果您没有为用于复制的备份适当地设置 `gtid_purged` 值，这可能导致复制过程中事务丢失或重复。执行以下步骤来设置正确的 `gtid_purged` 值。
**对副本设置 gtid\$1purged 值**
1. 确定要用作复制起点的时间点或特定的备份文件。这可能是逻辑备份（mysqldump 文件）或物理备份（Amazon RDS 快照）。
1. 确定 `gtid_executed` 值。此值表示在服务器上提交的所有 GTID 的集合。要检索此值，请在源实例上执行下列操作之一：
+ 在执行备份时运行 SQL 语句 `SELECT @@GLOBAL.GTID_EXECUTED;`。
+ 如果相应的备份实用程序中包含任何相关选项，请从备份文件中提取值。有关更多信息，请参阅 MySQL 文档中的 [set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged) 选项。
1. 确定用于调用 `mysql.rds_set_external_source_gtid_purged` 的 `gtid_purged` 值。`gtid_purged` 值应包括已在源实例上执行但不再需要用于复制的所有 GTID。因此，`gtid_purged` 值应是您在上一步中检索到的 `gtid_executed` 值的子集。
要确定 `gtid_purged` 值，请确定备份中未包含的且不再需要用于复制的 GTID。为此，可以通过分析二进制日志或使用 mysqlbinlog 等工具，来查找从二进制日志中清除的 GTID。
或者，如果您有一个一致的备份，其中包括截至备份点的所有二进制日志，则可以将 `gtid_purged` 值设置为与备份点处的 `gtid_executed` 值相同。
1. 确定与备份一致的适当 `gtid_purged` 值后，在 RDS for MySQL 数据库实例上调用 `mysql.rds_set_external_source_gtid_purged` 存储过程来设置该值。
### 示例
在 MySQL 数据库实例上运行时，以下示例将从 UUID 为 `12345678-abcd-1234-efgh-123456789abc` 的外部 MySQL 服务器设置 GTID 范围，起始位置为 `1`，结束位置为 `100`。生成的 GTID 值设置为 `+12345678-abcd-1234-efgh-123456789abc:1-100`。
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
## mysql.rds\$1set\$1master\$1auto\$1position（RDS for MySQL 主要版本 8.0 及更低版本）
将复制模式设置为基于二进制日志文件位置或全局事务标识符 (GTID)。
### 语法
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### 参数
*auto\$1position\$1mode*
该值指示是使用日志文件位置复制还是基于 GTID 的复制：
+ `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+ `1` – 使用基于 GTID 的复制方法。
### 使用说明
主用户必须运行 `mysql.rds_set_master_auto_position` 过程。
所有 RDS for MySQL 5.7 版本和 RDS for MySQL 8.0.26 及更高的 8.0 版本均支持此过程。
## mysql.rds\$1set\$1source\$1auto\$1position（RDS for MySQL 主要版本 8.4 及更高版本）
将复制模式设置为基于二进制日志文件位置或全局事务标识符 (GTID)。
### 语法
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### 参数
*auto\$1position\$1mode*
该值指示是使用日志文件位置复制还是基于 GTID 的复制：
+ `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+ `1` – 使用基于 GTID 的复制方法。
### 使用说明
管理用户必须运行 `mysql.rds_set_source_auto_position` 过程。
## mysql.rds\$1set\$1source\$1delay
设置延迟从源数据库实例复制到当前只读副本的最小秒数。在您连接到只读副本时使用该过程来从其源数据库实例延迟复制。
### 语法
```
CALL mysql.rds_set_source_delay(
delay
);
```
### 参数
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
### 使用说明
主用户必须运行 `mysql.rds_set_source_delay` 过程。
对于灾难恢复，您可以将该过程与 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_source_delay` 过程。在 `mysql.rds_start_replication_until` 或 `mysql.rds_start_replication_until_gtid` 过程停止复制后，您可以使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关基于 GTID 的复制的更多信息，请参阅 [使用基于 GTID 的复制](mysql-replication-gtid.md)。
`mysql.rds_set_source_delay` 过程在以下版本的 RDS for MySQL 中可用：
+ 所有 RDS for MySQL 8.4 版本
+ MySQL 8.0.26 和更高的 8.0.x 版本
+ 所有 5.7 版本
### 示例
要将从源数据库实例向当前只读副本的复制延迟至少一个小时（3600 秒），您可以使用以下参数调用 `mysql.rds_set_source_delay`：
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
跳过并删除 MySQL 数据库只读副本上的复制错误。
### 语法
```
CALL mysql.rds_skip_repl_error;
```
### 使用说明
主用户必须对只读副本运行 `mysql.rds_skip_repl_error` 过程。有关此过程的更多信息，请参阅[调用 mysql.rds\$1skip\$1repl\$1error 过程](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure)。
要确定是否存在错误，请运行 MySQL `SHOW REPLICA STATUS\G` 命令。如果复制错误不太严重，您可以运行 `mysql.rds_skip_repl_error` 以跳过该错误。如果有多个错误，`mysql.rds_skip_repl_error` 会删除第一个错误，并警告存在其他错误。然后，您可以使用 `SHOW REPLICA STATUS\G` 确定要对下一个错误采取的适当操作。有关返回的值的信息，请参阅 MySQL 文档中的 [SHOW REPLICA STATUS 语法](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html)。
想要了解更多有关解决 Amazon RDS 的复制错误的信息，请参阅 [排查 MySQL 只读副本问题](USER_ReadRepl.Troubleshooting.md)。
#### 复制已停止错误
调用 `mysql.rds_skip_repl_error` 过程时，您可能会收到一条错误消息，指出副本已关闭或禁用。
如果您对于主实例而不是只读副本运行该过程，则会出现此错误消息。您必须对只读副本运行此过程，该过程才能正常运行。
如果您对只读副本运行该过程，但无法成功重新启动复制，也可能会出现此错误消息。
如果您需要跳过大量错误，复制滞后时间可能会超出二进制日志 (binlog) 文件的默认保留期。在这种情况下，您可能会遇到一个因二进制日志文件在只读副本上进行重放之前被清除而引发的严重错误。此清除会导致复制停止，而您将无法再调用 `mysql.rds_skip_repl_error` 命令以跳过复制错误。
您可以增加在源数据库实例上保留 binlog 文件的小时数以缓解该问题。在增加二进制日志保留时间后，您可以重新启动复制进程，并根据需要调用 `mysql.rds_skip_repl_error` 命令。
要设置 binlog 保留时间，请使用 [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) 过程，并指定 `'binlog retention hours'` 配置参数以及在数据库集群上保留 binlog 文件的小时数。以下示例将 binlog 文件的保留期设置为 48 个小时。
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
从 RDS for MySQL 数据库实例发起复制。
**注意**
您可以使用 [mysql.rds\$1start\$1replication\$1until](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程从 RDS for MySQL 数据库实例中启动复制，并在指定的二进制日志文件位置停止复制。
### 语法
```
CALL mysql.rds_start_replication;
```
### 使用说明
主用户必须运行 `mysql.rds_start_replication` 过程。
要从 Amazon RDS 外部的 MySQL 实例导入数据，请在调用 [mysql.rds\$1set\$1external\$1master（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_set_external_master) 或 [mysql.rds\$1set\$1external\$1source（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_set_external_source) 以构建复制配置后，再对只读副本调用 `mysql.rds_start_replication` 以开始复制过程。有关更多信息，请参阅 [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md)。
要将数据导出到 Amazon RDS 外部的 MySQL 实例，请对只读副本调用 `mysql.rds_start_replication` 和 `mysql.rds_stop_replication` 以控制某些复制操作，如清除二进制日志。有关更多信息，请参阅 [使用复制从 MySQL 数据库实例中导出数据](MySQL.Procedural.Exporting.NonRDSRepl.md)。
您还可以对只读副本调用 `mysql.rds_start_replication`，以便重新启动您先前通过调用 `mysql.rds_stop_replication` 停止的任何复制过程。有关更多信息，请参阅 [使用数据库实例只读副本](USER_ReadRepl.md)。
## mysql.rds\$1start\$1replication\$1until
从 RDS for MySQL 数据库实例发起复制，并在指定的二进制日志文件位置停止复制。
### 语法
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### 参数
*replication\$1log\$1file*
源数据库实例上包含复制信息的二进制日志的名称。
*replication\$1stop\$1point *
`replication_log_file` 二进制日志中复制将停止的位置。
### 使用说明
主用户必须运行 `mysql.rds_start_replication_until` 过程。
`mysql.rds_start_replication_until` 过程在以下版本的 RDS for MySQL 中可用：
+ 所有 RDS for MySQL 8.4 版本
+ MySQL 8.0.26 和更高的 8.0.x 版本
+ 所有 5.7 版本
您可以对延迟复制使用该过程以进行灾难恢复。如果您已配置延迟复制，则可以使用该过程来将延迟只读副本的更改向前滚动到灾难之前的时间。在该过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明，将只读副本提升为新的主数据库实例。
您可以使用以下存储过程配置延迟复制：
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay（RDS for MySQL 主要版本 8.4 及更高版本）](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
为 `replication_log_file` 参数指定的文件名必须与源数据库实例二进制日志文件名匹配。
当 `replication_stop_point` 参数指定位于过去的某个停止位置时，即会立即停止复制。
### 示例
以下示例将启动复制并复制更改，直到它到达 `120` 二进制日志文件中的 `mysql-bin-changelog.000777` 位置。
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
停止从 MySQL 数据库实例中进行复制。
### 语法
```
CALL mysql.rds_stop_replication;
```
### 使用说明
主用户必须运行 `mysql.rds_stop_replication` 过程。
如果要配置复制，使其从在 Amazon RDS 外部运行的 MySQL 实例导入数据，则要在导入完成后，再对只读副本调用 `mysql.rds_stop_replication` 以停止复制过程。有关更多信息，请参阅 [将备份还原到 Amazon RDS for MySQL 数据库实例](MySQL.Procedural.Importing.md)。
如果要配置复制，使其将数据导出到在 Amazon RDS 外部运行的 MySQL 实例，则要对只读副本调用 `mysql.rds_start_replication` 和 `mysql.rds_stop_replication` 以控制某些复制操作，如清除二进制日志。有关更多信息，请参阅 [使用复制从 MySQL 数据库实例中导出数据](MySQL.Procedural.Exporting.NonRDSRepl.md)。
您还可以使用 `mysql.rds_stop_replication` 停止两个 Amazon RDS 数据库实例之间的复制。停止复制通常是为了对只读副本执行长时间运行的操作，如在只读副本上创建大型索引。您可以重新启动您通过对只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 停止的任何复制过程。有关更多信息，请参阅 [使用数据库实例只读副本](USER_ReadRepl.md)。
# 结束会话或查询
以下存储过程结束会话或查询。
**Topics**
+ [
## mysql.rds\$1kill
](#mysql_rds_kill)
+ [
## mysql.rds\$1kill\$1query
](#mysql_rds_kill_query)
## mysql.rds\$1kill
结束与 MySQL 服务器的连接。
### 语法
```
CALL mysql.rds_kill(processID);
```
### 参数
*processID*
要结束的连接线程的标识。
### 使用说明
与 MySQL 服务器的每个连接在单独的线程中运行。要结束连接，请使用 `mysql.rds_kill` 过程并传入该连接的线程 ID。要获取线程 ID，请使用 MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) 命令。
有关限制的信息，请参阅[MySQL 存储过程限制](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures)。
### 示例
以下示例结束线程 ID 为 4243 的连接：
```
CALL mysql.rds_kill(4243);
```
## mysql.rds\$1kill\$1query
结束针对 MySQL 服务器运行的查询。
### 语法
```
CALL mysql.rds_kill_query(processID);
```
### 参数
*processID*
运行正要结束的查询的进程或线程的身份。
### 使用说明
要停止针对 MySQL 服务器运行的查询，请使用 `mysql_rds_kill_query` 过程并传入正在运行查询的线程的连接 ID。然后，该过程将终止连接。
要获取 ID，请查询 MySQL [INFORMATION\$1SCHEMA PROCESSLIST 表](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html)或使用 MySQL [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) 命令。`SHOW PROCESSLIST` 或 `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` 中 ID 列的值为 *processID*。
有关限制的信息，请参阅[MySQL 存储过程限制](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures)。
### 示例
以下示例停止查询线程 ID 为 230040 的查询：
```
CALL mysql.rds_kill_query(230040);
```
# 管理主动-主动集群
以下存储过程用于设置和管理 RDS for MySQL 主动-主动集群。有关更多信息，请参阅 [为 RDS for MySQL 配置主动-主动集群](mysql-active-active-clusters.md)。
这些存储过程仅适用于运行以下版本的 RDS for MySQL 数据库实例：
+ 所有 MySQL 8.4 版本
+ MySQL 8.0.35 及更高的次要版本
**Topics**
+ [
## mysql.rds\$1group\$1replication\$1advance\$1gtid
](#mysql_rds_group_replication_advance_gtid)
+ [
## mysql.rds\$1group\$1replication\$1create\$1user
](#mysql_rds_group_replication_create_user)
+ [
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
](#mysql_rds_group_replication_set_recovery_channel)
+ [
## mysql.rds\$1group\$1replication\$1start
](#mysql_rds_group_replication_start)
+ [
## mysql.rds\$1group\$1replication\$1stop
](#mysql_rds_group_replication_stop)
## mysql.rds\$1group\$1replication\$1advance\$1gtid
在当前数据库实例上创建占位符 GTID。
### 语法
```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```
### 参数
*begin\$1id*
要创建的开始事务 ID。
*end\$1id*
要创建的结束事务 ID。
*begin\$1id*
要创建的事务的 `group_replication_group_name`。在与数据库实例关联的数据库参数组中将 `group_replication_group_name` 指定为 UUID。
### 使用说明
在主动-主动集群中，要使数据库实例加入组，在新数据库实例上执行的所有 GTID 事务都必须存在于集群中的其它成员上。在不寻常的情况下，在将实例加入组之前执行事务时，新的数据库实例可能会有更多的事务。在这种情况下，您无法移除任何现有事务，但您可以使用此过程在组中的其它数据库实例上创建相应的占位符 GTID。在执行此操作之前，请验证事务*不会影响复制的数据*。
当您调用此过程时，将创建 `server_uuid:begin_id-end_id` 的 GTID 事务，但内容为空。为避免复制问题，请勿在任何其它条件下使用此过程。
**重要**
避免在主动-主动集群运行正常时调用此过程。除非您了解正在创建的事务可能产生的后果，否则不要调用此过程。调用此过程可能会导致数据不一致。
### 示例
以下示例在当前数据库实例上创建占位符 GTID：
```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```
## mysql.rds\$1group\$1replication\$1create\$1user
为数据库实例上的组复制创建复制用户 `rdsgrprepladmin`。
### 语法
```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```
### 参数
*replication\$1user\$1password*
复制用户 `rdsgrprepladmin` 的密码。
### 使用说明
+ 在主动-主动集群中的所有数据库实例上，复制用户 `rdsgrprepladmin` 的密码必须相同。
+ `rdsgrprepladmin` 用户名保留用于组复制连接。任何其他用户（包括主用户）都不能拥有此用户名。
### 示例
以下示例为数据库实例上的组复制创建复制用户 `rdsgrprepladmin`：
```
CALL mysql.rds_group_replication_create_user('password');
```
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
设置主动-主动集群的 `group_replication_recovery` 通道。该过程使用保留的 `rdsgrprepladmin` 用户来配置通道。
### 语法
```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```
### 参数
*replication\$1user\$1password*
复制用户 `rdsgrprepladmin` 的密码。
### 使用说明
在主动-主动集群中的所有数据库实例上，复制用户 `rdsgrprepladmin` 的密码必须相同。调用 `mysql.rds_group_replication_create_user` 可指定密码。
### 示例
以下示例为主动-主动集群设置 `group_replication_recovery` 通道：
```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```
## mysql.rds\$1group\$1replication\$1start
在当前数据库实例上启动组复制。
### 语法
```
CALL mysql.rds_group_replication_start(
bootstrap
);
```
### 参数
*bootstrap*
一个值，它指定是初始化新组还是加入现有组。值为 `1` 时，将使用当前数据库实例初始化新组。值为 `0` 时，将通过连接到在与当前数据库实例关联的数据库参数组的 `group_replication_group_seeds` 参数中定义的端点，将该数据库实例加入到现有组。
### 示例
以下示例使用当前数据库实例初始化新组：
```
CALL mysql.rds_group_replication_start(1);
```
## mysql.rds\$1group\$1replication\$1stop
在当前数据库实例上停止组复制。
### 语法
```
CALL mysql.rds_group_replication_stop();
```
### 使用说明
当您在数据库实例上停止复制时，它不会影响主动-主动集群中的任何其它数据库实例。
# 管理多源复制
以下存储过程在 RDS for MySQL 多源副本上设置和管理复制通道。有关更多信息，请参阅 [为 Amazon RDS for MySQL 配置多源复制](mysql-multi-source-replication.md)。
这些存储过程仅适用于运行以下引擎版本的 RDS for MySQL 数据库实例：
+ 所有 8.4 版本
+ 8.0.35 及更高的次要版本
+ 5.7.44 及更高的次要版本
在使用这些存储过程管理复制时，如果其复制用户配置了 `caching_sha2_passwword`，则必须通过指定 `SOURCE_SSL=1` 来配置 TLS。`caching_sha2_password` 是 RDS for MySQL 8.4 的默认身份验证插件。
**注意**
尽管本文档将源数据库实例称为 RDS for MySQL 数据库实例，但这些过程也适用于在 Amazon RDS 外部运行的 MySQL 实例。
**Topics**
+ [
## mysql.rds\$1next\$1source\$1log\$1for\$1channel
](#mysql_rds_next_source_log_for_channel)
+ [
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
](#mysql_rds_reset_external_source_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
](#mysql_rds_set_external_source_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel
](#mysql_rds_set_external_source_with_auto_position_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel
](#mysql_rds_set_external_source_with_delay_for_channel)
+ [
## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel
](#mysql_rds_set_source_auto_position_for_channel)
+ [
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
](#mysql_rds_set_source_delay_for_channel)
+ [
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
](#mysql_rds_skip_repl_error_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1for\$1channel
](#mysql_rds_start_replication_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
](#mysql_rds_start_replication_until_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel
](#mysql_rds_start_replication_until_gtid_for_channel)
+ [
## mysql.rds\$1stop\$1replication\$1for\$1channel
](#mysql_rds_stop_replication_for_channel)
## mysql.rds\$1next\$1source\$1log\$1for\$1channel
将源数据库实例日志位置更改为通道的源数据库实例上下一个二进制日志的开始位置。只有在多源副本上收到复制 I/O 错误 1236 时，才能使用该过程。
### 语法
```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name
);
```
### 参数
*curr\$1master\$1log*
当前源日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。要确定当前源日志文件名，请运行 `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` 命令并查看 `Source_Log_File` 字段。
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_next_source_log_for_channel` 过程。例如，如果出现 IO\$1Thread 错误，则可以使用此过程跳过当前二进制日志文件中的所有事件，并从在 `channel_name` 中指定的通道的下一个二进制日志文件中恢复复制。
### 示例
假设在多源副本的通道上复制失败。对多源副本运行 `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` 会返回以下结果：
```
mysql> SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G
*************************** 1. row ***************************
Replica_IO_State: Waiting for source to send event
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: ReplicationUser
Source_Port: 3306
Connect_Retry: 60
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: replica-relay-bin.000003
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:.
.
.
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
.
.
Channel_name: channel_1
.
.
-- Some fields are omitted in this example output
```
`Last_IO_Errno` 字段显示该实例收到 I/O 错误 1236。`Source_Log_File` 字段显示文件名为 `mysql-bin-changelog.012345`，这意味着日志文件索引为 `12345`。要纠正该错误，您可以使用以下参数调用 `mysql.rds_next_source_log_for_channel`：
```
CALL mysql.rds_next_source_log_for_channel(12345,'channel_1');
```
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
停止指定通道上的复制过程，并从多源副本中移除该通道和关联的配置。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```
### 参数
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_reset_external_source_for_channel` 过程。此过程将删除属于要移除的通道的所有中继日志。
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
在 RDS for MySQL 数据库实例上配置复制通道，以从另一个 RDS for MySQL 数据库实例复制数据。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
**注意**
您可以改用 [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) 存储过程为该通道配置延迟复制。
### 语法
```
CALL mysql.rds_set_external_source_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, channel_name
);
```
### 参数
*host\$1name*
RDS for MySQL 源数据库实例的主机名或 IP 地址。
*host\$1port*
RDS for MySQL 源数据库实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对 RDS for MySQL 源数据库实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供源数据库实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW BINARY LOG STATUS` 来确定二进制日志文件名和位置。
以前的 MySQL 版本使用的是 `SHOW MASTER STATUS`，而不是 `SHOW BINARY LOG STATUS`。如果您使用的 MySQL 版本低于 8.4，请使用 `SHOW MASTER STATUS`。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*channel\$1name*
复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_set_external_source_for_channel` 过程。此过程必须在您要创建复制通道的目标 RDS for MySQL 数据库实例上运行。
在运行 `mysql.rds_set_external_source_for_channel` 之前，请为源数据库实例上的复制用户配置多源副本所需的权限。要将多源副本连接到源数据库实例，必须指定对源数据库实例拥有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户的 `replication_user_name` 和 `replication_user_password` 值。
**在源数据库实例上配置复制用户**
1. 通过使用所选的 MySQL 客户端，连接到源数据库实例并创建要用于复制的用户账户。示例如下：
**重要**
作为安全最佳实践，请指定除以下示例中所示占位符值以外的密码。
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. 在源数据库实例上，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例向您所在域的“repl\$1user”用户授予对所有数据库的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
要使用加密复制，请将源数据库实例配置为使用 SSL 连接。
在调用 `mysql.rds_set_external_source_for_channel` 以配置此复制通道后，可以在副本上调用 [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) 以启动通道上的复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) 以停止通道上的复制，并从副本中移除通道配置。
当您调用 `mysql.rds_set_external_source_for_channel` 时，Amazon RDS 将时间、用户和 `set channel source` 的操作记录在 `mysql.rds_history` 表（不包括通道特定的详细信息）和 `mysql.rds_replication_status` 表中，并包含通道名称。此信息仅用于内部使用和监控目的。要记录完整的过程调用以进行审核，请考虑根据应用程序的特定要求启用审核日志或常规日志。
### 示例
在 RDS for MySQL 数据库实例上运行时，以下示例将此数据库实例上名为 `channel_1` 的复制通道配置为从由主机 `sourcedb.example.com` 和端口 `3306` 指定的源复制数据。
```
call mysql.rds_set_external_source_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
0,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel
在 RDS for MySQL 数据库实例上配置一个复制通道，复制延迟为可选项。复制基于全局事务标识符（GTID）。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source_with_auto_position_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
, channel_name
);
```
### 参数
*host\$1name*
RDS for MySQL 源数据库实例的主机名或 IP 地址。
*host\$1port*
RDS for MySQL 源数据库实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对 RDS for MySQL 源数据库实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供源数据库实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
*channel\$1name*
复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_set_external_source_with_auto_position_for_channel` 过程。此过程必须在您要创建复制通道的目标 RDS for MySQL 数据库实例上运行。
在运行 `rds_set_external_source_with_auto_position_for_channel` 之前，请为源数据库实例上的复制用户配置多源副本所需的权限。要将多源副本连接到源数据库实例，必须指定对源数据库实例拥有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户的 `replication_user_name` 和 `replication_user_password` 值。
**在源数据库实例上配置复制用户**
1. 通过使用所选的 MySQL 客户端，连接到源数据库实例并创建要用于复制的用户账户。示例如下：
**重要**
作为安全最佳实践，请指定除以下示例中所示占位符值以外的密码。
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. 在源数据库实例上，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例向您所在域的“repl\$1user”用户授予对所有数据库的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
要使用加密复制，请将源数据库实例配置为使用 SSL 连接。
在调用 `mysql.rds_set_external_source_with_auto_position_for_channel` 之前，务必调用 [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_gtid_purged)，以便使用来自外部源的指定 GTID 范围设置 `gtid_purged` 系统变量。
在调用 `mysql.rds_set_external_source_with_auto_position_for_channel` 以将 Amazon RDS 数据库实例配置为特定通道上的只读副本后，可以在只读副本上调用 [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) 以启动该通道上的复制过程。
在调用 `mysql.rds_set_external_source_with_auto_position_for_channel` 以配置此复制通道后，可以在副本上调用 [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) 以启动通道上的复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) 以停止通道上的复制，并从副本中移除通道配置。
### 示例
在 RDS for MySQL 数据库实例上运行时，以下示例将此数据库实例上名为 `channel_1` 的复制通道配置为从由主机 `sourcedb.example.com` 和端口 `3306` 指定的源复制数据。它将最小复制延迟设置为一小时（3600 秒）。这意味着，来自源 RDS for MySQL 数据库实例的更改在至少一个小时内不会在多源副本上应用。
```
call mysql.rds_set_external_source_with_auto_position_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
1,
3600,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel
在 RDS for MySQL 数据库实例上配置一个具有指定复制延迟的复制通道。
**重要**
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。
### 语法
```
CALL mysql.rds_set_external_source_with_delay_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
, channel_name
);
```
### 参数
*host\$1name*
RDS for MySQL 源数据库实例的主机名或 IP 地址。
*host\$1port*
RDS for MySQL 源数据库实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。
*replication\$1user\$1name*
对 RDS for MySQL 源数据库实例具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供源数据库实例。
*replication\$1user\$1password*
在 `replication_user_name` 中指定的用户 ID 的密码。
*mysql\$1binary\$1log\$1file\$1name*
源数据库实例上包含复制信息的二进制日志的名称。
*mysql\$1binary\$1log\$1file\$1location*
`mysql_binary_log_file_name` 二进制日志中复制将开始读取复制信息的位置。
您可以通过在源数据库实例上运行 `SHOW BINARY LOG STATUS` 来确定二进制日志文件名和位置。
以前的 MySQL 版本使用的是 `SHOW MASTER STATUS`，而不是 `SHOW BINARY LOG STATUS`。如果您使用的 MySQL 版本低于 8.4，请使用 `SHOW MASTER STATUS`。
*ssl\$1encryption*
指定是否在复制连接中使用安全套接字层（SSL）加密的值。1 表示使用 SSL 加密，0 表示不使用加密。默认值为 0。
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。
*delay*
延迟从源数据库实例复制的最小秒数。
该参数的限制为一天（86400 秒）。
*channel\$1name*
复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_set_external_source_with_delay_for_channel` 过程。此过程必须在您要创建复制通道的目标 RDS for MySQL 数据库实例上运行。
在运行 `mysql.rds_set_external_source_with_delay_for_channel` 之前，请为源数据库实例上的复制用户配置多源副本所需的权限。要将多源副本连接到源数据库实例，必须指定对源数据库实例拥有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的复制用户的 `replication_user_name` 和 `replication_user_password` 值。
**在源数据库实例上配置复制用户**
1. 通过使用所选的 MySQL 客户端，连接到源数据库实例并创建要用于复制的用户账户。示例如下：
**重要**
作为安全最佳实践，请指定除以下示例中所示占位符值以外的密码。
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. 在源数据库实例上，向复制用户授予 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。以下示例向您所在域的“repl\$1user”用户授予对所有数据库的 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限。
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
要使用加密复制，请将源数据库实例配置为使用 SSL 连接。
在调用 `mysql.rds_set_external_source_with_delay_for_channel` 以配置此复制通道后，可以在副本上调用 [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) 以启动通道上的复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) 以停止通道上的复制，并从副本中移除通道配置。
当您调用 `mysql.rds_set_external_source_with_delay_for_channel` 时，Amazon RDS 将时间、用户和 `set channel source` 的操作记录在 `mysql.rds_history` 表（不包括通道特定的详细信息）和 `mysql.rds_replication_status` 表中，并包含通道名称。此信息仅用于内部使用和监控目的。要记录完整的过程调用以进行审核，请考虑根据应用程序的特定要求启用审核日志或常规日志。
### 示例
在 RDS for MySQL 数据库实例上运行时，以下示例将此数据库实例上名为 `channel_1` 的复制通道配置为从由主机 `sourcedb.example.com` 和端口 `3306` 指定的源复制数据。它将最小复制延迟设置为一小时（3600 秒）。这意味着，来自源 RDS for MySQL 数据库实例的更改在至少一个小时内不会在多源副本上应用。
```
call mysql.rds_set_external_source_with_delay_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.000777',
120,
1,
3600,
'channel_1');
```
## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel
将指定通道的复制模式设置为基于二进制日志文件位置或全局事务标识符（GTID）。
### 语法
```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
, channel_name
);
```
### 参数
*auto\$1position\$1mode*
该值指示是使用日志文件位置复制还是基于 GTID 的复制：
+ `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+ `1` – 使用基于 GTID 的复制方法。
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_set_source_auto_position_for_channel` 过程。此过程在指定的通道上重启复制，以应用指定的自动定位模式。
### 示例
以下示例将 channel\$11 的自动定位模式设置为使用基于 GTID 的复制方法。
```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
为指定的通道设置延迟从源数据库实例复制到多源副本的最小秒数。
### 语法
```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```
### 参数
*delay*
延迟从源数据库实例进行复制的最小秒数。
该参数的限制为一天（86400 秒）。
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_set_source_delay_for_channel` 过程。要使用此过程，请首先调用 `mysql.rds_stop_replication_for_channel` 以停止复制。然后，调用此过程来设置复制延迟值。设置延迟后，调用 `mysql.rds_start_replication_for_channel` 以重启复制。
### 示例
以下示例将从多源副本的 `channel_1` 上的源数据库实例进行复制的延迟设置为至少一小时（3600 秒）。
```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
跳过二进制日志事件并删除指定通道的 MySQL DB 多源副本上的复制错误。
### 语法
```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```
### 参数
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须对只读副本运行 `mysql.rds_skip_repl_error_for_channel` 过程。使用此过程的方式与使用 `mysql.rds_skip_repl_error` 跳过只读副本上的错误的方式类似。有关更多信息，请参阅 [调用 mysql.rds\$1skip\$1repl\$1error 过程](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure)。
**注意**
要跳过基于 GTID 的复制中的错误，建议您改用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 过程。
要确定是否存在错误，请运行 MySQL `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` 命令。如果复制错误不太严重，您可以运行 `mysql.rds_skip_repl_error_for_channel` 以跳过该错误。如果有多个错误，`mysql.rds_skip_repl_error_for_channel` 会删除指定复制通道上的第一个错误，然后警告存在其他错误。然后，您可以使用 `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` 确定要对下一个错误采取的适当操作。有关返回的值的信息，请参阅 MySQL 文档中的 [SHOW REPLICA STATUS 语法](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html)。
## mysql.rds\$1start\$1replication\$1for\$1channel
在指定的通道上发起从 RDS for MySQL 数据库实例到多源副本的复制。
**注意**
您可以使用 [mysql.rds\$1start\$1replication\$1until\$1for\$1channel](#mysql_rds_start_replication_until_for_channel) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel](#mysql_rds_start_replication_until_gtid_for_channel) 存储过程从 RDS for MySQL 数据库实例中启动复制，并在指定的二进制日志文件位置停止复制。
### 语法
```
CALL mysql.rds_start_replication_for_channel(channel_name);
```
### 参数
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_start_replication_for_channel` 过程。从源 RDS for MySQL 数据库实例导入数据后，在多源副本上运行此命令以在指定的通道上开始复制。
### 示例
以下示例开始在多源副本的 `channel_1` 上进行复制。
```
CALL mysql.rds_start_replication_for_channel('channel_1');
```
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
在指定的通道上从 RDS for MySQL 数据库实例启动复制，并在指定的二进制日志文件位置停止复制。
### 语法
```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
, replication_stop_point
, channel_name
);
```
### 参数
*replication\$1log\$1file*
源数据库实例上包含复制信息的二进制日志的名称。
*replication\$1stop\$1point *
`replication_log_file` 二进制日志中复制将停止的位置。
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_start_replication_until_for_channel` 过程。通过此过程，复制将启动，然后在达到指定的二进制日志文件位置时停止。此过程会同时停止 `SQL_THREAD` 和 `IO_THREAD`。
为 `replication_log_file` 参数指定的文件名必须与源数据库实例二进制日志文件名匹配。
当 `replication_stop_point` 参数指定过去的某个停止位置时，即会立即停止复制。
### 示例
以下示例在 `channel_1` 上启动复制并复制更改，直到它到达 `mysql-bin-changelog.000777` 二进制日志文件中的位置 `120`。
```
call mysql.rds_start_replication_until_for_channel(
'mysql-bin-changelog.000777',
120,
'channel_1'
);
```
## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel
在指定的通道上从 RDS for MySQL 数据库实例中启动复制，并在指定的全局事务标识符（GTID）处停止复制。
### 语法
```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```
### 参数
*gtid*
在其之后停止复制的 GTID。
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_start_replication_until_gtid_for_channel` 过程。该过程在指定的通道上启动复制并应用所有更改，直至指定的 GTID 值。然后，它在该通道上停止复制。
在 `gtid` 参数指定副本已运行的事务时，将会立即停止复制。
在运行此过程之前，必须通过将 `replica_parallel_workers` 或 `slave_parallel_workers` 的值设置为 `0` 来禁用多线程复制。
### 示例
以下示例在 `channel_1` 上启动复制并复制更改，直至到达 GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`。
```
call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1');
```
## mysql.rds\$1stop\$1replication\$1for\$1channel
停止在指定的通道上从 MySQL 数据库实例进行复制。
### 语法
```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```
### 参数
*channel\$1name*
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。
### 使用说明
主用户必须运行 `mysql.rds_stop_replication_for_channel` 过程。
### 示例
以下示例停止在多源副本的 `channel_1` 上进行复制。
```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```
# 使用 GTID 复制事务
以下存储过程控制如何使用 RDS for MySQL 中的全局事务标识符（GTID）复制事务。有关根据 RDS for MySQL 中的 GTID 进行复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
在使用这些存储过程管理复制时，如果其复制用户配置了 `caching_sha2_password`，则必须通过指定 `SOURCE_SSL=1` 来配置 TLS。`caching_sha2_password` 是 RDS for MySQL 8.4 的默认身份验证插件。
**Topics**
+ [
## mysql.rds\$1skip\$1transaction\$1with\$1gtid
](#mysql_rds_skip_transaction_with_gtid)
+ [
## mysql.rds\$1start\$1replication\$1until\$1gtid
](#mysql_rds_start_replication_until_gtid)
## mysql.rds\$1skip\$1transaction\$1with\$1gtid
在 MySQL 数据库实例上跳过复制具有指定全局事务标识符 (GTID) 的事务。
在已知特定 GTID 事务导致问题时，您可以使用该过程进行灾难恢复。请使用该存储过程跳过有问题的事务。有问题的事务示例包括禁用复制、删除重要数据或导致数据库实例变得不可用的事务。
### 语法
```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```
### 参数
*gtid\$1to\$1skip*
要跳过的复制事务的 GTID。
### 使用说明
主用户必须运行 `mysql.rds_skip_transaction_with_gtid` 过程。
所有 RDS for MySQL 5.7 版本、所有 RDS for MySQL 8.0 版本和所有 RDS for MySQL 8.4 版本均支持此过程。
### 示例
以下示例将跳过复制具有 GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23` 的事务。
```
CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
## mysql.rds\$1start\$1replication\$1until\$1gtid
从 RDS for MySQL 数据库实例中启动复制，并在指定的全局事务标识符（GTID）后面立即停止复制。
### 语法
```
CALL mysql.rds_start_replication_until_gtid(gtid);
```
### 参数
*gtid*
停止复制前的 GTID。
### 使用说明
主用户必须运行 `mysql.rds_start_replication_until_gtid` 过程。
所有 RDS for MySQL 5.7 版本、所有 RDS for MySQL 8.0 版本和所有 RDS for MySQL 8.4 版本均支持此过程。
您可以对延迟复制使用该过程以进行灾难恢复。如果您已配置延迟复制，则可以使用该过程来将延迟只读副本的更改向前滚动到灾难之前的时间。在该过程停止复制后，您可以通过使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明，将只读副本提升为新的主数据库实例。
您可以使用以下存储过程配置延迟复制：
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay（RDS for MariaDB 和 RDS for MySQL 主要版本 8.0 及更低版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay（RDS for MySQL 主要版本 8.4 及更高版本）](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay)
在 `gtid` 参数指定副本已运行的事务时，将会立即停止复制。
### 示例
以下示例启动复制并复制更改，直至到达 GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`。
```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
# 轮换查询日志
以下存储过程将 MySQL 日志交替到备份表。有关更多信息，请参阅 [MySQL 数据库日志文件](USER_LogAccess.Concepts.MySQL.md)。
**Topics**
+ [
## mysql.rds\$1rotate\$1general\$1log
](#mysql_rds_rotate_general_log)
+ [
## mysql.rds\$1rotate\$1slow\$1log
](#mysql_rds_rotate_slow_log)
## mysql.rds\$1rotate\$1general\$1log
将 `mysql.general_log` 表轮换到备份表。
### 语法
```
CALL mysql.rds_rotate_general_log;
```
### 使用说明
您可以通过调用 `mysql.general_log` 过程将 `mysql.rds_rotate_general_log` 表轮换到备份表。轮换日志表时，会将当前日志表复制到备份日志表，随后删除当前日志表中的条目。如果备份日志表已存在，则先将其删除，然后将当前日志表复制到备份。如果需要，您可以查询备份日志表。`mysql.general_log` 表的备份日志表名为 `mysql.general_log_backup`。
只有当 `log_output` 参数设置为 `TABLE` 时，您才能运行此过程。
## mysql.rds\$1rotate\$1slow\$1log
将 `mysql.slow_log` 表轮换到备份表。
### 语法
```
CALL mysql.rds_rotate_slow_log;
```
### 使用说明
您可以通过调用 `mysql.slow_log` 过程将 `mysql.rds_rotate_slow_log` 表轮换到备份表。轮换日志表时，会将当前日志表复制到备份日志表，随后删除当前日志表中的条目。如果备份日志表已存在，则先将其删除，然后将当前日志表复制到备份。
如果需要，您可以查询备份日志表。`mysql.slow_log` 表的备份日志表名为 `mysql.slow_log_backup`。
# 设置和显示二进制日志配置
以下存储过程设置和显示配置参数，例如用于二进制日志文件保留。
**Topics**
+ [
## mysql.rds\$1set\$1configuration
](#mysql_rds_set_configuration)
+ [
## mysql.rds\$1show\$1configuration
](#mysql_rds_show_configuration)
## mysql.rds\$1set\$1configuration
指定要保留二进制日志的小时数或要延迟复制的秒数。
### 语法
```
CALL mysql.rds_set_configuration(name,value);
```
### 参数
*name*
要设置的配置参数的名称。
*值*
配置参数的值。
### 使用说明
`mysql.rds_set_configuration` 过程支持以下配置参数：
+ [二进制日志保留小时数](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours)
+ [源延迟](#mysql_rds_set_configuration-usage-notes.source-delay)
+ [target delay](#mysql_rds_set_configuration-usage-notes.target-delay)
配置参数将永久存储，可在任何数据库实例重启或失效转移后继续使用。
#### 二进制日志保留小时数
`binlog retention hours` 参数用于指定要保留二进制日志文件的小时数。Amazon RDS 通常会尽快清除一个二进制日志，但对于 RDS 外部的 MySQL 数据库的复制，该二进制日志可能仍是必需的。
`binlog retention hours` 的默认值为 `NULL`。对于 RDS for MySQL，`NULL` 表示不保留二进制日志（0 小时）。
要指定在数据库实例上保留二进制日志的小时数，请使用 `mysql.rds_set_configuration` 存储过程并指定足以让复制发生的时段，如以下示例中所示。
`call mysql.rds_set_configuration('binlog retention hours', 24);`
**注意**
不能将值 `0` 用于 `binlog retention hours`。
对于 MySQL 数据库实例，最大 `binlog retention hours` 值为 168 个小时 (7 天)。
在设置保留期后，监视数据库实例的存储用量以确认保留的二进制日志不会占用太多存储空间。
对于多可用区数据库集群部署，您只能从写入器数据库实例中配置二进制日志保留，并且该设置会异步传播到所有读取器数据库实例。如果数据库集群上的二进制日志超过本地总存储空间的一半，Amazon RDS 会自动将陈旧的日志移至 EBS 卷。但是，最新的日志仍保留在本地存储中，因此，如果出现需要更换主机的故障，或者您纵向扩展或缩减数据库，这些日志可能会丢失。
#### 源延迟
使用只读副本中的 `source delay` 参数指定延迟从读取副本复制到其源数据库实例的秒数。Amazon RDS 通常会尽快复制更改，但您可能希望某些环境延迟复制。例如，在延迟复制后，您可以将延迟只读副本向前滚动到发生灾难之前的时间。如果意外删除一个表，您可以使用延迟的复制快速恢复该表。`target delay` 的默认值为 `0`（不延迟复制）。
当您使用此参数时，它会运行 [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) 并应用 CHANGE primary TO MASTER\$1DELAY = 输入值。如果成功，该过程将 `source delay` 参数保存到 `mysql.rds_configuration` 表中。
要指定 Amazon RDS 延迟复制到源数据库实例的秒数，请使用 `mysql.rds_set_configuration` 存储过程并指定要延迟复制的秒数。在以下示例中，复制至少延迟一小时（3600 秒）。
`call mysql.rds_set_configuration('source delay', 3600);`
然后，该程序运行 `mysql.rds_set_source_delay(3600)`。
`source delay` 参数的限制为一天（86400 秒）。
#### target delay
使用 `target delay` 参数指定在数据库实例与从该实例创建的任何将来的 RDS 托管式只读副本之间延迟复制的秒数。对于非 RDS 托管式只读副本，将忽略此参数。Amazon RDS 通常会尽快复制更改，但您可能希望某些环境延迟复制。例如，在延迟复制后，您可以将延迟只读副本向前滚动到发生灾难之前的时间。如果意外删除一个表，您可以使用延迟复制快速恢复该表。`target delay` 的默认值为 `0`（不延迟复制）。
对于灾难恢复，您可以将该配置参数与 [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程一起使用。要将延迟只读副本的更改向前滚动到发生灾难之前的时间，您可以运行 `mysql.rds_set_configuration` 过程并设置该参数。在 `mysql.rds_start_replication_until` 或 `mysql.rds_start_replication_until_gtid` 过程停止复制后，您可以使用[将只读副本提升为独立的数据库实例](USER_ReadRepl.Promote.md)中的说明将只读副本提升为新的主数据库实例。
要使用 `mysql.rds_rds_start_replication_until_gtid` 过程，必须启用基于 GTID 的复制。要跳过已知会导致灾难的特定基于 GTID 的事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) 存储过程。有关使用基于 GTID 的复制的更多信息，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。
要指定 Amazon RDS 延迟只读副本的复制的秒数，请使用 `mysql.rds_set_configuration` 存储过程并指定要延迟复制的秒数。以下示例指定至少一个小时（3600 秒）内延迟复制。
`call mysql.rds_set_configuration('target delay', 3600);`
`target delay` 参数的限制为一天（86400 秒）。
## mysql.rds\$1show\$1configuration
保留二进制日志的小时数。
### 语法
```
CALL mysql.rds_show_configuration;
```
### 使用说明
要验证 Amazon RDS 保留二进制日志的小时数，请使用 `mysql.rds_show_configuration` 存储过程。
### 示例
以下示例显示了保留期：
```
call mysql.rds_show_configuration;
name value description
binlog retention hours 24 binlog retention hours specifies the duration in hours before binary logs are automatically deleted.
```
# 预热 InnoDB 缓存
以下存储过程在 RDS for MySQL 数据库实例上保存、加载或取消加载 InnoDB 缓冲池。有关更多信息，请参阅 [Amazon RDS 上 MySQL 的 InnoDB 缓存预热](MySQL.Concepts.FeatureSupport.md#MySQL.Concepts.InnoDBCacheWarming)。
**Topics**
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now
](#mysql_rds_innodb_buffer_pool_dump_now)
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
](#mysql_rds_innodb_buffer_pool_load_abort)
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
](#mysql_rds_innodb_buffer_pool_load_now)
## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now
将缓冲池的当前状态转储到磁盘。
### 语法
```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```
### 使用说明
主用户必须运行 `mysql.rds_innodb_buffer_pool_dump_now` 过程。
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
在运行期间取消加载保存的缓冲池状态。
### 语法
```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```
### 使用说明
主用户必须运行 `mysql.rds_innodb_buffer_pool_load_abort` 过程。
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
从磁盘加载保存的缓冲池状态。
### 语法
```
CALL mysql.rds_innodb_buffer_pool_load_now();
```
### 使用说明
主用户必须运行 `mysql.rds_innodb_buffer_pool_load_now` 过程。