Configurer la réplication logique dans Kubernetes

Dans PostgreSQL, la réplication logique est une méthode permettant de copier les modifications de données d'une base de données d'éditeur vers un ou plusieurs abonnés, qui peuvent être des bases de données ou d'autres applications. Vous pouvez activer et configurer la réplication logique sur les clusters que vous créez à l'aide de l'opérateur Kubernetes AlloyDB Omni.

Ce document fournit des exemples qui vous montrent comment créer et configurer un cluster d'éditeur et un cluster d'abonné. Avant de lire ce document, vous devez connaître la présentation d'AlloyDB Omni. Vous devez également tenir compte des limites de la réplication logique PostgreSQL.

Les extraits de code de cette page sont des exemples que vous pouvez utiliser comme modèles, en remplaçant les valeurs par celles de vos ressources AlloyDB Omni.

Créer les clusters

  1. Installez Omni Operator sur Kubernetes.

  2. Créez un cluster d'éditeurs.

    $ 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. Créez un cluster d'abonnés.

    $ 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
    

Configurer le cluster d'éditeurs

Configurez le cluster d'éditeurs et créez un tableau. Vous pouvez éventuellement publier des données à titre de test pour vous assurer qu'elles sont répliquées auprès de l'abonné.

  1. Remplacez la valeur wal_level du paramètre wal_level par logical.

    $ kubectl patch dbclusters.al publisher  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge
    
  2. Recherchez le pod dont vous avez besoin.

    $ 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. Connectez-vous au pod de base de données du cluster d'éditeurs.

    NAME                                          READY   STATUS    RESTARTS   AGE
    al-2bce-publisher-0                           3/3     Running   0          36m
    $ kubectl exec -ti al-2bce-publisher-0  -- /bin/bash
    
  4. Créez une base de données nommée customer.

    CREATE DATABASE customer;
    
  5. Facultatif: À des fins de test, ajoutez une table à la base de données et insérez des données. Vous pouvez utiliser ces données pour observer la réplication des données de l'éditeur vers l'abonné.

    $ 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. Créez un utilisateur logicalreplica pour la réplication et pour lui accorder des autorisations.

    CREATE USER logicalreplica WITH REPLICATION LOGIN PASSWORD '123';
    
  7. octroyer des autorisations ; Cet exemple utilise un schéma public.

    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. Créez une publication dans la base de données customer.

    CREATE PUBLICATION pub_customer;
    ALTER PUBLICATION pub_customer ADD TABLE company;
    

Configurer le cluster d'abonnés

Activez le cluster d'abonnés pour qu'il reçoive les mises à jour de données du cluster d'éditeur.

  1. Définissez le paramètre wal_level sur logical dans la base de données des abonnés.

    $ kubectl patch dbclusters.al subscriber  -p '{"spec":{"primarySpec":{"parameters":{"wal_level":"logical"}}}}' --type=merge
    
  2. Recherchez le pod dont vous avez besoin.

    $ 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. Connectez-vous au pod de base de données du cluster d'abonnés.

    $ 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. Recherchez l'adresse IP du pod de l'éditeur, par exemple 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. Effectuez une sauvegarde du schéma de l'éditeur en tant que copie initiale des données publiées dans la base de données de l'éditeur. La réplication logique n'est pas compatible avec la réplication LDD. Un schéma ou une table que vous prévoyez de répliquer doit exister dans la destination (cluster abonné) avant le début de la réplication logique.

    postgres@al-3513-subscriber-0:/$ pg_dump -h 10.116.14.190 -U postgres --create --schema-only customer > /tmp/customer.schema-only.sql
    
  6. Appliquez la sauvegarde dans la base de données des abonnés.

    postgres@al-3513-subscriber-0:/$ psql -h localhost -U postgres < /tmp/customer.schema-only.sql
    
  7. (Facultatif) Vérifiez qu'aucune donnée n'est présente dans le tableau.

    # There is no data in table company
    customer=# select * from company;
    id | name | age | salary
    ----+------+-----+--------
    (0 rows)
    
  8. Créez un abonnement pour la base de données 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. Facultatif: Vérifiez la réplication sur le cluster d'abonnés.

    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. Dans le cluster des éditeurs, ajoutez une ligne au tableau.

    # 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. Sur le cluster abonné, vérifiez que la ligne ajoutée à la table dans le cluster éditeur a été répliquée dans la table du cluster abonné.

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

Créer manuellement des tables supplémentaires

La réplication logique ne synchronise pas automatiquement les modifications LDD, contrairement à replicate_ddl_command dans pglogical. Bien que l'outil Open Source pgl_ddl_deploy propose une solution, vous pouvez également exécuter manuellement des commandes LDD sur l'abonné.

  1. Pour illustrer cela, créez une table appelée finance dans la base de données customer du cluster de l'éditeur.

    # 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. Lorsqu'une nouvelle table est ajoutée au cluster éditeur, vous appliquez manuellement le LDD (création de table) dans l'abonné, puis vérifiez la réplication en exécutant ce qui suit sur le cluster abonné.

    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)
    

Étape suivante