Pg_chameleon टूल का उपयोग करके MySQL के लिए Percona सर्वर से PostgreSQL के लिए प्रतिकृति

प्रतिकृति एक प्रसिद्ध विशेषता है जो आपको डेटाबेस की एक समान प्रतिलिपि बनाने की अनुमति देती है। यह लगभग किसी भी रिलेशनल डेटाबेस मैनेजमेंट सिस्टम (RDBMS) में समर्थित है। प्रतिकृति महत्वपूर्ण लाभ प्रदान करती है, विशेष रूप से उच्च उपलब्धता और लोड संतुलन। लेकिन क्या होगा अगर दो डेटाबेस के बीच एक अलग संरचना जैसे कि MySQL और PostgreSQL के साथ प्रतिकृति की आवश्यकता है? क्या MySQL डेटाबेस से PostgreSQL डेटाबेस में लगातार परिवर्तन की पुनरावृत्ति संभव है? इस प्रश्न का उत्तर pg_chameleon प्रतिकृति उपकरण है ।

निरंतर परिवर्तन प्रतिकृति के लिए, pg_chameleon MySQL प्रतिकृति लाइब्रेरी का उपयोग करता है, जो आपको MySQL डेटाबेस से पंक्तियों की तार्किक प्रतियाँ प्राप्त करने की अनुमति देता है, जो कि jsonb ऑब्जेक्ट में परिवर्तित हो जाती हैं। Postgres में pl / pgsql फ़ंक्शन jsonb ऑब्जेक्ट को डीकोड करता है और Postgres डेटाबेस में परिवर्तनों को पुन: उत्पन्न करता है। इस प्रकार की प्रतिकृति को कॉन्फ़िगर करने के लिए, MySQL डेटाबेस के लिए binlog_format चर को ROW (स्ट्रिंग) पर सेट किया जाना चाहिए।

इस उपकरण को स्थापित करने से पहले जानने के लिए कुछ बिंदु:

1. जिन तालिकाओं को दोहराया जाना चाहिए उनके पास एक प्राथमिक कुंजी होनी चाहिए।
2. यह टूल 9.5 से ऊपर के PostgreSQL और 5.5 से ऊपर के MySQL सिस्टम के वर्जन में काम करता है
3. इस प्रतिकृति को कॉन्फ़िगर करने के लिए, Binlog_format चर को ROW पर सेट किया जाना चाहिए।
4. पायथन संस्करण 3.3 से अधिक होना चाहिए

प्रतिकृति शुरू करते समय, pg_chameleon CSV प्रारूप में MySQL से डेटा पुनर्प्राप्त करता है और मेमोरी अधिभार से बचने के लिए एक निश्चित लंबाई के समूहों में विभाजित होता है। यह डेटा COPY कमांड के साथ Postgres में फ्लश किया जाता है। यदि प्रतिलिपि विफल हो जाती है, तो INSERT कमांड निष्पादित होती है, जो प्रक्रिया को धीमा कर सकती है। यदि INSERT आदेश विफल रहता है, तो पंक्ति खो जाती है।

MySQL से परिवर्तनों को दोहराने के लिए, pg_chameleon MySQL प्रतिकृति (दास) के व्यवहार का अनुकरण करता है। यह Postgres में एक योजना बनाता है, प्रारंभिक डेटा लोडिंग करता है, MySQL प्रतिकृति प्रोटोकॉल से जुड़ता है, और Postgres तालिका में पंक्तियों को कॉपी करता है। इसी समय, संबंधित Postgres फ़ंक्शन स्ट्रिंग डीकोडिंग और परिवर्तन प्रदान करते हैं। यह Postgres तालिकाओं में स्थानांतरण लॉग को संग्रहीत करने और उन्हें Postgres स्कीमा पर लागू करने के समान है। किसी भी डेटा विवरण भाषा का उपयोग करके पोस्टग्रेज डेटाबेस स्कीमा बनाना आवश्यक नहीं है। प्रतिकृति को कॉन्फ़िगर करते समय निर्दिष्ट तालिकाओं के लिए, pg_chameleon टूल स्वचालित रूप से ऐसा करता है। यदि आपको किसी प्रकार को किसी विशिष्ट तरीके से परिवर्तित करने की आवश्यकता है, तो आप इसे कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट कर सकते हैं।

निम्नलिखित एक व्यायाम है जिसे आप प्रयोग कर सकते हैं। यदि यह पूरी तरह से आपकी आवश्यकताओं को पूरा करता है तो दिए गए विकल्पों का उपयोग करें। हमने CentOS Linux संस्करण 7.4 पर ये परीक्षण किए।

पर्यावरण की तैयारी

MySQL के लिए Percona Server कॉन्फ़िगर करें

MySQL संस्करण 5.7 स्थापित करें और प्रतिकृति के लिए उपयुक्त विकल्प जोड़ें।

इस अभ्यास में, मैंने YUM रिपॉजिटरी का उपयोग करके MySQL संस्करण 5.7 के लिए पेरकोना सर्वर स्थापित किया।

yum install http://www.percona.com/downloads/percona-release/redhat/0.1-6/percona-release-0.1-6.noarch.rpm yum install Percona-Server-server-57 echo "mysql ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers usermod -s /bin/bash mysql sudo su - mysql 

Pg_chameleon के लिए, निम्न मापदंडों को my.cnf फ़ाइल (MySQL सर्वर मापदंडों के साथ फ़ाइल) में कॉन्फ़िगर किया जाना चाहिए। आप /etc/my.cnf फ़ाइल में निम्न विकल्प जोड़ सकते हैं

 binlog_format= ROW binlog_row_image=FULL log-bin = mysql-bin server-id = 1 

अब, my.cnf फ़ाइल में उपरोक्त मापदंडों को शामिल करने के बाद, MySQL सर्वर शुरू करें।

 $ service mysql start 

Mysqld.log फ़ाइल से रूट खाते के लिए अस्थायी पासवर्ड प्राप्त करें और mysqladmin कमांड का उपयोग करके रूट पासवर्ड रीसेट करें।

 $ grep "temporary" /var/log/mysqld.log $ mysqladmin -u root -p password 'Secret123!' 

अब MySQL डेटाबेस के अपने उदाहरण से कनेक्ट करें और एक नमूना स्कीमा / टेबल बनाएं। मैंने सत्यापन के लिए एक एम्पायर टेबल भी बनाया।

 $ wget http://downloads.mysql.com/docs/sakila-db.tar.gz $ tar -xzf sakila-db.tar.gz $ mysql -uroot -pSecret123! < sakila-db/sakila-schema.sql $ mysql -uroot -pSecret123! < sakila-db/sakila-data.sql $ mysql -uroot -pSecret123! sakila -e "create table emp (id int PRIMARY KEY, first_name varchar(20), last_name varchar(20))" 

Pg_chameleon टूल का उपयोग करके प्रतिकृति को कॉन्फ़िगर करने के लिए एक उपयोगकर्ता बनाएं और इन चरणों का पालन करके उसे उचित अधिकार प्रदान करें।

 $ mysql -uroot -p create user 'usr_replica'@'%' identified by 'Secret123!'; GRANT ALL ON sakila.* TO 'usr_replica'@'%'; GRANT RELOAD, REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'usr_replica'@'%'; FLUSH PRIVILEGES; 

MySQL सर्वर ('usr_replica' @ '%') पर एक उपयोगकर्ता बनाते समय, "IP" वर्ण को संबंधित IP पते या pg_chameleon चलाने वाले सर्वर के होस्ट नाम के साथ बदलना आवश्यक हो सकता है।

PostgreSQL कॉन्फ़िगर करें

PostgreSQL स्थापित करें और डेटाबेस की एक प्रति चलाएँ।

PostgreSQL संस्करण 10.x स्थापित करने के लिए इन चरणों का पालन करें।

 yum install https://yum.postgresql.org/10/redhat/rhel-7.4-x86_64/pgdg-centos10-10-2.noarch.rpm yum install postgresql10* su - postgres $/usr/pgsql-10/bin/initdb $ /usr/pgsql-10/bin/pg_ctl -D /var/lib/pgsql/10/data start 

जैसा कि आप निम्नलिखित लॉग से देख सकते हैं, आपको PostgreSQL में एक उपयोगकर्ता बनाने की आवश्यकता है जिसके साथ pg_chameleon PostgreSQL में संशोधित डेटा लिखने में सक्षम होगा। एक लक्ष्य डेटाबेस भी बनाएँ।

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

Pg_chameleon का उपयोग करके प्रतिकृति स्थापित करने और कॉन्फ़िगर करने के लिए चरण

स्टेज 1. इस अभ्यास में, मैंने इन चरणों का पालन करके पायथन दुभाषिया संस्करण 3.6 और pg_chameleon संस्करण 2.0.8 स्थापित किया। यदि आपके पास पहले से ही स्थापित पायथन इंटरप्रेटर का आवश्यक संस्करण है, तो आप इसे स्थापित करने के लिए चरणों को छोड़ सकते हैं। हम एक आभासी वातावरण बना सकते हैं यदि ओएस में डिफ़ॉल्ट रूप से पायथन संस्करण 3.x शामिल नहीं है।

 yum install gcc openssl-devel bzip2-devel wget cd /usr/src wget https://www.python.org/ftp/python/3.6.6/Python-3.6.6.tgz tar xzf Python-3.6.6.tgz cd Python-3.6.6 ./configure --enable-optimizations make altinstall python3.6 -m venv venv source venv/bin/activate pip install pip --upgrade pip install pg_chameleon 

स्टेज 2. इस टूल के लिए एक कॉन्फ़िगरेशन फ़ाइल की आवश्यकता होती है जहां स्रोत और लक्ष्य सर्वर के बारे में जानकारी संग्रहीत की जाएगी, और लॉग को संग्रहीत करने के लिए एक फ़ोल्डर। Pg_chameleon कॉन्फ़िगरेशन फ़ाइल टेम्पलेट और संबंधित फ़ोल्डर्स बनाने के लिए, निम्न कमांड का उपयोग करें।

 $ chameleon set_configuration_files 

जब यह आदेश निष्पादित होता है, तो निम्न परिणाम प्रदर्शित होते हैं। वे दिखाते हैं कि इस कमांड ने उस जगह पर कई फ़ोल्डर्स और फाइलें बनाईं जहां आपने इसे चलाया था।

 creating directory /var/lib/pgsql/.pg_chameleon creating directory /var/lib/pgsql/.pg_chameleon/configuration/ creating directory /var/lib/pgsql/.pg_chameleon/logs/ creating directory /var/lib/pgsql/.pg_chameleon/pid/ copying configuration example in /var/lib/pgsql/.pg_chameleon/configuration//config-example.yml 

नमूना कॉन्फ़िगरेशन फ़ाइल को किसी अन्य फ़ाइल में कॉपी करें, default.yml कहें

 $ cd .pg_chameleon/configuration/ $ cp config-example.yml default.yml 

यह वही है जो मेरी 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: "localhost" port: "5432" user: "usr_replica" password: "secret" database: "db_replica" charset: "utf8" sources: mysql: db_conn: host: "localhost" port: "3306" user: "usr_replica" password: "Secret123!" charset: 'utf8' connect_timeout: 10 schema_mappings: sakila: sch_sakila 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: 

चरण 3. कमांड का उपयोग करके एक प्रतिकृति (लक्ष्य डेटाबेस) बनाएं:

 $ chameleon create_replica_schema --debug 

उपरोक्त आदेश .gpg_chameleon / कॉन्फ़िगरेशन / default.yml फ़ाइल में निर्दिष्ट PostgreSQL डेटाबेस में एक स्कीमा और नौ तालिकाएँ बनाता है। इन तालिकाओं को स्रोत डेटाबेस से लक्ष्य तक प्रतिकृति को नियंत्रित करने की आवश्यकता होती है। उसी को अगली पत्रिका में देखा जा सकता है।

 db_replica=# \dn List of schemas Name | Owner ---------------+------------- public | postgres sch_chameleon | target_user (2 rows) db_replica=# \dt sch_chameleon.t_* List of relations Schema | Name | Type | Owner ---------------+------------------+-------+------------- sch_chameleon | t_batch_events | table | target_user sch_chameleon | t_discarded_rows | table | target_user sch_chameleon | t_error_log | table | target_user sch_chameleon | t_last_received | table | target_user sch_chameleon | t_last_replayed | table | target_user sch_chameleon | t_log_replica | table | target_user sch_chameleon | t_replica_batch | table | target_user sch_chameleon | t_replica_tables | table | target_user sch_chameleon | t_sources | table | target_user (9 rows) 

चरण 4. निम्न आदेश का उपयोग करके pg_chameleon में स्रोत डेटाबेस डेटा जोड़ें। कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट स्रोत डेटाबेस का नाम निर्दिष्ट करें। इस उदाहरण में, स्रोत डेटाबेस का नाम mysql है, और लक्ष्य Postgres डेटाबेस है, जिसे pg -conn के रूप में परिभाषित किया गया है।

 $ chameleon add_source --config default --source mysql --debug 

निर्दिष्ट कमांड को निष्पादित करने के बाद, आप देखेंगे कि मूल डेटाबेस का डेटा t_sources तालिका में जोड़ा गया है।

 db_replica=# select * from sch_chameleon.t_sources; -[ RECORD 1 ]-------+---------------------------------------------- i_id_source | 1 t_source | mysql jsb_schema_mappings | {"sakila": "sch_sakila"} enm_status | ready t_binlog_name | i_binlog_position | b_consistent | t b_paused | f b_maintenance | f ts_last_maintenance | enm_source_type | mysql v_log_table | {t_log_replica_mysql_1,t_log_replica_mysql_2} $ chameleon show_status --config default Source id Source name Type Status Consistent Read lag Last read Replay lag Last replay ----------- ------------- ------ -------- ------------ ---------- ----------- ------------ ------------- 1 mysql mysql ready Yes N/AN/A 

चरण 5. निम्नलिखित कमांड का उपयोग करके प्रतिकृति (लक्ष्य डेटाबेस) को प्रारंभ करें। स्रोत डेटाबेस निर्दिष्ट करें जिसमें से परिवर्तन PostgreSQL डेटाबेस में प्रतिकृति हैं।

 $ chameleon init_replica --config default --source mysql --debug 

आरंभ में MySQL सर्वर (स्रोत) पर निम्नलिखित कार्य शामिल हैं।

1. तालिका कैश साफ़ करें और केवल-पढ़ने के लिए लॉक सेट करें
2. स्रोत डेटाबेस के निर्देशांक प्राप्त करें
3. डेटा कॉपी करें
4. अनलॉक

उपरोक्त कमांड स्वचालित रूप से लक्ष्य पोस्टग्रेज डेटाबेस का स्कीमा बनाता है।
Default.yml फ़ाइल में, हमने निम्न स्कीमा मैपिंग (स्कीमा_ मैपिंग) का उल्लेख किया है।

 schema_mappings: sakila: sch_sakila 

लक्ष्य db_replica डेटाबेस में अब एक नया स्कॉट स्कीमा बनाया गया है।

 db_replica=# \dn List of schemas Name | Owner ---------------+------------- public | postgres sch_chameleon | usr_replica sch_sakila | usr_replica (3 rows) 

चरण 6. अब निम्नलिखित कमांड का उपयोग करके प्रतिकृति शुरू करें।

 $ chameleon start_replica --config default --source mysql 

चरण 7. निम्नलिखित कमांड का उपयोग करके प्रतिकृति स्थिति और त्रुटियों को सत्यापित करें।

 $ chameleon show_status --config default $ chameleon show_errors 

यह प्रतिकृति स्थिति जैसा दिखता है:

 $ chameleon show_status --source mysql Source id Source name Type Status Consistent Read lag Last read Replay lag Last replay ----------- ------------- ------ -------- ------------ ---------- ----------- ------------ ------------- 1 mysql mysql running No N/AN/A == Schema mappings == Origin schema Destination schema --------------- -------------------- sakila sch_sakila == Replica status == --------------------- --- Tables not replicated 0 Tables replicated 17 All tables 17 Last maintenance N/A Next maintenance N/A Replayed rows Replayed DDL Skipped rows 

अब आप देख सकते हैं कि परिवर्तन MySQL डेटाबेस से PostgreSQL डेटाबेस में लगातार दोहराया जाता है।

चरण 8. सत्यापन के लिए, आप MySQL डेटाबेस तालिका में एक रिकॉर्ड सम्मिलित कर सकते हैं जिसे हमने पोस्टग्रेज डेटाबेस में प्रतिकृति की जांच करने के लिए बनाया था।

 $ mysql -u root -pSecret123! -e "INSERT INTO sakila.emp VALUES (1,'avinash','vallarapu')" mysql: [Warning] Using a password on the command line interface can be insecure. $ psql -d db_replica -c "select * from sch_sakila.emp" id | first_name | last_name ----+------------+----------- 1 | avinash | vallarapu (1 row) 

यह उपरोक्त लॉग से देखा जा सकता है कि MySQL तालिका में डाला गया रिकॉर्ड पोस्टग्रेज डेटाबेस में तालिका में दोहराया गया था।

आप लक्ष्य स्रोत डेटाबेस में कई स्रोत प्रतिकृति डेटाबेस भी जोड़ सकते हैं।

लिंक

इस दस्तावेज़ से आप pg_chameleon में उपलब्ध कई अतिरिक्त सुविधाओं के बारे में जान सकते हैं।