Configurare la replica logica in Kubernetes

In PostgreSQL, la replica logica è un metodo per copiare le modifiche ai dati da un database publisher a uno o più sottoscrittori, che possono essere database o altre applicazioni. Puoi attivare e configurare la replica logica sui cluster che crei utilizzando l'operatore Kubernetes AlloyDB Omni.

Questo documento fornisce esempi che mostrano come creare e configurare un cluster di publisher e un cluster di sottoscrittori. Prima di leggere questo documento, dovresti conoscere la panoramica di AlloyDB Omni. Inoltre, devi conoscere le limitazioni della replica logica di PostgreSQL.

Gli snippet di codice in questa pagina sono esempi che puoi utilizzare come modelli, sostituendo i valori con quelli delle tue risorse AlloyDB Omni.

Crea i cluster

  1. Installa Omni Operator su Kubernetes.

  2. Crea un cluster di publisher.

    $ 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.7.0"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

  3. Crea un cluster di abbonati.

    $ 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.7.0"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

Configura il cluster del publisher

Configura il cluster del publisher e crea una tabella. Se vuoi, puoi pubblicare i dati come prova per assicurarti che vengano replicati per l'abbonato.

  1. Aggiorna il parametro wal_level su logical.

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

  2. Trova il pod di cui hai bisogno.

    $ 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. Accedi al pod del database per il cluster dell'editore.

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

  4. Crea un database denominato customer.

    CREATE DATABASE customer;

  5. (Facoltativo) A scopo di test, aggiungi una tabella al database e inserisci alcuni dati. Puoi utilizzare questi dati per osservare la replica dei dati dal editore all'abbonato.

    $ 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. Crea un utente logicalreplica per la replica e a cui concedere le autorizzazioni.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';

  7. Concedere le autorizzazioni. Questo esempio utilizza uno schema pubblico.

    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. Crea una pubblicazione nel database customer.

    CREATE PUBLICATION pub_customer;
ALTER PUBLICATION pub_customer ADD TABLE company;

Configura il cluster sottoscrittore

Consenti al cluster di abbonati di ricevere aggiornamenti dei dati dal cluster di editori.

  1. Imposta il parametro wal_level su logical nel database degli abbonati.

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

  2. Trova il pod di cui hai bisogno.

    $ 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. Accedi al pod del database del cluster di abbonati.

    $ 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. Trova l'indirizzo IP del pod del publisher, ad esempio 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. Esegui un backup dello schema dell'editore come copia iniziale dei dati pubblicati nel database dell'editore. La replica logica non supporta la replica DDL. Uno schema o una tabella che prevedi di replicare deve esistere nella destinazione (cluster di abbonati) prima dell'avvio della replica logica.

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

  6. Applica il backup nel database degli abbonati.

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

  7. (Facoltativo) Verifica che la tabella non contenga dati.

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

  8. Crea una sottoscrizione per il database 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. (Facoltativo) Verifica la replica nel cluster di sottoscrittori.

    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. Nel cluster di publisher, aggiungi una riga alla tabella.

    # 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. Nel cluster di sottoscrittori, verifica che la riga aggiunta alla tabella nel cluster di publisher sia stata replicata nella tabella del cluster di sottoscrittori.

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

Creare manualmente tabelle aggiuntive

La replica logica non sincronizza automaticamente le modifiche DDL, a differenza del replicate_ddl_command in pglogical. Sebbene lo strumento open source pgl_ddl_deploy offra una soluzione, puoi anche eseguire manualmente i comandi DDL sul abbonato.

  1. Per esemplificare, crea una nuova tabella denominata finance nel database customer sul cluster del publisher.

    # 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 viene aggiunta una nuova tabella al cluster del publisher, applica manualmente il DDL (creazione della tabella) nel subscriber e poi verifica la replica eseguendo quanto segue sul cluster del subscriber.

    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)

Passaggi successivi