Come posso utilizzare la replica logica per aggiornare il mio cluster di database Aurora compatibile con PostgreSQL?

Breve descrizione

Per utilizzare la replica logica per aggiornare le versioni dei cluster di database Aurora compatibili con PostgreSQL, imposta la replica tra cluster di origine originale e nuovo cluster di destinazione. Quindi esegui gradualmente la migrazione delle modifiche dei dati e passa le applicazioni al nuovo cluster.

Risoluzione

Prepara il cluster di origine

Completa i seguenti passaggi:

1. Imposta il parametro rds.logical_replication su 1 nel gruppo di parametri del cluster di database personalizzato.

2. Esegui questa query per verificare che wal_level sia logical e che rds.logical_replication sia on:

   SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication');

   Esempio di output:

   name                    | setting
   ------------------------+---------
   rds.logical_replication | on
   wal_level              | logical
   (2 rows)

3. Esegui questo comando per creare una pubblicazione nel database:

   CREATE PUBLICATION my_publication FOR ALL TABLES;

   Nota: sostituisci my_publication con il nome della tua pubblicazione.

4. Esegui questa query per recuperare informazioni dalla pubblicazione:

   SELECT * FROM pg_publication;

   Esempio di output:

    oid   | pubname        | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate | pubviaroot
   -------+----------------+----------+--------------+-----------+-----------+-----------+-------------+------------
    20493 | my_publication | 16400    | t            | t         | t         | t         | t           | f
   (1 row)

5. Esegui questo comando per creare uno slot di replica nel database:

   SELECT pg_create_logical_replication_slot('my_replication_slot', 'pgoutput');

   Esempio di output per pg_create_logical_replication_slot:

    pg_create_logical_replication_slot
   ------------------------------------
    (my_replication_slot,0/6EC7260)
   (1 row)

   Nota: sostituisci my_replication_slot con il nome del tuo slot di replica.

6. Esegui questo comando per ottenere l'elenco degli slot di replica attualmente presenti nel cluster di database e il loro stato:

   SELECT * FROM pg_replication_slots;

   Esempio di output per pg_replication_slots:

    slot_name            | plugin   | slot_type | datoid | database | temporary | active | active_pid | xmin | catalog_xmin | restart_lsn | confirmed_flush_lsn | wal_status | safe_wal_size | two_phase
   ---------------------+----------+-----------+--------+----------+-----------+--------+------------+------+--------------+-------------+---------------------+------------+---------------+-----------
    my_replication_slot | pgoutput | logical   | 16401  | test     | f         | f      |            |      | 308479       | 0/6EC7208  | 0/6EC7260          | reserved   |               | f
   (1 row)

Clona il cluster di origine

Utilizza la console Amazon Relational Database Service (Amazon RDS) o l'Interfaccia della linea di comando AWS (AWS CLI) per creare un clone del cluster di database di origine Aurora compatibile con PostgreSQL.

Prepara il clone per un aggiornamento

Per ulteriori informazioni, consulta la sezione Per preparare il clone per un aggiornamento in Aggiornamento di Aurora PostgreSQL a una nuova versione principale.

Aggiorna il cluster a una nuova versione

Per ulteriori informazioni, consulta Per aggiornare il cluster a una nuova versione principale in Aggiornamento di Aurora PostgreSQL a una nuova versione principale.

Prepara il clone per la replica

Completa i seguenti passaggi:

1. Quando il clone diventa disponibile dopo l'aggiornamento, utilizza psql per connetterti al cluster, quindi esegui questo comando per creare la sottoscrizione:

   CREATE SUBSCRIPTION my_subscription
   CONNECTION 'postgres://admin_user_name:admin_user_password@source_instance_URL/database'
   PUBLICATION my_publication
   WITH (copy_data = false,
         create_slot = false,
         enabled = false,
         connect = true,
         slot_name = 'my_replication_slot');

   Nota: sostituisci admin_user_name con il nome utente del tuo cluster di origine e admin_user_password con la password del tuo cluster di origine. Inoltre, sostituisci source_instance_URL con l'endpoint del tuo cluster di origine e database con il nome del tuo database.

2. Esegui questa query per recuperare l'origine della replica che hai creato:

   SELECT * FROM pg_replication_origin;

   Esempio di output per pg_replication_origin:

    roident | roname
   ---------+----------
    1       | pg_32783
   (1 row)

3. Esegui questa query per recuperare informazioni sulla sottoscrizione della replica logica:

   SELECT * FROM pg_subscription;

   Esempio di output per pg_subscription:

    oid   | subdbid | subskiplsn | subname          | subowner | subenabled | subbinary | substream | subtwophasestate | subdisableonerr | subpasswordrequired | subrunasowner | subconninfo                                                                              | subslotname           | subsynccommit | subpublications    | suborigin
   -------+---------+------------+-----------------+----------+------------+-----------+-----------+------------------+-----------------+---------------------+---------------+------------------------------------------------------------------------------------------------+---------------------+---------------+------------------+-----------
    32783 | 16401   | 0/0        | my_subscription | 16400    | f          | f         | f         | d                | f               | t                   | f             | postgres://admin_user_name:admin_user_password@source_instance_URL/database                  | my_replication_slot   | off           | {my_publication}  | any
   (1 row)

4. Esegui questo comando per specificare il punto iniziale nella sequenza di log per la replica:

   SELECT pg_replication_origin_advance('roname', 'log_sequence_number');

   Nota: sostituisci roname con l'identificatore restituito dalla vista pg_replication_origin. Sostituisci log_sequence_number con il numero della tua sequenza di log.
   Esempio di output:

    pg_replication_origin_advance
   ------------------------------
   
   (1 row)

5. Esegui questo comando per attivare la replica logica:

   ALTER SUBSCRIPTION my_subscription ENABLE;

   Nota: sostituisci my_subscription con il nome della tua sottoscrizione.
   Esempio di output:

   ALTER SUBSCRIPTION

6. Esegui questo comando per verificare che la replica funzioni:

   SELECT now() AS CURRENT_TIME,
          slot_name,
          active,
          active_pid,
          pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn)) AS diff_size,
          pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn) AS diff_bytes
   FROM pg_replication_slots
   WHERE slot_type = 'logical';

   Esempio di output:

        current_time      |      slot_name       | active | active_pid | diff_size | diff_bytes
   ----------------------+---------------------+--------+------------+-----------+------------
    2024-01-20 10:30:45 | my_replication_slot | t      | 12345      | 16 MB     | 16777216
   (1 row)

7. (Facoltativo) Esegui questo comando per monitorare il ritardo di replica:

   SELECT now() AS CURRENT_TIME,
          slot_name,
          active,
          active_pid,
          pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn)) AS diff_size,
          pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn) AS diff_bytes
   FROM pg_replication_slots
   WHERE slot_type = 'logical';

   Esempio di output:

   -[ RECORD 1 ]+------------------------------
   current_time | 2025-10-05 22:07:16.077928+00
   slot_name    | my_replication_slot
   active       | t
   active_pid   | 5392
   diff_size    | 0 bytes
   diff_bytes   | 0

   Nota: quando i valori precedenti raggiungono 0, la replica corrisponde all'istanza database di origine.

Esegui le attività successive all'aggiornamento

Per ulteriori informazioni, consulta Esecuzione delle attività successive all'aggiornamento.

Informazioni correlate

Come posso utilizzare la replica logica per replicare le tabelle tra le mie istanze database Amazon RDS per PostgreSQL?

Using logical replication to replicate managed Amazon RDS for PostgreSQL and Amazon Aurora to self-managed PostgreSQL (Utilizzo della replica logica per replicare Amazon RDS per PostgreSQL gestito e Amazon Aurora per PostgreSQL self-managed)