🥇Cross-Replikatioun tëscht PostgreSQL a MySQL

Ech skizzéieren Kräizreplikatioun tëscht PostgreSQL a MySQL, souwéi Methoden fir Kräizreplikatioun tëscht den zwee Datebankserveren opzestellen. Typesch ginn cross-replizéiert Datenbanken homogen genannt, an et ass eng praktesch Method fir vun engem RDBMS Server op en aneren ze plënneren.

PostgreSQL a MySQL Datenbanken ginn allgemeng als relational ugesinn, awer mat zousätzlech Extensiounen bidden se NoSQL Fäegkeeten. Hei diskutéiere mir Replikatioun tëscht PostgreSQL a MySQL aus enger relationeller DBMS Perspektiv.

Mir beschreiwen net déi ganz bannenzeg Aarbecht, just d'Basisprinzipien, sou datt Dir eng Iddi kritt fir d'Replikatioun tëscht Datebankserveren, Virdeeler, Aschränkungen a Benotzungsfäll ze konfiguréieren.

Typesch gëtt Replikatioun tëscht zwee identesche Datebankserver entweder am binäre Modus gemaach oder mat Ufroen tëscht engem Master (alias Verlag, Master oder aktiv) an engem Sklave (Abonnent, Standby oder passiv). Den Zweck vun der Replikatioun ass eng Echtzäit Kopie vun der Master Datebank op der Sklave Säit ze bidden. An dësem Fall ginn d'Donnéeë vu Meeschter op Sklave transferéiert, dat heescht vun aktiv op passiv, well d'Replikatioun nëmmen an enger Richtung gemaach gëtt. Awer Dir kënnt Replikatioun tëscht zwou Datenbanken a béid Richtungen astellen, sou datt Daten vum Sklave op de Master an enger aktiv-aktiver Konfiguratioun transferéiert ginn. All dëst, dorënner Kaskadespär Replikatioun, ass méiglech tëscht zwee oder méi identesch Datebank Serveren.Aktiv-aktiv oder aktiv-passiv Konfiguratioun hänkt op Besoin, Disponibilitéit vun esou Fäegkeeten an der initialer Konfiguratioun oder Notzung vun externen Konfiguratioun Léisungen an bestehend Ofsaz.

Déi beschriwwe Konfiguratioun ass méiglech tëscht verschiddene Datebankserveren. De Server kann konfiguréiert ginn fir replizéiert Daten vun engem aneren Datebankserver z'akzeptéieren an ëmmer nach Echtzäit Snapshots vun de replizéierten Donnéeën z'erhalen. MySQL a PostgreSQL bidden déi meescht vun dëse Konfiguratiounen intern oder duerch Drëtt-Partei-Extensiounen, dorënner binäre Logmethoden, Disk Locking, a Statement- a Rei-baséiert Methoden.

Kräizreplikatioun tëscht MySQL a PostgreSQL ass néideg fir eng eemoleg Migratioun vun engem Datebankserver an en aneren. Dës Datenbanken benotzen verschidde Protokoller, sou datt et net méiglech ass se direkt ze verbannen. Fir Datenaustausch z'etabléieren, kënnt Dir en externen Open Source Tool benotzen, zum Beispill pg_chameleon.

Wat ass pg_chameleon

pg_chameleon ass e Replikatiounssystem vu MySQL op PostgreSQL am Python 3. Et benotzt d'Open Source mysql-Replikatiounsbibliothéik, och am Python. Zeile Biller ginn aus MySQL Dëscher extrahéiert an als JSONB Objekter an der PostgreSQL Datebank gespäichert, an dann vun der pl/pgsql Funktioun entschlësselt an an der PostgreSQL Datebank reproduzéiert.

Fonctiounen vun pg_chameleon

Multiple MySQL Schemaen aus dem selwechte Cluster kënnen op eng eenzeg Zil PostgreSQL Datebank replizéiert ginn an enger een-zu-vill Konfiguratioun
D'Quell- an Zilschemaname kënnen net d'selwecht sinn.
Replikatiounsdaten kënnen aus enger kaskadéierter MySQL Replica zréckgewonne ginn.
Dëscher déi net replizéiere kënnen oder Feeler produzéieren sinn ausgeschloss.
All Replikatiounsfunktioun gëtt vun Daemone kontrolléiert.
Kontroll iwwer YAML-baséiert Parameteren a Konfiguratiounsdateien.

Beispill:

Host
vm1
vm2

OS Versioun
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

DB Server Versioun
MySQL 5.7.26
10.5. PostgreSQL XNUMX

DB port
3306
5433

IP Adress
192.168.56.102
192.168.56.106

Fir unzefänken, preparéiert all déi néideg Komponenten fir pg_chameleon z'installéieren. Dëst Beispill installéiert Python 3.6.8, deen d'virtuell Ëmfeld erstellt an aktivéiert.

$> 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

Nodeems Dir Python3.6 erfollegräich installéiert hutt, musst Dir déi verbleiwen Ufuerderunge fäerdeg maachen, wéi zum Beispill e virtuellt Ëmfeld erstellen an aktivéieren. Zousätzlech gëtt de Pip Modul op déi lescht Versioun aktualiséiert a benotzt fir pg_chameleon z'installéieren. D'Befehle hei drënner installéiere bewosst pg_chameleon 2.0.9, obwuel déi lescht Versioun 2.0.10 ass. Dëst ass néideg fir nei Bugs an der aktualiséierter Versioun ze vermeiden.

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

Mir ruffen dann pg_chameleon (Chamäleon ass e Kommando) mam Argument set_configuration_files fir pg_chameleon z'aktivéieren an Standardverzeechnes a Konfiguratiounsdateien ze kreéieren.

(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

Elo kreéiere mir eng Kopie vu config-example.yml als default.yml sou datt et d'Standardkonfiguratiounsdatei gëtt. Eng Prouf Konfiguratiounsdatei fir dëst Beispill gëtt hei ënnendrënner.

$> 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:

D'Konfiguratiounsdatei an dësem Beispill ass eng Probe pg_chameleon Datei mat klengen Ännerungen fir d'Quell an d'Zilëmfeld ze passen, an hei drënner ass en Iwwerbléck iwwer déi verschidde Sektiounen vun der Konfiguratiounsdatei.

An der default.yml Konfiguratiounsdatei gëtt et eng Sektioun vu globalen Astellungen, wou Dir Astellunge wéi d'Plaz vun der Spärdatei verwalten, de Standort vun de Logbicher, d'Späicherzäit fir d'Logbicher, asw. eng Rei vu Reegele fir d'Typen während der Replikatioun ze iwwerschreiden. D'Beispill ass Standard op eng Typ iwwerschreidend Regel déi tinyint (1) an e boolesche Wäert konvertéiert. An der nächster Sektioun spezifizéiere mir d'Verbindungsdetailer op d'Zildatenbank. An eisem Fall ass dëst eng PostgreSQL Datebank, bezeechent pg_conn. An der leschter Sektioun weisen mir d'Quelldaten un, dat heescht d'Verbindungsparameter vun der Quelldatenbank, d'Mappingschema tëscht der Quell- an Zildatenbanken, Dëscher déi iwwersprangen musse ginn, Waardezäit, Erënnerung, Packagegréisst. Bedenkt datt "Quellen" Plural ass, dat heescht datt mir verschidde Quelldatenbanken an eng eenzeg Zildatenbank kënne addéieren fir eng vill-zu-een Konfiguratioun opzestellen.

D'Beispill Datebank world_x enthält 4 Dëscher mat Reihen déi d'MySQL Gemeinschaft als Beispiller bitt. Et kann erofgeluede ginn hei. D'Probe-Datebank kënnt als Tar a kompriméiert Archiv mat Instruktioune fir Zeilen ze kreéieren an z'importéieren.

An MySQL a PostgreSQL Datenbanken gëtt e spezielle Benotzer mam selwechten Numm usr_replica erstallt. Am MySQL gëtt et zousätzlech Liesrechter op all replizéiert Dëscher.

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;

Op der PostgreSQL Säit gëtt eng db_replica Datebank erstallt déi Ännerungen vun der MySQL Datebank akzeptéiert. De Benotzer usr_replica an PostgreSQL gëtt automatesch als Besëtzer vun zwee Schemaen konfiguréiert, pgworld_x a sch_chameleon, déi déi aktuell replizéiert Tabellen respektiv d'Replikatiounsverzeechnestabellen enthalen. D'Argument create_replica_schema ass verantwortlech fir automatesch Konfiguratioun, wéi Dir hei ënnen gesitt.

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

D'MySQL Datebank ass mat e puer Parameter Ännerungen konfiguréiert fir se op Replikatioun virzebereeden wéi hei ënnendrënner. Dir musst den Datebankserver nei starten fir datt d'Ännerungen a Kraaft trieden.

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

Elo ass et wichteg d'Verbindung mat béiden Datebankserver ze kontrolléieren sou datt et keng Probleemer gëtt wann Dir d'pg_chameleon Kommandoen ausféiert.

Am PostgreSQL Node:

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

Am MySQL Node:

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

Déi nächst dräi pg_chameleon (Chamäleon) Kommandoen preparéieren d'Ëmwelt, fügen d'Quell un an initialiséieren d'Replika. D'Argument create_replica_schema zu pg_chameleon erstellt e Standardschema (sch_chameleon) an e Replikatiounsschema (pgworld_x) an der PostgreSQL Datebank, wéi mir scho diskutéiert hunn. D'add_source Argument füügt eng Quelldatebank un d'Konfiguratioun un andeems d'Konfiguratiounsdatei (default.yml) gelies gëtt, an an eisem Fall ass et mysql, an init_replica initialiséiert d'Konfiguratioun baséiert op de Parameteren an der Konfiguratiounsdatei.

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

D'Ausgab vun dësen dräi Kommandoen weist kloer datt se erfollegräich ausgefouert goufen. All Crashen oder Syntaxfehler ginn an einfachen, klore Messagen gemellt mat Hiweiser wéi een de Problem fixéiert.

Endlech fänken mir d'Replikatioun mat start_replica un a kréien e Succès Message.

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

De Replikatiounsstatus kann mat dem show_status Argument gefrot ginn, a Feeler kënne gekuckt ginn mat dem show_errors Argument.

D 'Resultat.

Wéi mir scho gesot hunn, gëtt all Replikatiounsfunktioun vun Daemone kontrolléiert. Fir se ze gesinn, froe mir d'Prozesstabelle mam Linux ps Kommando, wéi hei ënnendrënner.

D 'Resultat.

Replikatioun gëtt net als konfiguréiert ugesinn bis mir et an Echtzäit testen, wéi hei ënnendrënner. Mir kreéieren en Dësch, setzen e puer records an d'MySQL Datebank, a ruffen d'sync_tables Argument am pg_chameleon fir d'Dämonen ze aktualiséieren an d'Tabell mat den Opzeechnungen an d'PostgreSQL Datebank ze replizéieren.

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.

Fir d'Testresultater ze bestätegen, froe mir d'Tabell aus der PostgreSQL-Datebank an erausginn d'Reihen.

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

Wa mir eng Migratioun maachen, sinn déi folgend pg_chameleon Kommandoen d'Enn dovun. D'Befehle mussen ausgefouert ginn nodeems mir sécher sinn datt d'Reihen vun all Ziltabellen replizéiert goufen, an d'Resultat wäert eng ordentlech migréiert PostgreSQL Datebank sinn ouni Referenzen op d'Quelldatenbank oder Replikatiounsschema (sch_chameleon).

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

Wann Dir wëllt, kënnt Dir déi folgend Kommandoen benotzen fir d'Original Konfiguratioun a Replikatiounsschema ze läschen.

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

Virdeeler vun pg_chameleon

Einfach Setup a Konfiguratioun.
Einfach Troubleshooting an Anomalien identifizéieren mat klore Feelermeldungen.
Zousätzlech speziell Dëscher kënnen op d'Replikatioun no der Initialiséierung bäigefüügt ginn ouni de Rescht vun der Konfiguratioun z'änneren.
Et ass méiglech verschidde Quelldatebanken fir eng eenzeg Zil-Datebank ze konfiguréieren, an dëst ass ganz nëtzlech wann Dir Daten aus enger oder méi MySQL-Datenbanken an eng eenzeg PostgreSQL-Datebank kombinéiert.
Dir musst déi gewielten Dëscher net replizéieren.

Nodeeler vun pg_chameleon

Nëmme ënnerstëtzt mat MySQL 5.5 a méi héich als Quell an PostgreSQL 9.5 a méi héich als Zildatabase.
All Dësch muss e primären oder eenzegaartege Schlëssel hunn, soss ginn d'Tabelle während dem init_replica Prozess initialiséiert awer net replizéiert.
One-Way Replikatioun - nëmme vu MySQL op PostgreSQL. Dofir ass et nëmme fir den "aktiv-passive" Circuit gëeegent.
D'Quell kann nëmmen eng MySQL Datebank sinn, an Ënnerstëtzung fir eng PostgreSQL Datebank als Quell ass nëmmen experimentell a mat Aschränkungen (léiert méi hei)

Resultater fir pg_chameleon

D'Replikatiounsmethod am pg_chameleon ass super fir eng Datebank vu MySQL op PostgreSQL ze migréieren. De bedeitende Nodeel ass datt d'Replikatioun nëmmen ee-Wee ass, sou datt d'Datebankfachleit et onwahrscheinlech fir eppes anescht wéi Migratioun benotze wëllen. Awer de Problem vun der One-Way Replikatioun kann mat engem aneren Open Source Tool geléist ginn - SymmetricDS.

Liest méi an der offizieller Dokumentatioun hei. Kommando Linn Hëllef kann fonnt ginn hei.

Iwwersiicht vun SymmetricDS

SymmetricDS ass en Open Source Tool dat all Datebank op all aner gemeinsam Datebank replizéiert: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird an aner Cloud Datebank Instanzen, zB Redshift, an Azure, etc.. Verfügbar Fonctiounen: Datebank an Datei Synchroniséierung, Multi-Master Datebank Replikatioun, Filter Synchroniséierung, Transformatioun an anerer. Dëst ass e Java-Tool a erfuerdert eng Standardverëffentlechung vum JRE oder JDK (Versioun 8.0 oder méi héich). Hei kënnen d'Datenännerungen un Ausléiser an der Quelldatenbank opgeholl ginn an an déi entspriechend Zil-Datebank a Form vu Chargen geschéckt ginn.

SymmetricDS Fonctiounen

D'Tool ass plattformonofhängeg, dat heescht datt zwou oder méi verschidden Datenbanken Daten austauschen kënnen.
Relational Datenbanken ginn synchroniséiert mat Datenännerungsrecords, während Dateisystem-baséiert Datenbanken Dateisynchroniséierung benotzen.
Zwee-Wee Replikatioun mat Push a Pull Methoden baséiert op enger Rei vu Reegelen.
Datenübertragung ass méiglech iwwer sécher an niddereg Bandbreed Netzwierker.
Automatesch Erhuelung wann Noden Operatioun no engem Feeler an automatesch Konfliktléisung erëmfannen.
Cloud kompatibel a mächteg Extensioun APIen.

Beispill:

SymmetricDS kann an enger vun zwou Optiounen konfiguréiert ginn:
E Meeschter (Elteren) Node deen daten Replikatioun tëscht zwee Sklave (Kand) Noden zentral koordinéiert, a Kommunikatioun tëscht Kannerknäppchen geschitt nëmmen duerch den Elterendeel.
En aktiven Node (Node 1) ka fir Replikatioun mat engem aneren aktive Node (Node 2) ouni Tëschestatioun kommunizéieren.

A béid Optiounen geschitt Datenaustausch mat Push a Pull. An dësem Beispill wäerte mir eng aktiv-aktiv Konfiguratioun betruechten. Et géif ze laang daueren fir déi ganz Architektur ze beschreiwen, also maacht Är Fuerschung. Leadershipfir méi iwwer de SymmetricDS Apparat ze léieren.

SymmetricDS installéieren ass ganz einfach: Luet d'Open Source Versioun vun der Zip Datei erof vun hei an huelt et eraus wou Dir wëllt. D'Tabell hei ënnen liwwert Informatiounen iwwer d'Installatiounsplaz an d'Versioun vum SymmetricDS an dësem Beispill, souwéi d'Datebankversioune, Linux Versiounen, IP Adressen a Ports fir béid Noden.

Host
vm1
vm2

OS Versioun
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

DB Server Versioun
MySQL 5.7.26
10.5. PostgreSQL XNUMX

DB port
3306
5832

IP Adress
192.168.1.107
192.168.1.112

SymmetricDS Versioun
SymmetricDS 3.9
SymmetricDS 3.9

SymmetricDS Installatioun Wee
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

SymmetricDS Node Numm
Corp-000
Buttek-001

Hei installéiere mir SymmetricDS an /usr/local/symmetric-server-3.9.20, a verschidde Ënnerverzeechnungen an Dateie ginn do gespäichert. Mir sinn interesséiert an de Proben a Motoren Ënnerverzeechnungen. D'Probe Verzeechnes enthält Beispill Konfiguratiounsdateien mat Node Eegeschaften, souwéi Beispill SQL Scripte fir Iech séier unzefänken.

Am Probenverzeichnis gesi mir dräi Konfiguratiounsdateien mat Node Properties - den Numm weist d'Natur vum Node an engem bestëmmte Schema.

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

SymmetricDS huet all néideg Configuratioun Fichieren fir eng Basis 3-Node Design (Optioun 1), an déi selwecht Fichieren kann fir eng 2-Node Design benotzt ginn (Optioun 2). Kopéiert déi erfuerderlech Konfiguratiounsdatei aus dem Probenverzeichnis op Motoren um vm1 Host. Et stellt sech esou eraus:

$> 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

Dëse Node an der SymmetricDS Konfiguratioun gëtt corp-000 genannt, an d'Datebankverbindung gëtt vum mysql jdbc Chauffer gehandhabt, deen d'Verbindungsstring uewen an d'Login-Umeldungsinformatioun benotzt. Mir verbannen mat der replica_db Datebank an Dëscher ginn während Schema Kreatioun erstallt. sync.url weist wou de Node fir Synchroniséierung ze kontaktéieren.

Node 2 op Host vm2 ass als store-001 konfiguréiert an de Rescht gëtt an der node.properties Datei hei ënnen spezifizéiert. Node store-001 leeft d'PostgreSQL Datebank an pgdb_replica ass d'Replikatiounsdatebank. registration.url erlaabt den Host vm2 de Host vm1 ze kontaktéieren an d'Konfiguratiounsdetailer dovunner ze kréien.

$> 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

De fäerdege SymmetricDS Beispill enthält Parameteren fir zwee-Wee Replikatioun tëscht zwee Datebankserver (zwee Noden) opzestellen. D'Schrëtt hei drënner ginn um Host vm1 (corp-000) ausgefouert, wat e Beispillschema mat 4 Dëscher erstellt. Dann laafen create-sym-Tables mam Symadmin Kommando erstellt Verzeechnestabellen wou d'Regelen an d'Richtung vun der Replikatioun tëscht Noden gespäichert ginn. Schlussendlech ginn Probedaten an d'Tabellen gelueden.

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

Am Beispill sinn d'Element an item_selling_price Dëscher automatesch konfiguréiert fir vu corp-000 op store-001 ze replizéieren, an d'Verkafstabellen (sale_transaction an sale_return_line_item) sinn automatesch konfiguréiert fir vun store-001 op corp-000 ze replizéieren. Elo kreéiere mir e Schema an der PostgreSQL Datebank op Host vm2 (store-001) fir et virzebereeden fir Daten vum corp-000 ze kréien.

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

Vergewëssert Iech datt d'MySQL Datebank op vm1 Beispilltabellen a SymmetricDS Katalogtabellen huet. Bedenkt datt d'SymmetricDS System Dëscher (virgeschriwwe mat sym_) am Moment nëmmen op Node corp-000 verfügbar sinn well dat ass wou mir de create-sym-tables Kommando lafen a Replikatioune verwalten. An an der Datebank op Node Store-001 ginn et nëmmen 4 Beispill Dëscher ouni Daten.

All. D'Ëmfeld ass prett fir Sym Server Prozesser op béide Wirbelen ze lafen wéi hei ënnendrënner.

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

Log Entréen ginn op eng Background Log Datei geschéckt (symmetric.log) am Logbuch Dossier am Verzeechnes wou SymmetricDS installéiert ass, souwéi Standard Output. De Sym Server kann elo am Node Store-001 initiéiert ginn.

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

Wann Dir de Sym-Serverprozess um vm2-Host leeft, erstellt et och SymmetricDS Katalogtabellen an der PostgreSQL Datebank. Wann Dir de Sym Server Prozess op béide Wirbelen leeft, koordinéieren se matenee fir Daten vu Corp-000 op Store-001 ze replizéieren. Wa mir no e puer Sekonnen all 4 Dëscher op béide Säiten ufroen, wäerte mir gesinn datt d'Replikatioun erfollegräich war. Oder Dir kënnt de Bootstrap an den Node Store-001 vum corp-000 mat dem folgenden Kommando schécken.

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

Zu dësem Zäitpunkt gëtt en neie Rekord an d'Elementtabell an der MySQL Datebank op Node corp-000 (Host: vm1) agebaut, an Dir kënnt seng Replikatioun op d'PostgreSQL Datebank op Node Store-001 (Host: vm2) iwwerpréiwen. Mir gesinn eng Pull Operatioun fir Daten vu Corp-000 op Store-001 ze réckelen.

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)

Fir eng Push-Operatioun auszeféieren fir Daten vum Store-001 op Corp-000 ze verschécken, setzen mir e Rekord an de Sale_Transaction Tabelle a verifizéieren datt d'Replikatioun erfollegräich ass.

D 'Resultat.

Mir gesinn den erfollegräiche Setup vun zwee-Wee Replikatioun vun de Beispilltabellen tëscht MySQL a PostgreSQL Datenbanken. Fir Replikatioun fir nei Benotzertabellen opzestellen, befollegt dës Schrëtt: Mir erstellen den Dësch t1 zum Beispill a konfiguréieren seng Replikatiounsregele wéi follegt. Op dës Manéier konfiguréiere mir nëmmen Replikatioun vu corp-000 op 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)

D'Konfiguratioun gëtt dann iwwer d'Schemaännerung informéiert, dat heescht d'Zousatz vun enger neier Tabell, mat dem Symadmin Kommando mat dem Sync-Triggers Argument, deen d'Ausléiser nei erstellt fir d'Tabelldefinitioune ze mapen. send-Schema gëtt ausgefouert fir Schema Ännerungen un Node Store-001 ze schécken, a Replikatioun vun der Tabell t1 ass konfiguréiert.

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

Virdeeler vun SymmetricDS

Einfach Installatioun a Konfiguratioun, dorënner e fäerdege Set vu Dateien mat Parameteren fir en Dräi-Node oder Zwee-Node Circuit ze kreéieren.
Cross-Plattform Datenbanken a Plattform Onofhängegkeet, dorënner Serveren, Laptops a mobilen Apparater.
Replizéiert all Datebank op all aner Datebank lokal, op der WAN oder an der Wollek.
Méiglechkeet vun enger optimaler Aarbecht mat e puer Datenbanken oder e puer dausend fir bequem Replikatioun.
Bezuelte Versioun mat GUI an excellent Ënnerstëtzung.

Nodeeler vun SymmetricDS

Dir musst manuell d'Regelen an d'Richtung vun der Replikatioun op der Kommandozeil duerch SQL Aussoen definéieren fir Katalogtabellen ze lueden, wat onbequem ka sinn.
Vill Tabelle fir Replikatioun opzestellen kann langweileg sinn, ausser Dir benotzt Skripte fir SQL Aussoen ze kreéieren déi d'Regelen an d'Richtung vun der Replikatioun definéieren.
Et gëtt ze vill Informatioun an de Logbicher opgeholl, an heiansdo musst Dir d'Logbuchdatei raumen fir datt se net ze vill Plaz ophëlt.

Resultater fir SymmetricDS

SymmetricDS erlaabt Iech zwee-Wee Replikatioun tëscht zwee, dräi oder souguer e puer dausend Noden opzestellen fir Dateien ze replizéieren an ze synchroniséieren. Dëst ass en eenzegaartegt Tool dat onofhängeg vill Aufgaben ausféiert, sou wéi automatesch Datenerhuelung no enger laanger Zäit vun Ausdauer op engem Node, sécheren an effizienten Datenaustausch tëscht Noden iwwer HTTPS, automatesch Konfliktmanagement baséiert op enger Rei vu Reegelen, etc. SymmetricDS fiert Replikatioun tëscht all Datenbanken, dofir kann et fir eng grouss Varietéit vun Szenarie benotzt ginn, dorënner Migratioun, Migratioun, Verdeelung, Filteren an Transformatioun vun Daten iwwer Plattformen.

D'Beispill baséiert op den offiziellen séier Guide vum SymmetricDS. IN Benotzerhandbuch Beschreift am Detail déi verschidde Konzepter, déi bei der Opstellung vun der Replikatioun mat SymmetricDS involvéiert sinn.

Source: will.com