Logische replicatie en logische decodering in flexibele Azure Database for PostgreSQL-server

Flexibele Azure Database for PostgreSQL-server ondersteunt de volgende logische methoden voor gegevensextractie en replicatie:

1. Logische replicatie

   1. Systeemeigen logische replicatie van PostgreSQL gebruiken om gegevensobjecten te repliceren. Logische replicatie biedt u nauwkeurige controle over de gegevensreplicatie, inclusief gegevensreplicatie op tabelniveau.
   2. Met behulp van de pglogical-extensie die logische streamingreplicatie biedt en meer mogelijkheden, zoals het kopiëren van het oorspronkelijke schema van de database, ondersteuning voor TRUNCATE, de mogelijkheid om DDL te repliceren en meer.

2. Logische decodering die wordt geïmplementeerd door de inhoud van het write-ahead-logboek (WAL) te decoderen .

Logische replicatie en logische decodering vergelijken

Logische replicatie en logische decodering hebben verschillende overeenkomsten. Zij beiden:

• Hiermee kunt u gegevens uit Postgres repliceren.

• Gebruik het write-ahead-logboek (WAL) als bron van wijzigingen.

• Gebruik logische replicatiesites om gegevens te verzenden. Een slot vertegenwoordigt een stroom wijzigingen.

• Gebruik de eigenschap REPLICA IDENTITY van een tabel om te bepalen welke wijzigingen kunnen worden verzonden.

• Repliceer DDL-wijzigingen niet.

De twee technologieën hebben hun verschillen:

Logische replicatie:

• Hiermee kunt u een tabel of set tabellen opgeven die moeten worden gerepliceerd.

Logische decodering:

• Extraheert wijzigingen in alle tabellen in een database.

Vereisten voor logische replicatie en logische decodering

1. Ga naar de pagina Parameters in de portal.

2. Stel de parameter wal_level op logical in.

3. Als u een pglogical-extensie wilt gebruiken, zoekt u naar de shared_preload_libraries en azure.extensions parameters en selecteert u pglogical deze in de vervolgkeuzelijst.

4. Werk max_worker_processes de parameterwaarde bij naar ten minste 16. Anders kan het zijn dat u problemen ondervindt zoals WARNING: out of background worker slots.

5. Sla de wijzigingen op en start de server opnieuw op om de wijzigingen toe te passen.

6. Controleer of uw Azure Database for PostgreSQL flexibele server netwerkverkeer van uw verbindingsresource toestaat.

7. Verleen de replicatiemachtigingen aan de beheerder.

   ALTER ROLE <adminname> WITH REPLICATION;
   

8. Zorg ervoor dat de rol die u gebruikt , bevoegdheden heeft voor het schema dat u repliceert. Anders kunnen er fouten optreden, zoals Permission denied for schema.

Logische replicatie en logische decodering gebruiken

Het gebruik van systeemeigen logische replicatie is de eenvoudigste manier om gegevens van uw Azure Database for PostgreSQL flexibele server te repliceren. U kunt de SQL-interface of het streamingprotocol gebruiken om de wijzigingen te gebruiken. U kunt ook de SQL-interface gebruiken om wijzigingen te verwerken door middel van logische decodering.

Systeemeigen logische replicatie

Logische replicatie maakt gebruik van de termenuitgever en abonnee.

• De uitgever is de Azure Database for PostgreSQL flexibele serverdatabase waarmee gegevens worden verzonden.
• De subscriber is de database van Azure Database for PostgreSQL Flexible Server die gegevens ontvangt.

Hier volgt enkele voorbeeldcode die u kunt gebruiken om logische replicatie uit te proberen.

1. Maak verbinding met de uitgeverdatabase. Maak een tabel en voeg enkele gegevens toe.

   CREATE TABLE basic (id INTEGER NOT NULL PRIMARY KEY, a TEXT);
   INSERT INTO basic VALUES (1, 'apple');
   INSERT INTO basic VALUES (2, 'banana');
   

2. Maak een publicatie voor de tabel.

   CREATE PUBLICATION pub FOR TABLE basic;
   

3. Maak verbinding met de abonneedatabase. Maak een tabel met hetzelfde schema als op de uitgever.

   CREATE TABLE basic (id INTEGER NOT NULL PRIMARY KEY, a TEXT);
   

4. Maak een abonnement dat verbinding maakt met de publicatie die u eerder hebt gemaakt.

   CREATE SUBSCRIPTION sub CONNECTION 'host=<server>.postgres.database.azure.com user=<rep_user> dbname=<dbname> password=<password>' PUBLICATION pub;
   

5. U kunt nu een query uitvoeren op de tabel bij de abonnee. U ziet dat er gegevens van de uitgever worden ontvangen.

   SELECT * FROM basic;
   

   U kunt meer rijen toevoegen aan de tabel van de uitgever en de wijzigingen van de abonnee bekijken.

   Als u de gegevens niet kunt zien, schakelt u over naar een gebruiker die lid is van de azure_pg_admin rol en controleert u de inhoud van de tabel.

Ga naar de PostgreSQL-documentatie voor meer informatie over logische replicatie.

Logische replicatie tussen databases op dezelfde server gebruiken

Als u logische replicatie tussen verschillende databases op dezelfde Azure Database for PostgreSQL flexibele server wilt instellen, volgt u specifieke richtlijnen om implementatiebeperkingen te voorkomen. Op dit moment kunt u alleen een abonnement maken dat verbinding maakt met hetzelfde databasecluster als het replicatieslot niet binnen dezelfde opdracht wordt aangemaakt. Anders blijft de CREATE SUBSCRIPTION aanroep hangen op een LibPQWalReceiverReceive wachtgebeurtenis. Dit gedrag wordt veroorzaakt door een bestaande beperking binnen de Postgres-engine, die mogelijk in toekomstige releases wordt verwijderd.

Voer de volgende stappen uit om logische replicatie in te stellen tussen uw brondatabases en doeldatabases op dezelfde server terwijl u deze beperking vermijdt:

Maak eerst een tabel met de naam basic met een identiek schema in de bron- en doeldatabases:

-- Run this on both source and target databases
CREATE TABLE basic (id INTEGER NOT NULL PRIMARY KEY, a TEXT);

Maak vervolgens in de brondatabase een publicatie voor de tabel en maak afzonderlijk een logische replicatieslot met behulp van de functie pg_create_logical_replication_slot. Deze aanpak helpt het probleem van vastlopen te voorkomen dat zich doorgaans voordoet wanneer de slot in dezelfde opdracht als het abonnement wordt gemaakt. Gebruik de pgoutput invoegtoepassing:

-- Run this on the source database
CREATE PUBLICATION pub FOR TABLE basic;
SELECT pg_create_logical_replication_slot('myslot', 'pgoutput');

Maak vervolgens in uw doeldatabase een abonnement op de eerder gemaakte publicatie. Stel create_slot in op false om te voorkomen dat uw Azure Database for PostgreSQL Flexible Server een nieuwe slot maakt, en geef de slotnaam op die u in de vorige stap hebt gemaakt. Voordat u de opdracht uitvoert, vervangt u de tijdelijke aanduidingen in de verbindingsreeks door uw werkelijke databasereferenties:

-- Run this on the target database
CREATE SUBSCRIPTION sub
   CONNECTION 'dbname=<source dbname> host=<server>.postgres.database.azure.com port=5432 user=<rep_user> password=<password>'
   PUBLICATION pub
   WITH (create_slot = false, slot_name='myslot');

Nadat u de logische replicatie hebt ingesteld, test u deze door een nieuwe record in de tabel in de basic brondatabase in te voegen en vervolgens te controleren of deze wordt gerepliceerd naar uw doeldatabase:

-- Run this on the source database
INSERT INTO basic SELECT 3, 'mango';

-- Run this on the target database
TABLE basic;

Als alles correct is geconfigureerd, ziet u de nieuwe record uit de brondatabase in uw doeldatabase, waarbij wordt bevestigd dat de logische replicatie is ingesteld.

pglogical extensie

Hier volgt een voorbeeld van het configureren van pglogical op de providerdatabaseserver en de abonnee. Zie de documentatie voor pglogical extension voor meer informatie. Zorg er ook voor dat u de vereiste taken uitvoert die eerder zijn vermeld.

1. Installeer de pglogical-extensie in de database op zowel de provider- als de abonneedatabaseservers.

   \c myDB
   CREATE EXTENSION pglogical;
   

2. Als de replicatiegebruiker niet de serverbeheergebruiker is (de gebruiker die de server heeft gemaakt), verleent u het gebruikerslidmaatschap aan de azure_pg_admin rol en wijst u de kenmerken REPLICATIE en AANMELDING toe aan de gebruiker. Zie de pglogical-documentatie voor meer informatie.

   GRANT azure_pg_admin to myUser;
   ALTER ROLE myUser REPLICATION LOGIN;
   

3. Maak op de databaseserver van de provider (bron/uitgever) het providerknooppunt.

   select pglogical.create_node( node_name := 'provider1',
   dsn := ' host=myProviderServer.postgres.database.azure.com port=5432 dbname=myDB user=myUser password=<password>');
   

4. Maak een replicatieset.

   select pglogical.create_replication_set('myreplicationset');
   

5. Voeg alle tabellen in de database toe aan de replicatieset.

   SELECT pglogical.replication_set_add_all_tables('myreplicationset', '{public}'::text[]);
   

   Als alternatieve methode kunt u ook tabellen uit een specifiek schema (bijvoorbeeld testUser) toevoegen aan een standaardreplicatieset.

   SELECT pglogical.replication_set_add_all_tables('default', ARRAY['testUser']);
   

6. Maak op de databaseserver van de abonnee een abonneeknooppunt.

   select pglogical.create_node( node_name := 'subscriber1',
   dsn := ' host=mySubscriberServer.postgres.database.azure.com port=5432 dbname=myDB user=myUser password=<password>' );
   

7. Maak een abonnement om de synchronisatie en het replicatieproces te starten.

   select pglogical.create_subscription (
   subscription_name := 'subscription1',
   replication_sets := array['myreplicationset'],
   provider_dsn := 'host=myProviderServer.postgres.database.azure.com port=5432 dbname=myDB user=myUser password=<password>');
   

8. Controleer de abonnementsstatus.

   SELECT subscription_name, status FROM pglogical.show_subscription_status();
   

Logische decodering

U kunt logische decodering gebruiken via het streamingprotocol of de SQL-interface.

Streamingprotocol

Het verwerken van wijzigingen via het streamingprotocol verdient vaak de voorkeur. U kunt uw eigen consument of connector maken of een service van derden gebruiken, zoals Debezium.

Zie de wal2json-documentatie voor een voorbeeld waarin het streamingprotocol pg_recvlogicalwordt gebruikt: een voorbeeld met behulp van het streamingprotocol met pg_recvlogical.

SQL-interface

Gebruik in het volgende voorbeeld de SQL-interface met de wal2json-invoegtoepassing.

1. Maak een slot.

   SELECT * FROM pg_create_logical_replication_slot('test_slot', 'wal2json');
   

2. Sql-opdrachten uitgeven. Voorbeeld:

   CREATE TABLE a_table (
      id varchar(40) NOT NULL,
      item varchar(40),
      PRIMARY KEY (id)
   );
   
   INSERT INTO a_table (id, item) VALUES ('id1', 'item1');
   DELETE FROM a_table WHERE id='id1';
   

3. De wijzigingen toepassen.

   SELECT data FROM pg_logical_slot_get_changes('test_slot', NULL, NULL, 'pretty-print', '1');
   

   De uitvoer ziet er als volgt uit:

   {
         "change": [
         ]
   }
   {
         "change": [
                  {
                           "kind": "insert",
                           "schema": "public",
                           "table": "a_table",
                           "columnnames": ["id", "item"],
                           "columntypes": ["character varying(40)", "character varying(40)"],
                           "columnvalues": ["id1", "item1"]
                  }
         ]
   }
   {
         "change": [
                  {
                           "kind": "delete",
                           "schema": "public",
                           "table": "a_table",
                           "oldkeys": {
                                 "keynames": ["id"],
                                 "keytypes": ["character varying(40)"],
                                 "keyvalues": ["id1"]
                           }
                  }
         ]
   }
   

4. Geef het slot vrij wanneer u het niet meer gebruikt.

   SELECT pg_drop_replication_slot('test_slot');
   

Zie de PostgreSQL-documentatie: logische decodering voor meer informatie over logische decodering.

Monitor

U moet logische decodering bewaken. Verwijder elk ongebruikt replicatieslot. Sleuven houden vast aan Postgres WAL-logboeken en relevante systeemcatalogussen totdat wijzigingen worden gelezen. Als uw abonnee of consument uitvalt of als deze onjuist is geconfigureerd, stapelen de niet-verwerkte logboeken zich op en vullen de opslag. Bovendien verhogen niet-gebruikte logboeken het risico op transactie-ID-wraparound. Beide situaties kunnen ertoe leiden dat de server niet meer beschikbaar is. Daarom moet u logische replicatieslots voortdurend verbruiken. Als een logische replicatieslot niet meer wordt gebruikt, verwijder het onmiddellijk.

De active kolom in de pg_replication_slots weergave geeft aan of er een gebruiker verbonden is met een slot.

SELECT * FROM pg_replication_slots;

Stel waarschuwingen in voor de maximaal gebruikte transactie-id's en metrische opslaggegevens om u op de hoogte te stellen wanneer de waarden hoger zijn dan normale drempelwaarden.

Beperkingen

• Beperkingen voor logische replicatie zijn van toepassing zoals hier wordt beschreven.

• Slots en HA-failover - In PostgreSQL 16 en eerdere versies blijven logische replicatieslots niet behouden tijdens failovergebeurtenissen bij gebruik van servers met hoge beschikbaarheid (HA) in Azure Database for PostgreSQL. Als u logische replicatieslots wilt behouden en gegevensconsistentie na een failover wilt waarborgen, gebruikt u de extensie PG Failover Slots en stelt u ondersteunende instellingen in, zoals hot_standby_feedback = on. Zie de documentatie voor meer informatie over het inschakelen van deze extensie.

Ondersteuning voor failover voor logische replicatieslots

Voor PostgreSQL 17 en latere versies wordt slotsynchronisatie standaard ondersteund. Als u de juiste PostgreSQL-configuraties (sync_replication_slots, hot_standby_feedback) inschakelt, worden logische replicatieslots automatisch behouden na een failover en is geen extensie vereist.

Verwante inhoud

• Firewallregels in Azure Database for PostgreSQL.
• Netwerkoverzicht voor Azure Database for PostgreSQL met openbare toegang.
• Integratie van virtuele netwerken in Azure Database for PostgreSQL.
• Extensies gebruiken.
• Hoge beschikbaarheid in Azure Database for PostgreSQL.