Ik sil cross-replikaasje tusken PostgreSQL en MySQL sketse, lykas metoaden foar it ynstellen fan cross-replikaasje tusken de twa databankservers. Typysk wurde cross-replikearre databases homogeen neamd, en it is in handige metoade om fan de iene RDBMS-tsjinner nei de oare te ferpleatsen.
PostgreSQL- en MySQL-databases wurde oer it algemien as relasjoneel beskôge, mar mei ekstra útwreidingen biede se NoSQL-mooglikheden. Hjir sille wy replikaasje tusken PostgreSQL en MySQL beprate út in relaasje DBMS-perspektyf.
Wy sille de heule ynderlike wurking net beskriuwe, allinich de basisprinsipes, sadat jo in idee krije fan it konfigurearjen fan replikaasje tusken databaseservers, foardielen, beheiningen en gebrûksgefallen.
Typysk wurdt replikaasje tusken twa identike databanktsjinners dien yn binêre modus of mei help fan queries tusken in master (aka útjouwer, master, as aktyf) en in slaaf (abonnee, standby, of passyf). It doel fan replikaasje is om in real-time kopy fan 'e masterdatabase oan' e slavekant te leverjen. Yn dit gefal wurde gegevens oerdroegen fan master nei slaaf, dat is fan aktyf nei passyf, om't replikaasje allinich yn ien rjochting wurdt útfierd. Mar jo kinne replikaasje ynstelle tusken twa databases yn beide rjochtingen, sadat gegevens oerdroegen wurde fan slaaf nei master yn in aktyf-aktive konfiguraasje. Dit alles, ynklusyf cascadearjende replikaasje, is mooglik tusken twa of mear identike databankservers. Aktyf-aktive of aktyf-passive konfiguraasje is ôfhinklik fan need, beskikberens fan sokke mooglikheden yn 'e earste konfiguraasje of gebrûk fan eksterne konfiguraasjeoplossingen en besteande ôfwagings.
De beskreaune konfiguraasje is mooglik tusken ferskate databaseservers. De tsjinner kin konfigurearre wurde om replikearre gegevens fan in oare databanktsjinner te akseptearjen en noch realtime snapshots fan 'e replikearre gegevens te behâlden. MySQL en PostgreSQL biede de measte fan dizze konfiguraasjes yn-hûs of fia útwreidingen fan tredden, ynklusyf binêre logmetoaden, skiifbeskoatteljen, en útspraak- en rige-basearre metoaden.
Cross-replikaasje tusken MySQL en PostgreSQL is nedich foar in ienmalige migraasje fan de iene databanktsjinner nei de oare. Dizze databases brûke ferskate protokollen, dus it is net mooglik om se direkt te keppeljen. Foar it fêstigjen fan gegevensútwikseling kinne jo in ekstern iepen boarne-ark brûke, bygelyks pg_chameleon.
Wat is pg_chameleon
pg_chameleon is in replikaasjesysteem fan MySQL nei PostgreSQL yn Python 3. It brûkt de iepen boarne mysql-replikaasjebibleteek, ek yn Python. Rigeôfbyldings wurde ekstrahearre út MySQL-tabellen en opslein as JSONB-objekten yn 'e PostgreSQL-database, en dan ûntsifere troch de pl/pgsql-funksje en reprodusearre yn' e PostgreSQL-database.
Skaaimerken fan pg_chameleon
Meardere MySQL-skema's fan itselde kluster kinne wurde replikearre nei in inkele doel PostgreSQL-database yn in ien-nei-folle konfiguraasje
De nammen fan it boarne- en doelskema kinne net itselde wêze.
Replikaasjegegevens kinne ophelle wurde fan in kaskadede MySQL-replika.
Tabellen dy't net replicate of produsearje flaters wurde útsletten.
Elke replikaasjefunksje wurdt regele troch daemons.
Kontrolearje fia YAML-basearre parameters en konfiguraasjebestannen.
Foarbyld:
Gasthear
vm1
vm2
OS ferzje
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64
DB tsjinner ferzje
MySQL 5.7.26
PostgreSQL 10.5
DB haven
3306
5433
IP-adres
192.168.56.102
192.168.56.106
Om te begjinnen, tariede alle nedige komponinten om pg_chameleon te ynstallearjen. Dit foarbyld ynstallearret Python 3.6.8, dy't de firtuele omjouwing makket en aktivearret.
$> 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 altinstallNei suksesfolle ynstallaasje fan Python3.6, moatte jo de oerbleaune easken foltôgje, lykas it meitsjen en aktivearjen fan in firtuele omjouwing. Derneist wurdt de pip-module bywurke nei de lêste ferzje en brûkt om pg_chameleon te ynstallearjen. De kommando's hjirûnder ynstallearje mei opsetsin pg_chameleon 2.0.9, hoewol de lêste ferzje 2.0.10 is. Dit is nedich om nije bugs yn 'e bywurke ferzje te foarkommen.
$> python3.6 -m venv venv
$> source venv/bin/activate
(venv) $> pip install pip --upgrade
(venv) $> pip install pg_chameleon==2.0.9Wy neame dan pg_chameleon (kameleon is in kommando) mei it argumint set_configuration_files om pg_chameleon yn te skeakeljen en standertmappen en konfiguraasjebestannen te meitsjen.
(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.ymlNo meitsje wy in kopy fan config-example.yml as default.yml sadat it it standert konfiguraasjetriem wurdt. In foarbyld konfiguraasjetriem foar dit foarbyld wurdt jûn hjirûnder.
$> 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:It konfiguraasjetriem yn dit foarbyld is in foarbyld pg_chameleon-bestân mei lytse oanpassingen om te passen by de boarne- en doelomjouwings, en hjirûnder is in oersjoch fan 'e ferskate seksjes fan it konfiguraasjetriem.
Yn it default.yml konfiguraasjetriem is der in seksje fan globale ynstellings, dêr't jo kinne beheare ynstellings lykas de lokaasje fan it slot triem, de lokaasje fan logs, de opslach perioade foar logs, ensfh Folgjende komt it type oerskriuwe seksje, dêr't in set regels foar it oerskriuwen fan typen by replikaasje. It foarbyld is standert foar in type oerskriuwende regel dy't tinyint(1) konvertearret nei in Booleaanske wearde. Yn 'e folgjende paragraaf spesifisearje wy de ferbiningsdetails oan' e doeldatabase. Yn ús gefal is dit in PostgreSQL-database, oanwiisd pg_conn. Yn 'e lêste paragraaf jouwe wy de boarnegegevens oan, dat is de ferbiningsparameters fan' e boarnedatabase, it mappingskema tusken de boarne- en doeldatabases, tabellen dy't moatte wurde oerslein, wachttiid, ûnthâld, pakketgrutte. Tink derom dat "boarnen" meartal is, wat betsjuttet dat wy meardere boarnedatabases kinne tafoegje oan in inkele doeldatabase om in konfiguraasje fan in protte-op-ien yn te stellen.
De foarbylddatabase world_x befettet 4 tabellen mei rigen dy't de MySQL-mienskip as foarbylden biedt. It kin ynladen wurde . De sample databank komt as tar en komprimearre argyf mei ynstruksjes foar it meitsjen en ymportearjen fan rigen.
Yn MySQL- en PostgreSQL-databases wurdt in spesjale brûker makke mei deselde namme usr_replica. Yn MySQL wurdt it ekstra lêsrjochten jûn oan alle replike tabellen.
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;Oan 'e PostgreSQL-kant wurdt in db_replica-database makke dy't wizigingen fan' e MySQL-database akseptearje sil. De brûker usr_replica yn PostgreSQL wurdt automatysk konfigureare as de eigner fan twa skema's, pgworld_x en sch_chameleon, dy't respektivelik de eigentlike replikearre tabellen en de replikaasjetafeltabellen befetsje. It argumint create_replica_schema is ferantwurdlik foar automatyske konfiguraasje, lykas jo hjirûnder sille sjen.
postgres=# CREATE USER usr_replica WITH PASSWORD 'pass123';
CREATE ROLE
postgres=# CREATE DATABASE db_replica WITH OWNER usr_replica;
CREATE DATABASEDe MySQL-database is konfigureare mei wat parameterwizigingen om it foar replikaasje te meitsjen lykas hjirûnder werjûn. Jo moatte de databanktsjinner opnij starte foar de wizigingen om effekt te nimmen.
$> vi /etc/my.cnf
binlog_format= ROW
binlog_row_image=FULL
log-bin = mysql-bin
server-id = 1No is it wichtich om de ferbining mei beide databankservers te kontrolearjen sadat d'r gjin problemen binne by it útfieren fan de kommando's pg_chameleon.
Op it PostgreSQL-knooppunt:
$> mysql -u usr_replica -Ap'admin123' -h 192.168.56.102 -D world_xOp it MySQL-knooppunt:
$> psql -p 5433 -U usr_replica -h 192.168.56.106 db_replicaDe folgjende trije kommando's pg_chameleon (kameleon) meitsje de omjouwing tariede, de boarne tafoegje en de replika inisjalisearje. It argumint create_replica_schema nei pg_chameleon makket in standertskema (sch_chameleon) en in replikaasjeskema (pgworld_x) yn 'e PostgreSQL-database, lykas wy al besprutsen. It argumint add_source foeget in boarne databank ta oan de konfiguraasje troch it lêzen fan it konfiguraasjetriem (default.yml), en yn ús gefal is it mysql, en init_replica inisjalisearret de konfiguraasje basearre op de parameters yn it konfiguraasjetriem.
$> chameleon create_replica_schema --debug
$> chameleon add_source --config default --source mysql --debug
$> chameleon init_replica --config default --source mysql --debugDe útfier fan dizze trije kommando's jout dúdlik oan dat se suksesfol binne útfierd. Alle crashes of syntaksisflaters wurde rapportearre yn ienfâldige, dúdlike berjochten mei hints oer hoe't jo it probleem kinne reparearje.
Uteinlik begjinne wy replikaasje mei start_replica en ûntfange in súksesberjocht.
$> chameleon start_replica --config default --source mysql
output: Starting the replica process for source mysqlReplikaasjestatus kin wurde frege mei it argumint show_status, en flaters kinne wurde besjoen mei it argumint show_errors.
Lykas wy al sein hawwe, wurdt elke replikaasjefunksje regele troch daemons. Om se te besjen, freegje wy de prosestabel mei it Linux ps kommando, lykas hjirûnder werjûn.
Replikaasje wurdt net beskôge as konfigureare oant wy it yn realtime testen, lykas hjirûnder werjûn. Wy meitsje in tabel, foegje in pear records yn 'e MySQL-database, en neame it sync_tables-argumint yn pg_chameleon om de daemons te aktualisearjen en de tabel mei de records te replikearjen nei de PostgreSQL-database.
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.Om de testresultaten te befêstigjen, freegje wy de tabel út 'e PostgreSQL-database en útfiere de rigen.
$> psql -p 5433 -U usr_replica -d db_replica -c "select * from pgworld_x.t1";
n1 | n2
----+-------
1 | one
2 | twoAs wy in migraasje dogge, sille de folgjende pg_chameleon-kommando's it ein wêze. De kommando's moatte wurde útfierd nei't wy wis binne dat de rigen fan alle doeltabellen binne replikearre, en it resultaat sil in kreas migrearre PostgreSQL-database wêze sûnder ferwizings nei de boarne-database of replikaasjeskema (sch_chameleon).
$> chameleon stop_replica --config default --source mysql
$> chameleon detach_replica --config default --source mysql --debugAs jo wolle, kinne jo de folgjende kommando's brûke om it orizjinele konfiguraasje- en replikaasjeskema te wiskjen.
$> chameleon drop_source --config default --source mysql --debug
$> chameleon drop_replica_schema --config default --source mysql --debugFoardielen fan pg_chameleon
Maklike opset en konfiguraasje.
Problemen oplosse en identifisearje anomalies maklik mei dúdlike flaterberjochten.
Oanfoljende spesjale tabellen kinne nei inisjalisaasje tafoege wurde oan replikaasje sûnder de rest fan 'e konfiguraasje te feroarjen.
It is mooglik om meardere boarnedatabases te konfigurearjen foar in inkele doeldatabase, en dit is heul nuttich as jo gegevens fan ien of mear MySQL-databases kombinearje yn ien PostgreSQL-database.
Jo moatte de selektearre tabellen net replikearje.
Neidielen fan pg_chameleon
Allinich stipe mei MySQL 5.5 en heger as boarne en PostgreSQL 9.5 en boppe as doeldatabase.
Elke tabel moat in primêre of unike kaai hawwe, oars wurde de tabellen inisjalisearre tidens it init_replica-proses, mar wurde net replikearre.
One-way replikaasje - allinich fan MySQL nei PostgreSQL. Dêrom is it allinich geskikt foar it "aktyf-passive" circuit.
De boarne kin allinich in MySQL-database wêze, en stipe foar in PostgreSQL-database as boarne is allinich eksperiminteel en mei beheiningen (lear mear )
Resultaten foar pg_chameleon
De replikaasjemetoade yn pg_chameleon is geweldich foar it migrearjen fan in database fan MySQL nei PostgreSQL. It wichtige neidiel is dat replikaasje mar ien-wei is, sadat databaseprofessionals it net wierskynlik wolle brûke foar wat oars as migraasje. Mar it probleem fan ien-wei replikaasje kin oplost wurde mei in oar iepen boarne-ark - SymmetricDS.
Lês mear yn 'e offisjele dokumintaasje . Kommandorigelhelp kin fûn wurde .
Oersjoch fan SymmetricDS
SymmetricDS is in iepen boarne-ark dat elke databank replikearret nei elke oare mienskiplike databank: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird en oare eksimplaren fan wolkdatabases, lykas Redshift, en Azure, ensfh Beskikbere funksjes: databank en triem syngronisaasje, multi-master databank replikaasje, filtere syngronisaasje, transformaasje en oaren. Dit is in Java-ark en fereasket in standert release fan de JRE of JDK (ferzje 8.0 of heger). Hjir kinne gegevenswizigingen oan triggers yn 'e boarnedatabase wurde opnommen en stjoerd nei de passende doeldatabase yn' e foarm fan batches.
SymmetricDS funksjes
It ark is platfoarmûnôfhinklik, wat betsjut dat twa of mear ferskillende databases gegevens kinne útwikselje.
Relasjonele databases wurde syngronisearre mei gegevensferoaringsrecords, wylst bestânsysteem-basearre databases bestânsyngronisaasje brûke.
Twa-wei replikaasje mei Push en Pull metoaden basearre op in set fan regels.
Gegevensferfier is mooglik oer feilige en netwurken mei lege bânbreedte.
Automatysk herstel as knooppunten de wurking ferfetsje nei in mislearring en automatyske konfliktoplossing.
Cloud-kompatible en krêftige útwreiding API's.
Foarbyld:
SymmetricDS kin op ien fan twa manieren konfigurearre wurde:
In master (âlder) node dy't sintraal koördinearret gegevens replikaasje tusken twa slave (bern) nodes, en kommunikaasje tusken bern nodes komt allinnich fia de âlder.
In aktive knooppunt (Node 1) kin kommunisearje foar replikaasje mei in oare aktive knooppunt (Node 2) sûnder in tuskenpersoan.
Yn beide opsjes komt gegevensútwikseling foar mei Push en Pull. Yn dit foarbyld sille wy in aktyf-aktive konfiguraasje beskôgje. It soe te lang duorje om de hiele arsjitektuer te beskriuwen, dus doch jo ûndersyk. om mear te learen oer it SymmetricDS-apparaat.
SymmetricDS ynstallearje is heul ienfâldich: download de iepen boarne ferzje fan it zip-bestân en nim it út wêr't jo wolle. De tabel hjirûnder jout ynformaasje oer de ynstallaasje lokaasje en ferzje fan SymmetricDS yn dit foarbyld, likegoed as de databank ferzjes, Linux ferzjes, IP adressen, en havens foar beide knopen.
Gasthear
vm1
vm2
OS ferzje
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64
DB tsjinner ferzje
MySQL 5.7.26
PostgreSQL 10.5
DB haven
3306
5832
IP-adres
192.168.1.107
192.168.1.112
SymmetricDS ferzje
SymmetricDS 3.9
SymmetricDS 3.9
SymmetricDS ynstallaasje paad
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20
SymmetricDS node namme
Corp-000
winkel-001
Hjiryn ynstallearje wy SymmetricDS yn /usr/local/symmetric-server-3.9.20, en ferskate submappen en bestannen wurde dêr opslein. Wy binne ynteressearre yn de samples en motoren submappen. De samplemap befettet foarbyldkonfiguraasjebestannen mei node-eigenskippen, lykas foarbylden fan SQL-skripts om jo fluch te begjinnen.
Yn 'e samplemap sjogge wy trije konfiguraasjebestannen mei node-eigenskippen - de namme toant de aard fan' e node yn in bepaald skema.
corp-000.properties
store-001.properties
store-002.propertiesSymmetricDS hat alle nedige konfiguraasje triemmen foar in basis 3-node design (opsje 1), en deselde triemmen kinne brûkt wurde foar in 2-node design (opsje 2). Kopiearje it fereaske konfiguraasjetriem fan 'e samplemap nei motoren op' e vm1-host. It komt sa út:
$> 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=000Dizze knooppunt yn 'e SymmetricDS-konfiguraasje hjit corp-000, en de databankferbining wurdt behannele troch de mysql jdbc-bestjoerder, dy't de ferbiningsstring hjirboppe brûkt en de oanmeldgegevens. Wy ferbine mei de replica_db-database en tabellen wurde makke by it oanmeitsjen fan skema. sync.url lit sjen wêr't jo kontakt opnimme mei it knooppunt foar syngronisaasje.
Node 2 op host vm2 is konfigurearre as store-001 en de rest wurdt oantsjutte yn de node.properties triem hjirûnder. Node store-001 rint de PostgreSQL-database en pgdb_replica is de replikaasjedatabase. registration.url lit host vm2 kontakt opnimme mei host vm1 en dêr konfiguraasjedetails fan ûntfange.
$> 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=001It foltôge SymmetricDS-foarbyld befettet parameters foar it ynstellen fan twa-wei-replikaasje tusken twa databanktsjinners (twa knopen). De stappen hjirûnder wurde útfierd op host vm1 (corp-000), dy't in foarbyldskema sil meitsje mei 4 tabellen. Dan it útfieren fan create-sym-tables mei it kommando symadmin makket maptabellen wêr't de regels en rjochting fan replikaasje tusken knopen wurde opslein. Uteinlik wurde samplegegevens yn 'e tabellen laden.
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.sqlYn it foarbyld wurde de tabel foar item en item_selling_price automatysk konfigureare om te replikearjen fan corp-000 nei store-001, en de ferkeaptabellen (sale_transaction en sale_return_line_item) wurde automatysk konfigureare om te replikearjen fan winkel-001 nei corp-000. No meitsje wy in skema yn 'e PostgreSQL-database op host vm2 (store-001) om it te meitsjen om gegevens te ûntfangen fan corp-000.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> ./dbimport --engine store-001 --format XML create_sample.xmlSoargje derfoar dat de MySQL-database op vm1 foarbyldtabellen en SymmetricDS-katalogustabellen hat. Tink derom dat de SymmetricDS-systeemtabellen (foarheaksel sym_) op it stuit allinich beskikber binne op node corp-000, om't dat is wêr't wy it kommando create-sym-tables rûnen en replikaasje sille beheare. En yn 'e databank op node store-001 sille d'r mar 4 foarbyldtabellen sûnder gegevens wêze.
Alle. De omjouwing is klear om sym-serverprosessen op beide knooppunten út te fieren lykas hjirûnder werjûn.
vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> sym 2>&1 &Log yngongen wurde stjoerd nei in eftergrûn log triem (symmetric.log) yn de logs map yn de map dêr't SymmetricDS is ynstallearre, likegoed as nei standert útfier. De sym-tsjinner kin no inisjearre wurde op node store-001.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> sym 2>&1 &As jo it sym-tsjinnerproses op 'e vm2-host útfiere, sil it ek SymmetricDS-katalogustabellen meitsje yn' e PostgreSQL-database. As jo it sym-tsjinnerproses op beide knooppunten útfiere, koördinearje se mei-inoar om gegevens fan corp-000 nei store-001 te replikearjen. As wy nei in pear sekonden alle 4 tabellen oan beide kanten freegje, sille wy sjen dat replikaasje suksesfol wie. Of jo kinne de bootstrap nei node store-001 stjoere fan corp-000 mei it folgjende kommando.
vm1$> ./symadmin --engine corp-000 reload-node 001Op dit punt wurdt in nij rekord ynfoege yn 'e itemtabel yn' e MySQL-database op node corp-000 (host: vm1), en jo kinne de replikaasje kontrolearje nei de PostgreSQL-database op node store-001 (host: vm2). Wy sjogge in Pull-operaasje om gegevens te ferpleatsen fan corp-000 nei winkel-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)Om in Push-operaasje út te fieren om gegevens fan store-001 nei corp-000 te ferpleatsen, foegje wy in rekord yn 'e sale_transaction-tabel yn en ferifiearje dat replikaasje suksesfol is.
Wy sjogge de suksesfolle opset fan twa-wei-replikaasje fan 'e foarbyldtabellen tusken MySQL- en PostgreSQL-databases. Om replikaasje yn te stellen foar nije brûkerstabellen, folgje dizze stappen: Wy meitsje bygelyks tabel t1 en konfigurearje har replikaasjeregels as folget. Op dizze manier konfigurearje wy allinich replikaasje fan corp-000 nei 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)De konfiguraasje wurdt dan op 'e hichte brocht fan' e skemawiziging, dat is, it tafoegjen fan in nije tabel, mei it kommando symadmin mei it argumint sync-triggers, dy't de triggers opnij oanmeitsje om de tabeldefinysjes yn kaart te bringen. send-skema wurdt útfierd om skemawizigingen te stjoeren nei node store-001, en replikaasje fan tabel t1 is konfigureare.
vm1$> ./symadmin -e corp-000 --node=001 sync-triggers
vm1$> ./symadmin send-schema -e corp-000 --node=001 t1Foardielen fan SymmetricDS
Maklike ynstallaasje en konfiguraasje, ynklusyf in ready-made set fan triemmen mei parameters foar it meitsjen fan in trije-node of twa-node circuit.
Cross-platform databases en platfoarmûnôfhinklikens, ynklusyf servers, laptops en mobile apparaten.
Replikearje elke databank nei elke oare databank lokaal, op it WAN of yn 'e wolk.
Mooglikheid fan optimaal wurk mei in pear databases of ferskate tûzen foar handige replikaasje.
Betelle ferzje mei GUI en poerbêste stipe.
Neidielen fan SymmetricDS
Jo moatte de regels en rjochting fan replikaasje manuell definiearje op 'e kommandorigel troch SQL-útspraken om katalogustabellen te laden, wat ûngemaklik kin wêze.
It opsetten fan in protte tabellen foar replikaasje kin ferfeelsum wêze, útsein as jo skripts brûke om SQL-útspraken te meitsjen dy't de regels en rjochting fan replikaasje definiearje.
Der wurdt tefolle ynformaasje opnommen yn 'e logs, en soms moatte jo it lochbestân opromje, sadat it net te folle romte nimt.
Resultaten foar SymmetricDS
SymmetricDS lit jo twa-wei-replikaasje ynstelle tusken twa, trije, of sels ferskate tûzen knooppunten om bestannen te replikearjen en te syngronisearjen. Dit is in unyk ark dat selsstannich in protte taken útfiert, lykas automatyske gegevensherstel nei in lange perioade fan downtime op in knooppunt, feilige en effisjinte gegevensútwikseling tusken knooppunten fia HTTPS, automatysk konfliktbehear basearre op in set regels, ensfh.. SymmetricDS fiert út replikaasje tusken alle databases, dêrom kin it brûkt wurde foar in breed ferskaat oan senario's, ynklusyf migraasje, migraasje, distribúsje, filterjen en transformaasje fan gegevens oer platfoarms.
It foarbyld is basearre op de amtner troch SymmetricDS. YN Beskriuwt yn detail de ferskate begripen belutsen by it opsetten fan replikaasje mei SymmetricDS.
Boarne: www.habr.com