Logische Replikation in Kubernetes konfigurieren

In PostgreSQL ist die logische Replikation eine Methode zum Kopieren von Datenänderungen aus einer Publisher-Datenbank in eine oder mehrere Abonnenten, die Datenbanken oder andere Anwendungen sein können. Sie können die logische Replikation in Clustern aktivieren und konfigurieren, die Sie mit dem AlloyDB Omni Kubernetes-Operator erstellen.

In diesem Dokument findest du Beispiele, die zeigen, wie du einen Publisher- und einen Abonnentencluster erstellst und konfigurierst. Bevor Sie dieses Dokument lesen, sollten Sie sich mit der AlloyDB Omni-Übersicht vertraut machen. Beachten Sie auch die Einschränkungen der logischen PostgreSQL-Replikation.

Die Code-Snippets auf dieser Seite sind Beispiele, die Sie als Vorlage verwenden können. Ersetzen Sie dazu die Werte durch Werte für Ihre AlloyDB Omni-Ressourcen.

Cluster erstellen

  1. Omni Operator in Kubernetes installieren

  2. Erstellen Sie einen Publisher-Cluster.

    $ 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. Erstellen Sie einen Abonnentencluster.

    $ 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
    

Publisher-Cluster konfigurieren

Konfiguriere den Publisher-Cluster und erstelle eine Tabelle. Optional können Sie Daten als Test veröffentlichen, um sicherzustellen, dass sie für den Abonnenten repliziert werden.

  1. Aktualisieren Sie den Parameter wal_level auf logical.

    $ kubectl patch dbclusters.al publisher  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge
    
  2. Suchen Sie den gewünschten Pod.

    $ 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. Melde dich im Datenbank-Pod für den Publisher-Cluster an.

    NAME                                          READY   STATUS    RESTARTS   AGE
    al-2bce-publisher-0                           3/3     Running   0          36m
    $ kubectl exec -ti al-2bce-publisher-0  -- /bin/bash
    
  4. Erstellen Sie eine Datenbank namens customer.

    CREATE DATABASE customer;
    
  5. Optional: Fügen Sie der Datenbank zu Testzwecken eine Tabelle hinzu und geben Sie einige Daten ein. Anhand dieser Daten kannst du die Datenreplikation vom Publisher zum Abonnenten beobachten.

    $ 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. Erstellen Sie einen Nutzer logicalreplica für die Replikation und gewähren Sie ihm Berechtigungen.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';
    
  7. Berechtigungen erteilen. In diesem Beispiel wird ein öffentliches Schema verwendet.

    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. Erstellen Sie eine Publikation in der Datenbank customer.

    CREATE PUBLICATION pub_customer;
    ALTER PUBLICATION pub_customer ADD TABLE company;
    

Abonnentencluster konfigurieren

Aktivieren Sie, dass der Abonnentencluster Datenaktualisierungen vom Publisher-Cluster erhält.

  1. Lege in der Abonnentendatenbank den Parameter wal_level auf logical fest.

    $ kubectl patch dbclusters.al subscriber  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge
    
  2. Suchen Sie den gewünschten Pod.

    $ 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. Melde dich im Datenbank-Pod des Abonnentenclusters an.

    $ 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. Ermitteln Sie die IP-Adresse des Publisher-Pods, z. B. 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. Erstelle eine Schemasicherung vom Publisher als erste Kopie der veröffentlichten Daten in der Publisher-Datenbank. Die logische Replikation unterstützt keine DDL-Replikation. Ein Schema oder eine Tabelle, die Sie replizieren möchten, muss am Ziel (Abonnentencluster) vorhanden sein, bevor die logische Replikation beginnt.

    postgres@al-3513-subscriber-0:/$ pg_dump -h 10.116.14.190 -U postgres --create --schema-only customer > /tmp/customer.schema-only.sql
    
  6. Wende die Sicherung auf die Abonnentendatenbank an.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres < /tmp/customer.schema-only.sql
    
  7. Optional: Prüfen Sie, ob die Tabelle keine Daten enthält.

    # There is no data in table company
    customer=# select * from company;
    id | name | age | salary
    ----+------+-----+--------
    (0 rows)
    
  8. Erstellen Sie ein Abo für die Datenbank 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. Optional: Replikation im Abonnentencluster prüfen

    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. Fügen Sie der Tabelle im Publisher-Cluster eine Zeile hinzu.

    # 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. Prüfen Sie im Abonnentencluster, ob die Zeile, die der Tabelle im Publisher-Cluster hinzugefügt wurde, in der Tabelle im Abonnentencluster repliziert wurde.

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

Zusätzliche Tabellen manuell erstellen

Im Gegensatz zur replicate_ddl_command in pglogical werden DDL-Änderungen bei der logischen Replikation nicht automatisch synchronisiert. Das Open-Source-Tool pgl_ddl_deploy bietet zwar eine Lösung, Sie können DDL-Befehle aber auch manuell auf dem Abonnenten ausführen.

  1. Erstelle dazu eine neue Tabelle namens finance in der Datenbank customer im Publisher-Cluster.

    # 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. Wenn dem Publisher-Cluster eine neue Tabelle hinzugefügt wird, wenden Sie die DDL (Tabellenerstellung) manuell auf den Abonnenten an und prüfen Sie dann die Replikation, indem Sie Folgendes im Abonnentencluster ausführen:

    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)
    

Nächste Schritte