# Aurora MySQL 存储过程参考
<a name="AuroraMySQL.Reference.StoredProcs"></a>

您可以通过调用内置的存储过程管理 Aurora MySQL 数据库集群。

**Topics**
+ [

# 收集和维护全局状态历史记录
](mysql-stored-proc-gsh.md)
+ [

# 配置、启动和停止二进制日志（binlog）复制
](mysql-stored-proc-replicating.md)
+ [

# 结束会话或查询
](mysql-stored-proc-ending.md)
+ [

# 使用 GTID 复制事务
](mysql-stored-proc-gtid.md)
+ [

# 轮换查询日志
](mysql-stored-proc-logging.md)
+ [

# 设置和显示二进制日志配置
](mysql-stored-proc-configuring.md)

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

Amazon RDS 提供了一组过程，这些过程可以随时间推移对状态变量的值创建快照，并将它们及上次创建快照后所做的任何更改写入一个表中。该基础设施称为全局状态历史记录。有关更多信息，请参阅[管理全局状态历史记录](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.CommonDBATasks.html#Appendix.MySQL.CommonDBATasks.GoSH)。

以下存储过程管理全局状态历史记录的收集和维护方式。

**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>

您可以在连接到 Aurora MySQL 集群中的主实例时，调用以下存储过程。这些过程控制事务如何从外部数据库复制到 Aurora MySQL，或从 Aurora MySQL 复制到外部数据库。

**Topics**
+ [

## mysql.rds\$1disable\$1session\$1binlog（Aurora MySQL 版本 2）
](#mysql_rds_disable_session_binlog)
+ [

## mysql.rds\$1enable\$1session\$1binlog（Aurora MySQL 版本 2）
](#mysql_rds_enable_session_binlog)
+ [

## mysql.rds\$1import\$1binlog\$1ssl\$1material
](#mysql_rds_import_binlog_ssl_material)
+ [

## mysql.rds\$1next\$1master\$1log（Aurora MySQL 版本 2）
](#mysql_rds_next_master_log)
+ [

## mysql.rds\$1next\$1source\$1log（Aurora MySQL 版本 3）
](#mysql_rds_next_source_log)
+ [

## mysql.rds\$1remove\$1binlog\$1ssl\$1material
](#mysql_rds_remove_binlog_ssl_material)
+ [

## mysql.rds\$1reset\$1external\$1master（Aurora MySQL 版本 2）
](#mysql_rds_reset_external_master)
+ [

## mysql.rds\$1reset\$1external\$1source（Aurora MySQL 版本 3）
](#mysql_rds_reset_external_source)
+ [

## mysql.rds\$1set\$1binlog\$1source\$1ssl（Aurora MySQL 版本 3）
](#mysql_rds_set_binlog_source_ssl)
+ [

## mysql.rds\$1set\$1external\$1master（Aurora MySQL 版本 2）
](#mysql_rds_set_external_master)
+ [

## mysql.rds\$1set\$1external\$1source（Aurora MySQL 版本 3）
](#mysql_rds_set_external_source)
+ [

## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position（Aurora MySQL 版本 2）
](#mysql_rds_set_external_master_with_auto_position)
+ [

## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（Aurora MySQL 版本 3）
](#mysql_rds_set_external_source_with_auto_position)
+ [

## mysql.rds\$1set\$1master\$1auto\$1position（Aurora MySQL 版本 2）
](#mysql_rds_set_master_auto_position)
+ [

## mysql.rds\$1set\$1read\$1only（Aurora MySQL 版本 3）
](#mysql_rds_set_read_only)
+ [

## mysql.rds\$1set\$1session\$1binlog\$1format（Aurora MySQL 版本 2）
](#mysql_rds_set_session_binlog_format)
+ [

## mysql.rds\$1set\$1source\$1auto\$1position（Aurora MySQL 版本 3）
](#mysql_rds_set_source_auto_position)
+ [

## mysql.rds\$1skip\$1repl\$1error
](#mysql_rds_skip_repl_error)
+ [

## mysql.rds\$1start\$1replication
](#mysql_rds_start_replication)
+ [

## mysql.rds\$1start\$1replication\$1until（Aurora MySQL 版本 3）
](#mysql_rds_start_replication_until)
+ [

## mysql.rds\$1stop\$1replication
](#mysql_rds_stop_replication)

## mysql.rds\$1disable\$1session\$1binlog（Aurora MySQL 版本 2）
<a name="mysql_rds_disable_session_binlog"></a>

通过将 `sql_log_bin` 变量设置为 `OFF` 来关闭当前会话的二进制日志记录。

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

```
CALL mysql.rds_disable_session_binlog;
```

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

无

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

对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

对于 Aurora，Aurora MySQL 版本 2.12 及更高的与 MySQL 5.7 兼容的版本支持此过程。

**注意**  
在 Aurora MySQL 版本 3 中，如果您具有 `SESSION_VARIABLES_ADMIN` 权限，则可以使用以下命令禁用当前会话的二进制日志记录：  

```
SET SESSION sql_log_bin = OFF;
```

## mysql.rds\$1enable\$1session\$1binlog（Aurora MySQL 版本 2）
<a name="mysql_rds_enable_session_binlog"></a>

通过将 `sql_log_bin` 变量设置为 `ON` 来开启当前会话的二进制日志记录。

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

```
CALL mysql.rds_enable_session_binlog;
```

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

无

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

对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

对于 Aurora，Aurora MySQL 版本 2.12 及更高的与 MySQL 5.7 兼容的版本支持此过程。

**注意**  
在 Aurora MySQL 版本 3 中，如果您具有 `SESSION_VARIABLES_ADMIN` 权限，则可以使用以下命令启用当前会话的二进制日志记录：  

```
SET SESSION sql_log_bin = ON;
```

## mysql.rds\$1import\$1binlog\$1ssl\$1material
<a name="mysql_rds_import_binlog_ssl_material"></a>

将证书颁发机构证书、客户端证书和客户端密钥导入到 Aurora MySQL 数据库集群中。SSL 通信和加密复制需要此类信息。

**注意**  
目前，Aurora MySQL 版本 2（2.09.2、2.10.0、2.10.1 和 2.11.0）以及版本 3（3.01.1 及更高版本）支持此过程。

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

 

```
CALL mysql.rds_import_binlog_ssl_material (
  ssl_material
);
```

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

 *ssl\$1material*   
包含 MySQL 客户端的以下 .pem 格式文件内容的 JSON 负载：  
+ "ssl\$1ca":"*证书颁发机构证书*"
+ "ssl\$1cert":"*客户端证书*"
+ "ssl\$1key":"*客户端密钥*"

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

在运行该过程之前，为加密复制做好以下准备：
+ 如果您没有在外部 MySQL 源数据库实例上启用 SSL，并且没有准备客户端密钥和客户端证书，请在 MySQL 数据库服务器上启用 SSL 并生成所需的客户端密钥和客户端证书。
+ 如果在外部源数据库实例上启用了 SSL，请提供 Aurora MySQL 数据库集群的客户端密钥和证书。如果未提供，请为 Aurora MySQL 数据库集群生成新密钥和证书。要对客户端证书进行签名，您必须拥有您用来在外部 MySQL 源数据库实例上配置 SSL 的证书颁发机构密钥。

有关更多信息，请参阅 MySQL 文档中的[使用 openssl 创建 SSL 证书和密钥](https://dev.mysql.com/doc/refman/8.0/en/creating-ssl-files-using-openssl.html)。

**重要**  
为加密复制做好准备后，使用 SSL 连接来运行该过程。不得通过不安全的连接传输客户端密钥。

该过程会将 SSL 信息从外部 MySQL 数据库导入到 Aurora MySQL 数据库集群中。SSL 信息是 .pem 格式文件，其中包含 Aurora MySQL 数据库集群的 SSL 信息。在加密复制期间，Aurora MySQL 数据库集群充当 MySQL 数据库服务器的客户端。Aurora MySQL 客户端的证书和密钥必须是 .pem 格式的文件。

您可以将这些文件中的信息复制到正确 JSON 负载的 `ssl_material` 参数中。要支持加密复制，请将此类 SSL 信息导入到 Aurora MySQL 数据库集群中。

JSON 负载必须为以下格式。

```
'{"ssl_ca":"-----BEGIN CERTIFICATE-----
ssl_ca_pem_body_code
-----END CERTIFICATE-----\n","ssl_cert":"-----BEGIN CERTIFICATE-----
ssl_cert_pem_body_code
-----END CERTIFICATE-----\n","ssl_key":"-----BEGIN RSA PRIVATE KEY-----
ssl_key_pem_body_code
-----END RSA PRIVATE KEY-----\n"}'
```

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

以下示例将 SSL 信息导入到 Aurora MySQL。在 .pem 格式文件中，主体代码通常比示例中显示的主体代码长。

```
call mysql.rds_import_binlog_ssl_material(
'{"ssl_ca":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_cert":"-----BEGIN CERTIFICATE-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END CERTIFICATE-----\n","ssl_key":"-----BEGIN RSA PRIVATE KEY-----
AAAAB3NzaC1yc2EAAAADAQABAAABAQClKsfkNkuSevGj3eYhCe53pcjqP3maAhDFcvBS7O6V
hz2ItxCih+PnDSUaw+WNQn/mZphTk/a/gU8jEzoOWbkM4yxyb/wB96xbiFveSFJuOp/d6RJhJOI0iBXr
lsLnBItntckiJ7FbtxJMXLvvwJryDUilBMTjYtwB+QhYXUMOzce5Pjz5/i8SeJtjnV3iAoG/cQk+0FzZ
qaeJAAHco+CY/5WrUBkrHmFJr6HcXkvJdWPkYQS3xqC0+FmUZofz221CBt5IMucxXPkX4rWi+z7wB3Rb
BQoQzd8v7yeb7OzlPnWOyN0qFU0XA246RA8QFYiCNYwI3f05p6KLxEXAMPLE
-----END RSA PRIVATE KEY-----\n"}');
```

## mysql.rds\$1next\$1master\$1log（Aurora MySQL 版本 2）
<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` 可能会导致只读副本丢失数据。

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

假设复制在 Aurora 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（Aurora MySQL 版本 3）
<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` 来减少发生这种情况的几率，尽管这可能会降低性能。

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

假设复制在 Aurora 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\$1remove\$1binlog\$1ssl\$1material
<a name="mysql_rds_remove_binlog_ssl_material"></a>

删除用于 SSL 通信和加密复制的证书颁发机构证书、客户端证书与客户端密钥。此类信息可通过使用 [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material) 来导入。

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

 

```
CALL mysql.rds_remove_binlog_ssl_material;
```

## mysql.rds\$1reset\$1external\$1master（Aurora MySQL 版本 2）
<a name="mysql_rds_reset_external_master"></a>

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

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon Aurora 中修改数据库参数组中的参数](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 外部运行的 MySQL 实例之间启用复制。建议您尽可能使用 Aurora 副本来管理 Aurora MySQL 数据库集群中的复制。有关在 Aurora MySQL 数据库集群中管理复制的信息，请参阅 [使用 Aurora 副本](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas)。

想要了解更多有关使用复制从在 Aurora MySQL 之外运行的 MySQL 实例导入数据的信息，请参阅[Aurora 与 MySQL 之间或 Aurora 与其他 Aurora 数据库集群之间的复制（二进制日志复制）](AuroraMySQL.Replication.MySQL.md)。

## mysql.rds\$1reset\$1external\$1source（Aurora MySQL 版本 3）
<a name="mysql_rds_reset_external_source"></a>

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

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon Aurora 中修改数据库参数组中的参数](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 外部运行的 MySQL 实例之间启用复制。建议您尽可能使用 Aurora 副本来管理 Aurora MySQL 数据库集群中的复制。有关在 Aurora MySQL 数据库集群中管理复制的信息，请参阅 [使用 Aurora 副本](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas)。

## mysql.rds\$1set\$1binlog\$1source\$1ssl（Aurora MySQL 版本 3）
<a name="mysql_rds_set_binlog_source_ssl"></a>

为二进制日志复制启用 `SOURCE_SSL` 加密。有关更多信息，请参阅 MySQL 文档中的 [CHANGE REPLICATION SOURCE TO statement](https://dev.mysql.com/doc/refman/8.0/en/change-replication-source-to.html)。

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

```
CALL mysql.rds_set_binlog_source_ssl(mode);
```

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

*mode*  
指示是否启用 `SOURCE_SSL` 加密的值：  
+ `0` – `SOURCE_SSL` 加密已禁用。默认值为 `0`。
+ `1` – `SOURCE_SSL` 加密已启用。您可以使用 SSL 或 TLS 配置加密。

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

Aurora MySQL 版本 3.06 及更高版本支持该过程。

## mysql.rds\$1set\$1external\$1master（Aurora MySQL 版本 2）
<a name="mysql_rds_set_external_master"></a>

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

`mysql.rds_set_external_master` 过程已弃用，并会在将来的版本中删除。请改用 `mysql.rds\$1set\$1external\$1source`。

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

### 语法
<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 连接。此外，使用 [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material) 过程，将证书颁发机构证书、客户端证书和客户端密钥导入到数据库实例或数据库集群中。

**注意**  
我们提供这些存储过程主要是为了与在 Amazon RDS 外部运行的 MySQL 实例之间启用复制。建议您尽可能使用 Aurora 副本来管理 Aurora MySQL 数据库集群中的复制。有关在 Aurora MySQL 数据库集群中管理复制的信息，请参阅 [使用 Aurora 副本](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas)。

在调用 `mysql.rds_set_external_master` 将 Amazon RDS 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1master（Aurora MySQL 版本 2）](#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（Aurora MySQL 版本 3）
<a name="mysql_rds_set_external_source"></a>

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

**重要**  
要运行此过程，必须启用 `autocommit`。要启用它，请将 `autocommit` 参数设置为 `1`。有关修改参数的信息，请参阅 [在 Amazon Aurora 中修改数据库参数组中的参数](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。  
要启用此选项，您必须已使用 [mysql.rds\$1import\$1binlog\$1ssl\$1material](#mysql_rds_import_binlog_ssl_material) 导入自定义 SSL 证书。如果您尚未导入自定义 SSL 证书，请将此参数设置为 0，然后使用 [mysql.rds\$1set\$1binlog\$1source\$1ssl（Aurora MySQL 版本 3）](#mysql_rds_set_binlog_source_ssl)启用 SSL 以进行二进制日志复制。  
不支持 `SOURCE_SSL_VERIFY_SERVER_CERT` 选项。此选项设置为 0，这意味着连接已加密，但未验证证书。

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

管理用户必须运行 `mysql.rds_set_external_source` 过程。该过程必须在以下 Aurora 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 外部运行的 MySQL 实例之间启用复制。建议您尽可能使用 Aurora 副本来管理 Aurora MySQL 数据库集群中的复制。有关在 Aurora MySQL 数据库集群中管理复制的信息，请参阅 [使用 Aurora 副本](AuroraMySQL.Replication.md#AuroraMySQL.Replication.Replicas)。

在调用 `mysql.rds_set_external_source` 将 Aurora MySQL 数据库实例配置为只读副本后，可对该只读副本调用 [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) 以开始复制过程。您可以调用 [mysql.rds\$1reset\$1external\$1source（Aurora MySQL 版本 3）](#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>

在 Aurora 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（Aurora MySQL 版本 2）
<a name="mysql_rds_set_external_master_with_auto_position"></a>

将 Aurora MySQL 主实例配置为接受来自外部 MySQL 实例的传入复制。此过程还会根据全局事务标识符 (GTID) 配置复制。

此过程不会配置延迟复制，因为 Aurora MySQL 不支持延迟复制。

### 语法
<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
);
```

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

*host\$1name*  
 在 Aurora 之外运行以变为复制源的 MySQL 实例的主机名或 IP 地址。

*host\$1port*  
 在 Aurora 之外运行的要配置为复制源的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。

*replication\$1user\$1name*  
 在对 Aurora 外部运行的 MySQL 实例上具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。

*replication\$1user\$1password*  
在 `replication_user_name` 中指定的用户 ID 的密码。

*ssl\$1encryption*  
目前未实施该选项。默认值是 0。

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

对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

主用户必须运行 `mysql.rds_set_external_master_with_auto_position` 过程。主用户在充当复制目标的 Aurora MySQL 数据库集群的主实例上运行此过程。这可能是外部 MySQL 数据库实例或 Aurora MySQL 数据库集群的复制目标。

Aurora MySQL 版本 2 支持该过程。对于 Aurora MySQL 版本 3，请改为使用程序 [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（Aurora MySQL 版本 3）](#mysql_rds_set_external_source_with_auto_position)。

在运行 `mysql.rds_set_external_master_with_auto_position` 前，请将外部 MySQL 数据库实例配置为复制源。要连接到外部 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.rds_set_external_master_with_auto_position` 时，Amazon RDS 将记录某些信息。这些信息包括 `"set master"` 和 `mysql.rds_history` 表中的时间、用户和 `mysql.rds_replication_status` 操作。

要跳过已知会导致问题的基于 GTID 的特定事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid（Aurora MySQL 版本 2 和 3）](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>

 在 Aurora 主实例上运行时，以下示例将 Aurora 集群配置为充当在 Aurora 之外运行的某个 MySQL 实例的只读副本。

```
call mysql.rds_set_external_master_with_auto_position(
  'Externaldb.some.com',
  3306,
  'repl_user'@'mydomain.com',
  'SomePassW0rd');
```

## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position（Aurora MySQL 版本 3）
<a name="mysql_rds_set_external_source_with_auto_position"></a>

将 Aurora MySQL 主实例配置为接受来自外部 MySQL 实例的传入复制。此过程还会根据全局事务标识符 (GTID) 配置复制。

### 语法
<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
);
```

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

*host\$1name*  
 在 Aurora 之外运行以变为复制源的 MySQL 实例的主机名或 IP 地址。

*host\$1port*  
 在 Aurora 之外运行的要配置为复制源的 MySQL 实例使用的端口。如果网络配置包括转换端口号的安全 Shell (SSH) 端口复制，请指定由 SSH 公开的端口号。

*replication\$1user\$1name*  
 在对 Aurora 外部运行的 MySQL 实例上具有 `REPLICATION CLIENT` 和 `REPLICATION SLAVE` 权限的用户的 ID。建议您向专用于复制的账户提供外部实例。

*replication\$1user\$1password*  
 在 `replication_user_name` 中指定的用户 ID 的密码。

*ssl\$1encryption*  
目前未实施该选项。默认值是 0。  
使用 [mysql.rds\$1set\$1binlog\$1source\$1ssl（Aurora MySQL 版本 3）](#mysql_rds_set_binlog_source_ssl)启用 SSL 以进行二进制日志复制。

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

 对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

 管理用户必须运行 `mysql.rds_set_external_source_with_auto_position` 过程。管理用户在充当复制目标的 Aurora MySQL 数据库集群的主实例上运行此过程。这可能是外部 MySQL 数据库实例或 Aurora MySQL 数据库集群的复制目标。

仅 Aurora MySQL 版本 3 支持此过程。此过程不会配置延迟复制，因为 Aurora MySQL 不支持延迟复制。

 在运行 `mysql.rds_set_external_source_with_auto_position` 前，请将外部 MySQL 数据库实例配置为复制源。要连接到外部 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.rds_set_external_source_with_auto_position` 时，Amazon RDS 将记录某些信息。这些信息包括 `"set master"` 和 `mysql.rds_history` 表中的时间、用户和 `mysql.rds_replication_status` 操作。

 要跳过已知会导致问题的基于 GTID 的特定事务，您可以使用 [mysql.rds\$1skip\$1transaction\$1with\$1gtid（Aurora MySQL 版本 2 和 3）](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>

 在 Aurora 主实例上运行时，以下示例将 Aurora 集群配置为充当在 Aurora 之外运行的某个 MySQL 实例的只读副本。

```
call mysql.rds_set_external_source_with_auto_position(
  'Externaldb.some.com',
  3306,
  'repl_user'@'mydomain.com',
  'SomePassW0rd');
```

## mysql.rds\$1set\$1master\$1auto\$1position（Aurora MySQL 版本 2）
<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` 过程。

Aurora MySQL 版本 2 支持此过程。

## mysql.rds\$1set\$1read\$1only（Aurora MySQL 版本 3）
<a name="mysql_rds_set_read_only"></a>

为数据库实例全局开启或关闭 `read_only` 模式。

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

```
CALL mysql.rds_set_read_only(mode);
```

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

*mode*  
指示是否为数据库实例全局启用 `read_only` 模式的值：  
+ `0` – `OFF`。默认值为 `0`。
+ `1` – `ON`

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

`mysql.rds_set_read_only` 存储过程仅修改 `read_only` 参数。无法在读取器数据库实例上更改 `innodb_read_only` 参数。

`read_only` 参数更改在重启时不会保留。要对 `read_only` 进行永久更改，必须使用 `read_only` 数据库集群参数。

Aurora MySQL 版本 3.06 及更高版本支持此过程。

## mysql.rds\$1set\$1session\$1binlog\$1format（Aurora MySQL 版本 2）
<a name="mysql_rds_set_session_binlog_format"></a>

设置当前会话的二进制日志格式。

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

```
CALL mysql.rds_set_session_binlog_format(format);
```

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

*format*  
一个表示当前会话的二进制日志格式的值：  
+ `STATEMENT` – 复制源基于 SQL 语句将事件写入二进制日志。
+ `ROW` – 复制源将事件写入二进制日志，指示各个表行发生更改。
+ `MIXED` – 日志记录通常基于 SQL 语句，但在某些条件下切换到行。有关更多信息，请参阅 MySQL 文档中的[混合二进制日志记录格式](https://dev.mysql.com/doc/refman/8.0/en/binary-log-mixed.html)。

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

对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

要使用此存储过程，必须为当前会话配置二进制日志记录。

对于 Aurora，Aurora MySQL 版本 2.12 及更高的与 MySQL 5.7 兼容的版本支持此过程。

## mysql.rds\$1set\$1source\$1auto\$1position（Aurora MySQL 版本 3）
<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>

对于 Aurora MySQL 数据库集群，您将在连接到主实例时调用此存储过程。

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

## 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` 过程。有关此过程的更多信息，请参阅[跳过当前的复制错误](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.MySQL.CommonDBATasks.html#Appendix.MySQL.CommonDBATasks.SkipError)。

要确定是否存在错误，请运行 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)。

有关解决 Aurora MySQL 的复制错误的信息，请参阅[诊断并解决 MySQL 读取复制故障](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.RR)。

#### 复制已停止错误
<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>

从 Aurora MySQL 数据库集群发起复制。

**注意**  
您可以使用 [mysql.rds\$1start\$1replication\$1until（Aurora MySQL 版本 3）](#mysql_rds_start_replication_until) 或 [mysql.rds\$1start\$1replication\$1until\$1gtid（Aurora MySQL 版本 3）](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 存储过程从 Aurora 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（Aurora MySQL 版本 2）](#mysql_rds_set_external_master) 或 [mysql.rds\$1set\$1external\$1source（Aurora MySQL 版本 3）](#mysql_rds_set_external_source) 以构建复制配置后，再对只读副本调用 `mysql.rds_start_replication` 以开始复制过程。有关更多信息，请参阅 [Aurora 与 MySQL 之间或 Aurora 与其他 Aurora 数据库集群之间的复制（二进制日志复制）](AuroraMySQL.Replication.MySQL.md)。

要将数据导出到 Amazon RDS 外部的 MySQL 实例，请对只读副本调用 `mysql.rds_start_replication` 和 `mysql.rds_stop_replication` 以控制某些复制操作，如清除二进制日志。有关更多信息，请参阅 [Aurora 与 MySQL 之间或 Aurora 与其他 Aurora 数据库集群之间的复制（二进制日志复制）](AuroraMySQL.Replication.MySQL.md)。

您还可以对只读副本调用 `mysql.rds_start_replication`，以便重新启动您先前通过调用 `mysql.rds_stop_replication` 停止的任何复制过程。有关更多信息，请参阅 [复制已停止错误](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.ReplicationStopped)。

## mysql.rds\$1start\$1replication\$1until（Aurora MySQL 版本 3）
<a name="mysql_rds_start_replication_until"></a>

从 Aurora 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` 过程。

Aurora MySQL 版本 3.04 及更高版本支持该过程。

托管式复制不支持 `mysql.rds_start_replication_until` 存储过程，其中包括以下内容：
+ [跨 AWS 区域复制 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Replication.CrossRegion.md)
+ [使用 Aurora 只读副本将数据从 RDS for MySQL 数据库实例迁移到 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Migrating.RDSMySQL.Replica.md)

为 `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` 以停止复制过程。有关更多信息，请参阅 [Aurora 与 MySQL 之间或 Aurora 与其他 Aurora 数据库集群之间的复制（二进制日志复制）](AuroraMySQL.Replication.MySQL.md)。

如果要配置复制，使其将数据导出到在 Amazon RDS 外部运行的 MySQL 实例，则要对只读副本调用 `mysql.rds_start_replication` 和 `mysql.rds_stop_replication` 以控制某些复制操作，如清除二进制日志。有关更多信息，请参阅 [Aurora 与 MySQL 之间或 Aurora 与其他 Aurora 数据库集群之间的复制（二进制日志复制）](AuroraMySQL.Replication.MySQL.md)。

托管式复制不支持 `mysql.rds_stop_replication` 存储过程，其中包括以下内容：
+ [跨 AWS 区域复制 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Replication.CrossRegion.md)
+ [使用 Aurora 只读副本将数据从 RDS for MySQL 数据库实例迁移到 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Migrating.RDSMySQL.Replica.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) 命令。

### 示例
<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*。

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

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

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

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

以下存储过程控制如何使用 Aurora MySQL 中的全局事务标识符（GTID）复制事务。要了解如何根据 Aurora MySQL 中的 GTID 使用复制，请参阅[使用基于 GTID 的复制](mysql-replication-gtid.md)。

**Topics**
+ [

## mysql.rds\$1assign\$1gtids\$1to\$1anonymous\$1transactions（Aurora MySQL 版本 3）
](#mysql_assign_gtids_to_anonymous_transactions)
+ [

## mysql.rds\$1gtid\$1purged（Aurora MySQL 版本 3）
](#mysql_rds_gtid_purged)
+ [

## mysql.rds\$1skip\$1transaction\$1with\$1gtid（Aurora MySQL 版本 2 和 3）
](#mysql_rds_skip_transaction_with_gtid)
+ [

## mysql.rds\$1start\$1replication\$1until\$1gtid（Aurora MySQL 版本 3）
](#mysql_rds_start_replication_until_gtid)

## mysql.rds\$1assign\$1gtids\$1to\$1anonymous\$1transactions（Aurora MySQL 版本 3）
<a name="mysql_assign_gtids_to_anonymous_transactions"></a>

配置 `CHANGE REPLICATION SOURCE TO` 语句的 `ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS` 选项。它使得复制通道将 GTID 分配给没有 GTID 的复制事务。这样，您就可以将二进制日志从不使用基于 GTID 的复制的源复制到使用该复制的副本。有关更多信息，请参阅 *MySQL 参考手册*中的 [CHANGE REPLICATION SOURCE TO 语句](https://dev.mysql.com/doc/refman/8.0/en/change-replication-source-to.html)和[从没有 GTID 的源复制到有 GTID 的副本](https://dev.mysql.com/doc/refman/8.0/en/replication-gtids-assign-anon.html)。

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

```
CALL mysql.rds_assign_gtids_to_anonymous_transactions(gtid_option);
```

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

 *gtid\$1option*  
字符串值。允许的值为 `OFF`、`LOCAL` 或者指定的 UUID。

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

此过程与在社群 MySQL 中发布语句 `CHANGE REPLICATION SOURCE TO ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS = gtid_option` 的效果相同。

 GTID 必须转向 `ON` 才能使 *gtid\$1option* 设置为 `LOCAL` 或指定的 UUID。

默认值为 `OFF`，这意味着不使用该功能。

`LOCAL` 会分配一个 GTID，其中包括副本自己的 UUID（`server_uuid` 设置)。

传递一个作为 UUID 的参数会分配一个包含指定 UUID 的 GTID，例如复制源服务器的 `server_uuid` 设置。

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

要关闭此功能：

```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('OFF');
+-------------------------------------------------------------+
| Message  |
+-------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: OFF |
+-------------------------------------------------------------+
1 row in set (0.07 sec)
```

要使用副本自己的 UUID：

```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('LOCAL');
+---------------------------------------------------------------+
| Message  |
+---------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: LOCAL |
+---------------------------------------------------------------+
1 row in set (0.07 sec)
```

要使用指定的 UUID：

```
mysql> call mysql.rds_assign_gtids_to_anonymous_transactions('317a4760-f3dd-3b74-8e45-0615ed29de0e');
+----------------------------------------------------------------------------------------------+
| Message |
+----------------------------------------------------------------------------------------------+
| ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS has been set to: 317a4760-f3dd-3b74-8e45-0615ed29de0e |
+----------------------------------------------------------------------------------------------+
1 row in set (0.07 sec)
```

## mysql.rds\$1gtid\$1purged（Aurora MySQL 版本 3）
<a name="mysql_rds_gtid_purged"></a>



将系统变量 `gtid_purged` 的全局值设置为给定的全局事务标识符（GTID）集。`gtid_purged` 系统变量是一个 GTID 集，由服务器上已提交但不存在于服务器上任何二进制日志文件中的所有事务的 GTID 组成。

为了与 MySQL 8.0 兼容，有两种方法可以设置 `gtid_purged` 的值：
+ 将 `gtid_purged` 的值替换为指定的 GTID 集。
+ 将您指定的 GTID 集附加到 `gtid_purged` 已经包含的 GTID 集。

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

要将 `gtid_purged` 的值替换为您指定的 GTID 集，请执行以下操作：

```
CALL mysql.rds_gtid_purged (gtid_set);
```

要将 `gtid_purged` 的值附加到您指定的 GTID 集，请执行以下操作：

```
CALL mysql.rds_gtid_purged (+gtid_set);
```

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

*gtid\$1set*  
*gtid\$1set* 的值必须是 `gtid_purged` 的当前值的超集，并且不能与 `gtid_subtract(gtid_executed,gtid_purged)` 相交。也就是说，新的 GTID 集必须包括 `gtid_purged` 中已经存在的任何 GTID，并且不能包括 `gtid_executed` 中尚未清除的任何 GTID。*gtid\$1set* 参数也不能包括全局 `gtid_owned` 集中的任何 GTID，即当前服务器上正在处理的事务的 GTID。

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

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

Aurora MySQL 版本 3.04 及更高版本支持此过程。

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

以下示例将 GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23` 分配给 `gtid_purged` 全局变量。

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

## mysql.rds\$1skip\$1transaction\$1with\$1gtid（Aurora MySQL 版本 2 和 3）
<a name="mysql_rds_skip_transaction_with_gtid"></a>

在 Aurora 主实例上跳过复制具有指定全局事务标识符 (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` 过程。

Aurora MySQL 版本 2 和 3 支持此过程。

### 示例
<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（Aurora MySQL 版本 3）
<a name="mysql_rds_start_replication_until_gtid"></a>

从 Aurora 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` 过程。

Aurora MySQL 版本 3.04 及更高版本支持该过程。

托管式复制不支持 `mysql.rds_start_replication_until_gtid` 存储过程，其中包括以下内容：
+ [跨 AWS 区域复制 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Replication.CrossRegion.md)
+ [使用 Aurora 只读副本将数据从 RDS for MySQL 数据库实例迁移到 Amazon Aurora MySQL 数据库集群](AuroraMySQL.Migrating.RDSMySQL.Replica.md)

在 `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 日志交替到备份表。有关更多信息，请参阅 [AuroraMySQL 数据库日志文件](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)

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

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

`binlog retention hours` 参数用于指定要保留二进制日志文件的小时数。Amazon Aurora 通常会尽快清除一个二进制日志，但对于 Amazon 外部的 MySQL 数据库的复制，该二进制日志可能仍是必需的。

`binlog retention hours` 的默认值为 `NULL`。对于 Aurora MySQL，`NULL` 表示延时清理二进制日志。Aurora MySQL 二进制日志可能会在系统中保留一段时间，但这通常不超过一天。

要指定在数据库集群上保留二进制日志的小时数，请使用 `mysql.rds_set_configuration` 存储过程并指定足以让复制发生的时段，如以下示例中所示。

`call mysql.rds_set_configuration('binlog retention hours', 24);`

**注意**  
不能将值 `0` 用于 `binlog retention hours`。

对于 Aurora MySQL 版本 2.11.0 及更高版本和版本 3 数据库集群，最大 `binlog retention hours` 值为 2160（90 天）。

在设置保留期后，监视数据库实例的存储用量以确认保留的二进制日志不会占用太多存储空间。

## 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.
```