Requisitos e limitações Configurar a extensão pglogical Configurar a replicação lógica Restabelecer a replicação lógica após uma atualização Gerenciar slots de replicação lógica Referência de parâmetros da extensão pglogical

Usar pglogical para sincronizar dados entre instâncias

Todas as versões do RDS para PostgreSQL atualmente disponíveis são compatíveis com a extensão pglogical. A extensão pglogical é anterior ao recurso de replicação lógica funcionalmente similar que foi introduzido pelo PostgreSQL na versão 10. Para obter mais informações, consulte Executar replicação lógica para o Amazon RDS para PostgreSQL.

A extensão pglogical é compatível com a replicação lógica entre dois ou mais Instâncias de banco de dados do RDS para PostgreSQL. Ela também é compatível com a replicação entre diferentes versões do PostgreSQL e entre bancos de dados executados em instâncias de banco de dados RDS para PostgreSQL e clusters de banco de dados Aurora PostgreSQL. A extensão pglogical usa um modelo de publicação e assinatura para replicar alterações em tabelas e outros objetos, como sequências, de um editor para um assinante. Ela depende de um slot de replicação para garantir que as alterações sejam sincronizadas de um nó do editor para um nó assinante, definido da seguinte forma.

O nó do editor é a instância de banco de dados RDS para PostgreSQL, que é a fonte de dados a serem replicados para outros nós. O nó do editor define as tabelas a serem replicadas em um conjunto de publicações.
O nó do assinante é a instância de banco de dados Aurora PostgreSQL que recebe atualizações WAL do editor. O assinante cria uma assinatura para se conectar ao editor e obter os dados WAL decodificados. Quando o assinante cria a assinatura, o slot de replicação é criado no nó do editor.

Depois, você pode encontrar informações sobre a configuração da extensão pglogical.

Tópicos

Requisitos e limitações da extensão pglogical
Configurar a extensão pglogical
Configurar a replicação lógica para a instância de banco de dados RDS para PostgreSQL
Restabelecer a replicação lógica após uma atualização principal
Gerenciar slots de replicação lógica para RDS para PostgreSQL
Referência de parâmetros da extensão pglogical

Requisitos e limitações da extensão pglogical

Todas as versões atualmente disponíveis do RDS para PostgreSQL são compatíveis com a extensão pglogical.

Tanto o nó do editor quanto o do assinante devem estar configurados para replicação lógica.

As tabelas que você deseja replicar de um publicador para um assinante devem ter os mesmos nomes e o mesmo esquema. Essas tabelas também devem conter as mesmas colunas, e as colunas devem usar os mesmos tipos de dados. As tabelas de editores e assinantes devem ter as mesmas chaves primárias. Recomendamos que você use somente a CHAVE PRIMÁRIA como restrição exclusiva.

As tabelas no nó do assinante podem ter mais restrições permissivas do que as do nó do editor para restrições CHECK e NOT NULL.

A extensão pglogical fornece recursos como replicação bidirecional que não são compatíveis com o recurso de replicação lógica incorporado ao PostgreSQL (versão 10 e superior). Para obter mais informações, consulte PostgreSQL bi-directional replication using pglogical (Replicação bidirecional do PostgreSQL usando pglogical).

Configurar a extensão pglogical

Para configurar a extensão pglogical em sua instância de banco de dados RDS para PostgreSQL , adicione pglogical às bibliotecas compartilhadas no grupo de parâmetros de banco de dados personalizado para sua instância de banco de dados RDS para PostgreSQL. Você também precisa definir o valor do parâmetro rds.logical_replication como 1, para ativar a decodificação lógica. Finalmente, você cria a extensão no banco de dados. Você pode usar o AWS Management Console ou a AWS CLI para essas tarefas.

Você deve ter permissões como a função rds_superuser para realizar essas tarefas.

As etapas a seguir pressupõem que sua instância de banco de dados do RDS para PostgreSQL esteja associada a um grupo de parâmetros de banco de dados. Para obter informações sobre como criar um grupo de parâmetros de banco de dados, consulte Grupos de parâmetros para Amazon RDS.

Como configurar a extensão pglogical

Faça login no AWS Management Console e abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
No painel de navegação, selecione sua instância de banco de dados do RDS para PostgreSQL.
Abra a guia Configuration (Configuração) para sua Instância de banco de dados do RDS para PostgreSQL. Entre os detalhes da instância, encontre o link Parameter group (Grupo de parâmetros).
Clique no link para abrir os parâmetros personalizados associados ao seu Instância de banco de dados do RDS para PostgreSQL.
No campo Parameters (Parâmetros), digite shared_pre para encontrar o parâmetro shared_preload_libraries.
Selecione Edit parameters (Editar parâmetros) para acessar os valores das propriedades.
Adicione pglogical à lista no campo Values (Valores). Use uma vírgula para separar itens na lista de valores.
Encontre o parâmetro rds.logical_replication e defina-o como 1 para ativar a replicação lógica.
Reinicialize a instância de banco de dados do RDS para PostgreSQL para que suas alterações tenham efeito.
Quando a instância estiver disponível, você poderá usar psql (ou pgAdmin) para se conectar à instância de banco de dados RDS para PostgreSQL.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```

Para verificar se pglogical foi inicializada, execute o comando a seguir.


SHOW shared_preload_libraries;
shared_preload_libraries 
--------------------------
rdsutils,pglogical
(1 row)

Verifique a configuração que permite a decodificação lógica da forma a seguir.
```
SHOW wal_level;
wal_level
-----------
 logical
(1 row)
```

Crie a extensão da forma a seguir.


CREATE EXTENSION pglogical;
EXTENSION CREATED

Escolha Salvar alterações.
Abra o console do Amazon RDS em https://console.aws.amazon.com/rds/.
Selecione a instância de banco de dados do RDS para PostgreSQL na lista de bancos de dados para selecioná-la e depois selecione Reboot (Reinicializar) no menu Actions (Ações).

Como configurar a extensão pglogical

Para configurar a pglogical usando a AWS CLI, chame a operação modify-db-parameter-group para modificar determinados parâmetros em seu grupo de parâmetros personalizado, conforme mostrado no procedimento a seguir.

Use o comando AWS CLI a seguir para adicionar pglogical ao 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

Use o comando AWS CLI a seguir para definir rds.logical_replication como 1 a fim de ativar o recurso de decodificação lógica para a Instância de banco de dados do 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

Use o comando AWS CLI a seguir para reinicializar a instância de banco de dados do RDS para PostgreSQL para que a biblioteca da pglogical seja inicializada.
```
aws rds reboot-db-instance \
    --db-instance-identifier your-instance \
    --region aws-region
```
Quando a instância estiver disponível, use psql para se conectar à instância de banco de dados RDS para PostgreSQL.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```

Crie a extensão da forma a seguir.


CREATE EXTENSION pglogical;
EXTENSION CREATED

Reinicie a instância de banco de dados do RDS para PostgreSQL usando o comando AWS CLI a seguir.


aws rds reboot-db-instance \
    --db-instance-identifier your-instance \
    --region aws-region

Configurar a replicação lógica para a instância de banco de dados RDS para PostgreSQL

O procedimento a seguir mostra como iniciar a replicação lógica entre duas instâncias de banco de dados RDS PostgreSQL. As etapas pressupõem que tanto a fonte (editor) quanto o destino (assinante) tenham a extensão pglogical configurada conforme detalhado em Configurar a extensão pglogical.

Como criar o nó do editor e definir as tabelas a serem replicadas

Estas etapas pressupõem que a instância de banco de dados do RDS para PostgreSQL tenha um banco de dados com uma ou mais tabelas que você deseja replicar para outro nó. Você precisa recriar a estrutura da tabela do editor no assinante, então, primeiro, obtenha a estrutura da tabela, se necessário. Você pode fazer isso usando o metacomando psq1 \d tablename e criando a mesma tabela na instância do assinante. O procedimento a seguir cria uma tabela de exemplo no editor (fonte) para fins de demonstração.

Use psql para se conectar à instância que tem a tabela que você deseja usar como fonte para assinantes.
```
psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
Se você não tiver uma tabela, crie uma tabela de exemplo da forma a seguir.
1. Crie uma tabela de exemplo usando a declaração SQL a seguir.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
2. Preencha a tabela com dados gerados usando a instrução SQL a seguir.
```
INSERT INTO docs_lab_table VALUES (generate_series(1,5000));
INSERT 0 5000
```
3. Verifique se os dados existem na tabela usando a declaração SQL a seguir.
```
SELECT count(*) FROM docs_lab_table;
```

Identifique essa instância de banco de dados do RDS para PostgreSQL como o nó do editor da forma a seguir.


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)

Adicione a tabela que você deseja replicar ao conjunto de replicação padrão. Para obter mais informações sobre conjuntos de replicação, consulte Replication sets (Conjuntos de replicação) na documentação da pglogical.
```
SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL);
 replication_set_add_table
  ---------------------------
  t
  (1 row)
```

A configuração do nó do editor está concluída. Agora você pode configurar o nó de assinante para receber as atualizações do editor.

Como configurar o nó de assinante e criar uma assinatura para receber atualizações

Estas etapas pressupõem que instância de banco de dados do RDS para PostgreSQL tenha sido configurada com a extensão pglogical. Para ter mais informações, consulte Configurar a extensão pglogical.

Use psql para se conectar à instância em que você deseja receber atualizações do editor.


psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb

Na instância de banco de dados RDS para PostgreSQL do assinante, crie a mesma tabela que existe no editor. Neste exemplo, a tabela é docs_lab_table. Você pode criar a tabela da seguinte maneira.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```

Verifique se essa tabela está vazia.


SELECT count(*) FROM docs_lab_table;
 count
-------
  0
(1 row)

Identifique essa instância de banco de dados RDS para PostgreSQL como o nó do assinante da forma a seguir.


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)

Crie a assinatura.


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)

Ao concluir essa etapa, os dados da tabela no editor são criados na tabela no assinante. Se você quiser verificar se isso ocorreu, verifique a consulta SQL a seguir.


SELECT count(*) FROM docs_lab_table;
 count
-------
  5000
(1 row)

Desse ponto em diante, as alterações feitas na tabela do editor são replicadas na tabela do assinante.

Restabelecer a replicação lógica após uma atualização principal

Antes de realizar uma atualização de versão principal de uma instância de banco de dados do RDS para PostgreSQL que está sendo configurada como um nó de editor para replicação lógica, você deve eliminar todos os slots de replicação, mesmo aqueles que não estão ativos. Recomendamos que você desvie temporariamente as transações do banco de dados do nó do editor, elimine os slots de replicação, atualize a instância de banco de dados do RDS para PostgreSQL e, depois, restabeleça e reinicie a replicação.

Os slots de replicação são hospedados somente no nó do editor. O nó de assinante do RDS para PostgreSQL em um cenário de replicação lógica não tem slots a serem descartados, mas não pode ser atualizado para uma versão principal enquanto estiver designado como um nó de assinante com uma assinatura do editor. Antes de atualizar o nó de assinante do RDS para PostgreSQL, elimine a assinatura e o nó. Para obter mais informações, consulte Gerenciar slots de replicação lógica para RDS para PostgreSQL.

Determinar se a replicação lógica foi interrompida

Você pode determinar se o processo de replicação foi interrompido consultando o nó do editor ou o nó do assinante da forma a seguir.

Como conferir o nó do editor

Use psql para se conectar ao nó do editor e, depois, consultar a função pg_replication_slots. Observe o valor na coluna ativa. Normalmente, isso retornará t (true) mostrando que a replicação está ativa. Se a consulta retornar f (false), é uma indicação de que a replicação para o assinante foi interrompida.


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)

Como conferir o nó do assinante

No nó do assinante, você pode conferir o status da replicação de três maneiras diferentes.

Examine os logs do PostgreSQL no nó do assinante para encontrar mensagens de falha. O log identifica falhas com mensagens que incluem o código de saída 1, conforme mostrado a seguir.


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 a função pg_replication_origin. Conecte-se ao banco de dados no nó do assinante usando psql e consulte a função pg_replication_origin da forma a seguir.
```
SELECT * FROM pg_replication_origin;
 roident | roname
---------+--------
(0 rows)
```
O conjunto de resultados vazio significa que a replicação foi interrompida. Normalmente, você deve ver a saída da forma a seguir.
```
   roident |                       roname
  ---------+----------------------------------------------------
         1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
  (1 row)
```

Consulte a função pglogical.show_subscription_status conforme exibido no exemplo a seguir.


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)

Essa saída mostra que a replicação foi interrompida. Seu status é down. Normalmente, a saída mostra o status como replicating.

Se seu processo de replicação lógica tiver sido interrompido, você poderá restabelecer a replicação seguindo estas etapas.

Como restabelecer a replicação lógica entre os nós do editor e do assinante

Para restabelecer a replicação, primeiro você desconecta o assinante do nó do editor e depois restabelece a assinatura, conforme descrito nestas etapas.

Conecte-se ao nó do assinante usando psql da forma a seguir.


psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb

Desative a assinatura usando a função pglogical.alter_subscription_disable.


SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true);
 alter_subscription_disable
----------------------------
 t
(1 row)

Obtenha o identificador do nó do editor consultando a pg_replication_origin da forma a seguir.


SELECT * FROM pg_replication_origin;
 roident |               roname
---------+-------------------------------------
       1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)

Use a resposta da etapa anterior com o comando pg_replication_origin_create para atribuir o identificador que pode ser usado pela assinatura quando restabelecida.


SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c');
  pg_replication_origin_create
------------------------------
                            1
(1 row)

Ative a assinatura passando seu nome com um status de true, conforme exibido no exemplo a seguir.


SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true);
  alter_subscription_enable
---------------------------
 t
(1 row)

Consulte o status do nó. Seu status deve ser replicating conforme mostrado neste exemplo.


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)

Confira o status do slot de replicação do assinante no nó do editor. A coluna active do slot deve retornar t (true), indicando que a replicação foi restabelecida.


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)

Gerenciar slots de replicação lógica para RDS para PostgreSQL

Antes de realizar uma atualização de versão principal de uma uma instância de banco de dados do RDS para PostgreSQL que está atuando como um nó de editor em um cenário de replicação lógica, você deve eliminar os slots de replicação na instância. O processo de pré-conferência da atualização da versão principal notifica você de que a atualização não pode continuar até que os slots sejam eliminados.

Para eliminar slots da sua instância de banco de dados do RDS para PostgreSQL, primeiro cancele a assinatura e depois o slot.

Para identificar os slots de replicação que foram criados usando a extensão pglogical, faça login em cada banco de dados e obtenha o nome dos nós. Ao consultar o nó do assinante, você obtém os nós do editor e do assinante na saída, conforme mostrado neste exemplo.


SELECT * FROM pglogical.node;
node_id   |     node_name
------------+-------------------
 2182738256 | docs_lab_target
 3410995529 | docs_lab_provider
(2 rows)

Você pode obter os detalhes sobre a assinatura com a consulta a seguir.


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)

Agora você pode cancelar a assinatura da forma a seguir.


SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription');
 drop_subscription
-------------------
                 1
(1 row)

Depois de cancelar a assinatura, você pode excluir o nó.


SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber');
 drop_node
-----------
 t
(1 row)

Você pode verificar se o nó não existe mais da forma a seguir.


SELECT * FROM pglogical.node;
 node_id | node_name
---------+-----------
(0 rows)

Referência de parâmetros da extensão pglogical

Na tabela, você pode encontrar parâmetros associados à extensão pglogical. Parâmetros como pglogical.conflict_log_level e pglogical.conflict_resolution são usados para lidar com conflitos de atualização. Podem surgir conflitos quando alterações são feitas localmente nas mesmas tabelas que estão inscritas para receber alterações do editor. Os conflitos também podem ocorrer durante vários cenários, como replicação bidirecional ou quando vários assinantes estão se replicando do mesmo editor. Para obter mais informações, consulte PostgreSQL bi-directional replication using pglogical (Replicação bidirecional do PostgreSQL usando pglogical).

Parâmetro	Descrição
pglogical.batch_inserts	Inserções em lote, se possível. Não definido por padrão. Mude para “1” para ativar, “0” para desativar.
pglogical.conflict_log_level	Define o nível de log a ser usado para registrar em log conflitos resolvidos. Os valores de string compatíveis são debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal, panic.
pglogical.conflict_resolution	Define o método a ser usado para resolver conflitos quando eles podem ser resolvidos. Os valores de string compatíveis são error, apply_remote, keep_local, last_update_wins, first_update_wins.
pglogical.extra_connection_options	Opções de conexão para adicionar a todas as conexões de nó de pares.
pglogical.synchronous_commit	Valor de confirmação síncrona específica do pglogical
pglogical.use_spi	Use a SPI (interface de programação de servidores) em vez da API de baixo nível para aplicar alterações. Defina como “1” para ativar, “0” para desativar. Para obter mais informações sobre a SPI, consulte Server Programming Interface (Interface de programação de servidores) na documentação do PostgreSQL.

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

Agendar manutenção com a extensão pg_cron

Gerenciar dados espaciais com PostGIS