Créer un emplacement de réplication et une publication

Sélectionnez une version de la documentation :

Ce document explique comment créer des emplacements de réplication logique dans AlloyDB Omni. 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.

Les modifications diffusées peuvent être des mises à jour, des insertions ou des suppressions de lignes individuelles. Les abonnés se connectent à l'éditeur via un emplacement de réplication unique qui garantit une connexion persistante. Une connexion persistante conserve l'état de diffusion des données. Par conséquent, en cas d'interruption, la diffusion reprend là où elle s'était arrêtée.

Pour en savoir plus sur la réplication logique dans PostgreSQL, consultez la page Réplication logique.

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.

Avant de commencer

Créer un cluster d'éditeur

Avant de créer les emplacements de réplication, vous devez créer le cluster d'éditeur avec la réplication logique activée. Vous devez définir le paramètre wal_level sur logical dans le fichier manifeste DBCluster.

Pour créer un cluster de base de données d'éditeur avec la réplication logique activée, appliquez le fichier manifeste suivant :

  apiVersion: v1
  kind: Secret
  metadata:
    name: db-pw-DB_CLUSTER_NAME
    namespace: DB_CLUSTER_NAMESPACE
  type: Opaque
  data:
    DB_CLUSTER_NAME: "ENCODED_PASSWORD"
  ---
  apiVersion: alloydbomni.dbadmin.goog/v1
  kind: DBCluster
  metadata:
    name: DB_CLUSTER_NAME
    namespace: DB_CLUSTER_NAMESPACE
  spec:
    databaseVersion: "ALLOYDB_OMNI_VERSION"
    spec:
    availability:
      numberOfStandbys: 1
    primarySpec:
      parameters:
        wal_level: "logical"
      adminUser:
        passwordRef:
          name: db-pw-DB_CLUSTER_NAME
      resources:
        cpu: CPU_COUNT
        memory: MEMORY_SIZE
        disks:
        - name: DataDisk
          size: DISK_SIZE

Remplacez les éléments suivants :

  • DB_CLUSTER_NAME : nom de ce cluster de bases de données, par exemple publisher.

  • DB_CLUSTER_NAMESPACE (facultatif) : espace de noms dans lequel vous souhaitez créer le cluster de bases de données, par exemple publisher-namespace.

  • ENCODED_PASSWORD : mot de passe de connexion à la base de données pour le rôle utilisateur par défaut postgres, encodé sous forme de chaîne base64 (par exemple, Q2hhbmdlTWUxMjM= pour ChangeMe123).

  • ALLOYDB_OMNI_VERSION : version AlloyDB Omni, 15.7.0 ou ultérieure.

  • CPU_COUNT : nombre de processeurs disponibles pour chaque instance de base de données de ce cluster de bases de données.

  • MEMORY_SIZE : quantité de mémoire par instance de base de données de ce cluster de bases de données. Nous vous recommandons de définir cette valeur sur 8 gigaoctets par processeur. Par exemple, si vous définissez cpu sur 2 plus haut dans ce fichier manifeste, nous vous recommandons de définir memory sur 16Gi.

  • DISK_SIZE : taille de disque par instance de base de données (par exemple, 10Gi).

Créer un emplacement de réplication

Une fois le cluster d'éditeur créé, vous pouvez créer un emplacement de réplication logique à l'aide de la ressource Replication dans le cluster d'éditeur. Chaque ressource Replication est associée à une ressource de cluster de bases de données correspondante. Un cluster de bases de données peut être associé à plusieurs ressources de réplication logique.

Pour configurer un emplacement de réplication dans votre cluster d'éditeur, appliquez le fichier manifeste suivant :

$ cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Secret
metadata:
  name: USER_PASSWORD_SECRET_NAME
  namespace: USER_PASSWORD_SECRET_NAMESPACE
type: Opaque
---
apiVersion: alloydbomni.dbadmin.goog/v1
kind: Replication
metadata:
  name: REPLICATION_NAME
  namespace: NAMESPACE
spec:
  dbcluster:
    name: DB_CLUSTER_NAME
  upstream:
    logicalReplication:
      pluginName: DECODER_PLUGIN
      databaseName: DATABASE_NAME
    applicationName: APPLICATION_NAME
    replicationSlotName: REPLICATION_SLOT_NAME
    synchronous: "REPLICATION_MODE"
    username: APPLICATION_USER
    password:
      name: USER_PASSWORD_SECRET_NAME
      namespace: USER_PASSWORD_SECRET_NAMESPACE
EOF

Remplacez les éléments suivants :

  • REPLICATION_NAME : nom de cette ressource Replication, par exemple replication-1.
  • NAMESPACE : espace de noms Kubernetes pour cette ressource Replication. Il doit correspondre à l'espace de noms du cluster de bases de données.
  • DB_CLUSTER_NAME : nom de votre cluster de bases de données, que vous avez attribué lors de sa création.
  • DECODER_PLUGIN : défini sur le plug-in de décodage, tel que pgoutput, que vous souhaitez utiliser pour la réplication logique. Pour en savoir plus sur les différents plug-ins de décodage, consultez la page Plug-ins de sortie.
  • DATABASE_NAME : défini sur le nom de la base de données dont vous souhaitez diffuser les modifications vers l'emplacement de réplication. Assurez-vous que la base de données est déjà créée dans le cluster d'éditeur.
  • APPLICATION_NAME (facultatif) : défini sur le nom de l'application qui se connectera à l'emplacement de réplication. Ce champ est obligatoire lorsque le mode de diffusion est défini sur synchrone.
  • REPLICATION_MODE (facultatif) : défini sur false pour la réplication asynchrone. Si vous souhaitez activer la réplication synchrone, mais au détriment de la vitesse, définissez cette valeur sur true. Si elle n'est pas définie explicitement, la valeur par défaut est false.
  • REPLICATION_SLOT_NAME : nom de l'emplacement de réplication qui sera créé et utilisé par l'abonné, par exemple logicalrepltestslot.
  • REPLICATION_USER (facultatif) : nom de l'utilisateur qui se connecte à l'emplacement de réplication. Si vous définissez l'utilisateur de réplication, vous devez définir le nom secret, l'espace de noms et le mot de passe.
  • USER_PASSWORD_SECRET_NAME (facultatif) : nom secret Kubernetes de l'utilisateur de l'application. Obligatoire si l'utilisateur de l'application est défini.
  • USER_PASSWORD_SECRET_NAMESPACE (facultatif) : espace de noms dans lequel se trouve le secret Kubernetes pour l'utilisateur de l'application. Obligatoire si l'utilisateur de l'application est défini.

Afficher l'état de l'emplacement de réplication

Pour afficher l'état des emplacements de réplication, exécutez la commande suivante :

kubectl get replication.alloydbomni.dbadmin.goog REPLICATION_NAME -n NAMESPACE -oyaml

Le champ status ainsi que d'autres détails sont inclus dans la réponse :

apiVersion: alloydbomni.dbadmin.goog/v1
kind: Replication
metadata:
  name: REPLICATION_NAME
  namespace: NAMESPACE
...
...
status:
  conditions:
  - lastTransitionTime: "2025-01-25T06:49:25Z"
    message: Ready for replication
    reason: Ready
    status: "True"
    type: Ready
  - lastTransitionTime: "2025-01-25T06:49:25Z"
    message: Replication slot is not being used
    reason: Unhealthy
    status: "False"
    type: Healthy
  observedGeneration: 2
  upstream:
    host: DATABASE_ENDPOINT
    password:
      name: USER_PASSWORD_SECRET_NAME
      namespace: USER_PASSWORD_SECRET_NAMESPACE
    port: DATABASE_PORT
    replicationSlotName: REPLICATION_SLOT_NAME
    username: APPLICATION_USER

DATABASE_ENDPOINT affiche l'adresse IP que vous utilisez pour vous connecter à la base de données. L'état TRUE dans la colonne READY indique que l'emplacement est prêt à être diffusé. Lorsque le DBCluster ou l'application de l'abonné se connecte à l'emplacement de réplication, l'état de la colonne HEALTHY passe à TRUE.

Configurer le cluster d'éditeur

  1. Recherchez le pod dont vous avez besoin.

    $ kubectl get pod -l "alloydbomni.internal.dbadmin.goog/dbcluster=DB_CLUSTER_NAME, alloydbomni.internal.dbadmin.goog/task-type=database, dbs.internal.dbadmin.goog/ha-role=Primary"

  2. Connectez-vous au pod principal du cluster d'éditeur à l'aide de psql :

    psql -h IP_ADDRESS -U USERNAME -d DATABASE_NAME

    Remplacez les éléments suivants :

    • IP_ADDRESS : adresse IP du pod principal du cluster d'éditeur.
    • USERNAME : utilisateur postgres de la base de données.
    • DATABASE_NAME : base de données à laquelle l'abonné souhaite s'abonner.

  3. Si le DATABASE_NAME spécifié dans la ressource de réplication n'existe pas, créez une base de données.

    CREATE DATABASE DATABASE_NAME;

  4. 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 DATABASE_NAME
customer=# CREATE TABLE TABLE_NAME(
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 TABLE_NAME (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 TABLE_NAME;
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)

    Remplacez le TABLE_NAME par une table dans laquelle vous souhaitez stocker les données et à laquelle l'abonné s'abonne.

  5. Accordez les autorisations :

    GRANT SELECT ON ALL TABLES IN SCHEMA public TO REPLICATION_USER;
GRANT USAGE ON SCHEMA public TO REPLICATION_USER;
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO REPLICATION_USER;

  6. Créez une publication en exécutant la commande suivante :

    CREATE PUBLICATION PUBLICATION_NAME;
ALTER PUBLICATION PUBLICATION_NAME ADD TABLE TABLE_NAME;

    Remplacez les éléments suivants :

    • PUBLICATION_NAME : nom de la publication que l'abonné utilisera pour s'abonner.

Après avoir créé la publication, vous pouvez soit configurer votre cluster d'abonné pour la réplication logique, soit configurer votre application pour lancer la réplication.

Limites

  • Les mises à jour de la configuration de l'emplacement de réplication ne sont pas acceptées. Pour mettre à jour la configuration, supprimez l'emplacement de réplication et recréez-le avec la configuration mise à jour.

    Pour supprimer l'emplacement de réplication, exécutez la commande suivante :

    kubectl delete replication.alloydbomni.dbadmin.goog REPLICATION_NAME -n NAMESPACE

  • Vous ne pouvez configurer l'emplacement de réplication logique que sur la base de données de l'éditeur. L'API de réplication n'est pas compatible avec les DBCluster ou les applications d'abonné de réplication logique.

  • Si le cluster de bases de données référencé par l'objet de réplication est configuré pour la haute disponibilité, l'emplacement de réplication logique est recréé sur l'instance de secours promue après un basculement. Une fois l'emplacement de réplication recréé, la position du flux dans l'emplacement n'est plus disponible, et toutes les applications abonnées au flux doivent se reconnecter et relire le flux.

Étape suivante