PostgreSQL మరియు MySQL మధ్య క్రాస్ రెప్లికేషన్

నేను PostgreSQL మరియు MySQL మధ్య క్రాస్-రెప్లికేషన్‌ను, అలాగే రెండు డేటాబేస్ సర్వర్‌ల మధ్య క్రాస్ రెప్లికేషన్‌ని సెటప్ చేసే పద్ధతులను వివరిస్తాను. సాధారణంగా, క్రాస్-రెప్లికేట్ డేటాబేస్‌లను సజాతీయంగా పిలుస్తారు మరియు ఇది ఒక RDBMS సర్వర్ నుండి మరొకదానికి తరలించడానికి అనుకూలమైన పద్ధతి.

PostgreSQL మరియు MySQL డేటాబేస్‌లు సాధారణంగా రిలేషనల్‌గా పరిగణించబడతాయి, అయితే అదనపు పొడిగింపులతో అవి NoSQL సామర్థ్యాలను అందిస్తాయి. ఇక్కడ మనం PostgreSQL మరియు MySQL మధ్య ప్రతిరూపాన్ని సంబంధిత DBMS కోణం నుండి చర్చిస్తాము.

డేటాబేస్ సర్వర్లు, ప్రయోజనాలు, పరిమితులు మరియు వినియోగ కేసుల మధ్య ప్రతిరూపణను కాన్ఫిగర్ చేయడం గురించి మీకు ఒక ఆలోచన వచ్చేలా మేము మొత్తం అంతర్గత పనితీరును కేవలం ప్రాథమిక సూత్రాలను వివరించము.

సాధారణంగా, రెండు సారూప్య డేటాబేస్ సర్వర్‌ల మధ్య ప్రతిరూపం బైనరీ మోడ్‌లో లేదా మాస్టర్ (అ.కా. పబ్లిషర్, మాస్టర్ లేదా యాక్టివ్) మరియు స్లేవ్ (చందాదారు, స్టాండ్‌బై లేదా నిష్క్రియ) మధ్య ప్రశ్నలను ఉపయోగించి జరుగుతుంది. స్లేవ్ వైపు మాస్టర్ డేటాబేస్ యొక్క నిజ-సమయ కాపీని అందించడం ప్రతిరూపణ యొక్క ఉద్దేశ్యం. ఈ సందర్భంలో, డేటా మాస్టర్ నుండి స్లేవ్‌కు బదిలీ చేయబడుతుంది, అనగా క్రియాశీల నుండి నిష్క్రియాత్మకంగా ఉంటుంది, ఎందుకంటే ప్రతిరూపణ ఒక దిశలో మాత్రమే జరుగుతుంది. కానీ మీరు రెండు డేటాబేస్‌ల మధ్య రెప్లికేషన్‌ను రెండు దిశల్లో సెటప్ చేయవచ్చు, తద్వారా డేటా యాక్టివ్-యాక్టివ్ కాన్ఫిగరేషన్‌లో స్లేవ్ నుండి మాస్టర్‌కు బదిలీ చేయబడుతుంది. క్యాస్కేడింగ్ రెప్లికేషన్‌తో సహా ఇవన్నీ రెండు లేదా అంతకంటే ఎక్కువ ఒకేలాంటి డేటాబేస్ సర్వర్‌ల మధ్య సాధ్యమవుతాయి. యాక్టివ్-యాక్టివ్ లేదా యాక్టివ్-పాసివ్ కాన్ఫిగరేషన్ అవసరం, ప్రాథమిక కాన్ఫిగరేషన్‌లో అటువంటి సామర్థ్యాల లభ్యత లేదా బాహ్య కాన్ఫిగరేషన్ సొల్యూషన్‌లు మరియు ఇప్పటికే ఉన్న ట్రేడ్-ఆఫ్‌లపై ఆధారపడి ఉంటుంది.

వివిధ డేటాబేస్ సర్వర్‌ల మధ్య వివరించిన కాన్ఫిగరేషన్ సాధ్యమవుతుంది. మరొక డేటాబేస్ సర్వర్ నుండి ప్రతిరూప డేటాను ఆమోదించడానికి సర్వర్ కాన్ఫిగర్ చేయబడుతుంది మరియు ఇప్పటికీ ప్రతిరూప డేటా యొక్క నిజ-సమయ స్నాప్‌షాట్‌లను నిర్వహించవచ్చు. MySQL మరియు PostgreSQL బైనరీ లాగ్ పద్ధతులు, డిస్క్ లాకింగ్ మరియు స్టేట్‌మెంట్- మరియు వరుస-ఆధారిత పద్ధతులతో సహా ఈ కాన్ఫిగరేషన్‌లలో చాలా వరకు అంతర్గతంగా లేదా మూడవ పక్ష పొడిగింపుల ద్వారా అందిస్తాయి.

MySQL మరియు PostgreSQL మధ్య క్రాస్ రెప్లికేషన్ ఒక డేటాబేస్ సర్వర్ నుండి మరొకదానికి ఒక సారి మైగ్రేషన్ కోసం అవసరం. ఈ డేటాబేస్‌లు వేర్వేరు ప్రోటోకాల్‌లను ఉపయోగిస్తాయి, కాబట్టి వాటిని నేరుగా లింక్ చేయడం సాధ్యం కాదు. డేటా మార్పిడిని స్థాపించడానికి, మీరు బాహ్య ఓపెన్ సోర్స్ సాధనాన్ని ఉపయోగించవచ్చు, ఉదాహరణకు pg_chameleon.

pg_ ఊసరవెల్లి అంటే ఏమిటి

pg_chameleon అనేది పైథాన్ 3లో MySQL నుండి PostgreSQL వరకు ప్రతిరూపణ వ్యవస్థ. ఇది పైథాన్‌లో కూడా ఓపెన్ సోర్స్ mysql-రెప్లికేషన్ లైబ్రరీని ఉపయోగిస్తుంది. వరుస చిత్రాలు MySQL పట్టికల నుండి సంగ్రహించబడతాయి మరియు PostgreSQL డేటాబేస్‌లో JSONB ఆబ్జెక్ట్‌లుగా నిల్వ చేయబడతాయి, ఆపై 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ని ఇన్‌స్టాల్ చేయడానికి అవసరమైన అన్ని భాగాలను సిద్ధం చేయండి. ఈ ఉదాహరణ పైథాన్ 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ని విజయవంతంగా ఇన్‌స్టాల్ చేసిన తర్వాత, మీరు వర్చువల్ వాతావరణాన్ని సృష్టించడం మరియు సక్రియం చేయడం వంటి మిగిలిన అవసరాలను పూర్తి చేయాలి. అదనంగా, పిప్ మాడ్యూల్ తాజా సంస్కరణకు నవీకరించబడింది మరియు pg_chameleonని ఇన్‌స్టాల్ చేయడానికి ఉపయోగించబడుతుంది. తాజా వెర్షన్ 2.0.9 అయినప్పటికీ దిగువ కమాండ్‌లు ఉద్దేశపూర్వకంగా pg_chameleon 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 MySQL సంఘం ఉదాహరణలుగా అందించే వరుసలతో 4 పట్టికలను కలిగి ఉంది. దీన్ని డౌన్‌లోడ్ చేసుకోవచ్చు ఇక్కడ. నమూనా డేటాబేస్ వరుసలను సృష్టించడం మరియు దిగుమతి చేయడం కోసం సూచనలతో తారు మరియు కంప్రెస్డ్ ఆర్కైవ్‌గా వస్తుంది.

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 వైపు, MySQL డేటాబేస్ నుండి మార్పులను ఆమోదించే db_replica డేటాబేస్ సృష్టించబడుతుంది. 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 (ఊసరవెల్లి) ఆదేశాలు పర్యావరణాన్ని సిద్ధం చేస్తాయి, మూలాన్ని జోడించి, ప్రతిరూపాన్ని ప్రారంభిస్తాయి. pg_chameleonకి create_replica_schema ఆర్గ్యుమెంట్ మేము ఇప్పటికే చర్చించినట్లుగా, PostgreSQL డేటాబేస్‌లో డిఫాల్ట్ స్కీమా (sch_chameleon) మరియు రెప్లికేషన్ స్కీమా (pgworld_x)ని సృష్టిస్తుంది. 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

షో_స్టేటస్ ఆర్గ్యుమెంట్ ఉపయోగించి రెప్లికేషన్ స్థితిని ప్రశ్నించవచ్చు మరియు షో_ఎర్రర్స్ ఆర్గ్యుమెంట్ ఉపయోగించి లోపాలను వీక్షించవచ్చు.

ఫలితం.

మేము ఇప్పటికే చెప్పినట్లుగా, ప్రతి రెప్లికేషన్ ఫంక్షన్ డెమోన్లచే నియంత్రించబడుతుంది. వాటిని వీక్షించడానికి, క్రింద చూపిన విధంగా, మేము Linux ps కమాండ్‌తో ప్రాసెస్ పట్టికను ప్రశ్నిస్తాము.

ఫలితం.

దిగువ చూపిన విధంగా మేము దానిని నిజ సమయంలో పరీక్షించే వరకు ప్రతిరూపణ కాన్ఫిగర్ చేయబడినట్లు పరిగణించబడదు. మేము ఒక టేబుల్‌ని సృష్టిస్తాము, MySQL డేటాబేస్‌లో కొన్ని రికార్డ్‌లను ఇన్‌సర్ట్ చేస్తాము మరియు డెమోన్‌లను అప్‌డేట్ చేయడానికి మరియు పోస్ట్‌గ్రెస్‌ఎస్‌క్యూఎల్ డేటాబేస్‌కు రికార్డ్‌లతో టేబుల్‌ను రెప్లికేట్ చేయడానికి pg_chameleonలోని సింక్_టేబుల్స్ ఆర్గ్యుమెంట్‌ని పిలుస్తాము.

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 ఆదేశాలు దాని ముగింపుగా ఉంటాయి. అన్ని లక్ష్య పట్టికల వరుసలు ప్రతిరూపం పొందాయని మేము నిర్ధారించుకున్న తర్వాత కమాండ్‌లను అమలు చేయాలి మరియు ఫలితం మూలాధార డేటాబేస్ లేదా రెప్లికేషన్ స్కీమ్ (sch_chameleon)కి సూచనలు లేకుండానే చక్కగా తరలించబడిన PostgreSQL డేటాబేస్ అవుతుంది.

$> 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 కోసం ఫలితాలు

MySQL నుండి PostgreSQLకి డేటాబేస్‌ను తరలించడానికి pg_chameleonలోని ప్రతిరూపణ పద్ధతి చాలా బాగుంది. ముఖ్యమైన ప్రతికూలత ఏమిటంటే రెప్లికేషన్ అనేది ఒక-మార్గం మాత్రమే, కాబట్టి డేటాబేస్ నిపుణులు దీన్ని మైగ్రేషన్ కాకుండా మరేదైనా ఉపయోగించాలనుకోరు. కానీ వన్-వే రెప్లికేషన్ సమస్య మరొక ఓపెన్ సోర్స్ సాధనంతో పరిష్కరించబడుతుంది - SymmetricDS.

అధికారిక డాక్యుమెంటేషన్‌లో మరింత చదవండి ఇక్కడ. కమాండ్ లైన్ సహాయం కనుగొనవచ్చు ఇక్కడ.

SymmetricDS యొక్క అవలోకనం

SymmetricDS అనేది ఏదైనా ఇతర సాధారణ డేటాబేస్‌కు ఏదైనా డేటాబేస్‌ను ప్రతిబింబించే ఓపెన్ సోర్స్ సాధనం: Oracle, MongoDB, PostgreSQL, MySQL, SQL సర్వర్, MariaDB, DB2, Sybase, Greenplum, Informix, H2, Firebird మరియు ఇతర క్లౌడ్ డేటాబేస్ సందర్భాలు, ఉదా. అజూర్, మొదలైనవి అందుబాటులో ఉన్న లక్షణాలు: డేటాబేస్ మరియు ఫైల్ సింక్రొనైజేషన్, మల్టీ-మాస్టర్ డేటాబేస్ రెప్లికేషన్, ఫిల్టర్ చేసిన సింక్రొనైజేషన్, ట్రాన్స్‌ఫర్మేషన్ మరియు ఇతరులు. ఇది జావా సాధనం మరియు JRE లేదా JDK (వెర్షన్ 8.0 లేదా అంతకంటే ఎక్కువ) యొక్క ప్రామాణిక విడుదల అవసరం. ఇక్కడ, సోర్స్ డేటాబేస్‌లోని ట్రిగ్గర్‌లకు డేటా మార్పులు రికార్డ్ చేయబడతాయి మరియు బ్యాచ్‌ల రూపంలో తగిన లక్ష్య డేటాబేస్‌కు పంపబడతాయి.

SymmetricDS లక్షణాలు

సాధనం ప్లాట్‌ఫారమ్ స్వతంత్రమైనది, అంటే రెండు లేదా అంతకంటే ఎక్కువ విభిన్న డేటాబేస్‌లు డేటాను మార్పిడి చేయగలవు.
రిలేషనల్ డేటాబేస్‌లు డేటా మార్పు రికార్డులను ఉపయోగించి సమకాలీకరించబడతాయి, అయితే ఫైల్ సిస్టమ్-ఆధారిత డేటాబేస్‌లు ఫైల్ సింక్రొనైజేషన్‌ను ఉపయోగిస్తాయి.
నియమాల సమితి ఆధారంగా పుష్ మరియు పుల్ పద్ధతులను ఉపయోగించి రెండు-మార్గం ప్రతిరూపణ.
సురక్షితమైన మరియు తక్కువ-బ్యాండ్‌విడ్త్ నెట్‌వర్క్‌ల ద్వారా డేటా బదిలీ సాధ్యమవుతుంది.
వైఫల్యం మరియు స్వయంచాలక సంఘర్షణ రిజల్యూషన్ తర్వాత నోడ్‌లు మళ్లీ ఆపరేషన్‌ను ప్రారంభించినప్పుడు స్వయంచాలకంగా పునరుద్ధరణ.
క్లౌడ్ అనుకూలత మరియు శక్తివంతమైన పొడిగింపు APIలు.

ఉదాహరణకు

SymmetricDS రెండు మార్గాలలో ఒకదానిలో కాన్ఫిగర్ చేయబడుతుంది:
రెండు స్లేవ్ (చైల్డ్) నోడ్‌ల మధ్య డేటా రెప్లికేషన్‌ను కేంద్రంగా సమన్వయం చేసే మాస్టర్ (పేరెంట్) నోడ్ మరియు చైల్డ్ నోడ్‌ల మధ్య కమ్యూనికేషన్ పేరెంట్ ద్వారా మాత్రమే జరుగుతుంది.
క్రియాశీల నోడ్ (నోడ్ 1) మధ్యవర్తి లేకుండా మరొక క్రియాశీల నోడ్ (నోడ్ 2)తో ప్రతిరూపణ కోసం కమ్యూనికేట్ చేయగలదు.

రెండు ఎంపికలలో, పుష్ మరియు పుల్ ఉపయోగించి డేటా మార్పిడి జరుగుతుంది. ఈ ఉదాహరణలో మేము యాక్టివ్-యాక్టివ్ కాన్ఫిగరేషన్‌ను పరిశీలిస్తాము. మొత్తం నిర్మాణాన్ని వివరించడానికి చాలా సమయం పడుతుంది, కాబట్టి మీ పరిశోధన చేయండి. గైడ్SymmetricDS పరికరం గురించి మరింత తెలుసుకోవడానికి.

SymmetricDS ఇన్‌స్టాల్ చేయడం చాలా సులభం: జిప్ ఫైల్ యొక్క ఓపెన్ సోర్స్ వెర్షన్‌ను డౌన్‌లోడ్ చేయండి ఇక్కడ నుండి మరియు మీకు కావలసిన చోటికి తీసుకెళ్లండి. దిగువ పట్టిక ఈ ఉదాహరణలో ఇన్‌స్టాలేషన్ స్థానం మరియు 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 వెర్షన్
సిమెట్రిక్డిఎస్ 3.9
సిమెట్రిక్డిఎస్ 3.9

SymmetricDS ఇన్‌స్టాలేషన్ మార్గం
/usr/local/symmetric-server-3.9.20
/usr/local/symmetric-server-3.9.20

SymmetricDS నోడ్ పేరు
corp-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 సమకాలీకరణ కోసం నోడ్‌కు కనెక్షన్ యొక్క స్థానాన్ని చూపుతుంది.

హోస్ట్ vm2లోని నోడ్ 2 స్టోర్-001గా కాన్ఫిగర్ చేయబడింది మరియు మిగిలినది దిగువన ఉన్న node.properties ఫైల్‌లో పేర్కొనబడింది. నోడ్ స్టోర్-001 PostgreSQL డేటాబేస్‌ను నడుపుతుంది మరియు pgdb_replica అనేది రెప్లికేషన్ డేటాబేస్. register.url హోస్ట్ vm2ని హోస్ట్ 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 పట్టికలతో ఉదాహరణ స్కీమాను సృష్టిస్తుంది. symadmin కమాండ్‌తో 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

ఉదాహరణలో, అంశం మరియు item_selling_price పట్టికలు స్వయంచాలకంగా corp-000 నుండి store-001కి ప్రతిరూపం అయ్యేలా కాన్ఫిగర్ చేయబడతాయి మరియు సేల్ టేబుల్‌లు (sale_transaction మరియు sale_return_line_item) స్వయంచాలకంగా store-001 నుండి corp-000కి ప్రతిరూపం అయ్యేలా కాన్ఫిగర్ చేయబడతాయి. ఇప్పుడు మేము corp-2 నుండి డేటాను స్వీకరించడానికి దానిని సిద్ధం చేయడానికి హోస్ట్ vm001 (స్టోర్-000)లో PostgreSQL డేటాబేస్‌లో స్కీమాను సృష్టిస్తాము.

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_తో ప్రిఫిక్స్ చేయబడినవి) ప్రస్తుతం node corp-000లో మాత్రమే అందుబాటులో ఉన్నాయని గుర్తుంచుకోండి ఎందుకంటే ఇక్కడే మేము create-sym-tables కమాండ్‌ని అమలు చేసాము మరియు ప్రతిరూపణను నిర్వహిస్తాము. మరియు నోడ్ స్టోర్-001లోని డేటాబేస్లో డేటా లేకుండా కేవలం 4 ఉదాహరణ పట్టికలు మాత్రమే ఉంటాయి.

అన్నీ. దిగువ చూపిన విధంగా రెండు నోడ్‌లలో సిమ్ సర్వర్ ప్రక్రియలను అమలు చేయడానికి పర్యావరణం సిద్ధంగా ఉంది.

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

లాగ్ ఎంట్రీలు SymmetricDS ఇన్‌స్టాల్ చేయబడిన డైరెక్టరీలోని లాగ్‌ల ఫోల్డర్‌లోని నేపథ్య లాగ్ ఫైల్ (symmetric.log)కి అలాగే ప్రామాణిక అవుట్‌పుట్‌కి పంపబడతాయి. సిమ్ సర్వర్ ఇప్పుడు నోడ్ స్టోర్-001లో ప్రారంభించబడుతుంది.

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

మీరు vm2 హోస్ట్‌లో సిమ్ సర్వర్ ప్రాసెస్‌ను అమలు చేస్తే, అది PostgreSQL డేటాబేస్‌లో SymmetricDS కేటలాగ్ పట్టికలను కూడా సృష్టిస్తుంది. మీరు రెండు నోడ్‌లలో సిమ్ సర్వర్ ప్రాసెస్‌ను అమలు చేస్తే, corp-000 నుండి స్టోర్-001 వరకు డేటాను ప్రతిబింబించడానికి అవి ఒకదానితో ఒకటి సమన్వయం చేసుకుంటాయి. కొన్ని సెకన్ల తర్వాత మేము రెండు వైపులా ఉన్న మొత్తం 4 పట్టికలను ప్రశ్నిస్తే, ప్రతిరూపణ విజయవంతమైందని మనం చూస్తాము. లేదా మీరు కింది ఆదేశంతో corp-001 నుండి node store-000కి బూట్‌స్ట్రాప్‌ను పంపవచ్చు.

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

ఈ సమయంలో, నోడ్ corp-000 (హోస్ట్: vm1)లోని MySQL డేటాబేస్‌లోని ఐటెమ్ టేబుల్‌లో కొత్త రికార్డ్ చొప్పించబడింది మరియు మీరు నోడ్ స్టోర్-001 (హోస్ట్: vm2)లోని PostgreSQL డేటాబేస్‌కు దాని ప్రతిరూపాన్ని తనిఖీ చేయవచ్చు. corp-000 నుండి store-001కి డేటాను తరలించడానికి మేము పుల్ ఆపరేషన్‌ని చూస్తాము.

mysql> insert into item values ('22000002','Jelly Bean');
Query OK, 1 row affected (0.00 sec)

vm2$> psql -p 5832 -U postgres pgdb_replica -c "select * from item"
 item_id  |   name
----------+-----------
 11000001 | Yummy Gum
 22000002 | Jelly Bean
(2 rows)

స్టోర్-001 నుండి కార్ప్-000కి డేటాను తరలించడానికి పుష్ ఆపరేషన్ చేయడానికి, మేము sale_ట్రాన్సాక్షన్ టేబుల్‌లో రికార్డ్‌ను ఇన్‌సర్ట్ చేస్తాము మరియు రెప్లికేషన్ విజయవంతమైందని ధృవీకరిస్తాము.

ఫలితం.

MySQL మరియు PostgreSQL డేటాబేస్‌ల మధ్య ఉదాహరణ పట్టికల యొక్క రెండు-మార్గం ప్రతిరూపణ యొక్క విజయవంతమైన సెటప్‌ను మేము చూస్తాము. కొత్త వినియోగదారు పట్టికల కోసం ప్రతిరూపాన్ని సెటప్ చేయడానికి, ఈ దశలను అనుసరించండి: మేము ఉదాహరణకు టేబుల్ t1ని సృష్టిస్తాము మరియు దాని ప్రతిరూపణ నియమాలను క్రింది విధంగా కాన్ఫిగర్ చేస్తాము. ఈ విధంగా మేము 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 కమాండ్‌ని ఉపయోగించి, టేబుల్ నిర్వచనాలను మ్యాప్ చేయడానికి ట్రిగ్గర్‌లను పునఃసృష్టిస్తుంది. స్కీమా మార్పులను నోడ్ స్టోర్-001కి పంపడానికి send-schema అమలు చేయబడుతుంది మరియు టేబుల్ 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 వాడుక సూచిక సిమెట్రిక్‌డిఎస్‌తో రెప్లికేషన్‌ను సెటప్ చేయడంలో ఉన్న వివిధ భావనలను వివరంగా వివరిస్తుంది.

మూలం: www.habr.com