Configurar a replicação lógica no Kubernetes

Selecione uma versão da documentação:

No PostgreSQL, a replicação lógica é um método para copiar mudanças de dados de um banco de dados de editor para um ou mais assinantes, que podem ser bancos de dados ou outros aplicativos. É possível ativar e configurar a replicação lógica em clusters criados com o operador do AlloyDB Omni no Kubernetes.

Este documento fornece exemplos que mostram como criar e configurar um cluster de editor e um cluster de assinante. Antes de ler este documento, familiarize-se com a visão geral do AlloyDB Omni. Também é importante conhecer as limitações da replicação lógica do PostgreSQL.

Os snippets de código nesta página são exemplos que podem ser usados como modelos, substituindo os valores pelos dos seus recursos do AlloyDB Omni.

Criar os clusters

  1. Instalar o Omni Operator no Kubernetes.

  2. Crie um cluster de editores.

    $ cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Secret
metadata:
  name: db-pw-publisher
type: Opaque
data:
  publisher: "b2RzcGFzc3dvcmQ=" # Password is odspassword
---
apiVersion: alloydbomni.dbadmin.goog/v1
kind: DBCluster
metadata:
  name: publisher
spec:
  primarySpec:
    adminUser:
      passwordRef:
        name: db-pw-publisher
    databaseVersion: "15.5.2"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

  3. Crie um cluster de assinante.

    $ cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Secret
metadata:
  name: db-pw-subscriber
type: Opaque
data:
  subscriber: "b2RzcGFzc3dvcmQ=" # Password is odspassword
---
apiVersion: alloydbomni.dbadmin.goog/v1
kind: DBCluster
metadata:
  name: subscriber
spec:
  primarySpec:
    adminUser:
      passwordRef:
        name: db-pw-subscriber
    databaseVersion: "15.5.2"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

Configurar o cluster do editor

Configure o cluster do editor e crie uma tabela. Se quiser, publique os dados como um teste para garantir que eles sejam replicados para o assinante.

  1. Atualize o parâmetro wal_level para logical.

    $ kubectl patch dbclusters.al publisher  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge

  2. Encontre o pod que você precisa.

    $ kubectl get pod -l "alloydbomni.internal.dbadmin.goog/dbcluster=publisher, alloydbomni.internal.dbadmin.goog/task-type=database, dbs.internal.dbadmin.goog/ha-role=Primary"

  3. Faça login no pod de banco de dados do cluster de editor.

    NAME                                          READY   STATUS    RESTARTS   AGE
al-2bce-publisher-0                           3/3     Running   0          36m
$ kubectl exec -ti al-2bce-publisher-0  -- /bin/bash

  4. Crie um banco de dados denominado customer.

    CREATE DATABASE customer;

  5. Opcional: para fins de teste, adicione uma tabela ao banco de dados e insira alguns dados. Você pode usar esses dados para observar a replicação do editor para o assinante.

    $ psql -h localhost -U postgres customer
customer=# CREATE TABLE COMPANY(
customer(#    ID INT PRIMARY KEY     NOT NULL,
customer(#    NAME           TEXT    NOT NULL,
customer(#    AGE            INT     NOT NULL,
customer(#    SALARY         REAL
customer(# );
CREATE TABLE
customer=# INSERT INTO COMPANY (ID,NAME,AGE,SALARY) VALUES
customer-# (1, 'Quinn', 25, 65000.00),
customer-# (2, 'Kim', 22, 72250.00),
customer-# (3, 'Bola', 31, 53000.00),
customer-# (4, 'Sasha', 33, 105000.00),
customer-# (5, 'Yuri', 27, 85000.00);
INSERT 0 5
customer=# \dt
          List of relations
Schema |  Name   | Type  |  Owner
--------+---------+-------+----------
public | company | table | postgres
(1 row)

customer=# select * from company;
id | name  | age | salary
----+-------+-----+--------
  1 | Quinn  |  25 |  65000
  2 | Kim  |  22 |  72250
  3 | Bola   |  31 |  53000
  4 | Sasha |  33 | 105000
  5 | Yuri |  27 |  85000
(5 rows)

  6. Crie um usuário logicalreplica para replicação e concessão de permissões.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';

  7. Conceder permissões. Este exemplo usa um esquema público.

    GRANT SELECT ON ALL TABLES IN SCHEMA public TO logicalreplica;
GRANT USAGE ON SCHEMA public TO logicalreplica;
ALTER DEFAULT PRIVILEGES IN SCHEMA public
    GRANT SELECT ON TABLES TO logicalreplica;

  8. Crie uma publicação no banco de dados customer.

    CREATE PUBLICATION pub_customer;
ALTER PUBLICATION pub_customer ADD TABLE company;

Configurar o cluster de assinante

Permita que o cluster assinante receba atualizações de dados do cluster editor.

  1. Defina o parâmetro wal_level como logical no banco de dados de assinantes.

    $ kubectl patch dbclusters.al subscriber  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge

  2. Encontre o pod que você precisa.

    $ kubectl get pod -l "alloydbomni.internal.dbadmin.goog/dbcluster=subscriber, alloydbomni.internal.dbadmin.goog/task-type=database, dbs.internal.dbadmin.goog/ha-role=Primary"

  3. Faça login no pod do banco de dados do cluster assinante.

    $ kubectl get pod
NAME                                          READY   STATUS    RESTARTS   AGE
al-2bce-publisher-0                           3/3     Running   0          20h

$ kubectl exec -ti al-3513-subscriber-0  -- /bin/bash
Defaulted container "database" out of: database, logrotate-agent, memoryagent, dbinit (init)
postgres@al-3513-subscriber-0:/$

  4. Encontre o endereço IP do pod do editor, como 10.116.14.190

    $ kubectl get service
NAME                     TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)          AGE
al-publisher-rw-ilb      ClusterIP      10.116.14.190   <none>         5432/TCP         21h

  5. Faça um backup do esquema do editor como uma cópia inicial dos dados publicados no banco de dados dele. A replicação lógica não é compatível com a replicação de DDL. Um esquema ou uma tabela que você planeja replicar precisa existir no destino (cluster assinante) antes do início da replicação lógica.

    postgres@al-3513-subscriber-0:/$ pg_dump -h 10.116.14.190 -U postgres --create --schema-only customer > /tmp/customer.schema-only.sql

  6. Aplique o backup no banco de dados do assinante.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres < /tmp/customer.schema-only.sql

  7. Opcional: verifique se não há dados na tabela.

    # There is no data in table company
customer=# select * from company;
id | name | age | salary
----+------+-----+--------
(0 rows)

  8. Crie uma assinatura para o banco de dados customer.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres customer
customer=# CREATE SUBSCRIPTION sub_customer CONNECTION 'host=10.116.14.190 port=5432 user=logicalreplica dbname=customer password=123' PUBLICATION pub_customer;

  9. Opcional: verifique a replicação no cluster de assinante.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres customer
customer=# select * from public.company;
id | name  | age | salary
----+-------+-----+--------
  1 | Quinn |  25 |  65000
  2 | Kim   |  22 |  72250
  3 | Bola  |  31 |  53000
  4 | Sasha |  33 | 105000
  5 | Yuri  |  27 |  85000
(5 rows)

  10. No cluster do editor, adicione uma linha à tabela.

    # On the publisher database
$ kubectl exec -ti al-2bce-publisher-0  -- /bin/bash
Defaulted container "database" out of: database, logrotate-agent, memoryagent, dbinit (init)
postgres@al-2bce-publisher-0:/$ psql -h localhost -U postgres customer
customer=# insert into company(id, name, age, salary) values (6, 'Alex', 39, 100000);

  11. No cluster assinante, verifique se a linha adicionada à tabela no cluster editor foi replicada para a tabela no cluster assinante.

    # On the subscriber database, data is synced.
postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres customer
customer=# select * from company;
id | name  | age | salary
----+-------+-----+--------
  1 | Quinn |  25 |  65000
  2 | Kim   |  22 |  72250
  3 | Bola  |  31 |  53000
  4 | Sasha |  33 | 105000
  5 | Yuri  |  27 |  85000
  6 | Alex  |  39 | 100000
(6 rows)

Criar manualmente outras tabelas

A replicação lógica não sincroniza automaticamente as mudanças de DDL, ao contrário do replicate_ddl_command em pglogical. Embora a ferramenta de código aberto pgl_ddl_deploy ofereça uma solução, também é possível executar comandos DDL manualmente no assinante.

  1. Para ilustrar isso, crie uma tabela chamada finance no banco de dados customer no cluster do editor.

    # On the publisher database
$ kubectl exec -ti al-2bce-publisher-0  -- /bin/bash
Defaulted container "database" out of: database, logrotate-agent, memoryagent, dbinit (init)
postgres@al-2bce-publisher-0:/$ psql -h localhost -U postgres customer
customer=# create table finance (row text);
CREATE TABLE
customer=# insert into finance values ('critical data');
INSERT 0 1
customer=# ALTER PUBLICATION pub_customer ADD TABLE finance;
ALTER PUBLICATION

  2. Quando uma nova tabela é adicionada ao cluster de editor, você aplica manualmente a DDL (criação de tabela) no assinante e verifica a replicação executando o comando a seguir no cluster de assinante.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres customer
customer=# create table finance (row text);
CREATE TABLE
customer=# ALTER SUBSCRIPTION sub_customer REFRESH PUBLICATION;
ALTER SUBSCRIPTION
customer=# select * from finance;
      row
---------------
critical data
(1 row)

A seguir