Mais confiabilidade no PostgreSQL 17: aproveitando o failover de replicação lógica

Antes de começar, garanta que você tenha:

1. AWS CLI configurada com access key e secret key.
2. Conectividade com as instâncias RDS.
3. Um Security Group (SG) de VPC já existente, permitindo que seu IP se conecte na porta 5432.

1. Crie e configure os parameter groups com os parâmetros necessários.
2. Provisione as instâncias RDS: crie as instâncias RDS PostgreSQL.
3. Configure a replicação lógica: defina os slots, publications e subscriptions.
4. Simule o failover e atualize a subscription: promova a read replica e aponte a subscription para o novo primary.
5. Teste o fluxo de replicação para garantir a consistência dos dados.
6. Faça a limpeza dos recursos.

1. Configure os Parameter Groups

• Primeiro, crie parameter groups customizados para o primary, a read replica e a logical replica. Habilite os seguintes parâmetros:

| Parâmetro                    | Valor     | Descrição                                                                       |
|------------------------------|-----------|---------------------------------------------------------------------------------|
| rds.logical_replication      | 1         | Habilita a replicação lógica na instância primary.                              |
| hot_standby_feedback         | 1         | Evita conflitos de query enviando feedback do standby para o primary.           |
| rds.logical_slot_sync_dbname | DB válido | Define o banco para sincronização do logical slot (padrão: `postgres`).         |
| synchronized_standby_slots   | Nome slot | Nome do slot de replicação física do standby que deve permanecer sincronizado.  |
| sync_replication_slots       | 1         | Habilita a sincronização automática dos slots de replicação.                    |

Crie o parameter group. Repita os mesmos passos para a read replica e a logical replica.

aws rds create-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --db-parameter-group-family postgres17 \
    --description "Logical replication setup with sync_replication_slots"

• Modifique os parâmetros. O synchronized_standby_slots só será definido depois que a read replica for criada:

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --parameters "ParameterName='rds.logical_replication',ParameterValue=logical,ApplyMethod=pending-reboot" \
                 "ParameterName='sync_replication_slots',ParameterValue=1,ApplyMethod=pending-reboot"

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-read-replica-group \
    --parameters "ParameterName='rds.logical_replication',ParameterValue=1,ApplyMethod=pending-reboot" \
                 "ParameterName='hot_standby_feedback',ParameterValue='1',ApplyMethod=pending-reboot" \
                 "ParameterName='rds.logical_slot_sync_dbname',ParameterValue='postgres',ApplyMethod=pending-reboot" \
                 "ParameterName='sync_replication_slots',ParameterValue=1,ApplyMethod=pending-reboot"

2. Provisione as instâncias RDS

• Pela AWS CLI, crie a instância primary, a logical replica e a read replica. Para fins de teste, essas instâncias terão acesso público:

aws rds create-db-instance \
    --db-instance-identifier primary-instance \
    --engine postgres \
    --engine-version 17.1 \
    --allocated-storage 20 \
    --master-username postgres \
    --master-user-password ChangeM3 \
    --db-instance-class db.t3.medium \
    --vpc-security-group-ids sg-xxxxxx

Repita o procedimento acima para a logical replica.

• Para a read replica:

aws rds create-db-instance-read-replica \
    --db-instance-identifier read-replica \
    --source-db-instance-identifier primary-instance

• Depois que a read replica for criada, obtenha o nome do slot físico na instância primary e atualize o parameter group pg-primary-group:

psql -h $DB_PRI -U postgres -t -c "SELECT slot_name FROM pg_replication_slots where slot_type='physical'"

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --parameters "ParameterName='synchronized_standby_slots',ParameterValue='rds_us_east_1_db_dn2uyr2436rexq3u7gcdfzw4hy',ApplyMethod=pending-reboot"

• Agora associe os parameter groups às instâncias correspondentes e reinicie.
• Verifique se os parâmetros estão definidos corretamente. Eles precisam estar configurados para que a replicação lógica continue funcionando após o failover:

psql -h $DB_PRI -U postgres -c "SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication','sync_replication_slots','synchronized_standby_slots')"
:' output
            name            |                   setting
----------------------------+---------------------------------------------
 rds.logical_replication    | on
 sync_replication_slots     | on
 synchronized_standby_slots | rds_us_east_1_db_dn2uyr2436rexq3u7gcdfzw4hy
 wal_level                  | logical
(4 rows)
'

# rds.logical_slot_sync_dbname is not available in pg_settings
# make sure to update it if your database is not "postgres."
psql -h $DB_RR -U postgres -c "SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication','sync_replication_slots','hot_standby_feedback','rds.logical_slot_sync_dbname')"
:' output
          name           | setting
-------------------------+---------
 hot_standby_feedback    | on
 rds.logical_replication | on
 sync_replication_slots  | on
 wal_level               | logical
(4 rows)
'

3. Configure a replicação lógica

Na instância primary:

• Crie a tabela de origem, popule com dados de exemplo e crie a publication:

CREATE TABLE reptab1 (slno int primary key);
INSERT INTO reptab1 VALUES (generate_series(1,1000));
CREATE PUBLICATION testpub FOR TABLE reptab1;

• Crie uma tabela idêntica e a subscription com failover = true na logical replica. Isso vai criar um slot de replicação lógica na primary-instance.

CREATE TABLE reptab1 (slno int primary key);
CREATE SUBSCRIPTION testsub CONNECTION 'host=<primary-endpoint> port=5432 dbname=postgres user=postgres password=ChangeM3' PUBLICATION testpub WITH (failover = true);

• Confirme se a subscription está ativa e se os dados foram copiados:

SELECT subname, subenabled FROM pg_subscription;
SELECT count(*) from reptab1;

• Você deve ver um slot de replicação lógica na instância read-replica:

psql -h $DB_RR -U postgres -c "select slot_name, slot_type, active, failover, synced from pg_replication_slots;"
:'output
 slot_name | slot_type | active | failover | synced
-----------+-----------+--------+----------+--------
 testsub   | logical   | f      | t        | t
(1 row)
'

4. Simule o failover e atualize a subscription

Para simular um failover:

• Promova a read replica a uma instância standalone:

aws rds promote-read-replica \
   --db-instance-identifier read-replica

• Atualize a subscription na logical replica para apontar para o novo primary:

ALTER SUBSCRIPTION testsub CONNECTION 'host=<read-replica-endpoint> port=5432 dbname=postgres user=postgres password=ChangeM3';

Com o sync_replication_slots habilitado, o slot de replicação lógica é preservado durante o failover, o que permite ao subscriber (logical replica) continuar replicando sem interrupções e sem precisar de resync.

• Insira novas linhas na read replica promovida para validar a replicação:

INSERT INTO reptab1 VALUES (generate_series(1001,2000));

• Confirme que a logical replica contém as linhas atualizadas:

SELECT COUNT(*) FROM reptab1;  -- Deve refletir os novos dados

Para evitar custos com recursos, exclua todas as instâncias RDS e os parameter groups:

aws rds delete-db-instance --db-instance-identifier primary-instance --skip-final-snapshot
aws rds delete-db-instance --db-instance-identifier read-replica --skip-final-snapshot
aws rds delete-db-instance --db-instance-identifier logical-replica --skip-final-snapshot

aws rds delete-db-parameter-group --db-parameter-group-name pg-primary-group
aws rds delete-db-parameter-group --db-parameter-group-name pg-read-replica-group
aws rds delete-db-parameter-group --db-parameter-group-name pg-logical-replica-group