# Uso de pglogical para sincronizar datos entre instancias Todas las versiones de RDS para PostgreSQL disponibles actualmente admiten la extensión `pglogical`. La extensión pglogical es anterior a la función de replicación lógica funcionalmente similar que se introdujo en la versión 10 de PostgreSQL. Para obtener más información, consulte [Replicación lógica para Amazon RDS para PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md). La extensión `pglogical` admite la replicación lógica entre dos o más Instancias de base de datos de RDS para PostgreSQL. También admite la replicación entre diferentes versiones de PostgreSQL y entre bases de datos que se ejecutan en instancias de base de datos de RDS para PostgreSQL y clústeres de bases de datos de Aurora PostgreSQL. La extensión `pglogical` utiliza un modelo de publicación y suscripción para replicar los cambios en las tablas y otros objetos, como secuencias, de un publicador a un suscriptor. Se basa en una ranura de replicación para garantizar que los cambios se sincronicen de un nodo publicador a un nodo suscriptor, que se define de la siguiente manera. + El *nodo publicador* es la instancia de base de datos de RDS para PostgreSQL, que es la fuente de datos que se van a replicar en otros nodos. El nodo publicador define las tablas que se van a replicar en un conjunto de publicaciones. + El *nodo suscriptor* es la instancia de base de datos de RDS para PostgreSQL que recibe las actualizaciones WAL del publicador. El suscriptor crea una suscripción para conectarse al publicador y obtener los datos WAL decodificados. Cuando el suscriptor crea la suscripción, se crea la ranura de replicación en el nodo del publicador. A continuación, encontrará información sobre cómo configurar la extensión `pglogical`. **Topics** + [Requisitos y limitaciones de la extensión pglogical](#Appendix.PostgreSQL.CommonDBATasks.pglogical.requirements-limitations) + [Configuración de la extensión pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md) + [Configuración de la replicación lógica para la instancia de base de datos de RDS para PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.setup-replication.md) + [Restablecimiento de la replicación lógica después de una actualización principal](Appendix.PostgreSQL.CommonDBATasks.pglogical.recover-replication-after-upgrade.md) + [Administración de ranuras de replicación lógica para RDS para PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md) + [Referencia de parámetros para la extensión pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.reference.md) ## Requisitos y limitaciones de la extensión pglogical Todas las versiones disponibles actualmente de RDS para PostgreSQL admiten la extensión `pglogical`. Tanto el nodo publicador como el nodo suscriptor deben estar configurados para la replicación lógica. Las tablas que desee replicar desde un publicador a un suscriptor deben tener los mismos nombres y el mismo esquema. Estas tablas también deben contener las mismas columnas y las columnas deben utilizar los mismos tipos de datos. Tanto las tablas de los publicadores como las de suscriptores deben tener las mismas claves principales. Se recomienda utilizar únicamente la PRIMARY KEY como restricción única. Las tablas del nodo suscriptor pueden tener restricciones más permisivas que las del nodo publicador para las restricciones CHECK y NOT NULL. La extensión `pglogical` proporciona funciones como la replicación bidireccional que no son compatibles con la función de replicación lógica integrada en PostgreSQL (versión 10 y posteriores). Para obtener más información, consulte [PostgreSQL bi-directional replication using pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/) (Replicación bidireccional de PostgreSQL mediante pglogical). # Configuración de la extensión pglogical Para configurar la extensión `pglogical` en la instancia de base de datos de RDS para PostgreSQL , añada `pglogical` a las bibliotecas compartidas en el grupo de parámetros de base de datos personalizado para su instancia de base de datos de RDS para PostgreSQL. También debe establecer el valor del parámetro `rds.logical_replication` en `1` para activar la descodificación lógica. Por último, cree la extensión en la base de datos. Puede utilizar la Consola de administración de AWS o la AWS CLI para estas tareas. Debe tener permisos como el rol `rds_superuser` para realizar estas tareas. En los pasos siguientes se supone que su instancia de base de datos de RDS para PostgreSQL está asociada a un grupo de parámetros de base de datos personalizado. Para obtener información acerca de cómo crear el grupo de parámetros de base de datos, consulte [Grupos de parámetros para Amazon RDS](USER_WorkingWithParamGroups.md). ## Consola **Para configurar la extensión pglogical** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. En el panel de navegación, elija la instancia de base de datos de RDS for PostgreSQL. 1. Abra la pestaña **Configuration** (Configuración) para su Instancia de base de datos RDS para PostgreSQL. Entre los detalles de la instancia, busque el enlace del **grupo de parámetros**. 1. Elija el enlace para abrir los parámetros personalizados asociados al Instancia de base de datos RDS para PostgreSQL. 1. En el campo de búsqueda **Parametes** (Parámetros), escriba `shared_pre` para buscar el parámetro `shared_preload_libraries`. 1. Seleccione **Edit parameters** (Editar parámetros) para acceder a los valores de las propiedades. 1. Añada `pglogical` a la lista en el campo **Values** (Valores). Utilice una coma para separar los elementos de la lista de valores. ![\[Imagen del parámetro shared_preload_libraries con pglogical añadido.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pglogical.png) 1. Busque el parámetro `rds.logical_replication` y configúrelo en `1` para activar la replicación lógica. 1. Reinicie la instancia de base de datos de RDS para PostgreSQL para que surtan efecto los cambios. 1. Cuando la instancia esté disponible, puede usar `psql` (o pgAdmin) para conectarse a la instancia de base de datos de RDS para PostgreSQL. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Para comprobar que pglogical esté inicializado, ejecute el siguiente comando. ``` SHOW shared_preload_libraries; shared_preload_libraries -------------------------- rdsutils,pglogical (1 row) ``` 1. Compruebe la configuración que permite la descodificación lógica, de la siguiente manera. ``` SHOW wal_level; wal_level ----------- logical (1 row) ``` 1. Cree la extensión de la siguiente manera. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Seleccione **Save changes (Guardar cambios)**. 1. Abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Elija instancia de base de datos de RDS for PostgreSQL en la lista de bases de datos para seleccionarla y, a continuación, elija **Reboot** (Reiniciar) en el menú Actions (Acciones). ## AWS CLI **Para configurar la extensión pglogical** Para configurar pglogical mediante la AWS CLI, llame a la operación [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) para modificar determinados parámetros de su grupo de parámetros personalizado, tal como se muestra en el siguiente procedimiento. 1. Utilice el siguiente comando AWS CLI para añadir `pglogical` al parámetro `shared_preload_libraries`. ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=shared_preload_libraries,ParameterValue=pglogical,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Utilice el siguiente comando AWS CLI para configurar `rds.logical_replication` en `1` y activar la función de descodificación lógica para la Instancia de base de datos RDS para PostgreSQL. ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Utilice el siguiente comando AWS CLI para reiniciar la instancia de base de datos de RDS para PostgreSQL para que se inicialice la biblioteca de pglogical. ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` 1. Cuando la instancia esté disponible, use `psql` para conectarse a la instancia de base de datos de RDS para PostgreSQL. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Cree la extensión de la siguiente manera. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Reinicie la instancia de base de datos de RDS for PostgreSQL mediante el siguiente comando AWS CLI. ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` # Configuración de la replicación lógica para la instancia de base de datos de RDS para PostgreSQL En el siguiente procedimiento, se muestra cómo iniciar la replicación lógica entre dos instancias de base de datos de RDS para PostgreSQL. En los pasos, se asume que tanto el origen (publicador) como el destino (suscriptor) tienen la extensión `pglogical` configurada como se detalla en [Configuración de la extensión pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md). **nota** El `node_name` de un nodo de suscriptor no puede empezar por `rds`. **Para crear el nodo publicador y definir las tablas que se van a replicar** En estos pasos se asume que la instancia de base de datos de RDS para PostgreSQL tiene una base de datos que tiene una o más tablas que desea replicar en otro nodo. Debe volver a crear la estructura de tablas del publicador en el suscriptor, así que primero debe obtener la estructura de la tabla si es necesario. Para ello, utilice el metacomando de `psql` `\d tablename` y, a continuación, cree la misma tabla en la instancia del suscriptor. El siguiente procedimiento crea una tabla de ejemplo en el publicador (origen) con fines de demostración. 1. Utilice `psql` para conectarse a la instancia que tiene la tabla que desea usar como origen para los suscriptores. ``` psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` Si no dispone de una tabla existente que desee replicar, puede crear una tabla de ejemplo de la siguiente manera. 1. Cree una tabla de ejemplo con la siguiente instrucción SQL. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Rellene la tabla con los datos generados mediante la siguiente instrucción SQL. ``` INSERT INTO docs_lab_table VALUES (generate_series(1,5000)); INSERT 0 5000 ``` 1. Compruebe que los datos existen en la tabla mediante la siguiente instrucción SQL. ``` SELECT count(*) FROM docs_lab_table; ``` 1. Identifique esta instancia de base de datos de RDS para PostgreSQL como nodo publicador de la siguiente manera. ``` SELECT pglogical.create_node( node_name := 'docs_lab_provider', dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 dbname=labdb'); create_node ------------- 3410995529 (1 row) ``` 1. Añada la tabla que desea replicar al conjunto de replicación predeterminado. Para obtener más información sobre los conjuntos de replicación, consulte [Replication sets](https://github.com/2ndQuadrant/pglogical/tree/REL2_x_STABLE/docs#replication-sets) (Conjuntos de replicación) en la documentación de pglogical. ``` SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL); replication_set_add_table --------------------------- t (1 row) ``` Se ha completado la configuración del nodo publicador. Ahora puede configurar el nodo suscriptor para recibir las actualizaciones del publicador. **Para configurar el nodo suscriptor y crear una suscripción para recibir actualizaciones** En estos pasos se asume que la instancia de base de datos de RDS para PostgreSQL se ha configurado con la extensión `pglogical`. Para obtener más información, consulte [Configuración de la extensión pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md). 1. Utilice `psql` para conectarse a la instancia en la que desea recibir actualizaciones del publicador. ``` psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. En , la instancia de base de datos de RDS para PostgreSQL del suscriptor, cree la misma tabla que existe en el publicador. En este ejemplo, la tabla es `docs_lab_table`. Puede crear la tabla tal y como se indica a continuación. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Compruebe que esta tabla esté vacía. ``` SELECT count(*) FROM docs_lab_table; count ------- 0 (1 row) ``` 1. Identifique esta instancia de base de datos de RDS para PostgreSQL como nodo suscriptor de la siguiente manera. ``` SELECT pglogical.create_node( node_name := 'docs_lab_target', dsn := 'host=target-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=********'); create_node ------------- 2182738256 (1 row) ``` 1. Cree la suscripción. ``` SELECT pglogical.create_subscription( subscription_name := 'docs_lab_subscription', provider_dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=*******', replication_sets := ARRAY['default'], synchronize_data := true, forward_origins := '{}' ); create_subscription --------------------- 1038357190 (1 row) ``` Al completar este paso, los datos de la tabla del publicador se crean en la tabla del suscriptor. Para comprobar que ha ocurrido esto, utilice la siguiente consulta SQL. ``` SELECT count(*) FROM docs_lab_table; count ------- 5000 (1 row) ``` A partir de este momento, los cambios realizados en la tabla del publicador se replicarán en la tabla del suscriptor. # Restablecimiento de la replicación lógica después de una actualización principal Para poder realizar una actualización de una versión principal de un instancia de base de datos de RDS para PostgreSQL que se haya configurado como nodo publicador para la replicación lógica, debe eliminar todas las ranuras de replicación, incluso las que no estén activas. Se recomienda desviar temporalmente las transacciones de la base de datos del nodo publicador, eliminar las ranuras de replicación, actualizar la instancia de base de datos de RDS para PostgreSQL y, a continuación, restablecer y reiniciar la replicación. Las ranuras de replicación se alojan únicamente en el nodo publicador. El nodo suscriptor de RDS para PostgreSQL en un escenario de replicación lógica no tiene espacios que eliminar, pero no se puede actualizar a una versión principal mientras esté designado como nodo suscriptor con una suscripción al publicador. Antes de actualizar el nodo suscriptor de RDS para PostgreSQL, elimine la suscripción y el nodo. Para obtener más información, consulte [Administración de ranuras de replicación lógica para RDS para PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md). ## Determinación de que la replicación lógica se ha interrumpido Puede determinar que el proceso de replicación se ha interrumpido consultando el nodo publicador o el nodo suscriptor de la siguiente manera. **Para comprobar el nodo publicador** + Utilice `psql` para conectarse al nodo publicador y, a continuación, consulte la función `pg_replication_slots`. Anote el valor de la columna activa. Normalmente, esto devolverá `t` (true) y mostrará que la replicación está activa. Si la consulta devuelve `f` (false), indica que la replicación en el suscriptor se ha detenido. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_labcb4fa94_docs_lab3de412c | pglogical_output | logical | f (1 row) ``` **Para comprobar el nodo suscriptor** En el nodo suscriptor, puede comprobar el estado de la replicación de tres maneras diferentes. + Revise los registros de PostgreSQL en el nodo suscriptor para encontrar los mensajes de error. El registro identifica el error con mensajes que incluyen el código de salida 1, como se muestra a continuación. ``` 2022-07-06 16:17:03 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 14610) exited with exit code 1 2022-07-06 16:19:44 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 21783) exited with exit code 1 ``` + Consulte la función `pg_replication_origin`. Conéctese a la base de datos en el nodo suscriptor mediante `psql` y consulte la función `pg_replication_origin` de la siguiente manera. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+-------- (0 rows) ``` Un conjunto de resultados vacío significa que la replicación se ha interrumpido. Debería ver una salida como la siguiente. ``` roident | roname ---------+---------------------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` + Consulte la función `pglogical.show_subscription_status` tal y como se muestra en el siguiente ejemplo. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name ---====----------------+--------+------------------------------------- docs_lab_subscription | down | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` Este resultado muestra que la replicación se ha interrumpido. Su estado es `down`. Normalmente, la salida muestra el estado como `replicating`. Si el proceso de replicación lógica se ha interrumpido, puede restablecerla siguiendo estos pasos. **Para restablecer la replicación lógica entre los nodos publicador y suscriptor** Para restablecer la replicación, primero debe desconectar el suscriptor del nodo publicador y, a continuación, restablecer la suscripción, tal como se describe en estos pasos. 1. Conéctese al nodo suscriptor con `psql` de la siguiente manera. ``` psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Desactive la suscripción mediante la función `pglogical.alter_subscription_disable`. ``` SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true); alter_subscription_disable ---------------------------- t (1 row) ``` 1. Obtenga el identificador del nodo publicador consultando el `pg_replication_origin` de la siguiente manera. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` 1. Utilice la respuesta del paso anterior con el comando `pg_replication_origin_create` para asignar el identificador que podrá utilizar la suscripción cuando se restablezca. ``` SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c'); pg_replication_origin_create ------------------------------ 1 (1 row) ``` 1. Para activar la suscripción, introduzca su nombre con un estado de `true`, tal como se muestra en el ejemplo siguiente. ``` SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true); alter_subscription_enable --------------------------- t (1 row) ``` Compruebe el estado del nodo. Su estado debería ser `replicating`, tal y como se muestra en este ejemplo. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name -------------------------------+-------------+------------------------------------- docs_lab_subscription | replicating | pgl_labdb_docs_lab98f517b_docs_lab3de412c (1 row) ``` Compruebe el estado de la ranura de replicación del suscriptor en el nodo publicador. La columna `active` de la ranura debe devolver `t` (true), lo que indica que se ha restablecido la replicación. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_lab98f517b_docs_lab3de412c | pglogical_output | logical | t (1 row) ``` # Administración de ranuras de replicación lógica para RDS para PostgreSQL Para poder realizar una actualización de una versión principal en instancia de base de datos de RDS para PostgreSQL que se utilice como nodo publicador en un escenario de replicación lógica, debe eliminar todas las ranuras de replicación de la instancia. El proceso de comprobación previa de la actualización de la versión principal le indica que la actualización no puede continuar hasta que se eliminen las ranuras disponibles. Para eliminar ranuras de su instancia de base de datos de RDS para PostgreSQL, primero elimine la suscripción y, a continuación, elimine la ranura. Para identificar las ranuras de replicación que se crearon con la extensión `pglogical`, inicie sesión en cada base de datos y obtenga el nombre de los nodos. Al consultar el nodo suscriptor, aparecen los nodos publicador y suscriptor en el resultado, tal como se muestra en este ejemplo. ``` SELECT * FROM pglogical.node; node_id | node_name ------------+------------------- 2182738256 | docs_lab_target 3410995529 | docs_lab_provider (2 rows) ``` Puede obtener los detalles de la suscripción con la siguiente consulta. ``` SELECT sub_name,sub_slot_name,sub_target FROM pglogical.subscription; sub_name | sub_slot_name | sub_target ----------+--------------------------------+------------ docs_lab_subscription | pgl_labdb_docs_labcb4fa94_docs_lab3de412c | 2182738256 (1 row) ``` Ahora puede eliminar la suscripción de la siguiente manera. ``` SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription'); drop_subscription ------------------- 1 (1 row) ``` Después de eliminar la suscripción, puede eliminar el nodo. ``` SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber'); drop_node ----------- t (1 row) ``` Puede comprobar que el nodo ya no existe de la siguiente manera. ``` SELECT * FROM pglogical.node; node_id | node_name ---------+----------- (0 rows) ``` # Referencia de parámetros para la extensión pglogical En la tabla verá los parámetros asociados a la extensión `pglogical`. Parámetros como `pglogical.conflict_log_level` y `pglogical.conflict_resolution` se utilizan para gestionar los conflictos de actualización. Pueden surgir conflictos cuando los cambios se realizan localmente en las mismas tablas que están suscritas a los cambios del publicador. Los conflictos también pueden producirse en varios escenarios, como la replicación bidireccional o cuando varios suscriptores replican desde el mismo publicador. Para obtener más información, consulte [PostgreSQL bi-directional replication using pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/) (Replicación bidireccional de PostgreSQL mediante pglogical). | Parámetro | Descripción | | --- | --- | | pglogical.batch\$1inserts | Inserciones por lotes si es posible. No establecido de manera predeterminada. Se cambia a 1 para activarlo y a 0 para desactivarlo. | | pglogical.conflict\$1log\$1level | Establece el nivel de registro utilizado para registrar los conflictos resueltos. Los valores permitidos son debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal y panic. | | pglogical.conflict\$1resolution | Establece el método que se utilizará para resolver conflictos si es posible resolverlos. Los valores de cadena admitidos son error, apply\$1remote, keep\$1local, last\$1update\$1wins y first\$1update\$1wins. | | pglogical.extra\$1connection\$1options | Opciones de conexión a añadir a todas las conexiones de los nodos pares. | | pglogical.synchronous\$1commit | valor de confirmación sincrónica específico de pglogical | | pglogical.use\$1spi | Utilice la SPI (interfaz de programación de servidores) en lugar de la API de nivel inferior para aplicar los cambios. Se establece en 1 para activarlo y en 0 para desactivarlo. Para obtener más información acerca de la SPI, consulte [Server Programming Interface](https://www.postgresql.org/docs/current/spi.html) (Interfaz de programación de servidores) en la documentación de PostgreSQL. |