Supervisa la replicación pglogical en AlloyDB Omni

En esta página, se proporciona información para supervisar y solucionar problemas de las implementaciones de pglogical mediante la verificación y validación de las bases de datos del proveedor y del suscriptor.

La información de esta página solo se aplica a las implementaciones de un solo servidor de AlloyDB Omni. No se aplica a las implementaciones de AlloyDB Omnibasadas en Kubernetes.

Antes de comenzar

Antes de comenzar a supervisar y solucionar problemas de las implementaciones de pglogical, verifica las bases de datos del proveedor y del suscriptor, comprende la implementación de pglogical y valida cómo está configurada.

Para obtener más información sobre la extensión pglogical, consulta Acerca de pglogical.

Para obtener información sobre la replicación de datos con pglogical, consulta Cómo replicar datos entre Google Cloud AlloyDB y AlloyDB Omni y Cómo replicar datos entre AlloyDB Omni y otras bases de datos.

Verifica la configuración de parámetros de pglogical, la replicación y AlloyDB Omni

Varios parámetros de configuración afectan el funcionamiento de la extensión pglogical, y puedes verificarlo en las bases de datos del proveedor y del suscriptor. Ten en cuenta que los valores de los parámetros pueden variar.

1. Muestra la configuración actual de los parámetros específicos de pglogical:

   SELECT name,
       setting,
       source,
       short_desc
   FROM pg_catalog.pg_settings
   WHERE name LIKE '%pglogical%' AND name NOT LIKE '%alloydb%'
   ORDER BY category, name;
   

2. Muestra otros parámetros lógicos relacionados con la replicación:

   SELECT name,
       setting,
       source,
       short_desc
   FROM pg_catalog.pg_settings
   WHERE name IN ('wal_level',
                'max_worker_processes',
                'max_replication_slots',
                'max_wal_senders',
                'shared_preload_libraries',
                'track_commit_timestamp')
   ORDER BY name;
   

3. Muestra los parámetros específicos de AlloyDB Omni:

   SELECT name,
       setting,
       source,
       short_desc
   FROM pg_catalog.pg_settings
   WHERE name LIKE '%alloydb%'
   ORDER BY category, name;
   

Nota: Te recomendamos que revises la configuración de los parámetros en todos los nodos.

Muestra una lista de los nodos en la configuración

1. Enumera los nodos locales y remotos en la configuración de replicación de pglogical:

   SELECT node_id,
       if_nodeid AS node_id,
       if_name AS node_name,
       if_dsn AS dsn
   FROM pglogical.node_interface
   LEFT JOIN pglogical.local_node ON (node_id = if_nodeid AND node_local_interface = if_id)
   ORDER BY node_name;
   

   Si la columna node_id es NOT NULL, ese es el nodo local.

2. Revisa la información de dsn en detalle. Cualquier información incorrecta o desactualizada de la cadena de conexión puede provocar fallas de replicación. Para obtener información sobre la solución de problemas de dsn, consulta Soluciona problemas de replicación de suscripciones.

Verifica el estado de la suscripción y el punto de replicación de la tabla

El estado de la suscripción siempre se verifica desde la base de datos de suscriptores. La suscripción muestra un estado de initializing o replicating. También muestra un estado de down. Para obtener más información sobre el estado down, consulta Soluciona problemas relacionados con la replicación de suscripciones.

1. Muestra una lista de las suscripciones, su estado y configuración actuales en la base de datos actual:

   SELECT s.sub_name AS subscription_name,
       n1.node_name AS origin_name,
       n2.node_name AS target_name,
       x.status,
       sub_slot_name,
       sub_replication_sets,
       sub_forward_origins,
       sub_apply_delay,
       sub_force_text_transfer,
       sub_enabled AS enabled
   FROM pglogical.subscription s,
       (SELECT subscription_name, status FROM pglogical.show_subscription_status()) AS x,
       pglogical.node n1,
       pglogical.node n2
   WHERE s.sub_origin = n1.node_id
   AND s.sub_target = n2.node_id
   AND s.sub_name = x.subscription_name
   ORDER BY s.sub_name;
   

   El resultado es similar a este:

   -[ RECORD 1 ]-----------+--------------------------------------
   subscription_id         | 3072625608
   subscription_name       | test_sub_1
   origin_name             | provider
   target_name             | subscriber
   status                  | replicating
   sub_slot_name           | pgl_my_test_db_provider_test_sub_1
   sub_replication_sets    | {default,default_insert_only,ddl_sql}
   sub_forward_origins     | {all}
   sub_apply_delay         | 00:00:00
   sub_force_text_transfer | f
   enabled                 | t
   my_test_db=#
   

2. La suscripción enumera las tablas que se replican actualmente y su número de secuencia de registro (LSN) actual:

   SELECT sync_nspname||'.'||sync_relname AS table_name,
       sync_status,
       sync_statuslsn
   FROM pglogical.local_sync_status
   WHERE sync_relname IS NOT NULL
   ORDER BY table_name;
   

   El resultado es similar a este:

     table_name      | sync_status | sync_statuslsn 
   ---------------------+-------------+----------------
   public.test_table_1 | r           | 0/B891BC0
   (1 row)
   
   my_test_db=#
   

   La columna sync_statuslsn muestra con qué LSN se sincroniza la tabla. Puedes comparar esto con el LSN en la base de datos del proveedor para medir el retraso de la replicación.

3. Verifica el estado de replicación de una tabla específica:

   SELECT * FROM pglogical.show_subscription_table('test_sub_1','test_table_1');
   

Verifica los detalles del conjunto de replicación en el proveedor

1. Enumera los conjuntos de replicación actuales en la base de datos del proveedor y verifica los elementos que se replican:

   SELECT set_name,
       node_name,
       replicate_insert,
       replicate_update,
       replicate_delete,
       replicate_truncate
   FROM pglogical.replication_set
   JOIN pglogical.node ON set_nodeid = node_id
   ORDER BY set_name, node_name;
   

2. Enumera las tablas y secuencias que se replican actualmente:

   -- Table details:
   SELECT set_name,
       set_reloid AS table_name,
       set_att_list,
       set_row_filter
   FROM pglogical.replication_set
   NATURAL JOIN pglogical.replication_set_table
   ORDER BY set_name, table_name;
   
   -- Sequence details:
   SELECT set_name,
       set_seqoid AS sequence_name
   FROM pglogical.replication_set
   NATURAL JOIN pglogical.replication_set_seq
   ORDER BY set_name, sequence_name;
   

Verifica la información de replicación y el retraso de la ranura en el proveedor

1. Para verificar el estado de cada suscriptor, genera la vista pg_stat_replication en la base de datos del proveedor:

   SELECT application_name,
       state,
       sync_state,
       client_addr,
       client_hostname,
       pg_wal_lsn_diff(pg_current_wal_lsn(),sent_lsn) AS sent_lag,
       pg_wal_lsn_diff(sent_lsn,flush_lsn) AS receiving_lag,
       pg_wal_lsn_diff(flush_lsn,replay_lsn) AS replay_lag,
       pg_wal_lsn_diff(pg_current_wal_lsn(),replay_lsn) AS total_lag,
       now()-reply_time AS reply_delay
   FROM pg_stat_replication
   ORDER BY client_hostname;
   

   El resultado es similar a este:

   -[ RECORD 1 ]----+------------------------------
   application_name | test_sub_1
   state            | streaming
   sync_state       | async
   client_addr      | 10.45.0.80
   client_hostname  | 
   sent_lag         | 0
   receiving_lag    | 0
   replay_lag       | 0
   total_lag        | 0
   reply_delay      | 00:00:26.203433
   
   my_test_db=#
   

   Precaución: Asegúrate de revisar solo las entradas de pglogical. Correlaciona la columna application_name con el nombre de la suscripción de la base de datos del suscriptor.

2. Ten en cuenta la columna reply_delay, que muestra la hora en la que recibió la última actualización de la base de datos de suscriptores.

3. Supervisa el retraso de replicación de la ranura de replicación en el proveedor, ya que pglogical crea ranuras de replicación en la base de datos del proveedor:

   SELECT slot_name,
       slot_type,
       database,
       active,
       COALESCE(pg_wal_lsn_diff(pg_current_wal_lsn(),restart_lsn),0) AS restart_lag,
       COALESCE(pg_wal_lsn_diff(pg_current_wal_lsn(),confirmed_flush_lsn),0) AS confirmed_flush_lag
   FROM pg_replication_slots
   WHERE plugin like '%pglogical%'
   ORDER BY slot_name;
   

   El resultado es similar a este:

   -[ RECORD 1 ]-------+-----------------------------------
   slot_name           | pgl_my_test_db_provider_test_sub_1
   slot_type           | logical
   database            | my_test_db
   active              | t
   restart_lag         | 56
   confirmed_flush_lag | 0
   
   my_test_db=# 
   

   Importante: Otras herramientas y extensiones pueden crear ranuras de replicación. Debes asegurarte de que la ranura de replicación que se revisa corresponda a un conjunto de replicación pglogical. Esto se incluye en el complemento, como el predicado de consulta '%pglogical%'.

Soluciona problemas de replicación de suscripciones

La suscripción que se verifica en la base de datos de suscriptores debe mostrar un estado de replicating o initializing si se creó recientemente. Si el estado es down, significa que se produjo un problema.

El estado down suele mostrarse después de que se intentó iniciar la replicación, pero falló. Esto se debe a problemas de conectividad causados por la configuración de dsn o a la falta de permisos de la base de datos, ya sea en el proveedor o en el suscriptor.

Usa el Explorador de registros y, luego, inspecciona los archivos de registro de PostgreSQL en Google Cloud cuando Google Cloud AlloyDB sea uno de los extremos para obtener información adicional que pueda indicar la causa del problema. Los archivos de registro proporcionan detalles del problema, incluidos detalles específicos sobre los permisos que faltan.

1. Verifica el registro de PostgreSQL en tu servidor de AlloyDB Omni:

   Docker

   docker logs CONTAINER_NAME

   Reemplaza CONTAINER_NAME por el nombre que le asignaste al contenedor de AlloyDB Omni cuando lo instalaste.

   Podman

   podman logs CONTAINER_NAME

   Reemplaza CONTAINER_NAME por el nombre que le asignaste al contenedor de AlloyDB Omni cuando lo instalaste.

2. Soluciona los problemas relacionados con la configuración de dsn y asegúrate de que la conectividad de red no sea la fuente del problema:

   1. Copia la cadena de conexión dsn y prueba una conexión manual con psql y la misma cadena. Si la sesión de psql no puede conectarse, se indica lo siguiente:
      • Un problema de red
      • Una dirección IP, un nombre de usuario o una contraseña incorrectos
      • Un firewall de bloqueo
      • El archivo pg_hba.conf del otro clúster no está configurado correctamente.

3. Vuelve a sincronizar una tabla si no quieres descartar y volver a crear la suscripción después de tomar medidas correctivas:

   SELECT pglogical.alter_subscription_resynchronize_table(subscription_name := 'test_sub_1',relation := 'table_name');
   

   Precaución: Esta función trunca la tabla.

4. Como alternativa, puedes cancelar la suscripción y volver a crearla:

   SELECT pglogical.drop_subscription(subscription_name := 'test_sub_1');
   

¿Qué sigue?

• Cambio y conmutación por error con replicación de pglogical
• Cómo replicar datos entre Google Cloud AlloyDB y AlloyDB Omni
• Replica datos entre AlloyDB Omni y otras bases de datos