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, devi conoscere la panoramica di AlloyDB Omni. Devi anche essere a conoscenza delle 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 tue 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.4"
    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.4"
    resources:
      memory: 10Gi
      cpu: 1
      disks:
      - name: DataDisk
        size: 40Gi
EOF

Configurare il cluster publisher

Configura il cluster publisher e crea una tabella. (Facoltativo) 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