Krížová replikácia medzi PostgreSQL a MySQL

Načrtnem krížovú replikáciu medzi PostgreSQL a MySQL, ako aj metódy na nastavenie krížovej replikácie medzi dvoma databázovými servermi. Krížovo replikované databázy sa zvyčajne nazývajú homogénne a je to pohodlný spôsob presunu z jedného servera RDBMS na druhý.

PostgreSQL a MySQL databázy sa vo všeobecnosti považujú za relačné, ale s ďalšími rozšíreniami ponúkajú možnosti NoSQL. Tu budeme diskutovať o replikácii medzi PostgreSQL a MySQL z pohľadu relačnej DBMS.

Nebudeme popisovať celé vnútorné fungovanie, len základné princípy, aby ste mali predstavu o konfigurácii replikácie medzi databázovými servermi, výhodách, obmedzeniach a prípadoch použitia.

Replikácia medzi dvoma identickými databázovými servermi sa zvyčajne vykonáva buď v binárnom režime, alebo pomocou dotazov medzi hlavným (známy ako vydavateľ, hlavný alebo aktívny) a podriadeným (predplatiteľ, pohotovostný alebo pasívny). Účelom replikácie je poskytnúť kópiu hlavnej databázy na strane slave v reálnom čase. V tomto prípade sa dáta prenášajú z mastera na slave, teda z aktívneho do pasívneho, pretože replikácia sa vykonáva len v jednom smere. Môžete však nastaviť replikáciu medzi dvoma databázami v oboch smeroch, takže údaje sa prenášajú z podriadenej jednotky na nadradenú v konfigurácii aktívna-aktívna. Toto všetko, vrátane kaskádovej replikácie, je možné medzi dvoma alebo viacerými identickými databázovými servermi. Aktívna-aktívna alebo aktívna-pasívna konfigurácia závisí od potreby, dostupnosti takýchto schopností v počiatočnej konfigurácii alebo použitia externých konfiguračných riešení a existujúcich kompromisov.

Opísaná konfigurácia je možná medzi rôznymi databázovými servermi. Server možno nakonfigurovať tak, aby prijímal replikované údaje z iného databázového servera a stále uchovával snímky replikovaných údajov v reálnom čase. MySQL a PostgreSQL ponúkajú väčšinu týchto konfigurácií interne alebo prostredníctvom rozšírení tretích strán, vrátane metód binárnych protokolov, uzamykania disku a metód založených na príkazoch a riadkoch.

Krížová replikácia medzi MySQL a PostgreSQL je potrebná na jednorazovú migráciu z jedného databázového servera na druhý. Tieto databázy používajú rôzne protokoly, takže nie je možné ich priamo prepojiť. Na vytvorenie výmeny údajov môžete použiť externý open source nástroj, napríklad pg_chameleon.

Čo je pg_chameleon

pg_chameleon je replikačný systém z MySQL do PostgreSQL v Pythone 3. Používa open source knižnicu mysql-replication, tiež v Pythone. Obrázky riadkov sú extrahované z tabuliek MySQL a uložené ako objekty JSONB v databáze PostgreSQL a potom dešifrované funkciou pl/pgsql a reprodukované v databáze PostgreSQL.

Vlastnosti pg_chameleon

Viaceré schémy MySQL z rovnakého klastra je možné replikovať do jednej cieľovej databázy PostgreSQL v konfigurácii jedna k mnohým
Názvy zdrojových a cieľových schém nemôžu byť rovnaké.
Údaje replikácie je možné získať z kaskádovej repliky MySQL.
Tabuľky, ktoré sa nemôžu replikovať alebo vytvárať chyby, sú vylúčené.
Každá funkcia replikácie je riadená démonmi.
Ovládanie pomocou parametrov a konfiguračných súborov založených na YAML.

Príklad

Hostiteľ
vm1
vm2

verzia OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

Verzia DB servera
MySQL 5.7.26
PostgreSQL 10.5

DB port
3306
5433

IP adresa
192.168.56.102
192.168.56.106

Na začiatok pripravte všetky potrebné komponenty na inštaláciu pg_chameleon. Tento príklad nainštaluje Python 3.6.8, ktorý vytvára a aktivuje virtuálne prostredie.

$> wget https://www.python.org/ftp/python/3.6.8/Python-3.6.8.tar.xz
$> tar -xJf Python-3.6.8.tar.xz
$> cd Python-3.6.8
$> ./configure --enable-optimizations
$> make altinstall

Po úspešnej inštalácii Pythonu 3.6 je potrebné splniť zostávajúce požiadavky, ako je vytvorenie a aktivácia virtuálneho prostredia. Okrem toho je modul pip aktualizovaný na najnovšiu verziu a používa sa na inštaláciu pg_chameleon. Nižšie uvedené príkazy zámerne inštalujú pg_chameleon 2.0.9, hoci najnovšia verzia je 2.0.10. Je to potrebné, aby ste sa vyhli novým chybám v aktualizovanej verzii.

$> python3.6 -m venv venv
$> source venv/bin/activate
(venv) $> pip install pip --upgrade
(venv) $> pip install pg_chameleon==2.0.9

Potom zavoláme pg_chameleon (chameleon je príkaz) s argumentom set_configuration_files, aby sme povolili pg_chameleon a vytvorili predvolené adresáre a konfiguračné súbory.

(venv) $> chameleon set_configuration_files
creating directory /root/.pg_chameleon
creating directory /root/.pg_chameleon/configuration/
creating directory /root/.pg_chameleon/logs/
creating directory /root/.pg_chameleon/pid/
copying configuration  example in /root/.pg_chameleon/configuration//config-example.yml

Teraz vytvoríme kópiu config-example.yml ako default.yml, takže sa stane predvoleným konfiguračným súborom. Vzorový konfiguračný súbor pre tento príklad je uvedený nižšie.

$> cat default.yml
---
#global settings
pid_dir: '~/.pg_chameleon/pid/'
log_dir: '~/.pg_chameleon/logs/'
log_dest: file
log_level: info
log_days_keep: 10
rollbar_key: ''
rollbar_env: ''

# type_override allows the user to override the default type conversion into a different one.
type_override:
  "tinyint(1)":
    override_to: boolean
    override_tables:
      - "*"

#postgres  destination connection
pg_conn:
  host: "192.168.56.106"
  port: "5433"
  user: "usr_replica"
  password: "pass123"
  database: "db_replica"
  charset: "utf8"

sources:
  mysql:
    db_conn:
      host: "192.168.56.102"
      port: "3306"
      user: "usr_replica"
      password: "pass123"
      charset: 'utf8'
      connect_timeout: 10
    schema_mappings:
      world_x: pgworld_x
    limit_tables:
#      - delphis_mediterranea.foo
    skip_tables:
#      - delphis_mediterranea.bar
    grant_select_to:
      - usr_readonly
    lock_timeout: "120s"
    my_server_id: 100
    replica_batch_size: 10000
    replay_max_rows: 10000
    batch_retention: '1 day'
    copy_max_memory: "300M"
    copy_mode: 'file'
    out_dir: /tmp
    sleep_loop: 1
    on_error_replay: continue
    on_error_read: continue
    auto_maintenance: "disabled"
    gtid_enable: No
    type: mysql
    skip_events:
      insert:
        - delphis_mediterranea.foo #skips inserts on the table delphis_mediterranea.foo
      delete:
        - delphis_mediterranea #skips deletes on schema delphis_mediterranea
      update:

Konfiguračný súbor v tomto príklade je vzorový súbor pg_chameleon s malými úpravami, aby vyhovoval zdrojovému a cieľovému prostrediu, a nižšie je prehľad rôznych sekcií konfiguračného súboru.

V konfiguračnom súbore default.yml sa nachádza sekcia globálnych nastavení, kde môžete spravovať nastavenia, ako je umiestnenie súboru zámku, umiestnenie protokolov, doba uloženia protokolov atď. Nasleduje sekcia prepísania typu, kde súbor pravidiel na prepísanie typov počas replikácie. V príklade je predvolené pravidlo prepisovania typu, ktoré konvertuje tinyint(1) na boolovskú hodnotu. V ďalšej časti špecifikujeme detaily pripojenia k cieľovej databáze. V našom prípade ide o PostgreSQL databázu s označením pg_conn. V poslednej časti uvádzame zdrojové dáta, teda parametre pripojenia zdrojovej databázy, schému mapovania medzi zdrojovou a cieľovou databázou, tabuľky, ktoré je potrebné preskočiť, čakaciu dobu, pamäť, veľkosť balíka. Všimnite si, že „zdroje“ je množné číslo, čo znamená, že do jednej cieľovej databázy môžeme pridať viacero zdrojových databáz a nastaviť tak konfiguráciu typu many-to-one.

Ukážková databáza world_x obsahuje 4 tabuľky s riadkami, ktoré komunita MySQL ponúka ako príklady. Dá sa stiahnuť tu. Vzorová databáza sa dodáva ako tar a komprimovaný archív s pokynmi na vytváranie a import riadkov.

V databázach MySQL a PostgreSQL sa vytvorí špeciálny používateľ s rovnakým názvom usr_replica. V MySQL má ďalšie práva na čítanie pre všetky replikované tabuľky.

mysql> CREATE USER usr_replica ;
mysql> SET PASSWORD FOR usr_replica='pass123';
mysql> GRANT ALL ON world_x.* TO 'usr_replica';
mysql> GRANT RELOAD ON *.* to 'usr_replica';
mysql> GRANT REPLICATION CLIENT ON *.* to 'usr_replica';
mysql> GRANT REPLICATION SLAVE ON *.* to 'usr_replica';
mysql> FLUSH PRIVILEGES;

Na strane PostgreSQL sa vytvorí databáza db_replica, ktorá bude akceptovať zmeny z databázy MySQL. Používateľ usr_replica v PostgreSQL je automaticky nakonfigurovaný ako vlastník dvoch schém, pgworld_x a sch_chameleon, ktoré obsahujú skutočné replikované tabuľky a tabuľky adresárov replikácie. Argument create_replica_schema je zodpovedný za automatickú konfiguráciu, ako uvidíte nižšie.

postgres=# CREATE USER usr_replica WITH PASSWORD 'pass123';
CREATE ROLE
postgres=# CREATE DATABASE db_replica WITH OWNER usr_replica;
CREATE DATABASE

Databáza MySQL je nakonfigurovaná s niekoľkými zmenami parametrov, aby bola pripravená na replikáciu, ako je uvedené nižšie. Aby sa zmeny prejavili, budete musieť reštartovať databázový server.

$> vi /etc/my.cnf
binlog_format= ROW
binlog_row_image=FULL
log-bin = mysql-bin
server-id = 1

Teraz je dôležité skontrolovať pripojenie k obom databázovým serverom, aby nedošlo k problémom pri spúšťaní príkazov pg_chameleon.

V uzle PostgreSQL:

$> mysql -u usr_replica -Ap'admin123' -h 192.168.56.102 -D world_x

V uzle MySQL:

$> psql -p 5433 -U usr_replica -h 192.168.56.106 db_replica

Nasledujúce tri príkazy pg_chameleon (chameleon) pripravia prostredie, pridajú zdroj a inicializujú repliku. Argument create_replica_schema pre pg_chameleon vytvorí predvolenú schému (sch_chameleon) a schému replikácie (pgworld_x) v databáze PostgreSQL, ako sme už diskutovali. Argument add_source pridáva do konfigurácie zdrojovú databázu načítaním konfiguračného súboru (default.yml), v našom prípade je to mysql a init_replica inicializuje konfiguráciu na základe parametrov v konfiguračnom súbore.

$> chameleon create_replica_schema --debug
$> chameleon add_source --config default --source mysql --debug
$> chameleon init_replica --config default --source mysql --debug

Výstup týchto troch príkazov jasne naznačuje, že boli úspešne vykonané. Akékoľvek zlyhania alebo chyby syntaxe sú hlásené v jednoduchých a jasných správach s radami, ako problém vyriešiť.

Nakoniec spustíme replikáciu pomocou start_replica a dostaneme správu o úspechu.

$> chameleon start_replica --config default --source mysql 
output: Starting the replica process for source mysql

Stav replikácie možno zistiť pomocou argumentu show_status a chyby je možné zobraziť pomocou argumentu show_errors.

Výsledok.

Ako sme už povedali, každá funkcia replikácie je riadená démonmi. Aby sme ich zobrazili, dopytujeme tabuľku procesov pomocou príkazu Linux ps, ako je uvedené nižšie.

Výsledok.

Replikácia sa nepovažuje za nakonfigurovanú, kým ju neotestujeme v reálnom čase, ako je uvedené nižšie. Vytvoríme tabuľku, vložíme niekoľko záznamov do databázy MySQL a zavoláme argument sync_tables v pg_chameleon na aktualizáciu démonov a replikáciu tabuľky so záznamami do databázy PostgreSQL.

mysql> create table t1 (n1 int primary key, n2 varchar(10));
Query OK, 0 rows affected (0.01 sec)
mysql> insert into t1 values (1,'one');
Query OK, 1 row affected (0.00 sec)
mysql> insert into t1 values (2,'two');
Query OK, 1 row affected (0.00 sec)

$> chameleon sync_tables --tables world_x.t1 --config default --source mysql
Sync tables process for source mysql started.

Na potvrdenie výsledkov testu vykonáme dotaz v tabuľke z databázy PostgreSQL a vypíšeme riadky.

$> psql -p 5433 -U usr_replica -d db_replica -c "select * from pgworld_x.t1";
 n1 |  n2
----+-------
  1 | one
  2 | two

Ak robíme migráciu, nasledujúce príkazy pg_chameleon budú jej koncom. Príkazy je potrebné vykonať, keď sme si istí, že riadky všetkých cieľových tabuliek boli replikované a výsledkom bude úhľadne migrovaná PostgreSQL databáza bez odkazov na zdrojovú databázu alebo schému replikácie (sch_chameleon).

$> chameleon stop_replica --config default --source mysql 
$> chameleon detach_replica --config default --source mysql --debug

Ak chcete, môžete použiť nasledujúce príkazy na odstránenie pôvodnej konfigurácie a schémy replikácie.

$> chameleon drop_source --config default --source mysql --debug
$> chameleon drop_replica_schema --config default --source mysql --debug

Výhody pg_chameleon

Jednoduché nastavenie a konfigurácia.
Pomocou jasných chybových hlásení môžete jednoducho odstraňovať a identifikovať anomálie.
Po inicializácii možno do replikácie pridať ďalšie špeciálne tabuľky bez zmeny zvyšku konfigurácie.
Je možné nakonfigurovať viacero zdrojových databáz pre jednu cieľovú databázu, čo je veľmi užitočné, ak kombinujete údaje z jednej alebo viacerých databáz MySQL do jednej databázy PostgreSQL.
Vybraté tabuľky nemusíte replikovať.

Nevýhody pg_chameleon

Podporované iba s MySQL 5.5 a novšou ako zdrojovou a PostgreSQL 9.5 a novšou ako cieľovou databázou.
Každá tabuľka musí mať primárny alebo jedinečný kľúč, inak sa tabuľky inicializujú počas procesu init_replica, ale nereplikujú sa.
Jednosmerná replikácia - iba z MySQL do PostgreSQL. Preto je vhodný len pre „aktívny-pasívny“ obvod.
Zdrojom môže byť len MySQL databáza a podpora PostgreSQL databázy ako zdroja je len experimentálna a s obmedzeniami (viac informácií tu)

Výsledky pre pg_chameleon

Metóda replikácie v pg_chameleon je skvelá na migráciu databázy z MySQL do PostgreSQL. Významnou nevýhodou je, že replikácia je len jednosmerná, takže databázoví profesionáli ju pravdepodobne nebudú chcieť použiť na niečo iné ako migráciu. Ale problém jednosmernej replikácie možno vyriešiť pomocou iného open source nástroja – SymmetricDS.

Prečítajte si viac v oficiálnej dokumentácii tu. Môžete nájsť pomoc s príkazovým riadkom tu.

Prehľad SymmetricDS

SymmetricDS je open source nástroj, ktorý replikuje akúkoľvek databázu do akejkoľvek inej bežnej databázy: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird a ďalšie inštancie cloudových databáz, napr. Redshift a Azure atď. Dostupné funkcie: synchronizácia databáz a súborov, replikácia multi-master databáz, filtrovaná synchronizácia, transformácia a iné. Toto je nástroj Java a vyžaduje štandardné vydanie JRE alebo JDK (verzia 8.0 alebo vyššia). Tu je možné zaznamenať zmeny údajov spúšťačov v zdrojovej databáze a odoslať ich do príslušnej cieľovej databázy vo forme dávok.

Funkcie SymmetricDS

Nástroj je nezávislý na platforme, čo znamená, že údaje si môžu vymieňať dve alebo viac rôznych databáz.
Relačné databázy sa synchronizujú pomocou záznamov o zmene údajov, zatiaľ čo databázy založené na súborovom systéme používajú synchronizáciu súborov.
Obojsmerná replikácia pomocou metód Push a Pull na základe súboru pravidiel.
Prenos dát je možný cez zabezpečené siete s nízkou šírkou pásma.
Automatické obnovenie, keď uzly obnovia prevádzku po zlyhaní a automatické riešenie konfliktov.
Cloud kompatibilné a výkonné rozšírenia API.

Príklad

SymmetricDS je možné nakonfigurovať v jednej z dvoch možností:
Hlavný (rodičovský) uzol, ktorý centrálne koordinuje replikáciu údajov medzi dvoma podriadenými (podradenými) uzlami a komunikácia medzi podriadenými uzlami prebieha iba cez nadradený.
Aktívny uzol (Uzol 1) môže komunikovať za účelom replikácie s iným aktívnym uzlom (Uzol 2) bez sprostredkovateľa.

V oboch možnostiach dochádza k výmene dát pomocou Push and Pull. V tomto príklade budeme uvažovať konfiguráciu aktívne-aktívne. Opísať celú architektúru by trvalo príliš dlho, tak si urobte prieskum. sprievodcasa dozviete viac o zariadení SymmetricDS.

Inštalácia SymmetricDS je veľmi jednoduchá: stiahnite si verziu zip súboru s otvoreným zdrojovým kódom preto a vytiahnite si ho, kam len chcete. Nižšie uvedená tabuľka poskytuje informácie o umiestnení inštalácie a verzii SymmetricDS v tomto príklade, ako aj o verziách databázy, verziách Linuxu, IP adresách a portoch pre oba uzly.

Hostiteľ
vm1
vm2

verzia OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

Verzia DB servera
MySQL 5.7.26
PostgreSQL 10.5

DB port
3306
5832

IP adresa
192.168.1.107
192.168.1.112

Verzia SymmetricDS
SymmetricDS 3.9
SymmetricDS 3.9

Inštalačná cesta SymmetricDS
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

Názov uzla SymmetricDS
corp-000
predajňa-001

Tu nainštalujeme SymmetricDS do /usr/local/symmetric-server-3.9.20 a budú tam uložené rôzne podadresáre a súbory. Máme záujem o vzorky a podadresáre motorov. Adresár vzoriek obsahuje vzorové konfiguračné súbory s vlastnosťami uzla, ako aj vzorové skripty SQL, aby ste mohli rýchlo začať.

V adresári sample vidíme tri konfiguračné súbory s vlastnosťami uzla – názov ukazuje povahu uzla v určitej schéme.

corp-000.properties
store-001.properties
store-002.properties

SymmetricDS má všetky potrebné konfiguračné súbory pre základný 3-uzlový dizajn (možnosť 1) a rovnaké súbory možno použiť pre 2-uzlový dizajn (možnosť 2). Skopírujte požadovaný konfiguračný súbor z adresára vzoriek do motorov na hostiteľovi vm1. Dopadá to takto:

$> cat engines/corp-000.properties
engine.name=corp-000
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://192.168.1.107:3306/replica_db?autoReconnect=true&useSSL=false
db.user=root
db.password=admin123
registration.url=
sync.url=http://192.168.1.107:31415/sync/corp-000
group.id=corp
external.id=000

Tento uzol v konfigurácii SymmetricDS sa nazýva corp-000 a o pripojenie k databáze sa stará ovládač mysql jdbc, ktorý používa vyššie uvedený reťazec pripojenia a prihlasovacie údaje. Pripojíme sa k databáze replica_db a pri vytváraní schémy sa vytvoria tabuľky. sync.url zobrazuje umiestnenie pripojenia k uzlu na synchronizáciu.

Uzol 2 na hostiteľovi vm2 je nakonfigurovaný ako store-001 a zvyšok je špecifikovaný v súbore node.properties nižšie. Node store-001 prevádzkuje databázu PostgreSQL a pgdb_replica je replikačná databáza. registration.url umožňuje hostiteľovi vm2 kontaktovať hostiteľa vm1 a získať od neho podrobnosti o konfigurácii.

$> cat engines/store-001.properties
engine.name=store-001
db.driver=org.postgresql.Driver
db.url=jdbc:postgresql://192.168.1.112:5832/pgdb_replica
db.user=postgres
db.password=admin123
registration.url=http://192.168.1.107:31415/sync/corp-000
group.id=store
external.id=001

Dokončený príklad SymmetricDS obsahuje parametre na nastavenie obojsmernej replikácie medzi dvoma databázovými servermi (dva uzly). Nasledujúce kroky sa vykonávajú na hostiteľovi vm1 (corp-000), čím sa vytvorí vzorová schéma so 4 tabuľkami. Potom spustením create-sym-tables pomocou príkazu symadmin sa vytvoria tabuľky adresárov, kde budú uložené pravidlá a smer replikácie medzi uzlami. Nakoniec sa do tabuliek načítajú vzorové údaje.

vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> ./dbimport --engine corp-000 --format XML create_sample.xml
vm1$> ./symadmin --engine corp-000 create-sym-tables
vm1$> ./dbimport --engine corp-000 insert_sample.sql

V príklade sú tabuľky item a item_selling_price automaticky nakonfigurované na replikáciu z corp-000 do store-001 a tabuľky predaja (sale_transaction a sale_return_line_item) sú automaticky nakonfigurované na replikáciu z store-001 na corp-000. Teraz vytvoríme schému v databáze PostgreSQL na hostiteľovi vm2 (store-001), aby sme ju pripravili na príjem údajov z corp-000.

vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> ./dbimport --engine store-001 --format XML create_sample.xml

Nezabudnite skontrolovať, či databáza MySQL na vm1 obsahuje vzorové tabuľky a tabuľky katalógu SymmetricDS. Všimnite si, že systémové tabuľky SymmetricDS (s predponou sym_) sú momentálne dostupné len na uzle corp-000, pretože tam sme spustili príkaz create-sym-tables a budeme spravovať replikáciu. A v databáze na node store-001 budú iba 4 príklady tabuliek bez údajov.

Všetky. Prostredie je pripravené na spustenie procesov sym servera na oboch uzloch, ako je znázornené nižšie.

vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> sym 2>&1 &

Záznamy denníka sa odosielajú do súboru denníka na pozadí (symmetric.log) v priečinku logs v adresári, kde je nainštalovaný SymmetricDS, ako aj na štandardný výstup. Sym server je teraz možné spustiť na node store-001.

vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> sym 2>&1 &

Ak spustíte proces sym servera na hostiteľovi vm2, vytvorí sa aj katalógové tabuľky SymmetricDS v databáze PostgreSQL. Ak spustíte proces sym servera na oboch uzloch, tieto sa navzájom koordinujú, aby replikovali údaje z corp-000 do store-001. Ak po niekoľkých sekundách skontrolujeme všetky 4 tabuľky na oboch stranách, uvidíme, že replikácia bola úspešná. Alebo môžete bootstrap odoslať do node store-001 z corp-000 pomocou nasledujúceho príkazu.

vm1$> ./symadmin --engine corp-000 reload-node 001

V tomto bode sa do tabuľky položiek v databáze MySQL na uzle corp-000 (hostiteľ: vm1) vloží nový záznam a môžete skontrolovať jeho replikáciu do databázy PostgreSQL na uzle store-001 (hostiteľ: vm2). Vidíme operáciu Pull na presun údajov z corp-000 do store-001.

mysql> insert into item values ('22000002','Jelly Bean');
Query OK, 1 row affected (0.00 sec)

vm2$> psql -p 5832 -U postgres pgdb_replica -c "select * from item"
 item_id  |   name
----------+-----------
 11000001 | Yummy Gum
 22000002 | Jelly Bean
(2 rows)

Ak chcete vykonať operáciu Push na presun údajov z obchodu-001 do corp-000, vložíme záznam do tabuľky sale_transaction a overíme, či je replikácia úspešná.

Výsledok.

Vidíme úspešné nastavenie obojsmernej replikácie vzorových tabuliek medzi databázami MySQL a PostgreSQL. Ak chcete nastaviť replikáciu pre nové užívateľské tabuľky, postupujte takto: Vytvoríme si napríklad tabuľku t1 a nakonfigurujeme jej pravidlá replikácie nasledovne. Týmto spôsobom konfigurujeme iba replikáciu z corp-000 do store-001.

mysql> create table  t1 (no integer);
Query OK, 0 rows affected (0.01 sec)

mysql> insert into sym_channel (channel_id,create_time,last_update_time) 
values ('t1',current_timestamp,current_timestamp);
Query OK, 1 row affected (0.01 sec)

mysql> insert into sym_trigger (trigger_id, source_table_name,channel_id,
last_update_time, create_time) values ('t1', 't1', 't1', current_timestamp,
current_timestamp);
Query OK, 1 row affected (0.01 sec)

mysql> insert into sym_trigger_router (trigger_id, router_id,
Initial_load_order, create_time,last_update_time) values ('t1',
'corp-2-store-1', 1, current_timestamp,current_timestamp);
Query OK, 1 row affected (0.01 sec)

Konfigurácia je potom upozornená na zmenu schémy, to znamená na pridanie novej tabuľky, pomocou príkazu symadmin s argumentom sync-triggers, ktorý znova vytvorí spúšťače na mapovanie definícií tabuľky. send-schema sa vykoná na odoslanie zmien schémy do uzla store-001 a nakonfiguruje sa replikácia tabuľky t1.

vm1$> ./symadmin -e corp-000 --node=001 sync-triggers    
vm1$> ./symadmin send-schema -e corp-000 --node=001 t1

Výhody SymmetricDS

Jednoduchá inštalácia a konfigurácia vrátane pripravenej sady súborov s parametrami na vytvorenie trojuzlového alebo dvojuzlového obvodu.
Multiplatformové databázy a platformová nezávislosť vrátane serverov, notebookov a mobilných zariadení.
Replikujte ľubovoľnú databázu do akejkoľvek inej databázy lokálne, na WAN alebo v cloude.
Možnosť optimálnej práce s niekoľkými databázami alebo niekoľkými tisíckami pre pohodlnú replikáciu.
Platená verzia s GUI a vynikajúcou podporou.

Nevýhody SymmetricDS

Na načítanie katalógových tabuliek musíte manuálne definovať pravidlá a smer replikácie na príkazovom riadku prostredníctvom príkazov SQL, čo môže byť nepohodlné.
Nastavenie mnohých tabuliek na replikáciu môže byť únavné, pokiaľ nepoužívate skripty na vytváranie príkazov SQL, ktoré definujú pravidlá a smer replikácie.
V protokoloch sa zaznamenáva príliš veľa informácií a niekedy je potrebné urobiť poriadok v súbore denníka, aby nezaberal príliš veľa miesta.

Výsledky pre SymmetricDS

SymmetricDS vám umožňuje nastaviť obojsmernú replikáciu medzi dvoma, tromi alebo dokonca niekoľkými tisíckami uzlov na replikáciu a synchronizáciu súborov. Ide o unikátny nástroj, ktorý nezávisle vykonáva množstvo úloh, ako je automatická obnova dát po dlhom odstávke na uzle, bezpečná a efektívna výmena dát medzi uzlami cez HTTPS, automatické riadenie konfliktov na základe sady pravidiel atď. SymmetricDS vykonáva replikáciu medzi ľubovoľnými databázami, preto ho možno použiť pre širokú škálu scenárov vrátane migrácie, migrácie, distribúcie, filtrovania a transformácie údajov naprieč platformami.

Príklad je založený na úradnom stručný návod spoločnosťou SymmetricDS. IN používateľská príručka Podrobne popisuje rôzne koncepty zapojené do nastavenia replikácie pomocou SymmetricDS.

Zdroj: hab.com