Share via

Logische replicatie en logisch decoderen in Azure Database for PostgreSQL - Flexible Server

  • Artikel

VAN TOEPASSING OP: Azure Database for PostgreSQL - Flexibele 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. Met logische replicatie kunt u de gegevensreplicatie op een fijner niveau beheren, met inbegrip van gegevensreplicatie op tabelniveau.
    2. Met behulp van 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, enzovoort.

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

Logische replicatie en logische decodering vergelijken

Logische replicatie en logische decodering hebben verschillende overeenkomsten. Ze beide:

  • 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 site 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 serverparameters in de portal.

  2. Stel de serverparameter in op wal_levellogical.

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

  4. Werk max_worker_processes de parameterwaarde bij naar ten minste 16. Anders kunnen er problemen optreden, 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 exemplaar van flexibele Azure Database for PostgreSQL-server netwerkverkeer vanaf uw verbindingsresource toestaat.

  7. Verdeel de gebruikersreplicatiemachtigingen van de beheerder.

    ALTER ROLE <adminname> WITH REPLICATION;

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

Notitie

Het is altijd een goede gewoonte om uw replicatiegebruiker te scheiden van een gewoon beheerdersaccount.

Logische replicatie en logische decodering gebruiken

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

Systeemeigen logische replicatie

Logische replicatie maakt gebruik van de termen 'uitgever' en 'abonnee'.

  • De uitgever is de flexibele Server-database van Azure Database for PostgreSQL waaruit u gegevens verzendt.
  • De abonnee is de flexibele Azure Database for PostgreSQL-serverdatabase waarnaar u gegevens verzendt.

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

  1. Verbinding maken naar 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. Verbinding maken naar 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 op de abonnee. U ziet dat deze gegevens van de uitgever heeft 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 de aanmeldingsbevoegdheden in voor azure_pg_admin en controleert u de inhoud van de tabel.

    ALTER ROLE azure_pg_admin login;

Raadpleeg de PostgreSQL-documentatie voor meer informatie over logische replicatie.

Logische replicatie tussen databases op dezelfde server gebruiken

Wanneer u logische replicatie wilt instellen tussen verschillende databases die zich op hetzelfde exemplaar van azure Database for PostgreSQL flexibele server bevinden, is het essentieel om specifieke richtlijnen te volgen om implementatiebeperkingen te voorkomen die momenteel aanwezig zijn. Vanaf nu slaagt het maken van een abonnement dat verbinding maakt met hetzelfde databasecluster alleen als de replicatiesite niet binnen dezelfde opdracht wordt gemaakt; anders loopt de CREATE SUBSCRIPTION oproep vast bij een LibPQWalReceiverReceive wachtevenement. Dit gebeurt vanwege een bestaande beperking in de Postgres-engine, die mogelijk in toekomstige releases wordt verwijderd.

Volg de onderstaande stappen om logische replicatie in te stellen tussen uw brondatabases en doeldatabases op dezelfde server terwijl u deze beperking omzeilt:

Maak eerst een tabel met de naam Basic met een identiek schema in zowel de bron- als 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 replicatiesite met behulp van de pg_create_logical_replication_slot functie, waarmee u het vastgelopen probleem kunt voorkomen dat meestal optreedt wanneer de site wordt gemaakt in dezelfde opdracht als het abonnement. U moet de pgoutput invoegtoepassing gebruiken:

-- 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, zodat deze is ingesteld om false te voorkomen dat create_slot azure Database for PostgreSQL flexibele server een nieuwe site maakt en de naam van de site die in de vorige stap is gemaakt correct opgeeft. 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, kunt u deze nu testen door een nieuwe record in te voegen in de 'basic'-tabel in uw brondatabase 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, moet u de nieuwe record van de brondatabase in uw doeldatabase bekijken en bevestigen dat de logische replicatie is ingesteld.

pglogical extensie

Hier volgt een voorbeeld van het configureren van pglogical op de providerdatabaseserver en de abonnee. Raadpleeg de documentatie voor pglogical-extensies voor meer informatie. Zorg er ook voor dat u vereiste taken hebt uitgevoerd die hierboven worden vermeld.

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

    \c myDB
CREATE EXTENSION pglogical;

  2. Als de replicatiegebruiker niet de serverbeheergebruiker is (die de server heeft gemaakt), moet u ervoor zorgen dat u lid bent van een rol azure_pg_admin aan de gebruiker en dat u REPLICATIE- en AANMELDINGskenmerken toewijst 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=myPassword');

  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=myPasword' );

  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=myPassword');

  8. Vervolgens kunt u de abonnementsstatus controleren.

    SELECT subscription_name, status FROM pglogical.show_subscription_status();

Let op

Pglogical biedt momenteel geen ondersteuning voor automatische DDL-replicatie. Het oorspronkelijke schema kan handmatig worden gekopieerd met behulp van pg_dump --schema-only. DDL-instructies kunnen tegelijkertijd worden uitgevoerd op de provider en abonnee met behulp van de functie pglogical.replicate_ddl_command. Houd rekening met andere beperkingen van de extensie die hier wordt vermeld.

Logische decodering

Logische decodering kan worden gebruikt via het streamingprotocol of de SQL-interface.

Streamingprotocol

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

Ga naar de wal2json-documentatie voor een voorbeeld met behulp van het streamingprotocol met pg_recvlogical.

SQL-interface

In het onderstaande voorbeeld gebruiken we de SQL-interface met de wal2json-invoegtoepassing.

  1. Maak een site.

    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 gebruiken.

    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. Zet de site neer zodra u klaar bent met het gebruik ervan.

    SELECT pg_drop_replication_slot('test_slot');

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

Bijhouden

U moet logische decodering bewaken. Ongebruikte replicatiesite moet worden verwijderd. Sleuven houden vast aan Postgres WAL-logboeken en relevante systeemcatalogussen totdat wijzigingen zijn 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-verwerkte logboeken het risico van de wraparound van transactie-id's. Beide situaties kunnen ertoe leiden dat de server niet meer beschikbaar is. Daarom moeten logische replicatiesites continu worden gebruikt. Als een logische replicatiesite niet meer wordt gebruikt, kunt u deze onmiddellijk verwijderen.

De kolom Actief in de pg_replication_slots weergave geeft aan of er een consument is verbonden met een site.

SELECT * FROM pg_replication_slots;

Stel waarschuwingen in voor de maximaal gebruikte transactie-id's en opslag die worden gebruikt voor azure Database for PostgreSQL flexibele servergegevens 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.

  • Sleuven en hoge beschikbaarheidsfailover: wanneer u servers met hoge beschikbaarheid (HA) gebruikt met Flexibele Azure Database for PostgreSQL-server, moet u er rekening mee houden dat logische replicatiesites niet behouden blijven tijdens failovergebeurtenissen. Als u logische replicatiesites wilt onderhouden en gegevensconsistentie na een failover wilt garanderen, is het raadzaam om de extensie PG-failoversites te gebruiken. Raadpleeg de documentatie voor meer informatie over het inschakelen van deze extensie.

Belangrijk

U moet de logische replicatiesite op de primaire server verwijderen als de bijbehorende abonnee niet meer bestaat. Anders verzamelen de WAL-bestanden zich in het primaire bestand, waarbij de opslag wordt gevuld. Stel dat de opslagdrempel een bepaalde drempelwaarde overschrijdt en dat de logische replicatiesite niet wordt gebruikt (vanwege een niet-beschikbare abonnee). In dat geval wordt met het flexibele serverexemplaren van Azure Database for PostgreSQL automatisch die ongebruikte logische replicatiesite verwijderd. Met deze actie worden samengevoegde WAL-bestanden uitgebracht en wordt voorkomen dat uw server niet meer beschikbaar is omdat de opslag wordt gevuld.

Gerelateerde inhoud