V stručnosti saznáme o krížovej replikácii medzi PostgreSQL a MySQL, ako aj o metódach nastavenia krížovej replikácie medzi týmito dvoma databázovými servermi. Zvyčajne sa databázy v krížovej replikácii nazývajú homogénnymi a je to pohodlný spôsob prechodu z jedného servera relačnej DBMS na iný.
Databázy PostgreSQL a MySQL sa považujú za relačné, ale s dodatočnými rozšíreniami ponúkajú možnosti NoSQL. Tu budeme diskutovať o replikácii medzi PostgreSQL a MySQL z pohľadu relačných DBMS.
Nebudeme popisovať celú vnútornú kuchyňu, len základné princípy, aby ste získali predstavu o nastavení replikácie medzi databázovými servermi, výhodách, obmedzeniach a scenároch 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 dopytov medzi vedúcim uzlom (rovnako ako publikátor, hlavný alebo aktívny) a nasledovníkom (predplatiteľ, čakať alebo pasívny). Cieľom replikácie je poskytnúť v reálnom čase kópiu hlavnej databázy na strane nasledovníka. Údaje sa pritom prenášajú z vedúceho k nasledovníkovi, teda z aktívneho na pasívny, pretože replikácia sa vykonáva len jedným smerom. Je však možné nastaviť replikáciu medzi dvoma databázami obojstranne, aby sa údaje prenášali od nasledovníka k vedúcemu v konfigurácii „aktívny-aktívny“. To všetko, vrátane kaskádovej replikácie, je možné medzi dvoma alebo viacerými identickými databázovými servermi. Konfigurácia „aktívny-aktívny“ alebo „aktívny-pasívny“ závisí od potreby, dostupnosti takýchto možností v pôvodnej konfigurácii alebo použitia externých riešení na nastavenie a existujúcich kompromisov.
Opísaná konfigurácia je možná medzi rôznymi databázovými servermi. Server môže byť nastavený na prijímanie replikovaných údajov z iného databázového servera a pritom udržiavať snímky replikovaných údajov v reálnom čase. MySQL a PostgreSQL ponúkajú väčšinu týchto konfigurácií svojimi silami alebo s pomocou externých rozšírení, vrátane metód binárneho denníka, blokovania disku a metód založených na operátoroch 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 ich nemožno priamo prepojiť. Na zavedenie výmeny údajov je možné použiť externý open-source nástroj, ako napríklad pg_chameleon.
Čo je pg_chameleon
pg_chameleon je replikačný systém z MySQL do PostgreSQL napísaný v Pythone 3. Využíva open-source knižnicu mysql-replication, taktiež v Pythone. Záznamy sú extrahované z tabuliek MySQL a ukladané ako objekty JSONB v databáze PostgreSQL, a potom sú dešifrované funkciou pl/pgsql a reprodukované v databáze PostgreSQL.
Možnosti pg_chameleon
Niekoľko schém MySQL z jedného klastra môže byť replikovaných do jednej cieľovej databázy PostgreSQL s konfiguráciou "jeden ku mnohým"
Názvy zdrojovej a cieľovej schémy sa nemôžu zhodovať.
Údaje replikácie môžu byť extrahované z kaskádovej repliky MySQL.
Tabuľky, ktoré nemôžu byť replikované alebo spôsobujú chyby, sú vylúčené.
Každú funkciu replikácie riadia démoni.
Kontrola pomocou parametrov a konfiguračných súborov vo formáte YAML.
Príklad
Hostiteľ
vm1
vm2
Verzia OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64
Verzia servera DB
MySQL 5.7.26
PostgreSQL 10.5
Port DB
3306
5433
IP adresa
192.168.56.102
192.168.56.106
Najprv si pripravte všetky potrebné komponenty na inštaláciu pg_chameleon. V tomto príklade je nainštalovaný Python 3.6.8, ktorý vytvára virtuálne prostredie a aktivuje ho.
$> 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 altinstallPo úspešnej inštalácii Python3.6 je potrebné splniť ďalšie požiadavky, ako je vytvorenie a aktivácia virtuálneho prostredia. Okrem toho sa modul pip aktualizuje na najnovšiu verziu a používa sa na inštaláciu pg_chameleon. V nižšie uvedených príkazoch sa úmyselne inštaluje pg_chameleon 2.0.9, hoci najnovšia verzia je 2.0.10. Toto je potrebné na vyhnutie sa novým chybám vo verzii po aktualizácii.
$> python3.6 -m venv venv
$> source venv/bin/activate
(venv) $> pip install pip --upgrade
(venv) $> pip install pg_chameleon==2.0.9Potom voláme pg_chameleon (chameleon je príkaz) so z argumentom set_configuration_files, aby sme zapli 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.ymlTeraz vytvárame kópiu config-example.yml ako default.yml, aby sa stal predvoleným konfiguračným súborom. Ukážka konfiguračného súboru pre tento príklad je uvedená nižšie.
$> cat default.yml
---
#globálne nastavenia
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 umožňuje používateľovi predefinovať predvolenú konverziu typu na iný.
type_override:
"tinyint(1)":
override_to: boolean
override_tables:
- "*"
#postgres cieľové pripojenie
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 deň'
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 #preskáče vkladanie do tabuľky delphis_mediterranea.foo
delete:
- delphis_mediterranea #preskáče mazanie v schéme delphis_mediterranea
update:Konfiguračný súbor v tomto príklade je vzorom súboru s pg_chameleon s drobnými zmenami v súlade so zdrojovým a cieľovým prostredím, a nižšie sa uvádzajú rôzne oddiely konfiguračného súboru.
V konfiguračnom súbore default.yml je sekcia globálnych parametrov (global settings), kde môžete spravovať nastavenia, ako sú umiestnenie súboru zámku, umiestnenie logov, doba uchovávania logov a pod. Následne nasleduje sekcia predefinovania typov (type override), kde je uvedená sada pravidiel na predefinovanie typov počas replikácie. V predvolenom prípade sa používa pravidlo predefinovania typu, ktoré konvertuje tinyint(1) na booleovskú hodnotu. V nasledujúcej sekcii uvádzame podrobnosti o pripojení k cieľovej databáze. V našom prípade je to databáza PostgreSQL, označená ako pg_conn. V poslednej sekcii uvádzame údaje o zdroji, t.j. parametre pripojenia k zdrojovej databáze, schému mapovania medzi zdrojovou a cieľovou databázou, tabuľky, ktoré sa majú preskočiť, časový limit, pamäť, veľkosť dávky. Všimnite si, že "sources" je uvedené v množnom čísle, čo znamená, že môžeme pridať niekoľko zdrojových databáz pre jednu cieľovú databázu, aby sme nastavili konfiguráciu "mnohí na jedného".
Databáza world_x v príklade obsahuje 4 tabuľky so záznamami, ktoré komunita MySQL ponúka ako vzor. Môžete ju načítať. . Príklad databázy je dodávaný vo forme tar a komprimovaného archívu s pokynmi na vytvorenie a import záznamov.
V databázach MySQL a PostgreSQL sa vytvára špeciálny používateľ s rovnakým menom usr_replica. V MySQL mu sú udelené ďalšie práva na čítanie všetkých replikovaných tabuliek.
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 vytvára databáza db_replica, ktorá bude prijímať zmeny z databázy MySQL. Používateľ usr_replica v PostgreSQL sa automaticky nastavuje ako vlastník dvoch schém pgworld_x a sch_chameleon, ktoré obsahujú faktické replikované tabuľky a tabuľky s katalógmi replikácie. O automatickú konfiguráciu sa stará argument create_replica_schema, 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 DATABASEDatabáza MySQL sa konfiguruje so zmenami niektorých parametrov, aby sa pripravila na replikáciu, ako je znázornené nižšie. Bude potrebné reštartovať databázový server, aby sa zmeny prejavili.
$> vi /etc/my.cnf
binlog_format= ROW
binlog_row_image=FULL
log-bin = mysql-bin
server-id = 1Je teraz dôležité skontrolovať pripojenie k obom databázovým serverom, aby sa pri vykonávaní príkazov pg_chameleon nevyskytli problémy.
Na uzle PostgreSQL:
$> mysql -u usr_replica -Ap'admin123' -h 192.168.56.102 -D world_xNa uzle MySQL :
$> psql -p 5433 -U usr_replica -h 192.168.56.106 db_replicaNasledujúce tri príkazy pg_chameleon (chameleon) pripravujú prostredie, pridávajú zdroj a inicializujú replikáciu. Argument create_replica_schema v pg_chameleon vytvára predvolenú schému (sch_chameleon) a schému replikácie (pgworld_x) v databáze PostgreSQL, ako sme už uviedli. Argument add_source pridáva zdrojovú databázu do konfigurácie, čítaním konfiguračného súboru (default.yml), a v tomto prípade ide o 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 --debugVýstupy týchto troch príkazov jasne naznačujú ich úspešné vykonanie. Všetky chyby alebo syntaxové chyby sú uvedené v jednoduchých a zrozumiteľných správach s návrhmi na opravu problémov.
Nakoniec spustíme replikáciu pomocou start_replica a obdržíme správu o úspešnom vykonaní.
$> chameleon start_replica --config default --source mysql
výstup: Spúšťam proces replikácie pre zdroj mysqlStav replikácie je možné skontrolovať pomocou argumentu show_status a prehľad chýb pomocou argumentu show_errors.
Ako sme už spomenuli, každou funkciou replikácie riadia démóny. Aby sme ich videli, požiadame o tabuľku procesov príkazom Linux ps, ako je uvedené nižšie.
Replikácia sa nepovažuje za nastavenú, poký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 vyvoláme argument sync_tables v pg_chameleon, aby sme aktualizovali démóny a replikovali tabuľku so záznamami do databázy PostgreSQL.
mysql> create table t1 (n1 int primary key, n2 varchar(10));
Dotaz bol úspešný, 0 riadkov ovplyvnených (0.01 sec)
mysql> insert into t1 values (1,'one');
Dotaz bol úspešný, 1 riadok ovplyvnený (0.00 sec)
mysql> insert into t1 values (2,'two');
Dotaz bol úspešný, 1 riadok ovplyvnený (0.00 sec)$> chameleon sync_tables --tables world_x.t1 --config default --source mysql
Proces synchronizácie tabuliek pre zdroj mysql bol spustený.Aby sme potvrdili výsledky testu, požiadame o tabuľku z databázy PostgreSQL a zobrazíme riadky.
$> psql -p 5433 -U usr_replica -d db_replica -c "select * from pgworld_x.t1";
n1 | n2
----+-------
1 | one
2 | twoAk vykonávame migráciu, nasledujúce príkazy pg_chameleon ju ukončia. Príkazy je potrebné vykonať po tom, čo sa presvedčíme, že všetky riadky cieľových tabuliek boli replikované, a výsledkom bude precízne prenesená databáza PostgreSQL bez odkazov na pôvodnú databázu alebo schému replikácie (sch_chameleon).
$> chameleon stop_replica --config default --source mysql
$> chameleon detach_replica --config default --source mysql --debugNa želanie je možné nasledujúcimi príkazmi odstrániť pôvodnú konfiguráciu a schému replikácie.
$> chameleon drop_source --config default --source mysql --debug
$> chameleon drop_replica_schema --config default --source mysql --debugVýhody pg_chameleon
Jednoduché nastavenie a konfigurácia.
Pohodlné odstraňovanie problémov a odhaľovanie anomálií s jasnými chybovými správami.
Do replikácie je možné pridať ďalšie špeciálne tabuľky po inicializácii, bez zmeny zvyšku konfigurácie.
Je možné nastaviť niekoľko zdrojových databáz pre jednu cieľovú, čo je veľmi pohodlné, ak kombinujete údaje z jednej alebo viacerých databáz MySQL do jednej databázy PostgreSQL.
Nie je potrebné replikovať vybrané tabuľky.
Nevýhody pg_chameleon
Podporuje sa iba s MySQL 5.5 a vyšším ako zdrojom a PostgreSQL 9.5 a vyšším ako cieľovou databázou.
Každá tabuľa musí mať primárny alebo unikátny kľúč, inak sa tabuľky inicializujú počas procesu init_replica, ale nereplikujú.
Jednosmerná replikácia — len z MySQL do PostgreSQL. Preto sa hodí iba pre schému "aktívny-pasívny".
Zdrojem môže byť iba databáza MySQL, a podpora databázy PostgreSQL ako zdroja je len experimentálna a s obmedzeniami (dozviete sa viac )
Zhrnutie k pg_chameleon
Metóda replikácie v pg_chameleon je skvelá na migráciu databázy z MySQL do PostgreSQL. Podstatnou nevýhodou je, že replikácia je len jednosmerná, preto odborníci na databázy pravdepodobne nebudú chcieť používať tento nástroj na nič iné, ako na migráciu. Problém jednosmernej replikácie sa však dá vyriešiť ďalším open-source nástrojom — SymmetricDS.
Viac informácií nájdete v oficiálnej dokumentácii . Návod k príkazovému riadku môžete nájsť .
Prehľad SymmetricDS
SymmetricDS je open-source nástroj, ktorý replikácie 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 cloudové databázové instance, ako Redshift, a Azure atď. Dostupné funkcie: synchronizácia databáz a súborov, replikácia viacerých hlavných databáz, filtrovaná synchronizácia, transformácie a ďalšie. Je to nástroj na Jave a vyžaduje štandardné vydanie JRE alebo JDK (verzia 8.0 alebo vyššie). Tu je možné zaznamenať zmeny údajov cez spúšťače v zdrojovej databáze a smerovať ich do príslušnej cieľovej databázy vo forme balíčkov.
Možnosti SymmetricDS
Nástroj je multiplatformový, čo znamená, že dve alebo viac rôznych databáz môžu vymieňať údaje.
Relačné databázy sa synchronizujú pomocou zaznamenávania zmien údajov, zatiaľ čo databázy založené na súborových systémoch používajú synchronizáciu súborov.
Dvojcestná replikácia pomocou metód Push a Pull na základe súboru pravidiel.
Prenos dát je možný cez zabezpečené siete a siete s nízkou priepustnosťou.
Automatické obnovenie pri obnovení funkčnosti uzlov po zlyhaní a automatické riešenie konfliktov.
Kompatibilita s cloudom a efektívne API rozšírení.
Príklad
SymmetricDS môže byť nakonfigurovaný dvoma spôsobmi:
Hlavný (rodičovský) uzol, ktorý centralizovane koordinuje replikáciu dát medzi dvoma podriadenými (dcérskymi) uzlami, pričom výmena dát medzi dcérskymi uzlami prebieha iba cez rodičovský.
Aktívny uzol (uzol 1) môže vymieňať dáta na replikáciu s iným aktívnym uzlom (uzol 2) bez sprostredkovateľa.
V oboch prípadoch prebieha výmena dát pomocou Push a Pull. V tomto príklade sa zameriame na konfiguráciu „aktívny-aktívny“. Opisovanie celej architektúry by trvalo príliš dlho, takže si preštudujte , aby ste sa dozvedeli viac o fungovaní SymmetricDS.
Inštalácia SymmetricDS je veľmi jednoduchá: stiahnite si open-source verziu zip súboru a rozbaľte ju kamkoľvek chcete. V tabuľke nižšie sú uvedené informácie o mieste inštalácie a verzii SymmetricDS v tomto príklade, ako aj verzie databáz, verzie Linuxu, IP adresy a porty pre oba uzly.
Hostiteľ
vm1
vm2
Verzia OS
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64
Verzia servera DB
MySQL 5.7.26
PostgreSQL 10.5
Port DB
3306
5832
IP adresa
192.168.1.107
192.168.1.112
Verzia SymmetricDS
SymmetricDS 3.9
SymmetricDS 3.9
Cesta inštalácie SymmetricDS
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20
Názov uzla SymmetricDS
corp-000
store-001
Tu inštalujeme SymmetricDS do /usr/local/symmetric-server-3.9.20, a tu budú uložené rôzne vnorené adresáre a súbory. Zaujímajú nás vnorené adresáre samples a engines. V adresári samples sa nachádzajú ukážky konfiguračných súborov s vlastnosťami uzla, ako aj ukážky SQL skriptov na rýchly začiatok demonštrácie.
V adresári samples vidíme tri konfiguračné súbory s vlastnosťami uzla – názov naznačuje charakter uzla v konkrétnej schéme.
corp-000.properties
store-001.properties
store-002.propertiesV SymmetricDS sú všetky potrebné konfiguračné súbory pre základnú schému pozostávajúcu z 3 uzlov (varianta 1), a tie isté súbory môžeme použiť aj pre schému z 2 uzlov (varianta 2). Skopírujeme potrebný konfiguračný súbor z adresára samples do engines na hostiteľovi vm1. Vyzerá 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=000Tento uzol v konfigurácii SymmetricDS sa nazýva corp-000 a pripojenie k databáze spracováva ovládač mysql jdbc, ktorý používa vyššie uvedený pripojovací reťazec a prihlasovacie údaje. Pripájame sa k databáze replica_db a počas vytvárania schémy budú vytvorené tabuľky. sync.url ukazuje miesto spojenia s uzlom pre synchronizáciu.
Uzol 2 na hoste vm2 sa nastavuje ako store-001 a zvyšok je uvedený v súbore node.properties, ktorý je uvedený nižšie. Uzol store-001 vykonáva databázu PostgreSQL a pgdb_replica je databáza pre replikáciu. registration.url umožňuje hostiteľovi vm2 spojiť sa s hostiteľom vm1 a získať od neho podrobnosti konfigurácie.
$> 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=001Hotový príklad SymmetricDS obsahuje parametre na nastavenie obojsmernej replikácie medzi dvoma servermi databáz (dvoma uzlami). Nižšie uvedené kroky sa vykonávajú na hoste vm1 (corp-000), ktorý vytvorí príklad schémy so 4 tabuľkami. Následne vykonanie create-sym-tables príkazom symadmin vytvorí tabuľky katalogu, kde budú uložené pravidlá a smer replikácie medzi uzlami. Nakoniec sa do tabuliek načíta príklad dát.
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.sqlV príklade sú tabuľky item a item_selling_price nastavené automaticky na replikáciu z corp-000 do store-001, a tabuľky sale (sale_transaction a sale_return_line_item) sú automaticky nastavené na replikáciu zo store-001 do corp-000. Teraz vytvoríme schému v databáze PostgreSQL na hoste vm2 (store-001), aby sme ju pripravili na prijímanie dát od corp-000.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> ./dbimport --engine store-001 --format XML create_sample.xmlUrčite overíme, že v databáze MySQL na vm1 sú príklady tabuliek a tabuľky katalogu SymmetricDS. Všimnite si, že systémové tabuľky SymmetricDS (s prefixom sym_) sú momentálne k dispozícii len na uzle corp-000, pretože tam sme vykonali príkaz create-sym-tables a budeme riadiť replikáciu. Okrem toho v databáze na uzle store-001 budú len 4 tabuľky príkladu bez dát.
Všetko. Prostredie je pripravené na spustenie serverových procesov sym na oboch uzloch, ako je uvedené nižšie.
vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> sym 2>&1 &Záznamy logov sa posielajú do súboru pozadia (symmetric.log) v priečinku logov v adresári, kde je nainštalovaný SymmetricDS, ako aj do štandardného výstupu. Server sym teraz môže byť inicializovaný na uzle store-001.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> sym 2>&1 &Ak spustíte serverový proces sym na hostiteľovi vm2, vytvorí tabuľky adresára SymmetricDS aj v databáze PostgreSQL. Ak spustíte serverový proces sym na oboch uzloch, koordinujú sa navzájom, aby replikovali dáta z corp-000 na store-001. Ak po niekoľkých sekundách požiadame o všetky 4 tabuľky na oboch stranách, uvidíme, že replikácia bola úspešná. Alebo môžeme odoslať počiatočné načítanie na uzol store-001 z corp-000 nasledujúcim príkazom.
vm1$> ./symadmin --engine corp-000 reload-node 001V tomto kroku je do tabuľky item v databáze MySQL na uzle corp-000 (host: vm1) vložený nový záznam a môžeme skontrolovať jeho replikáciu do databázy PostgreSQL na uzle store-001. Vidíme operáciu Pull na presun dát 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)Aby sme vykonali operáciu Push na presun dát z store-001 do corp-000, vložíme záznam do tabuľky sale_transaction a overíme, že replikácia bola úspešná.
Vidíme úspešné nastavenie obojsmernej replikácie tabuľiek medzi databázami MySQL a PostgreSQL. Na nastavenie replikácie pre nové používateľské tabuľky vykonáme nasledujúce kroky. Vytvárame tabuľku t1 ako príklad a nastavujeme pravidlá jej replikácie nasledujúcim spôsobom. Takto nastavujeme 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)Potom konfigurácia prijme oznámenie o zmene schémy, t.j. pridaní novej tabuľky, pomocou príkazu symadmin s argumentom sync-triggers, ktorý znovu vytvorí spúšťače na zladenie definícií tabuliek. Vykonáva sa send-schema na odoslanie zmien schémy na uzol store-001 a replikácia tabuľky t1 je nastavená.
vm1$> .\/symadmin -e corp-000 --node=001 sync-triggers
vm1$> .\/symadmin send-schema -e corp-000 --node=001 t1Výhody SymmetricDS
Jednoduchá inštalácia a konfigurácia, vrátane pripraveného balíka súborov s parametrami na vytvorenie schémy s tromi alebo dvoma uzlami.
Kros-platformnosť databáz a nezávislosť od platformy, vrátane serverov, notebookov a mobilných zariadení.
Replikácia akejkoľvek databázy do akejkoľvek inej databázy lokálne, v WAN alebo v cloude.
Možnosť optimálnej práce s párom databáz alebo niekoľkými tisícmi pre pohodlnú replikáciu.
Platená verzia s grafickým rozhraním a vynikajúcou podporou.
Nevýhody SymmetricDS
Je potrebné ručne definovať v príkazovom riadku pravidlá a smer replikácie cez SQL operátory na načítanie tabuliek katalógov, čo môže byť nepríjemné.
Nastavovanie množstva tabuliek na replikáciu môže byť únavné, ak sa nepoužívajú skripty na vytvorenie SQL operátorov, ktoré definujú pravidlá a smer replikácie.
Do logov sa zapisuje príliš veľa informácií a niekedy je potrebné upratať súbor logu, aby nezaberalo príliš veľa miesta.
Zhrnutie k SymmetricDS
SymmetricDS umožňuje nastavovať obojsmernú replikáciu medzi dvoma, tromi a dokonca niekoľkými tisíckami uzlov, aby vykonával replikáciu a synchronizoval súbory. Je to unikátne nástroje, ktoré samo vykonáva mnoho úloh, ako napríklad automatické obnovenie dát po dlhom výpadku na uzle, zabezpečená a efektívna výmena dát medzi uzlami cez HTTPS, automatické riadenie konfliktov na základe súboru pravidiel atď. SymmetricDS vykonáva replikáciu medzi akýmikoľvek databázami, takže ho možno využiť pre rôzne scenáre, vrátane migrácie, prechodu na novú verziu, distribúcie, filtrovania a transformácie dát na rôznych platformách.
Príklad bol vytvorený na základe oficiálneho k SymmetricDS. V podrobne sa opisujú rôzne pojmy týkajúce sa nastavenia replikácie pomocou SymmetricDS.
Zdroj: habr.com
