Áttekintést adok a keresztirányú replikációról a PostgreSQL és MySQL között, valamint a beállítási módszerekről. Általában a keresztirányú replikációval érintett adatbázisokat homogénnek nevezik, és ez egy kényelmes módszer a relációs DBMS szerverek közötti váltásra.
A PostgreSQL és MySQL adatbázisokat relációsnak tekintjük, de további kiterjesztésekkel NoSQL lehetőségeket is kínálnak. Itt a PostgreSQL és MySQL közötti replikációt fogjuk megtárgyalni, a relációs DBMS-ek szempontjából.
Nem fogjuk részletezni az összes belső folyamatot, csak az alapelveket, hogy áttekintést nyújtsunk a replikációs beállításról az adatbázis szerverek között, a előnyökről, korlátozásokról és használati forgatókönyvekről.
Általában két azonos adatbázis szerver közötti replikáció bináris módban vagy a vezető (kiadó, fő vagy aktív) és követő (feliratkozó, várakozó vagy passzív) csomópontok közötti lekérdezéseken keresztül történik. A replikáció célja, hogy valós időben egy másolatot biztosítson a fő adatbázisról a követő oldalon. A adatok egyirányúan jutnak el a vezetőtől a követőhöz, azaz az aktívból a passzívba, mivel a replikáció csak egy irányban zajlik. Azonban lehetséges a replikáció beállítása két adatbázis között kétirányú konfigurációban is, így az adatok a követőtől a vezetőhöz kerülhetnek az „aktív-aktív” beállítással. Mindez, beleértve a kaszkád replikációt, két vagy több azonos adatbázis szerver között is lehetséges. Az „aktív-aktív” vagy „aktív-passzív” konfiguráció a szükségletektől, az elérhetőségi lehetőségektől az eredeti konfigurációban vagy külső megoldások használatától és a meglévő kompromisszumoktól függ.
A leírt konfiguráció különböző adatbázis szerverek között is lehetséges. A szerver beállítható úgy, hogy más adatbázis szerverről replikált adatokat fogadjon, miközben valós időben megőrzi a replikált adatok pillanatképét. A MySQL és a PostgreSQL a legtöbb ilyen konfigurációt saját forrásaikkal vagy külső kiterjesztések segítségével kínálják, beleértve a bináris naplózás, a lemezlezárás és az operátorok és sorok alapú módszereit.
A MySQL és PostgreSQL közötti kereszt-replikáció egy alkalommal történő migráláshoz szükséges az egyik adatbázis szerverről a másikra. Ezek az adatbázisok különböző protokollokat használnak, így közvetlen összekapcsolásuk nem lehetséges. Az adatok cseréjének beállításához használható egy külső nyílt forráskódú eszköz, például a pg_chameleon.
Mi az a pg_chameleon
A pg_chameleon egy MySQL-ból PostgreSQL-be történő replikációs rendszer, amely Python 3-ra épül. Az eszköz használja az mysql-replication nevű nyílt forráskódú könyvtárat, szintén Pythonban. Az adatsorok a MySQL táblákból kivonásra kerülnek, és JSONB objektumokként tárolódnak a PostgreSQL adatbázisban, majd a pl/pgsql függvény segítségével dekódolódnak és visszaállítódnak a PostgreSQL adatbázisban.
A pg_chameleon lehetőségei
Több MySQL séma egyetlen cél-PostgreSQL adatbázisba replikálható egy 'egy a sokhoz' konfigurációval.
A forrásegy és a célséma neve nem lehet azonos.
A replikációs adatokat egy MySQL kaszkád replika segítségével is ki lehet nyerni.
A replikálásra alkalmatlan vagy hibát okozó táblák kizárásra kerülnek.
Minden replikációs funkciót démonok irányítanak.
Ellenőrzés YAML alapú paraméterek és konfigurációs fájlok segítségével.
támadásra
Gazda
vm1
vm2
Operációs rendszer verziója
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64
DB szerver verziója
MySQL 5.7.26
PostgreSQL 10.5
DB port
3306
5433
IP-cím
192.168.56.102
192.168.56.106
Először készítse elő a pg_chameleon telepítéséhez szükséges összes komponenst. Ebben a példában a Python 3.6.8 van telepítve, ami egy virtuális környezetet hoz létre és aktiválja azt.
$> 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 altinstallA Python 3.6 sikeres telepítése után a következő követelményeket kell teljesíteni, például létrehozni és aktiválni egy virtuális környezetet. Ezen kívül a pip modul frissítve lesz a legújabb verzióra, és a pg_chameleon telepítésére használják. Az alábbi parancsok szándékosan a pg_chameleon 2.0.9-es verzióját telepítik, bár a legújabb verzió a 2.0.10. Erre azért van szükség, hogy elkerüljük az új verzióban esetlegesen felmerülő hibákat.
$> python3.6 -m venv venv
$> source venv/bin/activate
(venv) $> pip install pip --upgrade
(venv) $> pip install pg_chameleon==2.0.9Ezután meghívjuk a pg_chameleon-t (a chameleon a parancs) a set_configuration_files argumentummal, amely lehetővé teszi a pg_chameleon aktiválását és az alapértelmezett konfigurációs mappák és fájlok létrehozását.
(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/
copíng konfigurációs példát a /root/.pg_chameleon/configuration//config-example.ymlMost már létrehozzuk a config-example.yml másolatát default.yml néven, hogy ez legyen az alapértelmezett konfigurációs fájl. Az alapértelmezett konfigurációs fájl mintája az alábbiakban található.
$> cat default.yml
---
#globális beállítások
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 lehetővé teszi a felhasználó számára, hogy felülbírálja az alapértelmezett típuskonverziót egy másikra.
type_override:
"tinyint(1)":
override_to: boolean
override_tables:
- "*"
#postgres célkapcsolat
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 #áthagyja az insert műveleteket a delphis_mediterranea.foo táblán
delete:
- delphis_mediterranea #áthagyja a delete műveleteket a delphis_mediterranea sémában
update:A példa konfigurációs fájl egy pg_chameleon fájl mintája, minimális eltérésekkel az eredeti és a célkörnyezet között. Az alábbiakban áttekintést adunk a konfigurációs fájl különböző szekcióiról.
A default.yml konfigurációs fájlban van egy globális beállításokat tartalmazó szekció (global settings), ahol kezelhetjük az olyan beállításokat, mint a zárolási fájl helye, a naplók helye, a naplók megtartásának időtartama stb. Ezt követi a típusfelülbírálat szekció (type override), ahol a replikáció során a típusok felülbírálásához tartozó szabályok találhatóak. Az alapértelmezett példában egy típusfelülbíráló szabályt használnak, amely a tinyint(1)-et boolean értékké alakítja. A következő szekcióban adunk meg részleteket a céladatbázis kapcsolatra. Ebben az esetben ez a PostgreSQL adatbázis, amely pg_conn néven van megjelölve. Az utolsó szekcióban találhatóak az forrást, vagyis az eredeti adatbázis kapcsolati paraméterei, az eredeti és a cél adatbázis közötti séma leképezés, a kihagyandó táblák, a várakozási idő, a memória és a csomag mérete. Ne felejtsük el, hogy a „sources” többes számú, tehát több forrásadatbázist is hozzáadhatunk egy célhoz az egyes „many to one” konfigurációhoz.
A world_x adatbázis példája 4 táblát tartalmaz, amelyeket a MySQL közösség példaként ajánl. Ez letölthető. . Az adatbázis példa tar formátumban és tömörített archívumként érkezik az adatok létrehozásának és importálásának útmutatójával.
MySQL és PostgreSQL adatbázisok esetében létrejön egy speciális usr_replica nevű felhasználó. A MySQL-ben további jogokat kap, hogy olvashassa az összes replikált táblát.
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;A PostgreSQL oldalon egy db_replica nevű adatbázis jön létre, amely a MySQL adatbázisból érkező változásokat fogadja. A usr_replica felhasználó PostgreSQL-ben automatikusan beállításra kerül a pgworld_x és sch_chameleon nevekkel rendelkező két séma tulajdonosaként, amelyek tartalmazzák a ténylegesen replikált táblákat és a replikációs könyvtárakat. Az automatikus konfigurációt a create_replica_schema argumentum irányítja, ahogyan azt lentebb láthatja.
postgres=# CREATE USER usr_replica WITH PASSWORD 'pass123';
CREATE ROLE
postgres=# CREATE DATABASE db_replica WITH OWNER usr_replica;
CREATE DATABASEA MySQL adatbázist néhány paraméter módosításával állítják be a replikációra, amint az alább látható. A módosítások életbe lépéséhez újra kell indítani az adatbázis szervert.
$> vi /etc/my.cnf
binlog_format= ROW
binlog_row_image=FULL
log-bin = mysql-bin
server-id = 1Jelenleg fontos ellenőrizni a kapcsolatot mindkét adatbázisszerverhez, hogy a pg_chameleon parancsainak végrehajtásakor ne merüljenek fel problémák.
A PostgreSQL node-on:
$> mysql -u usr_replica -Ap'admin123' -h 192.168.56.102 -D world_xA MySQL node-on:
$> psql -p 5433 -U usr_replica -h 192.168.56.106 db_replicaA következő három pg_chameleon (chameleon) parancs előkészíti a környezetet, hozzáadja a forrást és inicializálja a replikát. A pg_chameleon create_replica_schema argumentuma alapértelmezett séma (sch_chameleon) és replikációs séma (pgworld_x) létrehozására szolgál a PostgreSQL adatbázisban. Az add_source argumentum hozzáadja az alapadatbázist a konfigurációhoz a konfigurációs fájl (default.yml) beolvasásával, ebben az esetben=mysql, és az init_replica a konfiguráció inicializálására szolgál a konfigurációs fájlban lévő paraméterek alapján.
$> chameleon create_replica_schema --debug
$> chameleon add_source --config default --source mysql --debug
$> chameleon init_replica --config default --source mysql --debugE három parancs kimenete nyilvánvalóan mutatja a sikeres végrehajtásukat. Minden hiba vagy szintaktikai probléma egyszerű és érthető üzenetekben jelenik meg, amelyek utasításokat adnak a problémák megoldására.
Végül indítsuk el a replikációt a start_replica segítségével, és kapjunk egy sikeres végrehajtásról szóló üzenetet.
$> chameleon start_replica --config default --source mysql
output: A replikációs folyamat indítása a mysql forrásraA replikációs státusz lekérdezhető a show_status argumentummal, míg a hibák megtekintéséhez a show_errors argumentumot használhatjuk.
Ahogy már említettük, minden replikációs funkciót démonok irányítanak. Ezeket megtekinthetjük a Linux ps parancs segítségével, ahogy az alább látható.
A replikáció nem tekinthető beállítottnak, amíg nem teszteljük valós időben, ahogyan az alább látható. Létrehozunk egy táblát, beszúrunk néhány bejegyzést a MySQL adatbázisba, és meghívjuk a sync_tables argumentumot a pg_chameleonban, hogy frissítsük a démonokat és replikáljuk a táblát a PostgreSQL adatbázisba.
mysql> create table t1 (n1 int primary key, n2 varchar(10));
A lekérdezés rendben van, 0 sor érintett (0.01 sec)
mysql> insert into t1 values (1,'one');
A lekérdezés rendben van, 1 sor érintett (0.00 sec)
mysql> insert into t1 values (2,'two');
A lekérdezés rendben van, 1 sor érintett (0.00 sec)$> chameleon sync_tables --tables world_x.t1 --config default --source mysql
A táblák szinkronizálása a mysql forrással elindult.A teszt eredményeinek megerősítéséhez lekérdezzük a táblát a PostgreSQL adatbázisból és megjelenítjük a sorokat.
$> psql -p 5433 -U usr_replica -d db_replica -c "select * from pgworld_x.t1";
n1 | n2
----+-------
1 | one
2 | twoHa migrációt végzünk, a következő pg_chameleon parancsok zárják le azt. A parancsokat akkor kell végrehajtani, amikor megbizonyosodtunk arról, hogy az összes céltábla sora replikálva lett, és az eredmény egy gondosan átkonvertált PostgreSQL adatbázis lesz, amely nem hivatkozik az eredeti adatbázisra vagy a replikálási sémára (sch_chameleon).
$> chameleon stop_replica --config default --source mysql
$> chameleon detach_replica --config default --source mysql --debugOpcióként a következő parancsokkal eltávolíthatjuk az eredeti konfigurációt és replikációs sémát.
$> chameleon drop_source --config default --source mysql --debug
$> chameleon drop_replica_schema --config default --source mysql --debugA pg_chameleon előnyei
Egyszerű beállítás és konfiguráció.
Kényelmes hibakeresés és anomáliák azonosítása érthető hibaüzenetekkel.
A replikációhoz további speciális táblák is hozzáadhatók az inicializálás után, anélkül, hogy megváltoztatnánk a többi konfigurációt.
Lehet több forrás adatbázist beállítani egy céladatbázishoz, ami nagyon kényelmes, ha adatokat egy vagy több MySQL adatbázisból szeretne egy PostgreSQL adatbázisba egyesíteni.
Nem szükséges a kiválasztott táblák replikálása.
A pg_chameleon hátrányai
Csak MySQL 5.5 vagy újabb verzióval használható forrásként, valamint PostgreSQL 9.5 vagy újabb verzióval céladatbázisként.
Minden táblának rendelkeznie kell elsődleges vagy egyedi kulccsal, különben a táblák inicializálódnak az init_replica folyamat során, de nem replikálódnak.
Egyszeri replikáció — csak MySQL-ból PostgreSQL-be. Ezért csak az "aktív-passzív" sémához alkalmas.
A forrás csak MySQL adatbázis lehet, a PostgreSQL adatbázis forrásként való támogatása csak kísérleti és korlátozásokkal rendelkezik (tudjon meg többet )
Összefoglaló a pg_chameleon-ról
A pg_chameleon replikációs módszere jól alkalmas MySQL adatbázis PostgreSQL-ra történő migrálására. A lényeges hátrány, hogy a replikáció csak egységes irányú, ezért az adatbázis szakemberek valószínűleg nem szeretnék használni e cél érdekében. Az egységes irányú replikáció problémáját azonban egy másik nyílt forráskódú eszközzel, a SymmetricDS-sel meg lehet oldani.
További információkért olvassa el a hivatalos dokumentációt . A parancssori útmutatót itt találhatja .
SymmetricDS áttekintése
A SymmetricDS egy nyílt forráskódú eszköz, amely bármely adatbázist bármilyen más népszerű adatbázisra replikál: Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird és más felhőalapú adatbázis példányok, mint például a Redshift és az Azure stb. Elérhető funkciók: adatbázisok és fájlok szinkronizálása, több vezető adatbázis replikációja, szűrt szinkronizálás, átalakítás és egyebek. Ez egy Java-alapú eszköz, amelyhez a standard JRE vagy JDK kiadás szükséges (8.0-ás verzió vagy újabb). Itt a forrás adatbázisban a változások rögzíthetők a triggereken keresztül, és a megfelelő céladatbázisba csomagként irányíthatók.
A SymmetricDS lehetőségei
Az eszköz platformfüggetlen, tehát két vagy több különböző adatbázis képes adatokat cserélni.
A relációs adatbázisok a változtatások rögzítésével vannak szinkronizálva, míg a fájlrendszer alapú adatbázisok a fájlok szinkronizálásával működnek.
Kétirányú replikáció a Push és Pull módszerek használatával a szabályok alapján.
Az adatátvitel védett hálózatokban és alacsony sávszélességű hálózatokban lehetséges.
Automatikus helyreállítás a csomópontok újraindulásakor, valamint automatikus konfliktusmegoldás.
Felhőkompatibilitás és hatékony API-bővítmények.
támadásra
A SymmetricDS kétféle módon állítható be:
Egy vezető (szülő) csomópont, amely központosítottan koordinálja az adatok replikációját két követő (gyermek) csomópont között, és az adatok cseréje a gyermek csomópontok között csak a szülőn keresztül történik.
Egy aktív csomópont (1. csomópont) képes replikációs adatokat cserélni egy másik aktív csomóponttal (2. csomópont) közvetítő nélkül.
Mindkét esetben az adatok cseréje Push és Pull módszerekkel történik. Ebben a példában az 'aktív-aktív' konfigurációt vizsgáljuk. A teljes architektúra leírása túl hosszú lenne, ezért nézd meg , hogy többet megtudj a SymmetricDS működéséről.
A SymmetricDS telepítése rendkívül egyszerű: töltsd le az open-source verzió zip fájlt, és bontsd ki oda, ahová szeretnéd. Az alábbi táblázat tartalmazza a SymmetricDS telepítési helyét és verzióját az adott példában, valamint az adatbázis verziókat, a Linux verziókat, az IP-címeket és a portokat mindkét csomópont számára.
Gazda
vm1
vm2
Operációs rendszer verziója
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64
DB szerver verziója
MySQL 5.7.26
PostgreSQL 10.5
DB port
3306
5832
IP-cím
192.168.1.107
192.168.1.112
SymmetricDS verzió
SymmetricDS 3.9
SymmetricDS 3.9
SymmetricDS telepítési útvonal
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20
SymmetricDS csomópont neve
corp-000
store-001
Itt a SymmetricDS-t a /usr/local/symmetric-server-3.9.20 könyvtárba telepítjük, ahol különböző almappák és fájlok tárolódnak. Minket az almappák samples és engines érdekelnek. A samples könyvtárban a csomóponti tulajdonságokkal rendelkező konfigurációs fájlok példái, valamint SQL szkriptek példái találhatóak, amelyek segítségével gyorsan elindulhatunk a bemutatóval.
A samples könyvtárban három konfigurációs fájl található, amelyek a csomóponti tulajdonságokat tartalmazzák – a név jelzi a csomópont jellegét egy adott sémában.
corp-000.properties
store-001.properties
store-002.propertiesA SymmetricDS minden szükséges konfigurációs fájlt tartalmaz a három csomópontból álló alap séma (1. lehetőség) számára, és ugyanazokat a fájlokat felhasználhatjuk a két csomópontos séma (2. lehetőség) számára is. A megfelelő konfigurációs fájlt lemásoljuk a samples könyvtárból az engines-be a vm1 gazdagépen. Így néz ki:
$> 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=000Ez a csomópont a SymmetricDS konfigurációban corps-000 néven szerepel, és az adatbázis-kapcsolatot a mysql jdbc meghajtó kezeli, amely a fenti csatlakozási karakterláncot és a bejelentkezési adatokat használja. Mi a replica_db adatbázishoz kapcsolódunk, és az schema létrehozásakor táblák jönnek létre. A sync.url megjeleníti a csomópont szinkronizáláshoz szükséges összeköttetés helyét.
A 2. csomópont az vm2 hoszton store-001-ként van beállítva, míg a többi az alábbi node.properties fájlban található. A store-001 a PostgreSQL adatbázist használja, míg a pgdb_replica az replikációhoz használt adatbázis. A registration.url lehetővé teszi, hogy az vm2 hoszt kommunikáljon az vm1 hoszttal és megkapja annak konfigurációs részleteit.
$> 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=001A kész SymmetricDS példa tartalmazza a kétszeres replikáció beállításához szükséges paramétereket két adatbázisz szerver (két csomópont) között. Az alábbi lépések az vm1 (corp-000) hoszton hajtandók végre, amely létrehoz egy példasémát 4 táblával. Ezután a create-sym-tables parancs a symadmin segítségével létrehozza a replikációs irányelveket és szabályokat tartalmazó könyvtártáblákat. Végül példaadatokat töltenek be a táblákba.
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.sqlA példában az item és item_selling_price táblák automatikusan be vannak állítva a corp-000 és store-001 közötti replikációra, míg a sale (sale_transaction és sale_return_line_item) táblák automatikusan be vannak állítva a store-001 és corp-000 közötti replikációra. Most létrehozzuk a sémát a PostgreSQL adatbázisban az vm2 (store-001) hoszton, hogy felkészüljön az adatok fogadására a corp-000- tól.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> ./dbimport --engine store-001 --format XML create_sample.xmlElengedhetetlen, hogy ellenőrizzük, hogy vm1 MySQL adatbázisában vannak-e példák a táblákra és a SymmetricDS katalógustáblákra. Vegyük észre, hogy a SymmetricDS rendszer táblái (sym_ előtaggal) jelenleg csak corp-000 csomóponton elérhetők, mivel itt hajtottuk végre a create-sym-tables parancsot, és itt kezeljük a replikációt. A store-001 csomópont adatbázisában mindössze 4 példatáblának lesz helye adat nélkül.
Ennyi. A környezet készen áll a sym szerverfolyamatok elindítására mindkét csomóponton, ahogyan az alább látható.
vm1$> cd /usr/local/symmetric-server-3.9.20/bin
vm1$> sym 2>&1 &A naplóbejegyzések a SymmetricDS telepítési könyvtárában található log fájlba (symmetric.log) és a standard kimenetre kerülnek. A sym kiszolgáló mostantól elindítható a store-001 csomóponton.
vm2$> cd /usr/local/symmetric-server-3.9.20/bin
vm2$> sym 2>&1 &Ha a sym kiszolgáló folyamatot a vm2 hoszton indítjuk el, új táblákat hoz létre a SymmetricDS katalogusába a PostgreSQL adatbázisban. Ha a sym kiszolgáló folyamatot mindkét csomóponton elindítjuk, akkor azok együttműködnek, hogy replikálják az adatokat a corp-000-ból a store-001-be. Ha néhány másodperc múlva megkérdezzük mind a 4 táblát mindkét oldalon, láthatjuk, hogy a replikáció sikeresen megtörtént. Vagy az alábbi parancs segítségével elvégezhetjük a kezdeti betöltést a store-001 csomópontra a corp-000-ból.
vm1$> ./symadmin --engine corp-000 reload-node 001Ezen a ponton új rekord kerül be az item táblába a MySQL adatbázisba a corp-000 csomóponton (hoszt: vm1), és ellenőrizhetjük annak replikációját a PostgreSQL adatbázisba a store-001 csomóponton (hoszt: vm2). A Pull művelet látható, amely adatokat mozgathat a corp-000-ból a store-001-be.
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)Ahhoz, hogy Push műveletet hajtsunk végre az adatok átköltöztetésére a store-001-ből a corp-000-ba, be kell illesztenünk egy rekordot a sale_transaction táblába, és ellenőriznünk kell, hogy a replikáció megtörtént-e.
Sikeres kétsirányú replikációt láthatunk a táblák között a MySQL és PostgreSQL adatbázisokban. Új felhasználói táblák replikációjának beállításához a következő lépéseket kell követnünk. Példaként létrehozzuk a t1 táblát, és az alábbiak szerint állítjuk be a replikációs szabályait. Ezzel csak a corp-000-ból a store-001-be történő replikációt állítjuk be.
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)Ezután a konfiguráció értesítést kap a séma változásáról, azaz egy új táblázat hozzáadásáról, a symadmin parancs sync-triggers argumentumával, amely újból létrehozza a táblázatdefiníciókhoz illeszkedő trigger-eket. A send-schema végrehajtása a séma módosításainak elküldésére a store-001 csomópontnak, és a t1 táblázat replikálása be van állítva.
vm1$> ./symadmin -e corp-000 --node=001 sync-triggers
vm1$> ./symadmin send-schema -e corp-000 --node=001 t1A SymmetricDS előnyei
Egyszerű telepítés és konfiguráció, beleértve a három vagy két csomópont számára előkészített fájlok készletét a séma létrehozásához.
Adatbázisok platformok közötti kompatibilitása és platformfüggetlensége, beleértve a szervereket, laptopokat és mobil eszközöket.
Bármilyen adatbázis replikálása bármilyen más adatbázisra helyben, WAN-on vagy felhőben.
Optimális működési lehetőség egy pár adatbázissal vagy akár több ezerrel a kényelmes replikáció érdekében.
Fizetős verzió grafikus felhasználói felülettel és kiváló támogatással.
A SymmetricDS hátrányai
Kézzel kell meghatározni a replikációs szabályokat és irányt az SQL operátorok segítségével a katalogizálási táblázatok betöltéséhez, ami néha kényelmetlen lehet.
Sok táblázat beállítása a replikációhoz fárasztó lehet, hacsak nem használunk szkripteket az SQL operátorok létrehozásához, amelyek meghatározzák a szabályokat és irányokat.
Túl sok információ kerül a naplókba, és néha rendet kell tenni a naplófájlban, hogy ne foglaljon el túl sok helyet.
Összefoglalás a SymmetricDS-ről
A SymmetricDS lehetővé teszi a két, három és akár több ezer csomópont közötti kétirányú replikáció beállítását, amely replikálja és szinkronizálja a fájlokat. Ez egy egyedi eszköz, amely önállóan végrehajt számos feladatot, például automatikus adat-helyreállítást hosszú leállás után a csomóponton, védett és hatékony adatátvitelt a csomópontok között HTTPS-en keresztül, automatikus konfliktuskezelést szabálykészlet alapján stb. A SymmetricDS bármilyen adatbázis között végez replikációt, így a legkülönbözőbb forgatókönyvekben használható, beleértve az migrációt, a verzióváltást, elosztást, adatfeldolgozást és átalakítást különféle platformokon.
A példa az hivatalos a SymmetricDS-hez. A részletesen bemutatja azokat a különböző fogalmakat, amelyek a SymmetricDS segítségével történő replikáció beállításával kapcsolatosak.
Forrás: habr.com
