Configure 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 alterações de dados de uma base de dados de publicação para um ou mais subscritores, que podem ser bases de dados ou outras aplicações. Pode ativar e configurar a replicação lógica em clusters que criar através do AlloyDB Omni Kubernetes Operator.

Este documento fornece exemplos que mostram como criar e configurar um cluster de publicadores e um cluster de subscritores. Antes de ler este documento, deve conhecer a vista geral do AlloyDB Omni. Também deve ter em atenção as limitações da replicação lógica do PostgreSQL.

Os fragmentos de código nesta página são exemplos que pode usar como modelos, substituindo os valores por valores dos seus recursos do AlloyDB Omni.

Crie os clusters

  1. Instale o Omni Operator no Kubernetes.

  2. Crie um cluster de publicadores.

    $ 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 subscritores.

    $ 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

Configure o cluster de publicadores

Configure o cluster de publicadores e crie uma tabela. Opcionalmente, pode publicar dados como teste para garantir que são replicados para o subscritor.

  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 de que 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. Inicie sessão no pod da base de dados para o cluster do publicador.

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

  4. Cria uma base de dados denominada customer.

    CREATE DATABASE customer;

  5. Opcional: para fins de teste, adicione uma tabela à base de dados e insira alguns dados. Pode usar estes dados para observar a replicação de dados do publicador para o subscritor.

    $ 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 utilizador logicalreplica para a replicação e para conceder autorizações.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';

  7. Conceda autorizaçõ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 na base de dados customer.

    CREATE PUBLICATION pub_customer;
ALTER PUBLICATION pub_customer ADD TABLE company;

Configure o cluster de subscritores

Ative o cluster subscritor para receber atualizações de dados do cluster publicador.

  1. Defina o parâmetro wal_level como logical na base de dados de subscritores.

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

  2. Encontre o pod de que 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. Inicie sessão no pod da base de dados do cluster de subscritores.

    $ 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 de publicador, 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. Fazer uma cópia de segurança do esquema do publicador como uma cópia inicial dos dados publicados na base de dados do publicador. A replicação lógica não suporta a replicação de DDL. Um esquema ou uma tabela que planeia replicar tem de existir no destino (cluster de subscrição) antes de a replicação lógica ser iniciada.

    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 a cópia de segurança na base de dados de subscritores.

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

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

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

  8. Crie uma subscrição para a base 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: valide a replicação no cluster do subscritor.

    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 publicador, 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 de subscrição, verifique se a linha adicionada à tabela no cluster de publicação foi replicada para a tabela no cluster de subscrição.

    # 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)

Crie manualmente tabelas adicionais

A replicação lógica não sincroniza automaticamente as alterações de DDL, ao contrário da replicação física no pglogical.replicate_ddl_command Embora a ferramenta de código aberto pgl_ddl_deploy ofereça uma solução, também pode executar comandos DDL manualmente no subscritor.

  1. Para ilustrar isto, crie uma nova tabela denominada finance na base de dados customer no cluster do publicador.

    # 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 é adicionada uma nova tabela ao cluster do publicador, aplica manualmente o DDL (criação de tabelas) no subscritor e, em seguida, valida a replicação executando o seguinte no cluster do subscritor.

    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)

O que se segue?