Խաչաձև կրկնօրինակում PostgreSQL-ի և MySQL-ի միջև

Ես կներկայացնեմ PostgreSQL-ի և MySQL-ի միջև խաչաձև վերարտադրությունը, ինչպես նաև տվյալների բազայի երկու սերվերների միջև խաչաձև վերարտադրություն ստեղծելու մեթոդները: Սովորաբար, խաչաձև կրկնվող տվյալների բազաները կոչվում են միատարր, և դա մի RDBMS սերվերից մյուսը տեղափոխելու հարմար մեթոդ է:

PostgreSQL և MySQL տվյալների բազաները սովորաբար համարվում են հարաբերական, բայց լրացուցիչ ընդլայնումներով նրանք առաջարկում են NoSQL հնարավորություններ: Այստեղ մենք կքննարկենք PostgreSQL-ի և MySQL-ի միջև կրկնօրինակումը հարաբերական DBMS-ի տեսանկյունից:

Մենք չենք նկարագրի ամբողջ ներքին աշխատանքը, պարզապես հիմնական սկզբունքները, որպեսզի դուք պատկերացում կազմեք տվյալների բազայի սերվերների միջև կրկնօրինակումը կարգավորելու, առավելությունների, սահմանափակումների և օգտագործման դեպքերի միջև:

Սովորաբար, տվյալների բազայի երկու նույնական սերվերների միջև կրկնօրինակումը կատարվում է կամ երկուական ռեժիմով կամ օգտագործելով հարցումներ վարպետի (այսինքն՝ հրատարակիչ, վարպետ կամ ակտիվ) և ստրուկի (բաժանորդ, սպասման կամ պասիվ) միջև: Կրկնօրինակման նպատակն է ապահովել հիմնական տվյալների բազայի իրական ժամանակի պատճենը ստրուկ կողմում: Այս դեպքում տվյալները փոխանցվում են վարպետից ստրուկ, այսինքն՝ ակտիվից պասիվ, քանի որ կրկնօրինակումը կատարվում է միայն մեկ ուղղությամբ։ Բայց դուք կարող եք կրկնօրինակել երկու տվյալների բազաների միջև երկու ուղղություններով, այնպես որ տվյալները փոխանցվում են ստրկից վարպետ ակտիվ-ակտիվ կոնֆիգուրացիայի մեջ: Այս ամենը, ներառյալ կասկադային վերարտադրությունը, հնարավոր է տվյալների բազայի երկու կամ ավելի միանման սերվերների միջև: Ակտիվ-ակտիվ կամ ակտիվ-պասիվ կոնֆիգուրացիան կախված է կարիքից, նախնական կազմաձևում նման հնարավորությունների առկայությունից կամ արտաքին կոնֆիգուրացիայի լուծումների օգտագործումից և առկա փոխզիջումներից:

Նկարագրված կոնֆիգուրացիան հնարավոր է տվյալների բազայի տարբեր սերվերների միջև: Սերվերը կարող է կազմաձևվել այնպես, որ ընդունի կրկնօրինակված տվյալներ տվյալների բազայի մեկ այլ սերվերից և դեռ պահպանի կրկնօրինակված տվյալների իրական ժամանակի նկարները: MySQL-ը և PostgreSQL-ն առաջարկում են այս կոնֆիգուրացիաների մեծ մասը ներքին կամ երրորդ կողմի ընդլայնումների միջոցով, ներառյալ երկուական գրանցամատյանի մեթոդները, սկավառակի կողպումը և հայտարարությունների և տողերի վրա հիմնված մեթոդները:

MySQL-ի և PostgreSQL-ի միջև խաչաձև վերարտադրությունն անհրաժեշտ է տվյալների բազայի մի սերվերից մյուսը մեկանգամյա տեղափոխման համար: Այս տվյալների բազաները օգտագործում են տարբեր արձանագրություններ, ուստի հնարավոր չէ դրանք ուղղակիորեն կապել: Տվյալների փոխանակում հաստատելու համար կարող եք օգտագործել արտաքին բաց կոդով գործիք, օրինակ՝ pg_chameleon:

Ինչ է pg_chameleon

pg_chameleon-ը կրկնօրինակման համակարգ է MySQL-ից դեպի PostgreSQL Python 3-ում: Այն օգտագործում է բաց կոդով mysql-replication գրադարանը, ինչպես նաև Python-ում: Տողերի պատկերները հանվում են MySQL աղյուսակներից և պահվում որպես JSONB օբյեկտներ PostgreSQL տվյալների բազայում, այնուհետև վերծանվում են pl/pgsql ֆունկցիայի միջոցով և վերարտադրվում PostgreSQL տվյալների բազայում:

pg_chameleon-ի առանձնահատկությունները

Միևնույն կլաստերից բազմաթիվ MySQL սխեմաներ կարող են վերարտադրվել մեկ թիրախային PostgreSQL տվյալների բազայում մեկից շատ կազմաձևով
Աղբյուրի և թիրախային սխեմայի անունները չեն կարող նույնը լինել:
Կրկնօրինակման տվյալները կարող են առբերվել կասկադային MySQL կրկնօրինակից:
Աղյուսակները, որոնք չեն կարող կրկնօրինակել կամ սխալներ առաջացնել, բացառվում են:
Յուրաքանչյուր կրկնօրինակման ֆունկցիա վերահսկվում է դևերի կողմից:
Վերահսկում YAML-ի վրա հիմնված պարամետրերի և կազմաձևման ֆայլերի միջոցով:

Օրինակ

Հյուրընկալող
vm1
vm2

OS տարբերակ
CentOS Linux 7.6 x86_64
CentOS Linux 7.5 x86_64

DB սերվերի տարբերակը
MySQL 5.7.26- ը
PostgreSQL 10.5- ը

DB նավահանգիստ
3306
5433

IP հասցե
192.168.56.102
192.168.56.106

Սկսելու համար պատրաստեք բոլոր անհրաժեշտ բաղադրիչները pg_chameleon-ը տեղադրելու համար: Այս օրինակը տեղադրում է Python 3.6.8, որը ստեղծում և ակտիվացնում է վիրտուալ միջավայրը։

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

Python3.6-ը հաջողությամբ տեղադրելուց հետո դուք պետք է լրացնեք մնացած պահանջները, ինչպիսիք են վիրտուալ միջավայրի ստեղծումն ու ակտիվացումը: Բացի այդ, pip մոդուլը թարմացվում է վերջին տարբերակով և օգտագործվում pg_chameleon-ի տեղադրման համար: Ստորև բերված հրամանները միտումնավոր տեղադրում են pg_chameleon 2.0.9, թեև վերջին տարբերակը 2.0.10 է: Սա անհրաժեշտ է թարմացված տարբերակում նոր սխալներից խուսափելու համար:

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

Այնուհետև մենք կանչում ենք pg_chameleon (քամելեոնը հրաման է) set_configuration_files արգումենտով՝ pg_chameleon-ը միացնելու և լռելյայն դիրեկտորիաներ և կազմաձևման ֆայլեր ստեղծելու համար:

(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

Այժմ մենք ստեղծում ենք config-example.yml-ի պատճենը որպես default.yml, որպեսզի այն դառնա լռելյայն կազմաձևման ֆայլ: Այս օրինակի համար կազմաձևման ֆայլի նմուշը ներկայացված է ստորև:

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

Այս օրինակի կազմաձևման ֆայլը pg_chameleon ֆայլի նմուշ է, փոքր փոփոխություններով, որոնք համապատասխանում են աղբյուրին և թիրախային միջավայրին, իսկ ստորև ներկայացված է կազմաձևման ֆայլի տարբեր բաժինների ակնարկ:

Default.yml կազմաձևման ֆայլում կա գլոբալ կարգավորումների բաժին, որտեղ կարող եք կառավարել այնպիսի կարգավորումներ, ինչպիսիք են կողպեքի ֆայլի գտնվելու վայրը, տեղեկամատյանների գտնվելու վայրը, տեղեկամատյանների պահպանման ժամկետը և այլն: Այնուհետև գալիս է տիպի փոխարինման բաժինը, որտեղ մի շարք կանոններ վերարտադրման ժամանակ տիպերի գերակայության համար: Օրինակը կանխադրված է տիպի գերակայող կանոն, որը փոխակերպում է tinyint(1) բուլյան արժեքի: Հաջորդ բաժնում մենք նշում ենք թիրախային տվյալների բազայի միացման մանրամասները: Մեր դեպքում սա PostgreSQL տվյալների բազա է, որը նշանակված է pg_conn: Վերջին բաժնում մենք նշում ենք աղբյուրի տվյալները, այսինքն ՝ աղբյուրի տվյալների բազայի միացման պարամետրերը, աղբյուրի և թիրախային տվյալների բազաների միջև քարտեզագրման սխեման, աղյուսակները, որոնք պետք է բաց թողնել, սպասման ժամանակը, հիշողությունը, փաթեթի չափը: Նկատի ունեցեք, որ «աղբյուրները» հոգնակի է, ինչը նշանակում է, որ մենք կարող ենք ավելացնել մի քանի աղբյուրի տվյալների բազաներ մեկ թիրախային տվյալների բազայում՝ շատ-մեկ կոնֆիգուրացիա ստեղծելու համար:

World_x տվյալների բազայի օրինակը պարունակում է 4 աղյուսակ տողերով, որոնք MySQL համայնքն առաջարկում է որպես օրինակ: Այն կարելի է ներբեռնել այստեղ. Նմուշի տվյալների բազան գալիս է որպես tar և սեղմված արխիվ՝ տողեր ստեղծելու և ներմուծելու հրահանգներով:

MySQL և PostgreSQL տվյալների բազաներում ստեղծվում է հատուկ օգտատեր նույն անունով usr_replica: MySQL-ում նրան տրվում է կարդալու լրացուցիչ իրավունքներ բոլոր կրկնվող աղյուսակների համար:

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;

PostgreSQL-ի կողմից ստեղծվում է db_replica տվյալների բազա, որը կընդունի փոփոխությունները MySQL տվյալների բազայից: PostgreSQL-ում usr_replica օգտատերը ինքնաբերաբար կազմաձևվում է որպես երկու սխեմաների սեփականատեր՝ pgworld_x և sch_chameleon, որոնք համապատասխանաբար պարունակում են իրական կրկնվող աղյուսակները և վերարտադրման գրացուցակի աղյուսակները: Create_replica_schema արգումենտը պատասխանատու է ավտոմատ կազմաձևման համար, ինչպես կտեսնեք ստորև:

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

MySQL տվյալների բազան կազմաձևված է որոշ պարամետրերի փոփոխություններով՝ այն վերարտադրելու համար, ինչպես ցույց է տրված ստորև: Փոփոխությունների ուժի մեջ մտնելու համար դուք պետք է վերագործարկեք տվյալների բազայի սերվերը:

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

Այժմ կարևոր է ստուգել կապը տվյալների բազայի երկու սերվերների հետ, որպեսզի pg_chameleon հրամանները գործարկելիս խնդիրներ չառաջանան։

PostgreSQL հանգույցում.

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

MySQL հանգույցում.

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

Հաջորդ երեք pg_chameleon (քամելեոն) հրամանները նախապատրաստում են միջավայրը, ավելացնում աղբյուրը և սկզբնավորում են կրկնօրինակը: Create_replica_schema արգումենտը pg_chameleon-ին ստեղծում է լռելյայն սխեմա (sch_chameleon) և կրկնօրինակման սխեման (pgworld_x) PostgreSQL տվյալների բազայում, ինչպես մենք արդեն քննարկել ենք: add_source արգումենտը կոնֆիգուրացիային ավելացնում է աղբյուրի տվյալների բազա՝ կարդալով կազմաձևման ֆայլը (default.yml), և մեր դեպքում դա mysql է, իսկ init_replica-ն սկզբնավորում է կոնֆիգուրացիան՝ հիմնվելով կազմաձևման ֆայլի պարամետրերի վրա։

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

Այս երեք հրամանների արդյունքը հստակ ցույց է տալիս, որ դրանք հաջողությամբ են կատարվել: Ցանկացած խափանում կամ շարահյուսական սխալ հաղորդվում է պարզ, հստակ հաղորդագրություններով՝ ակնարկներով, թե ինչպես լուծել խնդիրը:

Ի վերջո, մենք սկսում ենք վերարտադրումը start_replica-ի միջոցով և ստանում հաջողության հաղորդագրություն:

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

Կրկնօրինակման կարգավիճակը կարելի է հարցնել՝ օգտագործելով show_status արգումենտը, իսկ սխալները կարող են դիտվել՝ օգտագործելով show_errors արգումենտը:

Արդյունքը.

Ինչպես արդեն ասացինք, կրկնօրինակման յուրաքանչյուր ֆունկցիա կառավարվում է դևերի կողմից: Դրանք դիտելու համար մենք հարցում ենք անում գործընթացի աղյուսակում Linux ps հրամանով, ինչպես ցույց է տրված ստորև:

Արդյունքը.

Կրկնօրինակումը չի համարվում կազմաձևված, քանի դեռ չենք փորձարկել այն իրական ժամանակում, ինչպես ցույց է տրված ստորև: Մենք ստեղծում ենք աղյուսակ, տեղադրում ենք մի քանի գրառում MySQL տվյալների բազայում և կանչում ենք sync_tables արգումենտը pg_chameleon-ում՝ դևերը թարմացնելու և գրառումների հետ աղյուսակը կրկնօրինակելու PostgreSQL տվյալների բազայում:

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

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

Թեստի արդյունքները հաստատելու համար մենք հարցում ենք անում աղյուսակը PostgreSQL տվյալների բազայից և դուրս ենք բերում տողերը:

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

Եթե ​​մենք միգրացիա ենք անում, ապա հետևյալ pg_chameleon հրամանները կլինեն դրա ավարտը։ Հրամանները պետք է կատարվեն այն բանից հետո, երբ համոզվենք, որ բոլոր թիրախային աղյուսակների տողերը կրկնօրինակվել են, և արդյունքը կլինի կոկիկ կերպով տեղափոխված PostgreSQL տվյալների բազա՝ առանց աղբյուրի տվյալների բազայի հղումների կամ կրկնօրինակման սխեմայի (sch_chameleon):

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

Ցանկության դեպքում կարող եք օգտագործել հետևյալ հրամանները բնօրինակ կազմաձևման և կրկնօրինակման սխեման ջնջելու համար:

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

pg_chameleon-ի առավելությունները

Հեշտ կարգավորում և կազմաձևում:
Հեշտությամբ շտկեք անսարքությունները և հայտնաբերեք անոմալիաները հստակ սխալի հաղորդագրություններով:
Լրացուցիչ հատուկ աղյուսակներ կարող են ավելացվել վերարտադրմանը սկզբնավորումից հետո՝ առանց մնացած կոնֆիգուրացիան փոխելու:
Հնարավոր է կարգավորել մի քանի աղբյուրի տվյալների բազաներ մեկ թիրախային տվյալների բազայի համար, և դա շատ օգտակար է, եթե դուք միավորում եք տվյալները մեկ կամ մի քանի MySQL տվյալների բազաներից մեկ PostgreSQL տվյալների բազայում:
Պետք չէ կրկնել ընտրված աղյուսակները:

pg_chameleon-ի թերությունները

Աջակցվում է միայն MySQL 5.5 և ավելի բարձր՝ որպես աղբյուր և PostgreSQL 9.5 և ավելի՝ որպես թիրախային տվյալների բազա:
Յուրաքանչյուր աղյուսակ պետք է ունենա հիմնական կամ եզակի բանալի, հակառակ դեպքում աղյուսակները սկզբնավորվում են init_replica գործընթացի ընթացքում, բայց չեն կրկնօրինակվում:
Միակողմանի կրկնօրինակում՝ միայն MySQL-ից PostgreSQL: Հետևաբար, այն հարմար է միայն «ակտիվ-պասիվ» միացման համար:
Աղբյուրը կարող է լինել միայն MySQL տվյալների բազա, իսկ PostgreSQL տվյալների բազայի աջակցությունը որպես աղբյուր միայն փորձնական է և սահմանափակումներով (մանրամասն այստեղ)

Արդյունքներ pg_chameleon-ի համար

Pg_chameleon-ում կրկնօրինակման մեթոդը հիանալի է տվյալների բազան MySQL-ից PostgreSQL տեղափոխելու համար: Էական բացասական կողմն այն է, որ կրկնօրինակումը միայն միակողմանի է, ուստի տվյալների բազայի մասնագետները դժվար թե ցանկանան օգտագործել այն այլ բանի համար, քան միգրացիան: Բայց միակողմանի կրկնօրինակման խնդիրը կարելի է լուծել մեկ այլ բաց կոդով գործիքով՝ SymmetricDS-ով:

Կարդացեք ավելին պաշտոնական փաստաթղթերում այստեղ. Հրամանի տողի օգնությունը կարելի է գտնել այստեղ.

SymmetricDS-ի ակնարկ

SymmetricDS-ը բաց կոդով գործիք է, որը կրկնօրինակում է ցանկացած տվյալների բազա ցանկացած այլ ընդհանուր տվյալների բազայի՝ Oracle, MongoDB, PostgreSQL, MySQL, SQL Server, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird և ամպային տվյալների բազայի այլ օրինակներ, օրինակ՝ Redshift և Azure և այլն: Հասանելի հնարավորություններ. տվյալների բազայի և ֆայլերի համաժամացում, տվյալների բազայի բազմաբնույթ վերարտադրություն, ֆիլտրացված համաժամացում, փոխակերպում և այլն: Սա Java գործիք է և պահանջում է JRE կամ JDK ստանդարտ թողարկում (տարբերակ 8.0 կամ ավելի բարձր): Այստեղ տվյալների փոփոխությունները դեպի տրիգերներ աղբյուրի տվյալների բազայում կարող են գրանցվել և ուղարկել համապատասխան թիրախային տվյալների բազա խմբաքանակների տեսքով:

SymmetricDS-ի առանձնահատկությունները

Գործիքը հարթակից անկախ է, ինչը նշանակում է, որ երկու կամ ավելի տարբեր տվյալների բազաներ կարող են փոխանակել տվյալներ:
Հարաբերական տվյալների բազաները համաժամացվում են տվյալների փոփոխության գրառումների միջոցով, մինչդեռ ֆայլային համակարգի վրա հիմնված տվյալների բազաները օգտագործում են ֆայլերի համաժամացում:
Երկկողմանի կրկնօրինակում՝ օգտագործելով Push և Pull մեթոդները՝ հիմնված մի շարք կանոնների վրա:
Տվյալների փոխանցումը հնարավոր է անվտանգ և ցածր թողունակությամբ ցանցերի միջոցով:
Ավտոմատ վերականգնում, երբ հանգույցները վերսկսում են աշխատանքը ձախողումից և կոնֆլիկտի ավտոմատ լուծումից հետո:
Ամպային համատեղելի և հզոր ընդլայնման API-ներ:

Օրինակ

SymmetricDS-ը կարող է կազմաձևվել երկու տարբերակներից մեկով.
Հիմնական (ծնող) հանգույց, որը կենտրոնական կերպով համակարգում է տվյալների վերարտադրությունը երկու ստրուկ (երեխա) հանգույցների միջև, և երեխայի հանգույցների միջև հաղորդակցությունը տեղի է ունենում միայն ծնողի միջոցով:
Ակտիվ հանգույցը (հանգույց 1) կարող է կրկնօրինակման համար հաղորդակցվել մեկ այլ ակտիվ հանգույցի հետ (հանգույց 2) առանց միջնորդի:

Երկու տարբերակում էլ տվյալների փոխանակումն իրականացվում է Push-ի և Pull-ի միջոցով: Այս օրինակում մենք կդիտարկենք ակտիվ-ակտիվ կոնֆիգուրացիան: Ամբողջ ճարտարապետությունը նկարագրելու համար չափազանց երկար կպահանջվի, այնպես որ կատարեք ձեր հետազոտությունը: ղեկավարությունըSymmetricDS սարքի մասին ավելին իմանալու համար:

SymmetricDS-ի տեղադրումը շատ պարզ է՝ ներբեռնեք zip ֆայլի բաց կոդով տարբերակը ուստի և հանիր այնտեղ, որտեղ ուզում ես: Ստորև բերված աղյուսակը տեղեկատվություն է տրամադրում այս օրինակում SymmetricDS-ի տեղադրման վայրի և տարբերակի, ինչպես նաև տվյալների բազայի տարբերակների, Linux-ի տարբերակների, IP հասցեների և երկու հանգույցների պորտերի մասին:

Հյուրընկալող
vm1
vm2

OS տարբերակ
CentOS Linux 7.6 x86_64
CentOS Linux 7.6 x86_64

DB սերվերի տարբերակը
MySQL 5.7.26- ը
PostgreSQL 10.5- ը

DB նավահանգիստ
3306
5832

IP հասցե
192.168.1.107
192.168.1.112

SymmetricDS տարբերակ
SymmetricDS 3.9
SymmetricDS 3.9

SymmetricDS տեղադրման ուղին
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

SymmetricDS հանգույցի անվանումը
կորպ-000
խանութ-001

Այստեղ մենք տեղադրում ենք SymmetricDS-ը /usr/local/symmetric-server-3.9.20-ում, և այնտեղ կպահվեն տարբեր ենթագրքեր և ֆայլեր: Մենք հետաքրքրված ենք նմուշների և շարժիչների ենթագրքերով: Նմուշների գրացուցակը պարունակում է օրինակ կազմաձևման ֆայլեր՝ հանգույցի հատկություններով, ինչպես նաև SQL սկրիպտներ՝ արագ սկսելու համար:

Նմուշների գրացուցակում մենք տեսնում ենք երեք կոնֆիգուրացիայի ֆայլեր հանգույցների հատկություններով. անունը ցույց է տալիս հանգույցի բնույթը որոշակի սխեմայի մեջ:

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

SymmetricDS-ն ունի բոլոր անհրաժեշտ կազմաձևման ֆայլերը հիմնական 3 հանգույցի դիզայնի համար (տարբերակ 1), և նույն ֆայլերը կարող են օգտագործվել 2 հանգույցի ձևավորման համար (տարբերակ 2): Պատճենեք պահանջվող կազմաձևման ֆայլը նմուշների գրացուցակից դեպի vm1 հոսթի շարժիչներ: Ստացվում է այսպես.

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

SymmetricDS կոնֆիգուրացիայի այս հանգույցը կոչվում է corp-000, և տվյալների բազայի կապը մշակվում է mysql jdbc դրայվերի կողմից, որն օգտագործում է վերևում գտնվող կապի տողը և մուտքի հավատարմագրերը: Մենք միանում ենք replica_db տվյալների բազային, և սխեմայի ստեղծման ժամանակ կստեղծվեն աղյուսակներ: sync.url-ը ցույց է տալիս, թե որտեղ կարելի է կապվել հանգույցի հետ համաժամացման համար:

Հանգույց 2-ը հոսթ vm2-ում կազմաձևված է որպես store-001, իսկ մնացածը նշված է ստորև բերված node.properties ֆայլում: Node store-001-ը գործարկում է PostgreSQL տվյալների բազան, իսկ pgdb_replica-ն կրկնօրինակման տվյալների բազան է: register.url-ը թույլ է տալիս հոսթ vm2-ին կապվել host vm1-ի հետ և ստանալ կազմաձևման մանրամասները դրանից:

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

Ավարտված SymmetricDS օրինակը պարունակում է պարամետրեր երկու տվյալների բազայի սերվերների (երկու հանգույց) միջև երկկողմանի կրկնօրինակման տեղադրման համար: Ստորև բերված քայլերը կատարվում են հյուրընկալող vm1-ի վրա (corp-000), որը կստեղծի 4 աղյուսակով օրինակելի սխեմա: Այնուհետև synadmin հրամանով create-sym-tables-ը գործարկելով՝ ստեղծում է գրացուցակի աղյուսակներ, որտեղ կպահվեն հանգույցների միջև կրկնօրինակման կանոններն ու ուղղությունը: Ի վերջո, նմուշի տվյալները բեռնվում են աղյուսակներում:

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

Օրինակ, ապրանքի և նյութի_վաճառքի_գնի աղյուսակները ավտոմատ կերպով կազմաձևված են՝ կրկնօրինակելու համար corp-000-ից խանութ-001, իսկ վաճառքի աղյուսակները (sale_transaction և sale_return_line_item) ավտոմատ կերպով կազմաձևված են՝ կրկնօրինակելու համար store-001-ից մինչև corp-000: Այժմ մենք ստեղծում ենք սխեմա PostgreSQL տվյալների բազայում host vm2-ի վրա (store-001), որպեսզի պատրաստենք այն corp-000-ից տվյալներ ստանալու համար:

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

Համոզվեք, որ ստուգեք, որ vm1-ի MySQL տվյալների բազան ունի օրինակ աղյուսակներ և SymmetricDS կատալոգի աղյուսակներ: Նկատի ունեցեք, որ SymmetricDS համակարգի աղյուսակները (նախածանցով sym_) ներկայումս հասանելի են միայն հանգույցի corp-000-ում, քանի որ այստեղ մենք գործարկեցինք create-sym-tables հրամանը և կկառավարենք վերարտադրությունը: Իսկ node store-001-ի տվյալների բազայում կլինի միայն 4 օրինակ աղյուսակ առանց տվյալների։

Բոլորը. Շրջակա միջավայրը պատրաստ է գործարկել sym սերվերի գործընթացները երկու հանգույցների վրա, ինչպես ցույց է տրված ստորև:

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

Մատյանների գրառումներն ուղարկվում են ֆոնային մատյան ֆայլ (symmetric.log) այն գրացուցակի տեղեկամատյանների թղթապանակում, որտեղ տեղադրված է SymmetricDS-ը, ինչպես նաև ստանդարտ արդյունք: Sym սերվերն այժմ կարող է գործարկվել node store-001-ում:

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

Եթե ​​դուք գործարկեք sym սերվերի գործընթացը vm2 հոսթի վրա, այն նաև կստեղծի SymmetricDS կատալոգի աղյուսակներ PostgreSQL տվյալների բազայում: Եթե ​​դուք գործարկում եք sym սերվերի պրոցեսը երկու հանգույցների վրա, դրանք համակարգվում են միմյանց հետ՝ կրկնօրինակելու տվյալները corp-000-ից դեպի store-001: Եթե ​​մի քանի վայրկյան անց երկու կողմերի բոլոր 4 աղյուսակները հարցումներ կատարենք, կտեսնենք, որ կրկնօրինակումը հաջող է: Կամ կարող եք bootstrap-ը ուղարկել node store-001 corp-000-ից հետևյալ հրամանով.

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

Այս պահին նոր գրառումը տեղադրվում է MySQL տվյալների աղյուսակում հանգույցի corp-000-ի (հյուրընկալող՝ vm1) աղյուսակում, և դուք կարող եք ստուգել դրա կրկնօրինակումը PostgreSQL տվյալների բազայում node store-001-ում (հյուրընկալող՝ vm2): Մենք տեսնում ենք Pull գործողություն՝ տվյալները corp-000-ից խանութ-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)

Տվյալները store-001-ից corp-000 տեղափոխելու Push գործողություն կատարելու համար մենք գրառում ենք տեղադրում sale_transaction աղյուսակում և ստուգում, որ կրկնօրինակումը հաջող է:

Արդյունքը.

Մենք տեսնում ենք օրինակների աղյուսակների երկկողմանի կրկնօրինակման հաջող կարգավորում MySQL և PostgreSQL տվյալների բազաների միջև: Նոր օգտվողների աղյուսակների համար կրկնօրինակումը կարգավորելու համար հետևեք հետևյալ քայլերին. Մենք, օրինակ, ստեղծում ենք t1 աղյուսակը և կարգավորում դրա կրկնօրինակման կանոնները հետևյալ կերպ. Այս կերպ մենք կարգավորում ենք միայն replication-ը corp-000-ից մինչև 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)

Այնուհետև կոնֆիգուրացիան ծանուցվում է սխեմայի փոփոխության, այսինքն՝ նոր աղյուսակի ավելացման մասին՝ օգտագործելով symadmin հրամանը sync-triggers արգումենտով, որը վերստեղծում է գործարկիչները՝ աղյուսակի սահմանումները քարտեզագրելու համար: send-schema-ն իրականացվում է սխեմայի փոփոխությունները հանգույցի խանութ-001 ուղարկելու համար, և t1 աղյուսակի կրկնօրինակումը կազմաձևվում է:

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

SymmetricDS-ի առավելությունները

Հեշտ տեղադրում և կազմաձևում, ներառյալ ֆայլերի պատրաստի հավաքածու երեք հանգույց կամ երկու հանգույց ստեղծելու պարամետրերով:
Միջպլատֆորմային տվյալների բազաներ և հարթակի անկախություն, ներառյալ սերվերներ, դյուրակիր համակարգիչներ և շարժական սարքեր:
Վերարտադրեք ցանկացած տվյալների բազա տեղական ցանկացած այլ տվյալների բազայի վրա, WAN-ում կամ ամպի մեջ:
Օպտիմալ աշխատանքի հնարավորություն մի քանի շտեմարանների կամ մի քանի հազարի հետ՝ հարմար վերարտադրության համար։
Վճարովի տարբերակ GUI-ով և գերազանց աջակցությամբ:

SymmetricDS-ի թերությունները

Կատալոգի աղյուսակները բեռնելու համար դուք պետք է ձեռքով սահմանեք հրամանի տողում կրկնօրինակման կանոններն ու ուղղությունը SQL հայտարարությունների միջոցով, ինչը կարող է անհարմար լինել:
Կրկնօրինակման համար շատ աղյուսակներ տեղադրելը կարող է հոգնեցուցիչ լինել, քանի դեռ չեք օգտագործում սկրիպտներ SQL հայտարարություններ ստեղծելու համար, որոնք սահմանում են կրկնօրինակման կանոններն ու ուղղությունը:
Գրանցամատյաններում չափազանց շատ տեղեկատվություն է գրանցվում, և երբեմն անհրաժեշտ է կարգի բերել գրանցամատյանի ֆայլը, որպեսզի այն շատ տեղ չզբաղեցնի:

SymmetricDS-ի արդյունքները

SymmetricDS-ը թույլ է տալիս ստեղծել երկկողմանի կրկնօրինակում երկու, երեք կամ նույնիսկ մի քանի հազար հանգույցների միջև՝ ֆայլերը կրկնօրինակելու և համաժամացնելու համար: Սա եզակի գործիք է, որն ինքնուրույն կատարում է բազմաթիվ առաջադրանքներ, ինչպիսիք են՝ տվյալների ավտոմատ վերականգնումը հանգույցի վրա երկարատև դադարից հետո, HTTPS-ի միջոցով հանգույցների միջև տվյալների անվտանգ և արդյունավետ փոխանակումը, մի շարք կանոնների վրա հիմնված կոնֆլիկտի ավտոմատ կառավարում և այլն: SymmetricDS-ը կատարում է: Վերարտադրությունը ցանկացած տվյալների բազաների միջև, հետևաբար, այն կարող է օգտագործվել տարբեր սցենարների համար, ներառյալ միգրացիան, միգրացիան, բաշխումը, զտումը և տվյալների փոխակերպումը հարթակներում:

Օրինակը հիմնված է պաշտոնյայի վրա արագ ուղեցույց SymmetricDS-ի կողմից: IN օգտագործողի ձեռնարկ Մանրամասն նկարագրում է SymmetricDS-ի հետ կրկնօրինակման ստեղծման հետ կապված տարբեր հասկացություններ:

Source: www.habr.com