# Uso de la replicación de MySQL en Amazon RDS
Normalmente se utilizan réplicas de lectura para configurar la replicación entre instancias de base de datos de Amazon RDS. Para obtener información general acerca de las réplicas de lectura, consulte [Trabajo con réplicas de lectura de instancias de base de datos](USER_ReadRepl.md). Para obtener información específica acerca de cómo utilizar las réplicas de lectura en Amazon RDS para MySQL, consulte [Uso de réplicas de lectura de MySQL](USER_MySQL.Replication.ReadReplicas.md).
Puede usar identificadores de transacciones globales (GTID) para la replicación con RDS para MySQL. Para obtener más información, consulte [Uso de la replicación basada en GTID](mysql-replication-gtid.md).
También puede configurar la replicación entre una instancia de base de datos de RDS para MySQL y una instancia de MariaDB o MySQL externa a Amazon RDS. Para obtener más información sobre cómo configurar la replicación con un origen externo, consulte [Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa](MySQL.Procedural.Importing.External.Repl.md).
Para cualquiera de estas opciones de replicación, puede utilizar replicación basada en filas, basada en instrucciones o mixta. La replicación basada en filas solo replica las filas cambiadas que resulten de una instrucción SQL. La replicación basada en instrucciones replica toda la instrucción SQL. La replicación mixta utiliza la replicación basada en instrucciones siempre que sea posible, pero alterna a la replicación basada en filas cuando se ejecutan las instrucciones SQL que no son seguras para la replicación basada en instrucciones. En la mayoría de los casos, se recomienda la replicación mixta. El formato de registro binario de la instancia de base de datos determina si la replicación se basa en filas, instrucciones o mixta. Para obtener información acerca de la configuración del formato de registro binario, consulte [Configuración del registro binario de RDS para MySQL para bases de datos Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**nota**
Puede configurar la replicación para importar bases de datos desde una instancia de MariaDB o MySQL que sea externa a Amazon RDS, o para exportar bases de datos a dichas instancias. Para obtener más información, consulte [Importación de datos a una base de datos de Amazon RDS para MySQL con un tiempo de inactividad reducido](mysql-importing-data-reduced-downtime.md) y [Exportación de datos desde una instancia de base de datos MySQL mediante replicación](MySQL.Procedural.Exporting.NonRDSRepl.md).
Tras restaurar la instancia de base de datos a partir de una instantánea o realizar una recuperación en un momento dado, puede ver la última posición de binlog recuperada de la base de datos de origen en la consola de RDS. En **Registros y eventos**, ingrese **binlog**. La posición del binlog aparece en **Notas del sistema**.
**Topics**
+ [Uso de réplicas de lectura de MySQL](USER_MySQL.Replication.ReadReplicas.md)
+ [Uso de la replicación basada en GTID](mysql-replication-gtid.md)
+ [Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa](MySQL.Procedural.Importing.External.Repl.md)
+ [Configuración de la replicación de varios orígenes de Amazon RDS para MySQL](mysql-multi-source-replication.md)
# Uso de réplicas de lectura de MySQL
A continuación, encontrará información específica acerca de cómo utilizar las réplicas de lectura en RDS para MySQL. Para obtener información general sobre las réplicas de lectura e instrucciones sobre cómo usarlas, consulte [Trabajo con réplicas de lectura de instancias de base de datos](USER_ReadRepl.md).
Para obtener más información sobre las réplicas de lectura de MySQL, consulte los siguientes temas.
+ [Configuración de filtros de replicación con MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)
+ [Configuración de la replicación retrasada con MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)
+ [Eliminación de réplicas de lectura con MySQL](USER_MySQL.Replication.ReadReplicas.Updates.md)
+ [Implementaciones de réplicas de lectura Multi-AZ con MySQL](USER_MySQL.Replication.ReadReplicas.MultiAZ.md)
+ [Uso de réplicas de lectura en cascada con RDS para MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)
+ [Supervisión del retardo de replicación para réplicas de lectura de MySQL](USER_MySQL.Replication.ReadReplicas.Monitor.md)
+ [Inicio y detención de replicaciones con réplicas de lectura de MySQL](USER_MySQL.Replication.ReadReplicas.StartStop.md)
+ [Solución de problemas de réplicas de lectura de MySQL](USER_ReadRepl.Troubleshooting.md)
## Configuración de réplicas con MySQL
Para que una instancia de base de datos de MySQL pueda servir como origen de replicación, asegúrese de habilitar las copias de seguridad automáticas en la instancia de base de datos de origen. Para ello, debe establecer el periodo de retención de copia de seguridad en un valor distinto de 0. Este requisito también es válido para una réplica de lectura que sea la instancia de base de datos de origen de otra réplica de lectura. Las copias de seguridad automáticas se admiten para las réplicas de lectura en las que se ejecuta cualquier versión de MySQL. Puede configurar la replicación en función de las coordenadas de los registros binarios para las instancias de base de datos MySQL.
Puede configurar la replicación mediante identificadores de transacciones globales (GTIDS) en las siguientes versiones:
+ RDS para MySQL versión 5.7.44 y versiones 5.7 posteriores
+ RDS para MySQL versión 8.0.28 y versiones 8.0 posteriores
+ RDS para MySQL versión 8.4.3 y versiones 8.4 posteriores
Para obtener más información, consulte [Uso de la replicación basada en GTID](mysql-replication-gtid.md).
Puede crear hasta 15 réplicas de lectura a partir de una instancia de base de datos de dentro de la misma región. Para que la replicación sea eficaz, cada réplica de lectura debe tener la misma cantidad de recursos de computación y de almacenamiento que la instancia de base de datos de origen. Si modifica la escala de la instancia de base de datos de origen, debe ajustar también la escala de las réplicas de lectura.
RDS para MySQL admite réplicas de lectura en cascada. Para obtener información sobre cómo configurar réplicas de lectura en cascada, consulte [Uso de réplicas de lectura en cascada con RDS para MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md).
Puede ejecutar varias acciones de creación y eliminación de réplicas de lectura al mismo tiempo que hagan referencia a la misma instancia de base de datos de origen. Al realizar estas acciones, permanezca dentro del límite de 15 réplicas de lectura para cada instancia de origen.
Una réplica de lectura de una instancia de base de datos MySQL no puede usar una versión de motor de base de datos inferior que su instancia de base de datos de origen.
### Preparación de instancias de base de datos de MySQL que usan MyISAM
Si una instancia de base de datos MySQL usa un motor no transaccional como MyISAM, debe llevar a cabo los siguientes pasos para configurar la réplica de lectura. Estos pasos son necesarios para garantizar que la réplica de lectura tiene una copia coherente de los datos. Los pasos no son necesarios si todas las tablas usan un motor transaccional como InnoDB.
1. Detenga todas las operaciones de lenguaje de manipulación de datos (DML) y lenguaje de definición de datos (DDL) que se lleven a cabo en las tablas no transaccionales de la instancia de base de datos de origen y espere a que se completen. Las declaraciones SELECT pueden seguir ejecutándose.
1. Vacíe y bloquee las tablas de la instancia de base de datos de origen.
1. Cree la réplica de lectura usando uno de los métodos que se describen en las siguientes secciones.
1. Compruebe el progreso de la creación de la réplica de lectura usando, por ejemplo, la operación de la API `DescribeDBInstances`. Una vez que la réplica de lectura esté disponible, desbloquee las tablas de la instancia de base de datos de origen y reanude las operaciones normales de la base de datos.
# Configuración de filtros de replicación con MySQL
Puede utilizar filtros de replicación para especificar qué bases de datos y tablas se replican con una réplica de lectura. Los filtros de replicación pueden incluir bases de datos y tablas en la replicación o excluirlas de la replicación.
Los siguientes son algunos casos de uso para filtros de replicación:
+ Para reducir el tamaño de una réplica de lectura. Con el filtrado de replicación, puede excluir las bases de datos y las tablas que no son necesarias en la réplica de lectura.
+ Para excluir bases de datos y tablas de réplicas de lectura por razones de seguridad.
+ Para replicar diferentes bases de datos y tablas para casos de uso específicos en diferentes réplicas de lectura. Por ejemplo, puede utilizar réplicas de lectura específicas para análisis o fragmentación.
+ Con una instancia de base de datos que tiene réplicas de lectura en diferentes Regiones de AWS, para replicar diferentes bases de datos o tablas en diferentes regiones de Regiones de AWS.
**nota**
También puede utilizar filtros de reproducción para especificar qué bases de datos y tablas se reproducen con una instancia de base de datos primaria de MySQL que está configurada como una réplica en una topología de reproducción entrante. Para obtener más información acerca de esta configuración, consulte [Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa](MySQL.Procedural.Importing.External.Repl.md).
**Topics**
+ [Configurar parámetros de filtrado de replicación de RDS for MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [Limitaciones del filtrado de replicación de RDS fopara r MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [Ejemplos de filtrado de replicación de RDS para MySQL](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [Visualización de los filtros de replicación para una réplica de lectura](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Configurar parámetros de filtrado de replicación de RDS for MySQL
Para configurar filtros de replicación, establezca los siguientes parámetros de filtrado de replicación en la réplica de lectura:
+ `replicate-do-db` – Replicar los cambios en las bases de datos especificadas. Cuando se establece este parámetro para una réplica de lectura, solo se replican las bases de datos especificadas en el parámetro.
+ `replicate-ignore-db` – No replicar los cambios en las bases de datos especificadas. Cuando el parámetro `replicate-do-db` se establece para una réplica de lectura, este parámetro no se evalúa.
+ `replicate-do-table` – Replicar los cambios en las tablas especificadas. Cuando se establece este parámetro para una réplica de lectura, solo se replican las tablas especificadas en el parámetro. Además, cuando se establece el parámetro `replicate-do-db` o `replicate-ignore-db`, asegúrese de incluir la base de datos que incluye las tablas especificadas en la replicación con la réplica de lectura.
+ `replicate-ignore-table` – No replicar los cambios en las tablas especificadas. Cuando el parámetro `replicate-do-table` se establece para una réplica de lectura, este parámetro no se evalúa.
+ `replicate-wild-do-table` – Replicar tablas en función de la base de datos y los patrones de nombre de tabla especificados. Se admiten los caracteres comodín `%` y `_`. Cuando se establece el parámetro `replicate-do-db` o `replicate-ignore-db`, asegúrese de incluir la base de datos que incluye las tablas especificadas en la replicación con la réplica de lectura.
+ `replicate-wild-ignore-table` – No replicar tablas en función de la base de datos y los patrones de nombre de tabla especificados. Se admiten los caracteres comodín `%` y `_`. Cuando el parámetro `replicate-do-table` o `replicate-wild-do-table` se establece para una réplica de lectura, este parámetro no se evalúa.
Los parámetros se evalúan en el orden en que se enumeran. Para obtener más información sobre cómo funcionan estos parámetros, consulte la documentación de MySQL.
+ Para obtener información general, consulte [Opciones y variables del servidor de réplica](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html).
+ Para obtener información acerca de cómo se evalúan los parámetros de filtrado de replicación de bases de datos, consulte [Evaluación de opciones de registros binarios y replicación a nivel de base de datos](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-db-options.html).
+ Para obtener información acerca de cómo se evalúan los parámetros de filtrado de replicación de tablas, consulte [Evaluación de las opciones de replicación a nivel de tabla](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-table-options.html).
Por defecto, cada uno de estos parámetros tiene un valor vacío. En cada réplica de lectura, puede utilizar estos parámetros para establecer, cambiar y eliminar los filtros de replicación. Cuando establezca uno de estos parámetros, separe cada filtro de los demás con una coma.
Puede utilizar los caracteres comodín `%` y `_` en los parámetros `replicate-wild-do-table` y `replicate-wild-ignore-table`. El comodín `%` coincide con cualquier número de caracteres y el comodín `_` solo coincide con un carácter.
El formato de registro binario de la instancia de base de datos de origen es importante para la replicación, ya que determina el registro de los cambios en los datos. La configuración del parámetro `binlog_format` determina si la replicación está basada en filas o en instrucciones. Para obtener más información, consulte [Configuración del registro binario de RDS para MySQL para bases de datos Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md).
**nota**
Todas las instrucciones de lenguaje de definición de datos (DDL) se replican como instrucciones, independientemente de la configuración de `binlog_format` en la instancia de base de datos de origen.
## Limitaciones del filtrado de replicación de RDS fopara r MySQL
Las siguientes limitaciones se aplican al filtrado de replicación de RDS para MySQL:
+ Cada parámetro de filtrado de replicación tiene un límite de 2000 caracteres.
+ No se admiten comas en los filtros de replicación para los valores de los parámetros. En una lista de parámetros, las comas solo se pueden usar como separadores de valores. Por ejemplo, no se admite `ParameterValue='`a,b`'`, pero sí `ParameterValue='a,b'`.
+ Las opciones `--binlog-do-db` y `--binlog-ignore-db` de MySQL para el filtrado de registros binarios no son compatibles.
+ El filtrado de replicación no es compatible con transacciones XA.
Para obtener más información, consulte [Restricciones a las transacciones XA ](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html) en la documentación de MySQL.
## Ejemplos de filtrado de replicación de RDS para MySQL
Para configurar el filtrado de replicación para una réplica de lectura, modifique los parámetros de filtrado de replicación en el grupo de parámetros asociado a la réplica de lectura.
**nota**
No puede modificar un grupo de parámetros predeterminado. Si la réplica de lectura emplea un grupo de parámetros predeterminado, cree un nuevo grupo de parámetros y asócielo con la réplica de lectura. Para obtener más información acerca de los grupos de parámetros de base de datos, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Puede establecer parámetros en un grupo de parámetros mediante la API de RDS, Consola de administración de AWS o AWS CLI. Para obtener información acerca de cómo configurar los parámetros, consulte [Modificación de los parámetros de un grupo de parámetros de base de datos en Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Cuando se establecen parámetros en un grupo de parámetros, todas las instancias de base de datos asociadas al grupo de parámetros utilizan la configuración de los parámetros. Si establece los parámetros de filtrado de replicación en un grupo de parámetros, asegúrese de que el grupo de parámetros está asociado solo con réplicas de lectura. Deje los parámetros de filtrado de replicación vacíos para las instancias de base de datos de origen
En los siguientes ejemplos se establecen los parámetros mediante el uso de AWS CLI. Estos ejemplos establecen `ApplyMethod` en `immediate` para que los cambios de los parámetros se produzcan inmediatamente después de que se complete el comando de la CLI. Si desea que se aplique un cambio pendiente después de reiniciar la réplica de lectura, establezca `ApplyMethod` en `pending-reboot`.
Los siguientes ejemplos establecen filtros de replicación:
+ [Including databases in replication](#rep-filter-in-dbs-mysql)
+ [Including tables in replication](#rep-filter-in-tables-mysql)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mysql)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mysql)
+ [Excluding tables from replication](#rep-filter-ex-tables-mysql)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mysql)
**Example Inclusión de bases de datos en la replicación**
En el ejemplo siguiente se incluyen las bases de datos `mydb1` y `mydb2` en la replicación.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
**Example Inclusión de tablas en la replicación**
En el siguiente ejemplo se incluyen las tablas `table1` y `table2` en la base de datos `mydb1` en la replicación.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
**Example Inclusión de tablas en la replicación mediante el uso de caracteres comodín**
En el ejemplo siguiente se incluyen tablas con nombres que empiezan con `order` y `return` en la base de datos `mydb` en la replicación.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
**Example Exclusión de bases de datos de la replicación**
En el siguiente ejemplo se excluyen las bases de datos `mydb5` y `mydb6` de la replicación.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
**Example Exclusión de tablas de la replicación**
En el siguiente ejemplo, se excluyen de la replicación las tablas `table1` en la base de datos `mydb5` y `table2` en la base de datos `mydb6`.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
**Example Exclusión de tablas de la replicación mediante el uso de caracteres comodín**
En el siguiente ejemplo se excluyen las tablas con nombres que empiezan con `order` y `return` en la base de datos `mydb7` de la replicación.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
## Visualización de los filtros de replicación para una réplica de lectura
Puede ver los filtros de replicación para una réplica de lectura de las siguientes maneras:
+ Verifique la configuración de los parámetros de filtrado de replicación en el grupo de parámetros asociado a la réplica de lectura.
Para obtener instrucciones, consulte [Visualización de los valores de parámetros de un grupo de parámetros de base de datos en Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
+ En un cliente de MySQL, conéctese a la réplica de lectura y ejecute la instrucción `SHOW REPLICA STATUS`.
En la salida, los siguientes campos muestran los filtros de replicación para la réplica de lectura:
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
Para obtener más información acerca de estos campos, consulte [Comprobación del estado de replicación](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) en la documentación de MySQL.
# Configuración de la replicación retrasada con MySQL
Puede utilizar la replicación retrasada como estrategia de recuperación de desastres. Con la replicación retardada, se especifica el tiempo mínimo, en segundos, que se retardará la replicación desde la instancia de origen a la réplica de lectura. En caso de desastre, por ejemplo, si se elimina una tabla involuntariamente, el procedimiento siguiente permite recuperarse rápidamente del desastre:
+ Detenga la replicación en la réplica de lectura antes de que se envíe a ella el cambio que provocó el desastre.
Utilice el procedimiento almacenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para detener la replicación.
+ Inicie la replicación y especifique que esta se detenga automáticamente en una ubicación del archivo registro.
Para especificar una ubicación justo anterior al desastre, se utiliza el procedimiento almacenado [mysql.rds\$1start\$1replication\$1until ](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
+ Promocione la réplica de lectura para que sea la nueva instancia de base de datos de origen; para ello, siga las instrucciones de [Promoción de una réplica de lectura para convertirla en una instancia de base de datos independiente](USER_ReadRepl.Promote.md).
**nota**
En Amazon RDS para MySQL 8.4, la replicación retrasada es compatible con MySQL 8.4.3 y versiones posteriores. En Amazon RDS para MySQL 8.0, la replicación retrasada es compatible con MySQL 8.0.28 y versiones posteriores. En Amazon RDS para MySQL 5.7, la replicación retardada es compatible con MySQL 5.7.44 y versiones posteriores.
Use procedimientos almacenados para configurar la replicación retardada. La reproducción retrasada no se puede configurar con la Consola de administración de AWS, la AWS CLI o la API de Amazon RDS.
Puede usar la replicación basada en identificadores de transacciones globales (GTID) en una configuración de replicación retrasada para las versiones siguientes.
RDS para MySQL versión 5.7.44 y versiones 5.7 posteriores
RDS para MySQL versión 8.0.28 y versiones 8.0 posteriores
RDS para MySQL versión 8.4.3 y versiones 8.4 posteriores
Si usa una replicación basada en GTID, use el procedimiento almacenado [mysql.rds\$1start\$1replication\$1until\$1gtid ](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) en lugar del procedimiento almacenado [mysql.rds\$1start\$1replication\$1until ](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Para obtener más información sobre la replicación basada en GTID, consulte [Uso de la replicación basada en GTID](mysql-replication-gtid.md).
**Topics**
+ [Configuración de la replicación retrasada durante la creación de réplicas de lectura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [Modificación de la replicación retrasada para una réplica de lectura existente](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [Establecimiento de una ubicación para detener la replicación en una réplica de lectura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.StartUntil)
+ [Promoción de una réplica de lectura](#USER_MySQL.Replication.ReadReplicas.DelayReplication.Promote)
## Configuración de la replicación retrasada durante la creación de réplicas de lectura
Para configurar la replicación retardada para cualquier réplica de lectura futura creada a partir de una instancia de base de datos, ejecute el procedimiento almacenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) con el parámetro `target delay`.
**Para configurar la replicación retardada durante la creación de réplicas de lectura**
1. Utilice un cliente de MySQL para conectarse como usuario maestro a la instancia de base de datos MySQL que vaya a ser el origen de las réplicas de lectura.
1. Ejecute el procedimiento almacenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) con el parámetro `target delay`.
Por ejemplo, ejecute el siguiente procedimiento almacenado para especificar que la replicación se retardará al menos una hora (3600 segundos) para todas las réplicas de lectura creadas desde la instancia de base de datos actual.
```
call mysql.rds_set_configuration('target delay', 3600);
```
**nota**
Después de ejecutar este procedimiento almacenado, todas las réplicas de lectura que cree mediante la AWS CLI o la API de Amazon RDS se configurarán con la reproducción retardada el número de segundos especificado.
## Modificación de la replicación retrasada para una réplica de lectura existente
Para modificar la replicación retardada para una réplica de lectura existente, ejecute el procedimiento almacenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
**Para modificar la replicación retardada de una réplica de lectura existente**
1. Use un cliente de MySQL para conectarse como usuario maestro a la réplica de lectura.
1. Utilice el procedimiento almacenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para detener la replicación.
1. Ejecute el procedimiento almacenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
Por ejemplo, ejecute el siguiente procedimiento almacenado para especificar que la replicación en la réplica de lectura se retardará al menos una hora (3600 segundos).
```
call mysql.rds_set_source_delay(3600);
```
1. Utilice el procedimiento almacenado [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar la replicación.
## Establecimiento de una ubicación para detener la replicación en una réplica de lectura
Después de detener la replicación en la réplica de lectura, puede utilizar el procedimiento almacenado [mysql.rds\$1start\$1replication\$1until ](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) para iniciar la replicación y volver a detenerla en una ubicación concreta del registro binario.
**Para iniciar la replicación en una réplica de lectura y detenerla en una ubicación concreta**
1. Use un cliente de MySQL para conectarse como usuario maestro a la instancia de base de datos MySQL de origen.
1. Ejecute el procedimiento almacenado [mysql.rds\$1start\$1replication\$1until ](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until).
En el ejemplo siguiente se inicia la replicación y se replican los cambios hasta que alcanza la ubicación `120` del archivo registro binario `mysql-bin-changelog.000777`. En una situación de recuperación de desastres, supongamos que la ubicación `120` es justo anterior al desastre.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
La replicación se detiene automáticamente cuando se alcanza el punto de detención. Se genera el siguiente evento de RDS: `Replication has been stopped since the replica reached the stop point specified by the rds_start_replication_until stored procedure`.
## Promoción de una réplica de lectura
Después de que se detenga la replicación, en una situación de recuperación de desastres, puede promocionar una réplica de lectura para que sea la nueva instancia de base de datos de origen. Para obtener información acerca de la promoción de una réplica de lectura, consulte [Promoción de una réplica de lectura para convertirla en una instancia de base de datos independiente](USER_ReadRepl.Promote.md).
# Eliminación de réplicas de lectura con MySQL
Las réplicas de lectura se han diseñado para permitir las consultas de lectura, pero puede necesitar actualizaciones ocasionales. Por ejemplo, puede necesitar añadir un índice para optimizar los tipos concretos de consultas que obtienen acceso a la réplica.
Aunque puede habilitar las actualizaciones configurando el parámetro `read_only` en `0` en el grupo de parámetros de base de datos de la réplica de lectura, se recomienda no hacerlo porque puede provocar problemas si la réplica de lectura es incompatible con la instancia de base de datos de origen. Para las operaciones de mantenimiento, se recomienda utilizar la implementación azul/verde. Para obtener más información, consulte [Uso de las implementaciones azul/verde para actualizar las bases de datos](blue-green-deployments.md).
Si deshabilita el modo de solo lectura en una réplica de lectura, cambie el valor del parámetro `read_only` a `1` de nuevo lo antes posible.
# Implementaciones de réplicas de lectura Multi-AZ con MySQL
Puede crear una réplica de lectura a partir de implementaciones de instancia de base de datos Single-AZ o Multi-AZ. Puede usar implementaciones Multi-AZ para mejorar la durabilidad y la disponibilidad de los datos críticos, pero no puede usar la implementación Multi-AZ secundaria para responder a consultas de solo lectura. En lugar de ello, puede crear réplicas de lectura a partir de una instancia de base de datos Multi-AZ con un tráfico elevado para descargar las consultas de solo lectura. Si la instancia de origen de una implementación Multi-AZ conmuta a la secundaria, las réplicas de lectura asociadas cambian automáticamente para usar la secundaria (ahora principal) como origen de replicación. Para obtener más información, consulte [Configuración y administración de una implementación multi-AZ para Amazon RDS](Concepts.MultiAZ.md).
Puede crear una réplica de lectura como instancia de base de datos de Multi-AZ. Amazon RDS crea una réplica en espera en otra zona de disponibilidad para permitir la conmutación por error de la réplica. La creación de su réplica de lectura como instancia de base de datos Multi-AZ es independiente de si la base de datos de origen es una instancia de base de datos Multi-AZ.
# Uso de réplicas de lectura en cascada con RDS para MySQL
RDS para MySQL admite réplicas de lectura en cascada. Con *réplicas de lectura en cascada*, puede escalar las lecturas sin agregar sobrecarga a su instancia de base de datos de origen de RDS para MySQL.
Con réplicas de lectura en cascada, la instancia de base de datos de RDS para MySQL envía datos a la primera réplica de lectura de la cadena. Esa réplica de lectura envía datos a la segunda réplica de la cadena, etc. El resultado final es que todas las réplicas de lectura de la cadena tienen los cambios de la instancia de base de datos de RDS para MySQL, pero sin la sobrecarga únicamente en la instancia de base de datos de origen.
Puede crear una serie de hasta tres réplicas de lectura en cadena a partir de una instancia de base de datos de origen de RDS para MySQL. Por ejemplo, suponga que tiene una instancia de base de datos de RDS para MySQL: `mysql-main`. Puede hacer lo siguiente:
+ A partir de `mysql-main`, cree la primera réplica de lectura de la cadena, `read-replica-1`.
+ A continuación, a partir de `read-replica-1`, cree la siguiente réplica de lectura de la cadena, `read-replica-2`.
+ Por último, a partir de `read-replica-2`, cree la tercera réplica de lectura de la cadena, `read-replica-3`.
No se puede crear otra réplica de lectura más allá de esta tercera réplica de lectura en cascada de la serie para `mysql-main`. Una serie completa de instancias de una instancia de base de datos de origen de RDS para MySQL hasta el final de una serie de réplicas de lectura en cascada puede constar de cuatro instancias de base de datos como máximo.
Para que las réplicas de lectura en cascada funcionen, cada instancia de base de datos de origen de RDS para MySQL debe tener las copias de seguridad automáticas activadas. Para habilitar las copias de seguridad automáticas en una réplica de lectura, primero debe crear la réplica de lectura y modificarla a continuación para habilitar las copias de seguridad automáticas. Para obtener más información, consulte [Creación de una réplica de lectura](USER_ReadRepl.Create.md).
Al igual que con cualquier réplica de lectura, puede promocionar una réplica de lectura que forma parte de una cascada. La promoción de una réplica de lectura desde dentro de una cadena de réplicas de lectura elimina esa réplica de la cadena. Por ejemplo, suponga que desea trasladar parte de la carga de trabajo de su Instancia de base de datos de `mysql-main` a una nueva instancia para que la utilice únicamente el departamento de contabilidad. Tomando la cadena de tres réplicas de lectura del ejemplo, decide promocionar `read-replica-2`. La cadena se ve afectada de la siguiente manera:
+ Promover `read-replica-2` la elimina de la cadena de replicación.
+ Ahora es una instancia de base de datos de lectura o escritura completa.
+ Continúa replicando en `read-replica-3`, tal como hacía antes de la promoción.
+ Su `mysql-main` sigue replicándose en `read-replica-1`.
Para obtener más información acerca de la promoción de réplicas de lectura, consulte [Promoción de una réplica de lectura para convertirla en una instancia de base de datos independiente](USER_ReadRepl.Promote.md).
# Supervisión del retardo de replicación para réplicas de lectura de MySQL
Para las réplicas de lectura de MySQL, puede monitorear el retraso de replicación en Amazon CloudWatch mediante la visualización de la métrica `ReplicaLag` de Amazon RDS. La métrica `ReplicaLag` indica el valor del campo `Seconds_Behind_Master` del comando `SHOW REPLICA STATUS`.
Los motivos comunes de retardo de la replicación para MySQL son los siguientes:
+ Una interrupción de la red.
+ Escritura en tablas con índices diferentes en una réplica de lectura. Si el parámetro `read_only` se establece en `0` en la réplica de lectura, la replicación puede bloquearse si la réplica de lectura es incompatible con la instancia de base de datos de origen. Una vez que haya realizado las tareas de mantenimiento en la réplica de lectura, le recomendamos que vuelva a establecer el parámetro `read_only` en `1`.
+ Uso de un motor de almacenamiento no transaccional como MyISAM. La replicación solo se admite para el motor de almacenamiento InnoDB en MySQL.
Cuando la métrica `ReplicaLag` llegue a 0, la réplica estará funcionando al mismo ritmo que la instancia de base de datos de origen. Si la métrica `ReplicaLag` devuelve -1, la replicación no está activa. `ReplicaLag` = -1 es equivalente a `Seconds_Behind_Master` = `NULL`.
# Inicio y detención de replicaciones con réplicas de lectura de MySQL
Puede detener y reiniciar el proceso de replicación en una instancia de base de datos de Amazon RDS llamando a los procedimientos [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) y [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) almacenados en el sistema. Puede hacerlo cuando replique entre dos instancias de Amazon RDS para las operaciones de larga duración, como la creación de índices grandes. También debe detener y comenzar la replicación cuando importe o exporte bases de datos. Para obtener más información, consulte [Importación de datos a una base de datos de Amazon RDS para MySQL con un tiempo de inactividad reducido](mysql-importing-data-reduced-downtime.md) y [Exportación de datos desde una instancia de base de datos MySQL mediante replicación](MySQL.Procedural.Exporting.NonRDSRepl.md).
Si la replicación se detiene durante más de 30 días consecutivos, ya sea manualmente o a causa de un error de replicación, Amazon RDS termina la replicación entre la instancia de base de datos de origen y todas las réplicas de lectura Realiza ese procedimiento para impedir que aumenten los requisitos de almacenamiento en la instancia de base de datos de origen y que se incrementen los tiempos de conmutación por error. La instancia de base de datos de la réplica de lectura seguirá estando disponible. Sin embargo, la replicación no se podrá reanudar porque los registros binarios requeridos por la réplica de lectura se eliminan de la instancia de base de datos de origen cuando termina la replicación. Puede crear una nueva réplica de lectura para la instancia de base de datos de origen si desea restablecer la replicación.
# Solución de problemas de réplicas de lectura de MySQL
Para las instancias de base de datos MySQL, en algunos casos, las réplicas de lectura tienen errores de replicación o incoherencias de datos (o ambos) entre la réplica de lectura y su instancia de base de datos de origen. Este problema se produce cuando algunos eventos de binglog o registros redo de InnoDB no se vacían durante un error de la réplica de lectura o la instancia de base de datos de origen. En estos casos, elimine y vuelva a crear manualmente las réplicas de lectura. Puede reducir la probabilidad de que esto ocurra al establecer los siguientes valores de parámetro: `sync_binlog=1` y `innodb_flush_log_at_trx_commit=1`. Estos ajustes pueden reducir el desempeño, así que es aconsejable probar su impacto antes de implementar los cambios en un entorno de producción.
**aviso**
En el grupo de parámetros asociado con la instancia de base de datos de origen, recomendamos mantener estos valores de parámetros: `sync_binlog=1` y `innodb_flush_log_at_trx_commit=1`. Estos parámetros son dinámicos. Si no quiere utilizar esta configuración, le recomendamos configurar temporalmente esos valores antes de ejecutar cualquier operación en la instancia de base de datos de origen que pueda provocar que se reinicie. Estas operaciones incluyen, entre otras, el reinicio, el reinicio con conmutación por error, la actualización de la versión de la base de datos y el cambio de la clase de la instancia de base de datos o su almacenamiento. La misma recomendación se aplica a la creación de nuevas réplicas de lectura de la instancia de base de datos de origen.
Si no se siguen estas recomendaciones, se aumenta el riesgo de que las réplicas de lectura tengan errores de replicación o incoherencias de datos (o ambos) entre la réplica de lectura y su instancia de base de datos de origen.
Las tecnologías de replicación para MySQL son asíncronas. Como son asíncronas, cabe esperar aumentos ocasionales de `BinLogDiskUsage` en la instancia de base de datos de origen y de `ReplicaLag` en la réplica de lectura. Por ejemplo, en paralelo se pueden realizar gran volumen de operaciones de escritura en la instancia de base de datos de origen. En cambio, las operaciones de escritura en la réplica de lectura se serializan con un único subproceso E/S que puede provocar un retraso entre la instancia de origen y la réplica de lectura. Para obtener más información acerca de las réplicas de solo lectura en la documentación de MySQL, consulte [Replication Implementation Details](https://dev.mysql.com/doc/refman/8.0/en/replication-implementation-details.html).
Puede hacer varias cosas para reducir el retraso entre las actualizaciones de una instancia de base de datos de origen y las actualizaciones posteriores de la réplica de lectura. Por ejemplo, puede hacer lo siguiente:
+ Dimensionar una réplica de lectura para que tenga un tamaño de almacenamiento y una clase de instancia de base de datos comparables a los de la instancia de base de datos de origen.
+ Asegurarse de que los valores de los parámetros de los grupos de parámetros de base de datos utilizados en la instancia de base de datos de origen y la réplica de lectura son compatibles. Para obtener más información y un ejemplo, consulte el análisis del parámetro `max_allowed_packet` que se puede encontrar más adelante en esta sección.
Amazon RDS monitorea el estado de la replicación de las réplicas de lectura y actualiza el campo `Replication State` de la instancia de la réplica de lectura a `Error` si la replicación se detiene por cualquier motivo. Un ejemplo de ello pueden ser las consultas DML que se ejecutan en la réplica de lectura y que entran en conflicto con las actualizaciones realizadas en la instancia de base de datos de origen.
Puede revisar los detalles del error asociado mostrado por el motor de MySQL visualizando el campo `Replication Error`. También se generan eventos que indican el estado de la réplica de lectura, entre los que se incluyen [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045), [RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) y [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047). Para obtener más información acerca de los eventos y la suscripción a ellos, consulte [Uso de notificaciones de eventos de Amazon RDS](USER_Events.md). Si aparece un mensaje de error de MySQL, revise el número del error en la [documentación sobre los mensajes de error de MySQL](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html).
Un problema frecuente que puede causar errores de replicación es que el valor del parámetro `max_allowed_packet` de una réplica de lectura sea inferior al parámetro `max_allowed_packet` de la instancia de base de datos de origen. El parámetro `max_allowed_packet` es un parámetro personalizado que puede establecer en un grupo de parámetros de base de datos. Utilice `max_allowed_packet` para especificar el tamaño máximo del código DML que se puede ejecutar en la base de datos. En algunos casos, el valor de `max_allowed_packet` en el grupo de parámetros de base de datos asociado a una réplica de lectura es inferior al valor de `max_allowed_packet` del grupo de parámetros de base de datos asociado a la instancia de base de datos de origen. En estos casos, el proceso de replicación puede generar el error `Packet bigger than 'max_allowed_packet' bytes` y detener la replicación. Para resolver el error, haga que la instancia de base de datos de origen y la réplica de lectura usen grupos de parámetros de base de datos con los mismos valores del parámetro `max_allowed_packet`.
Entre las situaciones comunes que pueden causar errores de replicación se incluyen las siguientes:
+ Escritura en tablas en una réplica de lectura. En algunos casos, puede crear índices en una réplica de lectura que sean diferentes de los índices de la instancia de base de datos de origen. Si lo hace, establezca el parámetro `read_only` en `0` para crear los índices. Si escribe en tablas en la réplica de lectura, la replicación puede bloquearse si la réplica de lectura es incompatible con la instancia de base de datos de origen. Una vez que haya realizado las tareas de mantenimiento en la réplica de lectura, le recomendamos que vuelva a establecer el parámetro `read_only` en `1`.
+ Uso de un motor de almacenamiento no transaccional como MyISAM. Las réplicas de lectura requieren un motor de almacenamiento transaccional. La replicación solo se admite para el motor de almacenamiento InnoDB en MySQL.
+ Uso de consultas no deterministas que no sean seguras, como `SYSDATE()`. Para obtener más información, consulte [Determinación de instrucciones seguras e inseguras en el registro binario](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html).
Si decide que es seguro hacer caso omiso de un error, puede seguir los pasos que se describen en la sección [Omisión del error de replicación actual de RDS para MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). De no ser así, primero puede eliminar la réplica de lectura. A continuación, cree una instancia que use el mismo identificador de instancias de bases de datos para que el punto de conexión siga siendo el mismo que en la réplica de lectura antigua. Si se corrige un error de replicación, `Replication State` cambia a *replicating*.
# Uso de la replicación basada en GTID
El siguiente contenido explica cómo utilizar los identificadores de transacciones globales (GTID) con replicación de registro binario (binlog) entre instancias de base de datos de Amazon RDS para MySQL
Si utiliza la replicación del binlog y no conoce la replicación basada en GTID con MySQL, consulte [Replication with global transaction identifiers](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids.html) en la documentación de MySQL.
La replicación basada en GTID no es compatible con las versiones siguientes:
+ Todas las versiones de RDS para MySQL 8.4
+ Todas las versiones de RDS para MySQL 8.0
+ Todas las versiones de RDS para MySQL 5.7
Todas las instancias de base de datos de MySQL en una configuración de replicación deben cumplir este requisito.
**Topics**
+ [Información general de identificadores de transacciones globales (GTID)](#mysql-replication-gtid.overview)
+ [Parámetros de replicación basada en GTID](#mysql-replication-gtid.parameters)
+ [Activación de la replicación basada en GTID de las nuevas réplicas de lectura para RDS para MySQL](mysql-replication-gtid.configuring-new-read-replicas.md)
+ [Activación de la replicación basada en GTID de las réplicas de lectura existentes para RDS para MySQL](mysql-replication-gtid.configuring-existing-read-replicas.md)
+ [Desactivación de la reproducción basada en GTID para una instancia de base de datos de MySQL de RDS con réplicas de lectura](mysql-replication-gtid.disabling.md)
## Información general de identificadores de transacciones globales (GTID)
Los *identificadores de transacciones globales (GTID)* son indentificadores únicos generados por transacciones confirmadas por MySQL. Puede utilizar GTID para que la replicación del binlog sea más simple y sencilla para la solución de problemas.
MySQL usa dos tipos distintos de transacciones para la replicación del binlog:
+ *Transacciones de GTID*: transacciones que se identifican mediante GTID.
+ *Transacciones anónimas*: transacciones que no tienen un GTID asignado.
En una configuración de replicación, los GTID son únicos en todas las instancias de base de datos. Los GTID simplifican la configuración de replicación porque cuando se usan no es necesario hacer referencia a las posiciones de los archivos de registro. Los GTID también simplifican el seguimiento de las transacciones replicadas y determinan si las instancias de origen y las réplicas son coherentes.
Puede usar una replicación basada en GTID para replicar los datos con réplicas de lectura de RDS for MySQL. Puede configurar la replicación basada en GTID cuando cree réplicas de lectura nuevas o puede convertir las réplicas de lectura existentes para que usen la replicación basada en GTID.
También puede usar la replicación basada en GTID en una configuración de replicación retrasada con RDS for MySQL. Para obtener más información, consulte [Configuración de la replicación retrasada con MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md).
## Parámetros de replicación basada en GTID
Use los parámetros siguientes para configurar replicación basada en GTID.
| Parámetro | Valores válidos | Descripción |
| --- | --- | --- |
| `gtid_mode` | `OFF`, `OFF_PERMISSIVE`, `ON_PERMISSIVE`, `ON` | `OFF` especifica que las nuevas transacciones son anónimas (es decir, no tienen GTID) y que una transacción debe ser anónima para replicarse. `OFF_PERMISSIVE` especifica que las nuevas transacciones son anónimas, pero que todas las transacciones pueden replicarse. `ON_PERMISSIVE` especifica que las nuevas transacciones son de GTID, pero que todas las transacciones pueden replicarse. `ON` especifica que las nuevas transacciones son de GTID y que una transacción debe ser de GTID para poder replicarse. |
| `enforce_gtid_consistency` | `OFF`, `ON`, `WARN` | `OFF` permite que las transacciones infrinjan la uniformidad de GTID. `ON` evita que las transacciones infrinjan la uniformidad de GTID. `WARN` permite que las transacciones infrinjan la uniformidad de GTID, pero genera un aviso cuando se proudce una infracción. |
**nota**
En la Consola de administración de AWS, el parámetro `gtid_mode` aparece como `gtid-mode`.
Para la replicación basada en GTID, utilice esta configuración para el grupo de parámetros para su instancia de base de datos o réplica de lectura:
+ `ON` y `ON_PERMISSIVE` se aplican solo a la replicación saliente de una instancia de base de datos de RDS. Estos valores provocan que su instancia de base de datos de RDS utilicen GTID para transacciones que se replican. `ON` requiere que la base de datos externa también utilice la replicación basada en GTID. `ON_PERMISSIVE` hace que la replicación basada en GTID sea opcional en la base de datos externa.
+ Si se establece `OFF_PERMISSIVE`, significa que sus instancias de base de datos de RDS pueden aceptar la replicación entrante de una base de datos externa. Esto se puede realizar sin importar si la base de datos de origen utiliza la replicación basada en GTID.
+ Si se establece `OFF`, significa que su instancia de base de datos de RDS solo acepta la replicación entrante desde bases de datos externas que no utilizan la replicación basada en GTID.
Para obtener más información acerca de los grupos de parámetros, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
# Activación de la replicación basada en GTID de las nuevas réplicas de lectura para RDS para MySQL
Cuando la reproducción basada en GTID esté habilitada para una instancia de base de datos de MySQL de RDS, la reproducción basada en GTID se configura automáticamente para las réplicas de lectura de la instancia de base de datos.
**Para habilitar la replicación basada en GTID para nuevas réplicas de lectura**
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos tiene la siguiente configuración de parámetros:
+ `gtid_mode` – `ON` o `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
Para obtener más información sobre el establecimiento de parámetros de configuración con grupos de consultas, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Si ha cambiado el grupo de parámetros de la instancia de base de datos, reinicie la instancia de base de datos. Para obtener más información acerca de cómo hacerlo, consulte [Reinicio de una instancia de base de datos ](USER_RebootInstance.md).
1. Cree una o varias réplicas de lectura de la instancia de base de datos. Para obtener más información acerca de cómo hacerlo, consulte [Creación de una réplica de lectura](USER_ReadRepl.Create.md).
Amazon RDS intenta establecer la replicación basada en GTID entre la instancia de base de datos de MySQL y las réplicas de lectura usando `MASTER_AUTO_POSITION`. Si el intento produce un error, Amazon RDS usa las posiciones de los archivos de registro para la replicación con las réplicas de lectura. Para obtener más información acerca de `MASTER_AUTO_POSITION`, consulte [GTID Auto-Positioning](https://dev.mysql.com/doc/refman/5.7/en/replication-gtids-auto-positioning.html) en la documentación de MySQL.
# Activación de la replicación basada en GTID de las réplicas de lectura existentes para RDS para MySQL
Para una instancia de base de datos de MySQL existente con réplicas de lectura que no utilice la reproducción basada en GTID, puede configurar la reproducción basada en GTID entre la instancia de base de datos y las réplicas de lectura.
**Habilitación de la replicación basada en GTID para las réplicas de lectura existentes**
1. Si la instancia de base de datos o cualquier réplica de lectura utiliza RDS para MySQL 8.0 o versiones anteriores a 8.0.26, actualice la instancia de base de datos o la réplica de lectura a la versión 8.0.26 o a versiones posteriores a MySQL 8.0. Todas las versiones de RDS para MySQL 8.4 y 5.7 admiten la replicación basada en GTID.
Para obtener más información, consulte [Actualizaciones del motor de base de datos de RDS para MySQL](USER_UpgradeDBInstance.MySQL.md).
1. De manera opcional, restablezca los parámetros de GTID y pruebe el comportamiento de la instancia de base de datos y las réplicas de lectura:
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos y cada réplica de lectura tiene el parámetro `enforce_gtid_consistency` establecido en `WARN`.
Para obtener más información sobre el establecimiento de parámetros de configuración con grupos de consultas, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Si ha cambiado el grupo de parámetros de la instancia de base de datos, reinicie la instancia de base de datos. Si ha cambiado el grupo de parámetros de una réplica de lectura, reinicie la réplica de lectura.
Para obtener más información, consulte [Reinicio de una instancia de base de datos ](USER_RebootInstance.md).
1. Ejecute la instancia de base de datos y las réplicas de lectura con su carga de trabajo normal y monitoree los archivos de registro.
Si ve advertencias sobre las transacciones incompatibles con GTID, ajuste su aplicación de forma que solo use características compatibles con GTID. Asegúrese de que la instancia de base de datos no está generando ningún aviso sobre transacciones incompatibles con GTID antes de continuar al paso siguiente.
1. Restablezca los parámetros de GTID para la replicación basada en GTID que permite las transacciones anónimas hasta que las réplicas de lectura las hayan procesado todas.
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos y cada réplica de lectura tienen la siguiente configuración de parámetros:
+ `gtid_mode` – `ON_PERMISSIVE`
+ `enforce_gtid_consistency` – `ON`
1. Si ha cambiado el grupo de parámetros de la instancia de base de datos, reinicie la instancia de base de datos. Si ha cambiado el grupo de parámetros de una réplica de lectura, reinicie la réplica de lectura.
1. Espere a que todas las transacciones anónimas se hayan replicado. Para comprobar que se han replicado, haga lo siguiente:
1. Ejecute la siguiente instrucción en su instancia de base de datos de origen:
**MySQL 8.4**
```
SHOW BINARY LOG STATUS;
```
**MySQL 5.7 y 8.0**
```
SHOW MASTER STATUS;
```
Anote los valores de las columnas `File` y `Position`.
1. En cada réplica de lectura, use la información de archivo y posición de su instancia de origen en el paso anterior para ejecutar la siguiente consulta.
```
SELECT MASTER_POS_WAIT('file', position);
```
Por ejemplo, si el nombre del archivo es `mysql-bin-changelog.000031` y la posición es `107`, ejecute la siguiente instrucción.
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
Si la réplica de lectura está después de la posición especificada, la consulta devuelve resultados inmediatamente. De no hacerlo, la función espera. Continúe al siguiente paso cuando la consulta haya devuelto resultados para todas las réplicas de lectura.
1. Restablezca los parámetros de GTID solo para la replicación basada en GTID.
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos y cada réplica de lectura tienen la siguiente configuración de parámetros:
+ `gtid_mode` – `ON`
+ `enforce_gtid_consistency` – `ON`
1. Reinicie la instancia de base de datos y cada réplica de lectura.
1. En cada réplica de lectura, ejecute el siguiente procedimiento.
**MySQL 8.4 y versiones principales superiores**
```
CALL mysql.rds_set_source_auto_position(1);
```
**MySQL 8.0 y versiones principales anteriores**
```
CALL mysql.rds_set_master_auto_position(1);
```
# Desactivación de la reproducción basada en GTID para una instancia de base de datos de MySQL de RDS con réplicas de lectura
Puede desactivar la reproducción basada en GTID para una instancia de base de datos de MySQL con réplicas de lectura.
**Para desactivar la reproducción basada en GTID para y una instancia de base de datos de MySQL con réplicas de lectura**
1. En cada réplica de lectura, ejecute el siguiente procedimiento:
**MySQL 8.4 y versiones principales superiores**
```
CALL mysql.rds_set_source_auto_position(0);
```
**MySQL 8.0 y versiones principales anteriores**
```
CALL mysql.rds_set_master_auto_position(0);
```
1. Restablezca `gtid_mode` en `ON_PERMISSIVE` .
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos de MySQL y cada réplica de lectura tiene el parámetro `gtid_mode` establecido en `ON_PERMISSIVE`.
Para obtener más información sobre el establecimiento de parámetros de configuración con grupos de consultas, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Reinicie la instancia de base de datos de MySQL y cada réplica de lectura. Para obtener más información acerca del reinicio, consulte [Reinicio de una instancia de base de datos ](USER_RebootInstance.md).
1. Restablezca `gtid_mode` en `OFF_PERMISSIVE` .
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos de MySQL y cada réplica de lectura tiene el parámetro `gtid_mode` establecido en `OFF_PERMISSIVE`.
1. Reinicie la instancia de base de datos de MySQL y cada réplica de lectura.
1. Espere a que todas las transacciones de GTID se hayan replicado a todas las réplicas de lectura. Para comprobar que se hayan aplicado, realice los siguientes pasos:
1. Ejecute el comando siguiente en la instancia de bases de datos de MySQL:
**MySQL 8.4**
```
SHOW BINARY LOG STATUS
```
**MySQL 5.7 y 8.0**
```
SHOW MASTER STATUS
```
El resultado debería ser similar al que se indica a continuación.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
Tenga en cuenta el archivo y la posición en su resultado.
1. En cada réplica de lectura, use la información de archivo y posición de su instancia de origen en el paso anterior para ejecutar la siguiente consulta:
**Versiones de MySQL 8.4 y 8.0.26 y versiones superiores de MySQL**
```
SELECT SOURCE_POS_WAIT('file', position);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('file', position);
```
Por ejemplo, si el nombre del archivo es `mysql-bin-changelog.000031` y la posición es `107`, ejecute la siguiente instrucción:
**Versiones de MySQL 8.4 y 8.0.26 y versiones superiores de MySQL 8.0**
```
SELECT SOURCE_POS_WAIT('mysql-bin-changelog.000031', 107);
```
**MySQL 5.7**
```
SELECT MASTER_POS_WAIT('mysql-bin-changelog.000031', 107);
```
1. Restablezca los parámetros de GTID para deshabilitar la replicación basada en GTID.
1. Asegúrese de que el grupo de parámetros asociado a la instancia de base de datos de MySQL y cada réplica de lectura tienen la siguiente configuración de parámetros:
+ `gtid_mode` – `OFF`
+ `enforce_gtid_consistency` – `OFF`
1. Reinicie la instancia de base de datos de MySQL y cada réplica de lectura.
# Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa
Puede configurar la replicación entre una instancia de base de datos de RDS for MySQL o MariaDB y una instancia MySQL o MariaDB externa a Amazon RDS usando la replicación del archivo de registro binario.
**Topics**
+ [Antes de empezar](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa](#MySQL.Procedural.Importing.External.Repl.Procedure)
## Antes de empezar
Puede configurar la replicación usando la posición de los archivos de registro binarios de transacciones replicadas.
Los permisos requeridos para comenzar la replicación en una instancia de base de datos de Amazon RDS están restringidos y no están disponibles para el usuario maestro de Amazon RDS. Por este motivo, asegúrese de usar los comandos [mysql.rds\$1set\$1external\$1master (RDS para MariaDB y RDS para las versiones principales de MySQL 8.0 e inferiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) o [mysql.rds\$1set\$1external\$1source (RDS para las versiones principales de MySQL 8.4 y superiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) y [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) de Amazon RDS para configurar la replicación entre la base de datos en funcionamiento y la base de datos de Amazon RDS.
Para establecer el formato de registro binario para una base de datos MySQL o MariaDB, actualice el parámetro `binlog_format`. Si su instancia de base de datos usa el grupo de parámetros de instancia de base de datos predeterminado, cree un nuevo grupo de parámetros de base de datos para modificar el parámetro `binlog_format`. En MariaDB y MySQL 8.0 y versiones anteriores, el valor predeterminado de `binlog_format` es `MIXED`. Sin embargo, también puede configurar `binlog_format` como `ROW` o `STATEMENT` si necesita un formato de registro binario (binlog) concreto. Reinicie la instancia de base de datos para que el cambio entre en vigor. En MySQL 8.4 y versiones posteriores, el valor predeterminado de `binlog_format` es `ROW`.
Para obtener más información sobre configurar el parámetro `binlog_format`, consulte [Configuración del registro binario de RDS para MySQL para bases de datos Single-AZ](USER_LogAccess.MySQL.BinaryFormat.md). Para obtener más información acerca de las implicaciones de distintos tipos de replicación de MySQL, consulte [Advantages and Disadvantages of Statement-Based and Row-Based Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) en la documentación de MySQL.
## Configuración de la replicación de posición de archivo de registro binario con una instancia de origen externa
Siga estas directrices al configurar una instancia de origen externa y una réplica en Amazon RDS:
+ Monitorice los eventos de conmutación por error para la instancia de base de datos de Amazon RDS que usa como réplica. Si se produce una conmutación por error, la instancia de base de datos que es la réplica se puede volver a crear en un nuevo host con una dirección de red diferente. Para obtener información acerca de la monitorización de los eventos de conmutación por error, consulte [Uso de notificaciones de eventos de Amazon RDS](USER_Events.md).
+ Mantenga los binlogs en la instancia de origen hasta que haya verificado que se han aplicado a la réplica. Este mantenimiento garantiza que se pueda restaurar la instancia de origen en caso de error.
+ Active las copias de seguridad automatizadas para la instancia de base de datos de Amazon RDS. La activación de las copias de seguridad automatizadas garantiza que puede restaurar su réplica a un momento dado si necesita volver a sincronizar la instancia de origen y la réplica. Para obtener información acerca de las copias de seguridad y la restauración a un momento dado, consulte [Copia de seguridad, restauración y exportación de datos](CHAP_CommonTasks.BackupRestore.md).
**Para configurar la replicación de archivos de registro binario con una instancia de origen externa**
1. Configure la instancia de base de datos MySQL o MariaDB de origen como de solo lectura.
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Ejecute el comando `SHOW MASTER STATUS` en la instancia de base de datos MySQL o MariaDB para determinar la ubicación del binlog.
Se recibe un resultado similar al del siguiente ejemplo.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. Copie la base de datos de la instancia externa a la instancia de Amazon RDS con `mysqldump`. Para las bases de datos muy grandes, puede usar el procedimiento que se describe en [Importación de datos a una base de datos de Amazon RDS para MySQL con un tiempo de inactividad reducido](mysql-importing-data-reduced-downtime.md).
Para Linux, macOS o Unix:
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Para Windows:
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**nota**
Asegúrese de que no haya ningún espacio entre la opción `-p` y la contraseña que haya escrito.
Para especificar el nombre de host, el nombre de usuario, el puerto y la contraseña para conectarse a su instancia de base de datos en Amazon RDS, use las opciones `--host`, `--user (-u)`, `--port` y `-p` en el comando `mysql`. El nombre de host es el nombre del servicio de nombre de dominio (DNS) tomado del punto de enlace de la instancia de base de datos de Amazon RDS, por ejemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Puede encontrar el valor del punto de conexión en los detalles de la instancia en la Consola de administración de AWS.
1. Haga que la instancia MySQL o MariaDB de origen vuelvan a admitir la escritura.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
Para obtener más información sobre cómo hacer copias de seguridad para su uso con replicación, consulte [la documentación de MySQL](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html).
1. En la Consola de administración de AWS, agregue la dirección IP del servidor que aloja la base de datos externa al grupo de seguridad de la nube virtual privada (VPC) para la instancia de base de datos de Amazon RDS. Para obtener más información acerca de la modificación de un grupo de seguridad de VPC, consulte [Grupos de seguridad de su VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) en la *Guía del usuario de Amazon Virtual Private Cloud*.
La dirección IP puede cambiar cuando se cumplen las siguientes condiciones:
+ Está usando una dirección IP pública para la comunicación entre la instancia de origen externa y la instancia de base de datos.
+ La instancia de origen externa se detuvo y se reinició.
Si se cumplen esas condiciones, compruebe la dirección IP antes de añadirla.
Es posible que también necesite configurar su red local para permitir las conexiones desde la dirección IP de la instancia de base de datos de Amazon RDS. Eso se hace para que la red local se pueda comunicar con la instancia de MySQL o MariaDB externa. Para encontrar la dirección IP de la instancia de base de datos de Amazon RDS, use el comando `host`.
```
host db_instance_endpoint
```
El nombre de host es el nombre de DNS tomado del punto de conexión de la instancia de base de datos de Amazon RDS.
1. Con el cliente que prefiera, conecte con la instancia externa y cree un usuario para la replicación. Use esta cuenta únicamente para la replicación y limítela a su dominio para mejorar la seguridad. A continuación se muestra un ejemplo.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**nota**
Especifique una contraseña distinta de la que se muestra aquí como práctica recomendada de seguridad.
1. Para la instancia externa, conceda los privilegios `REPLICATION CLIENT` y `REPLICATION SLAVE` al usuario de replicación. Por ejemplo, para conceder los privilegios `REPLICATION CLIENT` y `REPLICATION SLAVE` en todas las bases de datos al usuario "`repl_user`" del dominio, ejecute el siguiente comando.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Defina la instancia de base de datos de Amazon RDS como réplica, Para ello, en primer lugar, conéctese a la instancia de base de datos de Amazon RDS como usuario maestro. A continuación, identifique la base de datos de MySQL o MariaDB externa como instancia de origen usando el comando [mysql.rds\$1set\$1external\$1source (RDS para las versiones principales de MySQL 8.4 y superiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) o [mysql.rds\$1set\$1external\$1master (RDS para MariaDB y RDS para las versiones principales de MySQL 8.0 e inferiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master). Use el nombre del archivo de registro maestro y la posición del registro maestro que determinó en el paso 2. Los siguientes comandos son ejemplos.
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB y MySQL 8.0 y 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**nota**
En RDS para MySQL, puede aplicar la replicación retrasada si lo desea ejecutando el procedimiento [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para las versiones principales de MySQL 8.4 y superiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay) o [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB y RDS para las versiones principales de MySQL 8.0 e inferiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay) almacenado en su lugar. Un motivo para usar la replicación retrasada en RDS para MySQL es activar la recuperación de desastres con el procedimiento almacenado [mysql.rds\$1start\$1replication\$1until ](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). En la actualidad, RDS para MariaDB es compatible con la replicación retrasada, pero no con el procedimiento `mysql.rds_start_replication_until`.
1. En la instancia de base de datos de Amazon RDS, ejecute el comando [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para comenzar la replicación.
```
CALL mysql.rds_start_replication;
```
# Configuración de la replicación de varios orígenes de Amazon RDS para MySQL
Con la replicación de varios orígenes, puede configurar una instancia de base de datos de Amazon RDS para MySQL como una réplica que reciba eventos de registros binarios de más de una instancia de base de datos de origen de RDS para MySQL. Las instancias de base de datos de RDS para MySQL que ejecutan las siguientes versiones de motor admiten la replicación de varios orígenes:
+ Todas las versiones MySQL 8.4
+ 8.0.35 y versiones secundarias posteriores
+ 5.7.44 y versiones secundarias posteriores
Para obtener información acerca de la replicación varios orígenes de MySQL, consulte [MySQL Multi-Source Replication](https://dev.mysql.com/doc/refman/8.0/en/replication-multi-source.html) en la documentación de MySQL. La documentación de MySQL contiene información detallada sobre esta característica, mientras que en este tema se describe cómo configurar y administrar canales de replicación de varios orígenes en las instancias de base de datos de RDS para MySQL.
## Casos de uso de la replicación de varios orígenes
Los siguientes casos son buenos candidatos para utilizar la replicación de varios orígenes en RDS para MySQL:
+ Aplicaciones que necesitan fusionar o combinar varias particiones de instancias de base de datos independientes en una sola.
+ Aplicaciones que necesitan generar informes a partir de datos consolidados de varios orígenes.
+ Requisitos para crear copias de seguridad consolidadas de los datos a largo plazo que se distribuyen entre varias instancias de base de datos de RDS para MySQL.
## Requisitos previos para la replicación de varios orígenes
Antes de configurar la replicación de varios orígenes, se deben completar los siguientes requisitos previos.
+ Asegúrese de que cada instancia de base de datos de RDS para MySQL de origen tenga habilitadas las copias de seguridad automáticas. Al habilitar las copias de seguridad automáticas, se habilita el registro binario. Para obtener información acerca de cómo habilitar las copias de seguridad automáticas, consulte [Habilitar las copias de seguridad automatizadas](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Para evitar errores de replicación, se recomienda bloquear las operaciones de escritura en las instancias de base de datos de origen. Para ello, defina el parámetro `read-only` en `ON` en un grupo de parámetros personalizado asociado a la instancia de base de datos de origen de RDS para MySQL. Puede utilizar la Consola de administración de AWS o la AWS CLI para crear un nuevo grupo de parámetros personalizado o modificar uno existente. Para obtener más información, consulte [Creación de un grupo de parámetros de base de datos en Amazon RDS](USER_WorkingWithParamGroups.Creating.md) y [Modificación de los parámetros de un grupo de parámetros de base de datos en Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
+ Para cada instancia de base de datos de origen, agregue la dirección IP de la instancia al grupo de seguridad de la nube privada virtual (VPC) de Amazon para la instancia de base de datos de varios orígenes. Para identificar la dirección IP de una instancia de base de datos de origen, puede ejecutar el comando `dig RDS Endpoint`. Ejecute el comando desde una instancia de Amazon EC2 en la misma VPC que la instancia de base de datos de varios orígenes de destino.
+ Para cada instancia de base de datos de origen, utilice un cliente para conectarse a la instancia de base de datos y cree un usuario de base de datos con los privilegios necesarios para la replicación, como en el siguiente ejemplo.
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user';
```
**nota**
A partir de MySQL 8.4, el privilegio `REPLICATION SLAVE` ha quedado obsoleto y se ha reemplazado por `REPLICATION REPLICA`. Para MySQL 8.4 y versiones posteriores, utilice la siguiente sintaxis:
```
CREATE USER 'repl_user' IDENTIFIED BY 'password';
GRANT REPLICATION CLIENT, REPLICATION REPLICA ON *.* TO 'repl_user';
```
## Configuración de canales de replicación de varios orígenes en instancias de base de datos de RDS para MySQL
La configuración de los canales de replicación de varios orígenes es similar a la configuración de la replicación de un solo origen. Para la replicación de varios orígenes, primero habilite el registro binario en la instancia de origen. A continuación, importe los datos desde los orígenes a la réplica de varios orígenes. A continuación, se inicia la replicación desde cada origen utilizando las coordenadas del registro binario o el posicionamiento automático de GTID.
Para configurar una instancia de base de datos de RDS para MySQL como una réplica de varios orígenes de dos o más instancias de base de datos de RDS para MySQL, realice estos pasos.
**Topics**
+ [Paso 1: importe datos de las instancias de base de datos de origen a la réplica de varios orígenes](#mysql-multi-source-replication-import)
+ [Paso 2: inicie la replicación desde las instancias de base de datos de origen a la réplica de varios orígenes](#mysql-multi-source-replication-setting-up-start-replication-other)
### Paso 1: importe datos de las instancias de base de datos de origen a la réplica de varios orígenes
Realice los siguientes pasos en cada instancia de base de datos de origen.
Antes de importar los datos de un origen a la réplica de varios orígenes, ejecute el comando `SHOW MASTER STATUS` para determinar el archivo de registro binario actual y su posición. Tome nota de estos datos para usarlos en el paso siguiente. En este ejemplo de salida, el archivo es `mysql-bin-changelog.000031` y la posición es `107`.
**nota**
A partir de MySQL 8.4, el comando `SHOW MASTER STATUS` ha quedado obsoleto y se ha reemplazado por `SHOW BINARY LOG STATUS`. Para MySQL 8.4 y versiones posteriores, utilice `SHOW BINARY LOG STATUS`.
```
File Position
-----------------------------------
mysql-bin-changelog.000031 107
-----------------------------------
```
Ahora copie la base de datos desde la instancia de base de datos de origen a la réplica de varios orígenes utilizando `mysqldump`, como en el ejemplo siguiente.
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u RDS_user_name \
-p RDS_password \
--host=RDS Endpoint | mysql \
--host=RDS Endpoint \
--port=3306 \
-u RDS_user_name \
-p RDS_password
```
Tras copiar la base de datos, puede establecer el parámetro de solo lectura en `OFF` en la instancia de base de datos de origen.
### Paso 2: inicie la replicación desde las instancias de base de datos de origen a la réplica de varios orígenes
Para cada instancia de base de datos de origen, use las credenciales de usuario administrativo para conectarse a la instancia y ejecute los siguientes dos procedimientos almacenados. Estos procedimientos almacenados configuran la replicación en un canal e inician la replicación. En este ejemplo, se utilizan el nombre y la posición del archivo binlog de la salida del ejemplo del paso anterior.
```
CALL mysql.rds_set_external_source_for_channel('mysourcehost.example.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1, 'channel_1');
CALL mysql.rds_start_replication_for_channel('channel_1');
```
Para obtener más información acerca del uso de estos procedimientos almacenados y otros para configurar y administrar los canales de replicación, consulte [Administración de la replicación de varios orígenes](mysql-stored-proc-multi-source-replication.md).
## Uso de filtros con la replicación de varios orígenes
Puede utilizar filtros de replicación para especificar qué bases de datos y tablas se replican con una réplica de varios orígenes. Los filtros de replicación pueden incluir bases de datos y tablas en la replicación o excluirlas de la replicación. Para obtener información sobre los filtros de replicación, consulte [Configuración de filtros de replicación con MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md).
Con la replicación de varios orígenes, puede configurar los filtros de replicación de forma global o en el nivel del canal. El filtrado en el nivel del canal solo está disponible con las instancias de base de datos compatibles que ejecutan la versión 8.0 o la versión 8.4. Los siguientes ejemplos muestran cómo configurar filtros globalmente o en el nivel del canal.
Tenga en cuenta los siguientes requisitos y comportamiento con el filtrado en la replicación de varios orígenes:
+ Los nombres de los canales deben ir entre comillas inversas (``).
+ Si cambia los filtros de replicación en el grupo de parámetros, el `sql_thread` de la réplica de varios orígenes de todos los canales con actualizaciones se reinicia para aplicar los cambios de forma dinámica. Si una actualización incluye un filtro global, se reinician todos los canales de replicación en estado de ejecución.
+ Todos los filtros globales se aplican antes que cualquier filtro específico del canal.
+ Si un filtro se aplica globalmente y en el ámbito del canal, el filtro solo se aplica en el nivel del canal. Por ejemplo, si los filtros son `replicate_ignore_db="db1,`channel_22`:db2"`, `replicate_ignore_db` configurado en `db1` se aplica a todos los canales excepto a `channel_22` y solo `channel_22` omite los cambios efectuados desde `db2`.
Ejemplo 1: configuración de un filtro global
En el ejemplo siguiente, la base de datos `temp_data` se excluye de la replicación en todos los canales.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='temp_data',ApplyMethod=immediate"
```
Ejemplo 2: configuración de un filtro en el nivel del canal
En el siguiente ejemplo, los cambios efectuados desde la base de datos `sample22` solo se incluyen en el canal `channel_22`. Del mismo modo, los cambios efectuados desde la base de datos `sample99` solo se incluyen en el canal `channel_99`.
Para Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='\`channel_22\`:sample22,\`channel_99\`:sample99',ApplyMethod=immediate"
```
## Monitorización de canales de replicación de varios orígenes
Puede monitorizar canales individuales en una réplica de varios orígenes mediante los siguientes métodos:
+ Para monitorizar el estado de todos los canales o de un canal específico, conéctese a la réplica de varios orígenes y ejecute el comando `SHOW REPLICA STATUS` o `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'`. Para obtener más información, consulte [Checking Replication Status](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) en la documentación de MySQL.
+ Para recibir una notificación cuando se inicie, detenga o elimine un canal de replicación, utilice la notificación de eventos de RDS. Para obtener más información, consulte [Uso de notificaciones de eventos de Amazon RDS](USER_Events.md).
+ Para monitorizar el retardo de un canal específico, compruebe la métrica `ReplicationChannelLag` correspondiente. Los puntos de datos de esta métrica tienen un periodo de 60 segundos (1 minuto) y están disponibles 15 días. Para localizar el retardo del canal de replicación de un canal, utilice el identificador de instancia y el nombre del canal de replicación. Para recibir una notificación cuando este retardo supere un umbral determinado, puede configurar una alarma de CloudWatch. Para obtener más información, consulte [Supervisión de métricas de Amazon RDS con Amazon CloudWatch](monitoring-cloudwatch.md).
## Consideraciones y prácticas recomendadas para la replicación de varios orígenes
Antes de utilizar la replicación de varios orígenes en RDS para MySQL, revise las siguientes consideraciones y prácticas recomendadas:
+ Asegúrese de que una instancia de base de datos configurada como réplica de varios orígenes cuente con recursos suficientes, como rendimiento, memoria, CPU e IOPS, para gestionar la carga de trabajo de varias instancias de origen.
+ Monitorice periódicamente el uso de los recursos en su réplica de varios orígenes y ajuste la configuración de la instancia o el almacenamiento para gestionar la carga de trabajo sin agotar los recursos.
+ Para configurar la replicación de varios subprocesos en una réplica de varios orígenes, configure la variable del sistema `replica_parallel_workers` en un valor superior a `0`. En este caso, el número de subprocesos asignados a cada canal es el valor de esta variable, más un subproceso coordinador para administrar los subprocesos del aplicador.
+ Configure los filtros de replicación de la forma adecuada para evitar conflictos. Para replicar una base de datos completa en otra base de datos en una réplica, puede usar la opción `--replicate-rewrite-db`. Por ejemplo, puede replicar todas las tablas de la base de datos A en la base de datos B en una instancia de réplica. Este enfoque puede resultar útil cuando todas las instancias de origen utilizan la misma convención de nomenclatura de esquemas. Para obtener información sobre la opción `--replicate-rewrite-db`, consulte [Replica Server Options and Variables](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html) en la documentación de MySQL.
+ Para evitar errores de replicación, evite escribir en la réplica. Se recomienda activar el parámetro `read_only` en réplicas de varios orígenes para bloquear las operaciones de escritura. Esto ayuda a eliminar los problemas de replicación causados por operaciones de escritura conflictivas.
+ Para aumentar el rendimiento de las operaciones de lectura, como las ordenaciones y las uniones de carga elevada que se ejecutan en la réplica de varios orígenes, considere la posibilidad de utilizar lecturas optimizadas para RDS. Esta característica puede ayudar con las consultas que dependen de tablas temporales o archivos de ordenación de gran tamaño. Para obtener más información, consulte [Mejora del rendimiento de las consultas de RDS para MySQL con lecturas optimizadas de Amazon RDS](rds-optimized-reads.md).
+ Para minimizar el retardo en la replicación y mejorar el rendimiento de una réplica de varios orígenes, considere la posibilidad de habilitar escrituras optimizadas. Para obtener más información, consulte [Mejora del rendimiento de escritura con escrituras optimizadas para RDS para MySQL](rds-optimized-writes.md).
+ Realice operaciones de administración (como cambiar la configuración) en un canal a la vez y evite realizar cambios en varios canales desde varias conexiones. Estas prácticas pueden provocar conflictos en las operaciones de replicación. Por ejemplo, la ejecución de los procedimientos `rds_skip_repl_error_for_channel` y `rds_start_replication_for_channel` de forma simultánea desde varias conexiones puede provocar la omisión de eventos en un canal diferente al previsto.
+ Puede habilitar las copias de seguridad en una instancia de replicación de varios orígenes y exportar los datos de esa instancia a un bucket de Amazon S3 para almacenarlos a largo plazo. Sin embargo, también es importante configurar las copias de seguridad con la retención adecuada en las instancias de origen individuales. Para obtener más información acerca de la exportación de datos de instantáneas a Amazon S3, consulte [Exportación de datos de instantáneas de bases de datos a Amazon S3 para Amazon RDS](USER_ExportSnapshot.md).
+ Para distribuir la carga de trabajo de lectura en una réplica de varios orígenes, puede crear réplicas de lectura a partir de una réplica de varios orígenes. Puede ubicar estas réplicas de lectura en diferentes Regiones de AWS según los requisitos de su aplicación. Para obtener más información acerca de las réplicas de lectura, consulte [Uso de réplicas de lectura de MySQL](USER_MySQL.Replication.ReadReplicas.md).
## Limitaciones de la replicación de varios orígenes en RDS para MySQL
Las siguientes limitaciones se aplican a la replicación de varios orígenes en RDS para MySQL:
+ Actualmente, RDS para MySQL admite la configuración de un máximo de 15 canales para una réplica de varios orígenes.
+ Una instancia de réplica de lectura no se puede configurar como una réplica de varios orígenes.
+ Para configurar la replicación de varios orígenes en RDS para MySQL con el motor que ejecuta la versión 5.7, Performance Schema debe estar habilitado en la instancia de réplica. La habilitación de Performance Schema es opcional en la versión 8.0 u 8.4 del motor de ejecución de RDS para MySQL.
+ En el caso del motor que ejecuta la versión 5.7 de RDS para MySQL, los filtros de replicación se aplican a todos los canales de replicación. Para el motor que ejecuta la versión 8.0 u 8.4 de RDS para MySQL, puede configurar filtros que se apliquen a todos los canales de replicación o a canales individuales.
+ Al restaurar una instantánea de RDS o realizar una restauración a un momento dado (PITR), no se restauran las configuraciones de los canales de réplica de varios orígenes.
+ Cuando se crea una réplica de lectura de una réplica de varios orígenes, solo se replican los datos de la instancia de varios orígenes. No se restaura la configuración de ningún canal.
+ MySQL no admite la configuración de un número diferente de trabajadores paralelos para cada canal. Cada canal recibe el mismo número de trabajadores paralelos en función del valor de `replica_parallel_workers`.
Si su objetivo de replicación de varios orígenes es un clúster de base de datos multi-AZ, se aplican las siguientes limitaciones adicionales:
+ Se debe configurar un canal para una instancia de RDS para MySQL de origen antes de que se produzca cualquier escritura en esa instancia.
+ Cada instancia de RDS para MySQL de origen debe tener la replicación basada en GTID habilitada.
+ Un evento de conmutación por error en el clúster de base de datos elimina la configuración de replicación de varios orígenes. Para restaurar esa configuración, es necesario repetir los pasos de configuración.