# RDS for MySQL 存储过程参考
<a name="Appendix.MySQL.SQLRef"></a>

这些主题介绍对于运行 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)

# 收集和维护全局状态历史记录
<a name="mysql-stored-proc-gsh"></a>

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
<a name="mysql_rds_collect_global_status_history"></a>

按需为全局状态历史记录创建快照。

### 语法
<a name="rds_collect_global_status_history-syntax"></a>

 

```
CALL mysql.rds_collect_global_status_history;
```

## mysql.rds\$1disable\$1gsh\$1collector
<a name="mysql_rds_disable_gsh_collector"></a>

关闭全局状态历史记录创建的快照。

### 语法
<a name="mysql_rds_disable_gsh_collector-syntax"></a>

 

```
CALL mysql.rds_disable_gsh_collector;
```

## mysql.rds\$1disable\$1gsh\$1rotation
<a name="mysql_rds_disable_gsh_rotation"></a>

关闭 `mysql.global_status_history` 表的交替。

### 语法
<a name="mysql_rds_disable_gsh_rotation-syntax"></a>

 

```
CALL mysql.rds_disable_gsh_rotation;
```

## mysql.rds\$1enable\$1gsh\$1collector
<a name="mysql_rds_enable_gsh_collector"></a>

开启全局状态历史记录，以 `rds_set_gsh_collector` 指定的间隔创建原定设置快照。

### 语法
<a name="mysql_rds_enable_gsh_collector-syntax"></a>

 

```
CALL mysql.rds_enable_gsh_collector;
```

## mysql.rds\$1enable\$1gsh\$1rotation
<a name="mysql_rds_enable_gsh_rotation"></a>

按照 `rds_set_gsh_rotation` 指定的间隔，开启将 `mysql.global_status_history` 表的内容交替到 `mysql.global_status_history_old`

### 语法
<a name="mysql_rds_enable_gsh_rotation-syntax"></a>

 

```
CALL mysql.rds_enable_gsh_rotation;
```

## mysql.rds\$1rotate\$1global\$1status\$1history
<a name="mysql_rds_rotate_global_status_history"></a>

根据需求将 `mysql.global_status_history` 表的内容交替到 `mysql.global_status_history_old`。

### 语法
<a name="mysql_rds_rotate_global_status_history-syntax"></a>

 

```
CALL mysql.rds_rotate_global_status_history;
```

## mysql.rds\$1set\$1gsh\$1collector
<a name="mysql_rds_set_gsh_collector"></a>

指定全局状态历史记录创建的快照之间的间隔，以分钟为单位。

### 语法
<a name="mysql_rds_set_gsh_collector-syntax"></a>

 

```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```

### 参数
<a name="mysql_rds_set_gsh_collector-parameters"></a>

 *intervalPeriod*   
快照之间的间隔，以分钟为单位。默认值为 `5`。

## mysql.rds\$1set\$1gsh\$1rotation
<a name="mysql_rds_set_gsh_rotation"></a>

指定 `mysql.global_status_history` 表轮换之间的间隔，以天为单位。

### 语法
<a name="mysql_rds_set_gsh_rotation-syntax"></a>

 

```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```

### 参数
<a name="mysql_rds_set_gsh_rotation-parameters"></a>

 *intervalPeriod*   
表轮换之间的间隔，以天为单位。默认值为 `7`。

# 配置、启动和停止二进制日志（binlog）复制
<a name="mysql-stored-proc-replicating"></a>

以下存储过程控制事务如何从外部数据库复制到 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 及更低版本）
<a name="mysql_rds_next_master_log"></a>

将源数据库实例日志位置更改为源数据库实例上的下一个二进制日志的开始位置。只有在只读副本上收到复制 I/O 错误 1236 时，才能使用该过程。

### 语法
<a name="mysql_rds_next_master_log-syntax"></a>

 

```
CALL mysql.rds_next_master_log(
curr_master_log
);
```

### 参数
<a name="mysql_rds_next_master_log-parameters"></a>

 *curr\$1master\$1log*   
当前主日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。若要确定当前主日志文件名，请运行 `SHOW REPLICA STATUS` 命令并查看 `Master_Log_File` 字段。

### 使用说明
<a name="mysql_rds_next_master_log-usage-notes"></a>

主用户必须运行 `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)。

### 示例
<a name="mysql_rds_next_master_log-examples"></a>

假设复制在 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 及更高版本）
<a name="mysql_rds_next_source_log"></a>

将源数据库实例日志位置更改为源数据库实例上的下一个二进制日志的开始位置。只有在只读副本上收到复制 I/O 错误 1236 时，才能使用该过程。

### 语法
<a name="mysql_rds_next_source_log-syntax"></a>

 

```
CALL mysql.rds_next_source_log(
curr_source_log
);
```

### 参数
<a name="mysql_rds_next_source_log-parameters"></a>

 *curr\$1source\$1log*   
当前源日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。要确定当前源日志文件名，请运行 `SHOW REPLICA STATUS` 命令并查看 `Source_Log_File` 字段。

### 使用说明
<a name="mysql_rds_next_source_log-usage-notes"></a>

管理用户必须运行 `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)。

### 示例
<a name="mysql_rds_next_source_log-examples"></a>

假设复制在 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 及更低版本）
<a name="mysql_rds_reset_external_master"></a>

重新配置 RDS for MySQL 数据库实例，使其不再是在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_reset_external_master-syntax"></a>

 

```
CALL mysql.rds_reset_external_master;
```

### 使用说明
<a name="mysql_rds_reset_external_master-usage-notes"></a>

主用户必须运行 `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 及更高版本）
<a name="mysql_rds_reset_external_source"></a>

重新配置 RDS for MySQL 数据库实例，使其不再是在 Amazon RDS 之外运行的某个 MySQL 实例的只读副本。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_reset_external_source-syntax"></a>

 

```
CALL mysql.rds_reset_external_source;
```

### 使用说明
<a name="mysql_rds_reset_external_source-usage-notes"></a>

管理用户必须运行 `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 及更低版本）
<a name="mysql_rds_set_external_master"></a>

将 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) 存储过程配置外部源数据库实例和延迟复制。

### 语法
<a name="mysql_rds_set_external_master-syntax"></a>

 

```
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
);
```

### 参数
<a name="mysql_rds_set_external_master-parameters"></a>

 *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，这意味着连接已加密，但未验证证书。

### 使用说明
<a name="mysql_rds_set_external_master-usage-notes"></a>

主用户必须运行 `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` 表中。

### 示例
<a name="mysql_rds_set_external_master-examples"></a>

在 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 及更高版本）
<a name="mysql_rds_set_external_source"></a>

将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_source-syntax"></a>

 

```
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
);
```

### 参数
<a name="mysql_rds_set_external_source-parameters"></a>

 *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，这意味着连接已加密，但未验证证书。

### 使用说明
<a name="mysql_rds_set_external_source-usage-notes"></a>

管理用户必须运行 `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` 表中。

### 示例
<a name="mysql_rds_set_external_source-examples"></a>

在 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 及更低版本）
<a name="mysql_rds_set_external_master_with_auto_position"></a>

将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。该过程还会配置延迟复制和基于全局事务标识符 (GTID) 的复制。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_master_with_auto_position-syntax"></a>

 

```
CALL mysql.rds_set_external_master_with_auto_position (
  host_name
  , host_port
  , replication_user_name
  , replication_user_password
  , ssl_encryption
  , delay
);
```

### 参数
<a name="mysql_rds_set_external_master_with_auto_position-parameters"></a>

 *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 秒）。

### 使用说明
<a name="mysql_rds_set_external_master_with_auto_position-usage-notes"></a>

主用户必须运行 `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)。

### 示例
<a name="mysql_rds_set_external_master_with_auto_position-examples"></a>

在 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 及更高版本）
<a name="mysql_rds_set_external_source_with_auto_position"></a>

将 RDS for MySQL 数据库实例配置为在 Amazon RDS 之外运行的 MySQL 实例的只读副本。该过程还会配置延迟复制和基于全局事务标识符 (GTID) 的复制。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_source_with_auto_position-syntax"></a>

 

```
CALL mysql.rds_set_external_source_with_auto_position (
  host_name
  , host_port
  , replication_user_name
  , replication_user_password
  , ssl_encryption
  , delay
);
```

### 参数
<a name="mysql_rds_set_external_source_with_auto_position-parameters"></a>

 *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 秒）。

### 使用说明
<a name="mysql_rds_set_external_source_with_auto_position-usage-notes"></a>

管理用户必须运行 `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)。

### 示例
<a name="mysql_rds_set_external_source_with_auto_position-examples"></a>

在 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 及更低版本）
<a name="mysql_rds_set_external_master_with_delay"></a>

将 RDS for MySQL 数据库实例配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本并配置延迟复制。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_master_with_delay-syntax"></a>

 

```
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
);
```

### 参数
<a name="mysql_rds_set_external_master_with_delay-parameters"></a>

 *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 秒）。

### 使用说明
<a name="mysql_rds_set_external_master_with_delay-usage-notes"></a>

 主用户必须运行 `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 版本

### 示例
<a name="mysql_rds_set_external_master_with_delay-examples"></a>

在 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 及更高版本）
<a name="mysql_rds_set_external_source_with_delay"></a>

将 RDS for MySQL 数据库实例配置为在 Amazon RDS 外部运行的 MySQL 实例的只读副本并配置延迟复制。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_source_with_delay-syntax"></a>

```
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
);
```

### 参数
<a name="mysql_rds_set_external_source_with_delay-parameters"></a>

 *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 秒）。

### 使用说明
<a name="mysql_rds_set_external_source_with_delay-usage-notes"></a>

管理用户必须运行 `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)。

### 示例
<a name="mysql_rds_set_external_master_with_delay-examples"></a>

在 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
<a name="mysql_rds_set_external_source_gtid_purged"></a>

使用来自外部源的指定 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)。

### 语法
<a name="mysql_rds_set_external_source_gtid_purged-syntax"></a>

 

```
CALL mysql.rds_set_external_source_gtid_purged(
  server_uuid
  , start_pos
  , end_pos
);
```

### 参数
<a name="mysql_rds_set_external_source_gtid_purged-parameters"></a>

 *server\$1uuid*   
从中导入 GTID 范围的外部服务器的通用唯一标识符（UUID）。

 *start\$1pos*   
要设置的 GTID 范围的起始位置。

 *end\$1pos*   
要设置的 GTID 范围的结束位置。

### 使用说明
<a name="mysql_rds_set_external_source_gtid_purged-usage-notes"></a>

`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` 存储过程来设置该值。

### 示例
<a name="mysql_rds_set_external_source_gtid_purged-examples"></a>

在 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 及更低版本）
<a name="mysql_rds_set_master_auto_position"></a>

将复制模式设置为基于二进制日志文件位置或全局事务标识符 (GTID)。

### 语法
<a name="mysql_rds_set_master_auto_position-syntax"></a>

 

```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```

### 参数
<a name="mysql_rds_set_master_auto_position-parameters"></a>

 *auto\$1position\$1mode*   
该值指示是使用日志文件位置复制还是基于 GTID 的复制：  
+ `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+ `1` – 使用基于 GTID 的复制方法。

### 使用说明
<a name="mysql_rds_set_master_auto_position-usage-notes"></a>

主用户必须运行 `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 及更高版本）
<a name="mysql_rds_set_source_auto_position"></a>

将复制模式设置为基于二进制日志文件位置或全局事务标识符 (GTID)。

### 语法
<a name="mysql_rds_set_source_auto_position-syntax"></a>

```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```

### 参数
<a name="mysql_rds_set_source_auto_position-parameters"></a>

*auto\$1position\$1mode*  
该值指示是使用日志文件位置复制还是基于 GTID 的复制：  
+  `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+  `1` – 使用基于 GTID 的复制方法。

### 使用说明
<a name="mysql_rds_set_source_auto_position-usage-notes"></a>

管理用户必须运行 `mysql.rds_set_source_auto_position` 过程。

## mysql.rds\$1set\$1source\$1delay
<a name="mysql_rds_set_source_delay"></a>

设置延迟从源数据库实例复制到当前只读副本的最小秒数。在您连接到只读副本时使用该过程来从其源数据库实例延迟复制。

### 语法
<a name="mysql_rds_set_source_delay-syntax"></a>

```
CALL mysql.rds_set_source_delay(
delay
);
```

### 参数
<a name="mysql_rds_set_source_delay-parameters"></a>

 *delay*   
延迟从源数据库实例复制的最小秒数。  
该参数的限制为一天（86400 秒）。

### 使用说明
<a name="mysql_rds_set_source_delay-usage-notes"></a>

主用户必须运行 `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 版本

### 示例
<a name="mysql_rds_set_source_delay-examples"></a>

要将从源数据库实例向当前只读副本的复制延迟至少一个小时（3600 秒），您可以使用以下参数调用 `mysql.rds_set_source_delay`：

```
CALL mysql.rds_set_source_delay(3600);
```

## mysql.rds\$1skip\$1repl\$1error
<a name="mysql_rds_skip_repl_error"></a>

跳过并删除 MySQL 数据库只读副本上的复制错误。

### 语法
<a name="mysql_rds_skip_repl_error-syntax"></a>

 

```
CALL mysql.rds_skip_repl_error;
```

### 使用说明
<a name="mysql_rds_skip_repl_error-usage-notes"></a>

主用户必须对只读副本运行 `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)。

#### 复制已停止错误
<a name="skip_repl_error.stopped-error"></a>

调用 `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
<a name="mysql_rds_start_replication"></a>

从 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 数据库实例中启动复制，并在指定的二进制日志文件位置停止复制。

### 语法
<a name="mysql_rds_start_replication-syntax"></a>

 

```
CALL mysql.rds_start_replication;
```

### 使用说明
<a name="mysql_rds_start_replication-usage-notes"></a>

主用户必须运行 `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
<a name="mysql_rds_start_replication_until"></a>

从 RDS for MySQL 数据库实例发起复制，并在指定的二进制日志文件位置停止复制。

### 语法
<a name="mysql_rds_start_replication_until-syntax"></a>

 

```
CALL mysql.rds_start_replication_until (
replication_log_file
  , replication_stop_point
);
```

### 参数
<a name="mysql_rds_start_replication_until-parameters"></a>

 *replication\$1log\$1file*   
源数据库实例上包含复制信息的二进制日志的名称。

 *replication\$1stop\$1point *   
`replication_log_file` 二进制日志中复制将停止的位置。

### 使用说明
<a name="mysql_rds_start_replication_until-usage-notes"></a>

主用户必须运行 `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` 参数指定位于过去的某个停止位置时，即会立即停止复制。

### 示例
<a name="mysql_rds_start_replication_until-examples"></a>

以下示例将启动复制并复制更改，直到它到达 `120` 二进制日志文件中的 `mysql-bin-changelog.000777` 位置。

```
call mysql.rds_start_replication_until(
  'mysql-bin-changelog.000777',
  120);
```

## mysql.rds\$1stop\$1replication
<a name="mysql_rds_stop_replication"></a>

停止从 MySQL 数据库实例中进行复制。

### 语法
<a name="mysql_rds_stop_replication-syntax"></a>

 

```
CALL mysql.rds_stop_replication;
```

### 使用说明
<a name="mysql_rds_stop_replication-usage-notes"></a>

主用户必须运行 `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)。

# 结束会话或查询
<a name="mysql-stored-proc-ending"></a>

以下存储过程结束会话或查询。

**Topics**
+ [

## mysql.rds\$1kill
](#mysql_rds_kill)
+ [

## mysql.rds\$1kill\$1query
](#mysql_rds_kill_query)

## mysql.rds\$1kill
<a name="mysql_rds_kill"></a>

结束与 MySQL 服务器的连接。

### 语法
<a name="mysql_rds_kill-syntax"></a>

```
CALL mysql.rds_kill(processID);
```

### 参数
<a name="mysql_rds_kill-parameters"></a>

 *processID*   
要结束的连接线程的标识。

### 使用说明
<a name="mysql_rds_kill-usage-notes"></a>

与 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)。

### 示例
<a name="mysql_rds_kill-examples"></a>

以下示例结束线程 ID 为 4243 的连接：

```
CALL mysql.rds_kill(4243);
```

## mysql.rds\$1kill\$1query
<a name="mysql_rds_kill_query"></a>

结束针对 MySQL 服务器运行的查询。

### 语法
<a name="mysql_rds_kill_query-syntax"></a>

```
CALL mysql.rds_kill_query(processID);
```

### 参数
<a name="mysql_rds_kill_query-parameters"></a>

 *processID*   
运行正要结束的查询的进程或线程的身份。

### 使用说明
<a name="mysql_rds_kill_query-usage-notes"></a>

要停止针对 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)。

### 示例
<a name="mysql_rds_kill_query-examples"></a>

以下示例停止查询线程 ID 为 230040 的查询：

```
CALL mysql.rds_kill_query(230040);
```

# 管理主动-主动集群
<a name="mysql-stored-proc-active-active-clusters"></a>

以下存储过程用于设置和管理 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
<a name="mysql_rds_group_replication_advance_gtid"></a>

在当前数据库实例上创建占位符 GTID。

### 语法
<a name="mysql_rds_group_replication_advance_gtid-syntax"></a>

```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```

### 参数
<a name="mysql_rds_group_replication_advance_gtid-parameters"></a>

 *begin\$1id*   
要创建的开始事务 ID。

 *end\$1id*   
要创建的结束事务 ID。

 *begin\$1id*   
要创建的事务的 `group_replication_group_name`。在与数据库实例关联的数据库参数组中将 `group_replication_group_name` 指定为 UUID。

### 使用说明
<a name="mysql_rds_group_replication_advance_gtid-usage-notes"></a>

在主动-主动集群中，要使数据库实例加入组，在新数据库实例上执行的所有 GTID 事务都必须存在于集群中的其它成员上。在不寻常的情况下，在将实例加入组之前执行事务时，新的数据库实例可能会有更多的事务。在这种情况下，您无法移除任何现有事务，但您可以使用此过程在组中的其它数据库实例上创建相应的占位符 GTID。在执行此操作之前，请验证事务*不会影响复制的数据*。

当您调用此过程时，将创建 `server_uuid:begin_id-end_id` 的 GTID 事务，但内容为空。为避免复制问题，请勿在任何其它条件下使用此过程。

**重要**  
避免在主动-主动集群运行正常时调用此过程。除非您了解正在创建的事务可能产生的后果，否则不要调用此过程。调用此过程可能会导致数据不一致。

### 示例
<a name="mysql_rds_group_replication_advance_gtid-examples"></a>

以下示例在当前数据库实例上创建占位符 GTID：

```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```

## mysql.rds\$1group\$1replication\$1create\$1user
<a name="mysql_rds_group_replication_create_user"></a>

为数据库实例上的组复制创建复制用户 `rdsgrprepladmin`。

### 语法
<a name="mysql_rds_group_replication_create_user-syntax"></a>

```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```

### 参数
<a name="mysql_rds_group_replication_create_user-parameters"></a>

 *replication\$1user\$1password*   
复制用户 `rdsgrprepladmin` 的密码。

### 使用说明
<a name="mysql_rds_group_replication_create_user-usage-notes"></a>
+ 在主动-主动集群中的所有数据库实例上，复制用户 `rdsgrprepladmin` 的密码必须相同。
+ `rdsgrprepladmin` 用户名保留用于组复制连接。任何其他用户（包括主用户）都不能拥有此用户名。

### 示例
<a name="mysql_rds_group_replication_create_user-examples"></a>

以下示例为数据库实例上的组复制创建复制用户 `rdsgrprepladmin`：

```
CALL mysql.rds_group_replication_create_user('password');
```

## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
<a name="mysql_rds_group_replication_set_recovery_channel"></a>

设置主动-主动集群的 `group_replication_recovery` 通道。该过程使用保留的 `rdsgrprepladmin` 用户来配置通道。

### 语法
<a name="mysql_rds_group_replication_set_recovery_channel-syntax"></a>

```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```

### 参数
<a name="mysql_rds_group_replication_set_recovery_channel-parameters"></a>

 *replication\$1user\$1password*   
复制用户 `rdsgrprepladmin` 的密码。

### 使用说明
<a name="mysql_rds_group_replication_set_recovery_channel-usage-notes"></a>

在主动-主动集群中的所有数据库实例上，复制用户 `rdsgrprepladmin` 的密码必须相同。调用 `mysql.rds_group_replication_create_user` 可指定密码。

### 示例
<a name="mysql_rds_group_replication_set_recovery_channel-examples"></a>

以下示例为主动-主动集群设置 `group_replication_recovery` 通道：

```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```

## mysql.rds\$1group\$1replication\$1start
<a name="mysql_rds_group_replication_start"></a>

在当前数据库实例上启动组复制。

### 语法
<a name="mysql_rds_group_replication_start-syntax"></a>

```
CALL mysql.rds_group_replication_start(
bootstrap
);
```

### 参数
<a name="mysql_rds_group_replication_start-parameters"></a>

 *bootstrap*   
一个值，它指定是初始化新组还是加入现有组。值为 `1` 时，将使用当前数据库实例初始化新组。值为 `0` 时，将通过连接到在与当前数据库实例关联的数据库参数组的 `group_replication_group_seeds` 参数中定义的端点，将该数据库实例加入到现有组。

### 示例
<a name="mysql_rds_group_replication_start-examples"></a>

以下示例使用当前数据库实例初始化新组：

```
CALL mysql.rds_group_replication_start(1);
```

## mysql.rds\$1group\$1replication\$1stop
<a name="mysql_rds_group_replication_stop"></a>

在当前数据库实例上停止组复制。

### 语法
<a name="mysql_rds_group_replication_stop-syntax"></a>

```
CALL mysql.rds_group_replication_stop();
```

### 使用说明
<a name="mysql_rds_group_replication_stop-usage-notes"></a>

当您在数据库实例上停止复制时，它不会影响主动-主动集群中的任何其它数据库实例。

# 管理多源复制
<a name="mysql-stored-proc-multi-source-replication"></a>

以下存储过程在 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
<a name="mysql_rds_next_source_log_for_channel"></a>

将源数据库实例日志位置更改为通道的源数据库实例上下一个二进制日志的开始位置。只有在多源副本上收到复制 I/O 错误 1236 时，才能使用该过程。

### 语法
<a name="mysql_rds_next_source_log_for_channel-syntax"></a>

 

```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name           
);
```

### 参数
<a name="mysql_rds_next_source_log_for_channel-parameters"></a>

 *curr\$1master\$1log*  
当前源日志文件的索引。例如，如果当前文件名为 `mysql-bin-changelog.012345`，则索引为 12345。要确定当前源日志文件名，请运行 `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` 命令并查看 `Source_Log_File` 字段。

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_next_source_log_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_next_source_log_for_channel` 过程。例如，如果出现 IO\$1Thread 错误，则可以使用此过程跳过当前二进制日志文件中的所有事件，并从在 `channel_name` 中指定的通道的下一个二进制日志文件中恢复复制。

### 示例
<a name="mysql_rds_group_replication_advance_gtid-examples"></a>

假设在多源副本的通道上复制失败。对多源副本运行 `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
<a name="mysql_rds_reset_external_source_for_channel"></a>

停止指定通道上的复制过程，并从多源副本中移除该通道和关联的配置。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_reset_external_source_for_channel-syntax"></a>



```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```

### 参数
<a name="mysql_rds_reset_external_source_for_channel-parameters"></a>

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_reset_external_source_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_reset_external_source_for_channel` 过程。此过程将删除属于要移除的通道的所有中继日志。

## mysql.rds\$1set\$1external\$1source\$1for\$1channel
<a name="mysql_rds_set_external_source_for_channel"></a>

在 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) 存储过程为该通道配置延迟复制。

### 语法
<a name="mysql_rds_set_external_source_for_channel-syntax"></a>



```
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
);
```

### 参数
<a name="mysql_rds_set_external_source_for_channel-parameters"></a>

 *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 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_set_external_source_for_channel-usage-notes"></a>

 主用户必须运行 `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` 表中，并包含通道名称。此信息仅用于内部使用和监控目的。要记录完整的过程调用以进行审核，请考虑根据应用程序的特定要求启用审核日志或常规日志。

### 示例
<a name="mysql_rds_set_external_source_for_channel-examples"></a>

在 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
<a name="mysql_rds_set_external_source_with_auto_position_for_channel"></a>

在 RDS for MySQL 数据库实例上配置一个复制通道，复制延迟为可选项。复制基于全局事务标识符（GTID）。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_master_with_auto_position_for_channel-syntax"></a>

 

```
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
);
```

### 参数
<a name="mysql_rds_set_external_master_with_auto_position_for_channel-parameters"></a>

 *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 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_set_external_master_with_auto_position_for_channel-usage-notes"></a>

主用户必须运行 `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) 以停止通道上的复制，并从副本中移除通道配置。

### 示例
<a name="mysql_rds_set_external_master_with_auto_position_for_channel-examples"></a>

在 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
<a name="mysql_rds_set_external_source_with_delay_for_channel"></a>

在 RDS for MySQL 数据库实例上配置一个具有指定复制延迟的复制通道。

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon RDS 中修改数据库参数组中的参数](USER_WorkingWithParamGroups.Modifying.md)。

### 语法
<a name="mysql_rds_set_external_source_with_delay_for_channel-syntax"></a>

 

```
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
);
```

### 参数
<a name="mysql_rds_set_external_source_with_delay_for_channel-parameters"></a>

 *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 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_set_external_source_with_delay_for_channel-usage-notes"></a>

主用户必须运行 `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` 表中，并包含通道名称。此信息仅用于内部使用和监控目的。要记录完整的过程调用以进行审核，请考虑根据应用程序的特定要求启用审核日志或常规日志。

### 示例
<a name="mysql_rds_set_external_source_with_delay_for_channel-examples"></a>

在 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
<a name="mysql_rds_set_source_auto_position_for_channel"></a>

将指定通道的复制模式设置为基于二进制日志文件位置或全局事务标识符（GTID）。

### 语法
<a name="mysql_rds_set_source_auto_position_for_channel-syntax"></a>

 

```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
 , channel_name
);
```

### 参数
<a name="mysql_rds_set_source_auto_position_for_channel-parameters"></a>

 *auto\$1position\$1mode*   
该值指示是使用日志文件位置复制还是基于 GTID 的复制：  
+ `0` – 使用基于二进制日志文件位置的复制方法。默认为 `0`。
+ `1` – 使用基于 GTID 的复制方法。

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_set_source_auto_position_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_set_source_auto_position_for_channel` 过程。此过程在指定的通道上重启复制，以应用指定的自动定位模式。

### 示例
<a name="mysql_rds_set_source_auto_position_for_channel-examples"></a>

以下示例将 channel\$11 的自动定位模式设置为使用基于 GTID 的复制方法。

```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```

## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
<a name="mysql_rds_set_source_delay_for_channel"></a>

为指定的通道设置延迟从源数据库实例复制到多源副本的最小秒数。

### 语法
<a name="mysql_rds_set_source_delay_for_channel-syntax"></a>

```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```

### 参数
<a name="mysql_rds_set_source_delay_for_channel-parameters"></a>

 *delay*   
延迟从源数据库实例进行复制的最小秒数。  
该参数的限制为一天（86400 秒）。

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_set_source_delay_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_set_source_delay_for_channel` 过程。要使用此过程，请首先调用 `mysql.rds_stop_replication_for_channel` 以停止复制。然后，调用此过程来设置复制延迟值。设置延迟后，调用 `mysql.rds_start_replication_for_channel` 以重启复制。

### 示例
<a name="mysql_rds_set_source_delay_for_channel-examples"></a>

以下示例将从多源副本的 `channel_1` 上的源数据库实例进行复制的延迟设置为至少一小时（3600 秒）。

```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```

## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
<a name="mysql_rds_skip_repl_error_for_channel"></a>

跳过二进制日志事件并删除指定通道的 MySQL DB 多源副本上的复制错误。

### 语法
<a name="mysql_rds_skip_repl_error_for_channel-syntax"></a>

 

```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```

### 参数
<a name="mysql_rds_skip_repl_error_for_channel-parameters"></a>

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_skip_repl_error_for_channel-usage-notes"></a>

主用户必须对只读副本运行 `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
<a name="mysql_rds_start_replication_for_channel"></a>

在指定的通道上发起从 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 数据库实例中启动复制，并在指定的二进制日志文件位置停止复制。

### 语法
<a name="mysql_rds_start_replication_for_channel-syntax"></a>

 

```
CALL mysql.rds_start_replication_for_channel(channel_name);
```

### 参数
<a name="mysql_rds_start_replication_for_channel-parameters"></a>

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_start_replication_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_start_replication_for_channel` 过程。从源 RDS for MySQL 数据库实例导入数据后，在多源副本上运行此命令以在指定的通道上开始复制。

### 示例
<a name="mysql_rds_start_replication_for_channel-examples"></a>

以下示例开始在多源副本的 `channel_1` 上进行复制。

```
CALL mysql.rds_start_replication_for_channel('channel_1');
```

## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
<a name="mysql_rds_start_replication_until_for_channel"></a>

在指定的通道上从 RDS for MySQL 数据库实例启动复制，并在指定的二进制日志文件位置停止复制。

### 语法
<a name="mysql_rds_start_replication_until_for_channel-syntax"></a>

 

```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
  , replication_stop_point
  , channel_name
);
```

### 参数
<a name="mysql_rds_start_replication_until_for_channel-parameters"></a>

 *replication\$1log\$1file*   
源数据库实例上包含复制信息的二进制日志的名称。

 *replication\$1stop\$1point *   
`replication_log_file` 二进制日志中复制将停止的位置。

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_start_replication_until_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_start_replication_until_for_channel` 过程。通过此过程，复制将启动，然后在达到指定的二进制日志文件位置时停止。此过程会同时停止 `SQL_THREAD` 和 `IO_THREAD`。

为 `replication_log_file` 参数指定的文件名必须与源数据库实例二进制日志文件名匹配。

当 `replication_stop_point` 参数指定过去的某个停止位置时，即会立即停止复制。

### 示例
<a name="mysql_rds_start_replication_until_for_channel-examples"></a>

以下示例在 `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
<a name="mysql_rds_start_replication_until_gtid_for_channel"></a>

在指定的通道上从 RDS for MySQL 数据库实例中启动复制，并在指定的全局事务标识符（GTID）处停止复制。

### 语法
<a name="mysql_rds_start_replication_until_gtid_for_channel-syntax"></a>

 

```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```

### 参数
<a name="mysql_rds_start_replication_until_gtid_for_channel-parameters"></a>

 *gtid*   
在其之后停止复制的 GTID。

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_start_replication_until_gtid_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_start_replication_until_gtid_for_channel` 过程。该过程在指定的通道上启动复制并应用所有更改，直至指定的 GTID 值。然后，它在该通道上停止复制。

在 `gtid` 参数指定副本已运行的事务时，将会立即停止复制。

在运行此过程之前，必须通过将 `replica_parallel_workers` 或 `slave_parallel_workers` 的值设置为 `0` 来禁用多线程复制。

### 示例
<a name="mysql_rds_start_replication_until_gtid_for_channel-examples"></a>

以下示例在 `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
<a name="mysql_rds_stop_replication_for_channel"></a>

停止在指定的通道上从 MySQL 数据库实例进行复制。

### 语法
<a name="mysql_rds_stop_replication_for_channel-syntax"></a>

 

```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```

### 参数
<a name="mysql_rds_stop_replication_for_channel-parameters"></a>

 *channel\$1name*   
多源副本上复制通道的名称。每个复制通道接收来自在特定主机和端口上运行的单个源 RDS for MySQL 数据库实例的二进制日志事件。

### 使用说明
<a name="mysql_rds_stop_replication_for_channel-usage-notes"></a>

主用户必须运行 `mysql.rds_stop_replication_for_channel` 过程。

### 示例
<a name="mysql_rds_stop_replication_for_channel-examples"></a>

以下示例停止在多源副本的 `channel_1` 上进行复制。

```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```

# 使用 GTID 复制事务
<a name="mysql-stored-proc-gtid"></a>

以下存储过程控制如何使用 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
<a name="mysql_rds_skip_transaction_with_gtid"></a>

在 MySQL 数据库实例上跳过复制具有指定全局事务标识符 (GTID) 的事务。

在已知特定 GTID 事务导致问题时，您可以使用该过程进行灾难恢复。请使用该存储过程跳过有问题的事务。有问题的事务示例包括禁用复制、删除重要数据或导致数据库实例变得不可用的事务。

### 语法
<a name="mysql_rds_skip_transaction_with_gtid-syntax"></a>

 

```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```

### 参数
<a name="mysql_rds_skip_transaction_with_gtid-parameters"></a>

 *gtid\$1to\$1skip*   
要跳过的复制事务的 GTID。

### 使用说明
<a name="mysql_rds_skip_transaction_with_gtid-usage-notes"></a>

主用户必须运行 `mysql.rds_skip_transaction_with_gtid` 过程。

所有 RDS for MySQL 5.7 版本、所有 RDS for MySQL 8.0 版本和所有 RDS for MySQL 8.4 版本均支持此过程。

### 示例
<a name="mysql_rds_skip_transaction_with_gtid-examples"></a>

以下示例将跳过复制具有 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
<a name="mysql_rds_start_replication_until_gtid"></a>

从 RDS for MySQL 数据库实例中启动复制，并在指定的全局事务标识符（GTID）后面立即停止复制。

### 语法
<a name="mysql_rds_start_replication_until_gtid-syntax"></a>

 

```
CALL mysql.rds_start_replication_until_gtid(gtid);
```

### 参数
<a name="mysql_rds_start_replication_until_gtid-parameters"></a>

 *gtid*   
停止复制前的 GTID。

### 使用说明
<a name="mysql_rds_start_replication_until_gtid-usage-notes"></a>

主用户必须运行 `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` 参数指定副本已运行的事务时，将会立即停止复制。

### 示例
<a name="mysql_rds_start_replication_until_gtid-examples"></a>

以下示例启动复制并复制更改，直至到达 GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`。

```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```

# 轮换查询日志
<a name="mysql-stored-proc-logging"></a>

以下存储过程将 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
<a name="mysql_rds_rotate_general_log"></a>

将 `mysql.general_log` 表轮换到备份表。

### 语法
<a name="mysql_rds_rotate_general_log-syntax"></a>

 

```
CALL mysql.rds_rotate_general_log;
```

### 使用说明
<a name="mysql_rds_rotate_general_log-usage-notes"></a>

您可以通过调用 `mysql.general_log` 过程将 `mysql.rds_rotate_general_log` 表轮换到备份表。轮换日志表时，会将当前日志表复制到备份日志表，随后删除当前日志表中的条目。如果备份日志表已存在，则先将其删除，然后将当前日志表复制到备份。如果需要，您可以查询备份日志表。`mysql.general_log` 表的备份日志表名为 `mysql.general_log_backup`。

只有当 `log_output` 参数设置为 `TABLE` 时，您才能运行此过程。

## mysql.rds\$1rotate\$1slow\$1log
<a name="mysql_rds_rotate_slow_log"></a>

将 `mysql.slow_log` 表轮换到备份表。

### 语法
<a name="mysql_rds_rotate_slow_log-syntax"></a>

 

```
CALL mysql.rds_rotate_slow_log;
```

### 使用说明
<a name="mysql_rds_rotate_slow_log-usage-notes"></a>

您可以通过调用 `mysql.slow_log` 过程将 `mysql.rds_rotate_slow_log` 表轮换到备份表。轮换日志表时，会将当前日志表复制到备份日志表，随后删除当前日志表中的条目。如果备份日志表已存在，则先将其删除，然后将当前日志表复制到备份。

如果需要，您可以查询备份日志表。`mysql.slow_log` 表的备份日志表名为 `mysql.slow_log_backup`。

# 设置和显示二进制日志配置
<a name="mysql-stored-proc-configuring"></a>

以下存储过程设置和显示配置参数，例如用于二进制日志文件保留。

**Topics**
+ [

## mysql.rds\$1set\$1configuration
](#mysql_rds_set_configuration)
+ [

## mysql.rds\$1show\$1configuration
](#mysql_rds_show_configuration)

## mysql.rds\$1set\$1configuration
<a name="mysql_rds_set_configuration"></a>

指定要保留二进制日志的小时数或要延迟复制的秒数。

### 语法
<a name="mysql_rds_set_configuration-syntax"></a>

 

```
CALL mysql.rds_set_configuration(name,value);
```

### 参数
<a name="mysql_rds_set_configuration-parameters"></a>

 *name*   
要设置的配置参数的名称。

 *值*   
配置参数的值。

### 使用说明
<a name="mysql_rds_set_configuration-usage-notes"></a>

`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)

配置参数将永久存储，可在任何数据库实例重启或失效转移后继续使用。

#### 二进制日志保留小时数
<a name="mysql_rds_set_configuration-usage-notes.binlog-retention-hours"></a>

`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 卷。但是，最新的日志仍保留在本地存储中，因此，如果出现需要更换主机的故障，或者您纵向扩展或缩减数据库，这些日志可能会丢失。

#### 源延迟
<a name="mysql_rds_set_configuration-usage-notes.source-delay"></a>

使用只读副本中的 `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
<a name="mysql_rds_set_configuration-usage-notes.target-delay"></a>

使用 `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
<a name="mysql_rds_show_configuration"></a>

保留二进制日志的小时数。

### 语法
<a name="mysql_rds_show_configuration-syntax"></a>

 

```
CALL mysql.rds_show_configuration;
```

### 使用说明
<a name="mysql_rds_show_configuration-usage-notes"></a>

要验证 Amazon RDS 保留二进制日志的小时数，请使用 `mysql.rds_show_configuration` 存储过程。

### 示例
<a name="mysql_rds_show_configuration-examples"></a>

以下示例显示了保留期：

```
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 缓存
<a name="mysql-stored-proc-warming"></a>

以下存储过程在 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
<a name="mysql_rds_innodb_buffer_pool_dump_now"></a>

将缓冲池的当前状态转储到磁盘。

### 语法
<a name="mysql_rds_innodb_buffer_pool_dump_now-syntax"></a>

 

```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```

### 使用说明
<a name="mysql_rds_innodb_buffer_pool_dump_now-usage"></a>

主用户必须运行 `mysql.rds_innodb_buffer_pool_dump_now` 过程。

## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
<a name="mysql_rds_innodb_buffer_pool_load_abort"></a>

在运行期间取消加载保存的缓冲池状态。

### 语法
<a name="mysql_rds_innodb_buffer_pool_load_abort-syntax"></a>

 

```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```

### 使用说明
<a name="mysql_rds_innodb_buffer_pool_load_abort-usage"></a>

主用户必须运行 `mysql.rds_innodb_buffer_pool_load_abort` 过程。

## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
<a name="mysql_rds_innodb_buffer_pool_load_now"></a>

从磁盘加载保存的缓冲池状态。

### 语法
<a name="mysql_rds_innodb_buffer_pool_load_now-syntax"></a>

 

```
CALL mysql.rds_innodb_buffer_pool_load_now();
```

### 使用说明
<a name="mysql_rds_innodb_buffer_pool_load_now-usage"></a>

主用户必须运行 `mysql.rds_innodb_buffer_pool_load_now` 过程。