Configurare la replica logica in Kubernetes

Seleziona una versione della documentazione:

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

Questo documento fornisce esempi che mostrano come creare e configurare un cluster publisher e un cluster sottoscrittore. Prima di leggere questo documento, dovresti acquisire familiarità con la panoramica di AlloyDB Omni. Dovresti anche 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 i valori delle risorse AlloyDB Omni.

Creare i cluster

  1. Installa l'operatore Omni su Kubernetes.

  2. Crea un cluster 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.5.2"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

  3. Crea un cluster sottoscrittore.

    $ 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

Configurare il cluster publisher

Configura il cluster publisher e crea una tabella. Facoltativamente, puoi pubblicare i dati come test per assicurarti che vengano replicati nel sottoscrittore.

  1. Aggiorna il parametro wal_level a 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 publisher.

    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 publisher al sottoscrittore.

    $ 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 per concedere le autorizzazioni.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';

  7. Concedi 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;

Configurare il cluster sottoscrittore

Consenti al cluster sottoscrittore di ricevere gli aggiornamenti dei dati dal cluster publisher.

  1. Imposta il parametro wal_level su logical nel database del sottoscrittore.

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

    $ 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 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 dal publisher come copia iniziale dei dati pubblicati nel database del publisher. La replica logica non supporta la replica DDL. Uno schema o una tabella che intendi replicare deve esistere nella destinazione (cluster sottoscrittore) prima dell'inizio 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 del sottoscrittore.

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

  7. (Facoltativo) Verifica che nella tabella non siano presenti dati.

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

  8. Crea un abbonamento 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 sul cluster sottoscrittore.

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

    # 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

A differenza di replicate_ddl_command in pglogical, la replica logica non sincronizza automaticamente le modifiche DDL. Sebbene lo strumento open source pgl_ddl_deploy offra una soluzione, puoi anche eseguire manualmente i comandi DDL sul sottoscrittore.

  1. Per illustrare questo aspetto, crea una nuova tabella denominata finance nel database customer sul cluster 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 publisher, devi applicare manualmente il DDL (creazione della tabella) nel sottoscrittore e poi verificare la replica eseguendo il seguente comando sul cluster sottoscrittore.

    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