Considerações sobre a replicação lógica e a decodificação lógica Como trabalhar com slots de replicação lógica Replicar dados em nível de tabela usando replicação lógica

Executar replicação lógica para o Amazon RDS para PostgreSQL

A partir da versão 10.4, o RDS para PostgreSQL é compatível com a sintaxe SQL de publicação e assinatura, que foi introduzida pela primeira vez no PostgreSQL 10. Para saber mais, consulte Logical replication (Replicação lógica) na documentação do PostgreSQL.

nota

Além do recurso nativo de replicação lógica do PostgreSQL introduzido no PostgreSQL 10, o RDS para PostgreSQL também é compatível com a extensão pglogical. Para obter mais informações, consulte Usar pglogical para sincronizar dados entre instâncias.

A seguir, você pode encontrar informações sobre como configurar a replicação lógica de uma instância de banco de dados do RDS para PostgreSQL.

Tópicos

Considerações sobre a replicação lógica e a decodificação lógica
Como trabalhar com slots de replicação lógica
Replicar dados em nível de tabela usando replicação lógica

Considerações sobre a replicação lógica e a decodificação lógica

O RDS para PostgreSQL oferece suporte a transmissão de alterações de Write-Ahead Log (WAL – Log de gravação antecipada) usando slots de replicação lógica. Ele também permite o uso de decodificação lógica. Você pode configurar slots de replicação lógica em sua instância e transmitir alterações no banco de dados por meio desses slots para um cliente, como pg_recvlogical. Você cria slots de replicação lógica no nível do banco de dados. Esses slots são compatíveis com conexões de replicação para um único banco de dados.

Os clientes mais comuns para replicação lógica do PostgreSQL são o AWS Database Migration Service ou um host gerenciado personalizado em uma instância do Amazon EC2. O slot de replicação lógica não tem informações sobre o receptor do transmissão. Além disso, não é exigido que o destino seja um banco de dados de réplica. Se você configurar um slot de replicação lógica e não fizer a leitura no slot, os dados poderão ser gravados no armazenamento da instância de banco de dados e lotá-lo rapidamente.

Ative a replicação lógica do PostgreSQL e a descodificação lógica no Amazon RDS com um parâmetro, um tipo de conexão de replicação e uma função de segurança. O cliente da descodificação lógica pode ser qualquer cliente que possa estabelecer uma conexão de replicação a um banco de dados em uma instância de banco de dados PostgreSQL.

Como ativar a descodificação lógica de uma instância de banco de dados do RDS para PostgreSQL

Verifique se a conta de usuário que você está usando tem as seguintes funções:
- A função rds_superuser para que você possa ativar a replicação lógica
- A função rds_replication atribui as permissões necessárias para gerenciar slots lógicos e transmitir dados usando slots lógicos.
Defina o parâmetro estático rds.logical_replication como 1. Como parte da aplicação desse parâmetro, defina também os parâmetros wal_level, max_wal_senders, max_replication_slots e max_connections. Essas alterações de parâmetros podem aumentar a geração de WALs. Portanto, configure o parâmetro rds.logical_replication quando estiver usando slots lógicos.
Reinicialize a instância de banco de dados para que o parâmetro estático rds.logical_replication tenha efeito.
Crie um slot de replicação lógica conforme explicado na próxima seção. Esse processo requer que você especifique um plug-in de decodificação. Atualmente, o RDS para PostgreSQL aceita os plug-ins de saída test_decoding e wal2json fornecidos com o PostgreSQL.

Para obter mais informações sobre a descodificação lógica do PostgreSQL, consulte a documentação do PostgreSQL.

Como trabalhar com slots de replicação lógica

Você pode usar comandos SQL para trabalhar com slots lógicos. Por exemplo, o comando a seguir cria um slot lógico denominado test_slot usando o plug-in de saída padrão test_decoding do PostgreSQL.


SELECT * FROM pg_create_logical_replication_slot('test_slot', 'test_decoding');
slot_name    | xlog_position
-----------------+---------------
regression_slot | 0/16B1970
(1 row)

Para listar slots lógicos, use o seguinte comando.


SELECT * FROM pg_replication_slots;

Para descartar um slot lógico, use o seguinte comando.


SELECT pg_drop_replication_slot('test_slot');
pg_drop_replication_slot
-----------------------
(1 row)

Para obter mais exemplos sobre como trabalhar com slots lógicos de replicação, consulte “Logical decoding examples” (Exemplos de decodificação lógica) na documentação do PostgreSQL.

Após criar um slot de replicação lógica, você pode iniciar o streaming. O exemplo a seguir mostra como a decodificação lógica é controlada sobre o protocolo de replicação de streaming. Este exemplo usa o programa pg_recvlogical, incluído na distribuição do PostgreSQL. Para fazer Isso, a autenticação do cliente deve estar configurada para permitir conexões de replicação.


pg_recvlogical -d postgres --slot test_slot -U postgres
    --host -instance-name.111122223333.aws-region.rds.amazonaws.com 
    -f -  --start

Para ver o conteúdo da visualização pg_replication_origin_status, consulte a função pg_show_replication_origin_status.


SELECT * FROM pg_show_replication_origin_status();
local_id | external_id | remote_lsn | local_lsn
----------+-------------+------------+-----------
(0 rows)

Replicar dados em nível de tabela usando replicação lógica

Você pode usar a replicação lógica para replicar dados das tabelas de origem para as tabelas de destino no RDS para PostgreSQL. A replicação lógica primeiro executa um carregamento inicial dos dados existentes das tabelas de origem e, em seguida, continua a replicar as alterações em andamento.

Criar as tabelas de origem

Conecte-se ao banco de dados de origem na instância de banco de dados do RDS para PostgreSQL:
```
source=> CREATE TABLE testtab (slno int primary key);
CREATE TABLE
        
```

Inserir dados nas tabelas de origem



source=> INSERT INTO testtab VALUES (generate_series(1,1000));
INSERT 0 1000

Criar uma publicação para tabelas de origem

Crie uma publicação para tabelas de origem:



source=> CREATE PUBLICATION testpub FOR TABLE testtab;
CREATE PUBLICATION

Use uma consulta SELECT para verificar os detalhes da publicação que foi criada:



source=> SELECT * FROM pg_publication;
  oid   | pubname | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate | pubviaroot
--------+---------+----------+--------------+-----------+-----------+-----------+-------------+------------
 115069 | testpub |    16395 | f            | t         | t         | t         | t           | f
(1 row)

Verifique se as tabelas de origem foram adicionadas à publicação:



source=> SELECT * FROM pg_publication_tables; 
pubname | schemaname | tablename
---------+------------+-----------
 testpub | public     | testtab
(1 rows)

Para replicar todas as tabelas em um banco de dados, use:



CREATE PUBLICATION testpub FOR ALL TABLES;

Se a publicação já tiver sido criada para uma tabela individual e você precisar adicionar uma nova tabela, execute a seguinte consulta para adicionar novas tabelas à publicação existente:
```
ALTER PUBLICATION <publication_name> add table <new_table_name>;
          
```

Conectar-se ao banco de dados de destino e criar tabelas de destino
- Conecte-se ao banco de dados de destino na instância de banco de dados de destino. Crie as tabelas de destino com o mesmo nome das tabelas de origem:
```
target=> CREATE TABLE testtab (slno int primary key);
CREATE TABLE
```
- Verifique se não há dados presentes nas tabelas de destino executando uma consulta SELECT nas tabelas de destino:
```
    
target=> SELECT count(*) FROM testtab;
 count
-------
     0
(1 row)
        
```

Criar e verificar a assinatura no banco de dados de destino

Crie a assinatura no banco de dados de destino:



target=> CREATE SUBSCRIPTION testsub 
CONNECTION 'host=<source RDS/host endpoint> port=5432 dbname=<source_db_name> user=<user> password=<password>' 
PUBLICATION testpub;
NOTICE:  Created replication slot "testsub" on publisher
CREATE SUBSCRIPTION

Use uma consulta SELECT para verificar se a assinatura está habilitada:



target=> SELECT oid, subname, subenabled, subslotname, subpublications FROM pg_subscription;
  oid  | subname | subenabled | subslotname | subpublications
-------+---------+------------+-------------+-----------------
 16434 | testsub | t          | testsub     | {testpub}
(1 row)

Quando a assinatura é criada, ela carrega todos os dados das tabelas de origem para as tabelas de destino. Execute uma consulta SELECT nas tabelas de destino para verificar se os dados iniciais foram carregados:
```
target=> SELECT count(*) FROM testtab;
 count
-------
  1000
(1 row)
        
```

Verificar o slot de replicação no banco de dados de origem

A criação de uma assinatura no banco de dados de destino cria um slot de replicação no banco de dados de origem. Verifique os detalhes do slot de replicação executando a seguinte consulta SELECT no banco de dados de origem:



source=> SELECT * FROM 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
----------+----------+-----------+--------+----------+-----------+--------+------------+------+--------------+-------------+---------------------+------------+---------------
testsub   | pgoutput | logical   | 115048 | source   | f         | t      |        846 |      |         6945 | 58/B4000568 | 58/B40005A0         | reserved   |
(1 row)

Testar a replicação
- Teste se as alterações de dados nas tabelas de origem estão sendo replicadas para as tabelas de destino inserindo linhas nas tabelas de origem:
```
source=> INSERT INTO testtab VALUES(generate_series(1001,2000));
INSERT 0 1000

source=> SELECT count(*) FROM testtab; 
 count
-------
  2000
(1 row)
      
```
- Verifique o número de linhas nas tabelas de destino para confirmar se novas inserções estão sendo replicadas:
```
target=> SELECT count(*) FROM testtab;
 count
-------
  2000
(1 row)
      
```
Atualizar a assinatura depois de adicionar tabelas
- Quando você adiciona novas tabelas a uma publicação existente, é obrigatório atualizar a assinatura para que as alterações entrem em vigor:
```
ALTER SUBSCRIPTION <subscription_name> REFRESH PUBLICATION;
      
```
- Esse comando busca informações ausentes da tabela no publicador e inicia a replicação das tabelas que foram adicionadas às publicações assinadas desde que a assinatura foi criada ou atualizada pela última vez.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Páginas grandes

Disco de RAM para o stats_temp_directory