Oracle और MySQL से प्रतिकृति समाधान की तुलना करना

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

इस पोस्ट में, हम ग्रह पर दो सबसे लोकप्रिय डेटाबेस सिस्टम (डीबी-इंजन के अनुसार) में प्रतिकृति कार्यक्षमता की तुलना करने जा रहे हैं - ओरेकल और माईएसक्यूएल। हम विशेष रूप से Oracle 12c तार्किक प्रतिकृति और MySQL 5.7 को देखेंगे। दोनों प्रौद्योगिकियां उत्पादन कार्यभार को उतारने और आपदा के मामले में मदद करने के लिए विश्वसनीय स्टैंडबाय सिस्टम प्रदान करती हैं। हम उनके विभिन्न आर्किटेक्चर पर एक नज़र डालेंगे, पेशेवरों और विपक्षों का विश्लेषण करेंगे और Oracle और MySQL के साथ प्रतिकृति सेटअप करने के तरीके के बारे में जानेंगे।

Oracle डेटा गार्ड आर्किटेक्चर - यह कैसे काम करता है

Oracle डेटा गार्ड आपके डेटा की उच्च उपलब्धता, डेटा सुरक्षा और आपदा पुनर्प्राप्ति का आश्वासन देता है। डेटा की नकल करने के लिए यह शायद Oracle DBA की पहली पसंद है। प्रौद्योगिकी को 1990 (संस्करण 7.0) में स्टैंडबाय डेटाबेस पर संग्रह लॉग के एक अनिवार्य अनुप्रयोग के साथ पेश किया गया था। डेटा गार्ड वर्षों में विकसित हुआ और अब सेवाओं का एक व्यापक सेट प्रदान करता है जो स्टैंडबाय डेटाबेस बनाता है, बनाए रखता है, प्रबंधित करता है और मॉनिटर करता है।

डेटा गार्ड उत्पादन डेटाबेस की प्रतियों के रूप में स्टैंडबाय डेटाबेस रखता है। यदि प्राथमिक डेटाबेस प्रत्युत्तर देना बंद कर देता है, तो डेटा गार्ड किसी भी स्टैंडबाय को उत्पादन भूमिका में बदल सकता है, इस प्रकार डाउनटाइम। डेटा गार्ड का उपयोग उच्च स्तर की डेटा सुरक्षा और डेटा उपलब्धता प्रदान करने के लिए बैकअप, बहाली और क्लस्टर तकनीकों के लिए किया जा सकता है।

डेटा गार्ड एक शिप रेडो / अप्लाई रेडो तकनीक है, "फिर से करें" लेनदेन को पुनर्प्राप्त करने के लिए आवश्यक जानकारी है। एक उत्पादन डेटाबेस को प्राथमिक डेटाबेस के रूप में संदर्भित किया जाता है जो स्टैंडबाय डेटाबेस के रूप में संदर्भित एक या अधिक प्रतिकृतियों को फिर से प्रसारित करता है। जब किसी तालिका में कोई सम्मिलित या अद्यतन किया जाता है, तो यह परिवर्तन लॉग लेखक द्वारा संग्रह लॉग में कैप्चर किया जाता है, और स्टैंडबाय सिस्टम में दोहराया जाता है। स्टैंडबाय डेटाबेस प्राथमिक डेटाबेस के साथ सिंक्रनाइज़ेशन बनाए रखने के लिए पुनर्प्राप्ति, सत्यापन और पुन:लागू करने के निरंतर चरण में हैं। एक स्टैंडबाय डेटाबेस भी स्वचालित रूप से फिर से सिंक्रनाइज़ हो जाएगा यदि यह अस्थायी रूप से बिजली की कमी, नेटवर्क समस्याओं आदि के कारण प्राथमिक से डिस्कनेक्ट हो जाता है।

Oracle डेटा गार्ड नेट सेवाएं

डेटा गार्ड रेडो ट्रांसपोर्ट सर्विसेज प्राथमिक डेटाबेस से स्टैंडबाय डेटाबेस में रीडो के प्रसारण को नियंत्रित करती है। LGWR (लॉग राइटर) प्रक्रिया एक या अधिक नेटवर्क सर्वर (LNS1, LSN2, LSN3, ...LSNn) प्रक्रियाओं के लिए डेटा को फिर से सबमिट करती है। एलएनएस एसजीए (साझा वैश्विक क्षेत्र) में रीडो बफर से पढ़ रहा है और स्टैंडबाय डेटाबेस में संचारित करने के लिए ओरेकल नेट सर्विसेज को फिर से भेजता है। आप LGWR विशेषताएँ चुन सकते हैं:सिंक्रोनस (LogXptMode ='SYNC') या एसिंक्रोनस मोड (LogXptMode ='ASYNC')। इस तरह के आर्किटेक्चर के साथ कई स्टैंडबाय डेटाबेस में फिर से डेटा देना संभव है या इसे Oracle RAC (रियल एप्लिकेशन क्लस्टर) के साथ उपयोग करना संभव है। रिमोट फाइल सर्वर (आरएफएस) प्रक्रिया एलएनएस से फिर से प्राप्त करती है और इसे एक नियमित फाइल में लिखती है जिसे स्टैंडबाय रीडो लॉग (एसआरएल) फाइल कहा जाता है।

Oracle डेटा गार्ड के दो प्रमुख प्रकार हैं। फिर से लागू करने के साथ भौतिक और SQL के साथ तार्किक स्टैंडबाय डेटाबेस लागू होते हैं।

Oracle Dataguard तार्किक प्रतिकृति वास्तुकला

SQL लागू को फिर से लागू करने की तुलना में अधिक प्रसंस्करण की आवश्यकता होती है, प्रक्रिया पहले SRL और "माइन" रीडो को तार्किक परिवर्तन रिकॉर्ड में परिवर्तित करके पढ़ती है, और फिर SQL को स्टैंडबाय डेटाबेस में लागू करने से पहले SQL लेनदेन का निर्माण करती है। अधिक चलने वाले हिस्से हैं इसलिए इसे अधिक CPU, मेमोरी और I/O की आवश्यकता होती है, फिर से लागू करें।

"एसक्यूएल लागू" का मुख्य लाभ यह है कि डेटाबेस पढ़ने-लिखने के लिए खुला है, जबकि आवेदन प्रक्रिया सक्रिय है।

तुम भी विचार और स्थानीय अनुक्रमणिका बना सकते हैं। यह रिपोर्टिंग टूल के लिए इसे आदर्श बनाता है। स्टैंडबाय डेटाबेस का आपके प्राथमिक डेटाबेस की एक से एक प्रति होना जरूरी नहीं है, और इसलिए यह डीआर उद्देश्यों के लिए सबसे अच्छा उम्मीदवार नहीं हो सकता है।

इस समाधान की प्रमुख विशेषताएं हैं:

एक स्टैंडबाय डेटाबेस जो SQL लागू होने पर पढ़ने-लिखने के लिए खोला गया है, सक्रिय है
एसक्यूएल द्वारा बनाए रखा जा रहा डेटा का संभावित संशोधन लॉक लागू होता है
रोलिंग डेटाबेस अपग्रेड निष्पादित करने में सक्षम

कमियां हैं। तार्किक स्टैंडबाय डेटाबेस में एक संशोधित पंक्ति को तार्किक रूप से पहचानने के लिए Oracle प्राथमिक-कुंजी या अद्वितीय-बाधा/सूचकांक पूरक लॉगिंग का उपयोग करता है। जब डेटाबेस-व्यापी प्राथमिक-कुंजी और अद्वितीय-बाधा/सूचकांक पूरक लॉगिंग सक्षम होती है, तो प्रत्येक अद्यतन विवरण तार्किक स्टैंडबाय डेटाबेस में संशोधित पंक्ति को विशिष्ट रूप से पहचानने के लिए रीडो लॉग में आवश्यक कॉलम मान भी लिखता है। Oracle डेटा गार्ड जंजीर प्रतिकृति का समर्थन करता है, जिसे यहां "कैस्केड" कहा जाता है, हालांकि यह सेटअप की जटिलता के कारण विशिष्ट नहीं है।

Oracle अनुशंसा करता है कि आप प्राथमिक डेटाबेस में तालिकाओं में एक प्राथमिक कुंजी या एक गैर-शून्य अद्वितीय अनुक्रमणिका जोड़ें, जब भी संभव हो, यह सुनिश्चित करने के लिए कि SQL लागू तार्किक स्टैंडबाय डेटाबेस में डेटा अपडेट को कुशलतापूर्वक लागू कर सकता है। इसका मतलब है कि यह किसी भी सेटअप पर काम नहीं करता है, आपको अपने आवेदन को संशोधित करने की आवश्यकता हो सकती है।

ओरेकल गोल्डन गेट आर्किटेक्चर - यह कैसे काम करता है

डेटा गार्ड के साथ, जैसे ही डेटाबेस में ब्लॉक बदलते हैं, रिकॉर्ड फिर से लॉग में जोड़े जाते हैं। फिर आपके द्वारा चलाए जा रहे प्रतिकृति मोड के आधार पर, इन लॉग रिकॉर्ड्स को या तो तुरंत स्टैंडबाय में कॉपी किया जाएगा या SQL कमांड के लिए खनन किया जाएगा और लागू किया जाएगा। गोल्डन गेट एक अलग तरीके से काम करता है।

गोल्डन गेट केवल लेन-देन के प्रतिबद्ध होने के बाद परिवर्तनों को दोहराता है, इसलिए यदि आपके पास लंबे समय तक चलने वाला लेनदेन है, तो इसे दोहराने में कुछ समय लग सकता है। गोल्डन गेट "एक्सट्रैक्ट प्रोसेस" मेमोरी में ट्रांजेक्शनल बदलाव रखता है।

एक और बड़ा अंतर यह है कि ओरेकल गोल्डन गेट कई, विषम प्लेटफार्मों के बीच लेनदेन स्तर पर डेटा के आदान-प्रदान और हेरफेर को सक्षम बनाता है। आप केवल Oracle डेटाबेस तक ही सीमित नहीं हैं। यह आपको विभिन्न टोपोलॉजी में चयनित डेटा रिकॉर्ड, लेन-देन संबंधी परिवर्तन, और डीडीएल (डेटा परिभाषा भाषा) में परिवर्तन निकालने और दोहराने की सुविधा देता है।

ओरेकल गोल्डन गेट आर्किटेक्चर

विशिष्ट गोल्डन गेट प्रवाह स्रोत डेटाबेस से कैप्चर किए जा रहे नए और परिवर्तित डेटाबेस डेटा को दिखाता है। कैप्चर किया गया डेटा सोर्स ट्रेल नामक फ़ाइल में लिखा जाता है। फिर ट्रेल को एक डेटा पंप द्वारा पढ़ा जाता है, जिसे पूरे नेटवर्क में भेजा जाता है, और कलेक्टर प्रक्रिया द्वारा रिमोट ट्रेल फ़ाइल को लिखा जाता है। डिलीवरी फ़ंक्शन रिमोट ट्रेल को पढ़ता है और लक्ष्य डेटाबेस को अपडेट करता है। प्रत्येक घटक को प्रबंधक प्रक्रिया द्वारा प्रबंधित किया जाता है।

MySQL तार्किक प्रतिकृति - यह कैसे काम करता है

MySQL में प्रतिकृति लंबे समय से है और वर्षों से विकसित हो रही है। समूह प्रतिकृति, गैलेरा क्लस्टर, एसिंक्रोनस "मास्टर टू स्लेव" सहित MySQL प्रतिकृति को सक्षम करने के विभिन्न तरीके हैं। Oracle बनाम MySQL आर्किटेक्चर की तुलना करने के लिए, हम प्रतिकृति स्वरूपों पर ध्यान केंद्रित करेंगे क्योंकि यह सभी विभिन्न प्रतिकृति प्रकारों के लिए आधार है।

सबसे पहले, विभिन्न प्रतिकृति प्रारूप my.cnf कॉन्फ़िगरेशन फ़ाइल में निर्दिष्ट बाइनरी लॉगिंग प्रारूप के अनुरूप हैं। प्रारूप के बावजूद, लॉग हमेशा बाइनरी तरीके से संग्रहीत होते हैं, नियमित संपादक के साथ देखने योग्य नहीं होते हैं। तीन प्रारूप प्रकार हैं:पंक्ति-आधारित, कथन आधारित और मिश्रित। मिश्रित पहले दो का संयोजन है। हम कथन और पंक्ति आधारित पर एक नज़र डालेंगे।

कथन आधारित - इस मामले में ये लिखित प्रश्न हैं। डेटा को संशोधित करने वाले सभी कथन (जैसे INSERT DELETE, UPDATE, और REPLACE कथन) को कथन-आधारित प्रतिकृति का उपयोग करके दोहराया नहीं जा सकता है। LOAD_FILE (), UUID (), UUID_SHORT (), USER (), FOUND_ROWS () आदि को दोहराया नहीं जाएगा।

पंक्ति-आधारित - इस मामले में, ये रिकॉर्ड में परिवर्तन हैं। सभी परिवर्तनों को दोहराया जा सकता है। यह प्रतिकृति का सबसे सुरक्षित रूप है। 5.7.7 के बाद से, यह डिफ़ॉल्ट विकल्प है।

अब देखते हैं कि प्रतिकृति सक्षम होने पर हुड के नीचे क्या हो रहा है।

MySQL प्रतिकृति वास्तुकला

सबसे पहले, मास्टर डेटाबेस बाइनरी लॉग या बिनलॉग नामक फ़ाइल में परिवर्तन लिखता है। बाइनरी लॉग को लिखना आमतौर पर एक हल्की गतिविधि होती है क्योंकि राइट बफ़र और अनुक्रमिक होते हैं। बाइनरी लॉग फ़ाइल डेटा संग्रहीत करती है जिसे एक प्रतिकृति दास बाद में संसाधित करेगा, मास्टर गतिविधि उन पर निर्भर नहीं करती है। जब प्रतिकृति शुरू होती है, तो mysql तीन थ्रेड्स को ट्रिगर करेगा। एक मालिक पर, दो गुलाम पर। मास्टर के पास एक थ्रेड होता है, जिसे डंप थ्रेड कहा जाता है, जो मास्टर के बाइनरी लॉग को पढ़ता है और उसे स्लेव को डिलीवर करता है।

दास पर, आईओ थ्रेड नामक एक प्रक्रिया मास्टर से जुड़ती है, मास्टर से बाइनरी लॉग ईवेंट पढ़ती है क्योंकि वे आते हैं और उन्हें रिले लॉग नामक स्थानीय लॉग फ़ाइल में कॉपी करते हैं। दूसरी स्लेव प्रक्रिया - SQL थ्रेड - प्रतिकृति स्लेव पर स्थानीय रूप से संग्रहीत रिले लॉग से घटनाओं को पढ़ती है और फिर उनका उपयोग करती है।

MySQL जंजीर प्रतिकृति का समर्थन करता है, जिसे सेटअप करना बहुत आसान है। दास जो स्वामी भी हैं उन्हें --log-bin और --log-slave-update पैरामीटर के साथ चलना चाहिए।

प्रतिकृति की स्थिति की जांच करने और धागे के बारे में जानकारी प्राप्त करने के लिए, आप दास पर चलते हैं:

MariaDB [(none)]> show slave status\G
*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                 Master_Host: master
                  Master_User: rpl_user
                  Master_Port: 3306
                Connect_Retry: 10
              Master_Log_File: binlog.000005
          Read_Master_Log_Pos: 339
               Relay_Log_File: relay-bin.000002
                Relay_Log_Pos: 635
        Relay_Master_Log_File: binlog.000005
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB: 
          Replicate_Ignore_DB: 
           Replicate_Do_Table: 
       Replicate_Ignore_Table: 
      Replicate_Wild_Do_Table: 
  Replicate_Wild_Ignore_Table: 
                   Last_Errno: 0
                   Last_Error: 
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 339
              Relay_Log_Space: 938
              Until_Condition: None
               Until_Log_File: 
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File: 
           Master_SSL_CA_Path: 
              Master_SSL_Cert: 
            Master_SSL_Cipher: 
               Master_SSL_Key: 
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error: 
               Last_SQL_Errno: 0
               Last_SQL_Error: 
  Replicate_Ignore_Server_Ids: 
             Master_Server_Id: 1
               Master_SSL_Crl: 
           Master_SSL_Crlpath: 
                   Using_Gtid: Current_Pos
                  Gtid_IO_Pos: 0-1-8
      Replicate_Do_Domain_Ids: 
  Replicate_Ignore_Domain_Ids: 
                Parallel_Mode: conservative
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Slave has read all relay log; waiting for the slave I/O thread to update it
1 row in set (0.00 sec)

Oracle में डेटा गार्ड लॉजिकल रेप्लिकेशन सेट करना

भौतिक स्टैंडबाय डेटाबेस बनाएं

एक तार्किक स्टैंडबाय डेटाबेस बनाने के लिए, आप पहले एक भौतिक स्टैंडबाय डेटाबेस बनाते हैं और फिर इसे एक तार्किक स्टैंडबाय डेटाबेस में परिवर्तित करते हैं।
भौतिक स्टैंडबाय डेटाबेस पर फिर से लागू करना रोकें

परिवर्तनों को लागू करने से बचने के लिए Redo Apply को रोकना आवश्यक है।
```
SQL> ALTER DATABASE RECOVER MANAGED STANDBY DATABASE CANCEL;
```
एक तार्किक स्टैंडबाय डेटाबेस का समर्थन करने के लिए प्राथमिक डेटाबेस तैयार करें

मूल LOG_ARCHIVE_DEST_1 में VALID_FOR विशेषता बदलें और तार्किक डेटाबेस के लिए LOG_ARCHIVE_DEST_3 जोड़ें।
```
LOG_ARCHIVE_DEST_1=
 'LOCATION=/arch1/severalnines/
  VALID_FOR=(ONLINE_LOGFILES,ALL_ROLES)
  DB_UNIQUE_NAME=severalnines'
LOG_ARCHIVE_DEST_3=
 'LOCATION=/arch2/severalnines/
  VALID_FOR=(STANDBY_LOGFILES,STANDBY_ROLE)
  DB_UNIQUE_NAME=severalnines'
LOG_ARCHIVE_DEST_STATE_3=ENABLE
```
फिर से करें डेटा में एक शब्दकोश बनाएं
```
SQL> EXECUTE DBMS_LOGSTDBY.BUILD;
```
लॉजिकल स्टैंडबाय डेटाबेस में कनवर्ट करें

भौतिक स्टैंडबाय डेटाबेस में फिर से डेटा लागू करना जारी रखने के लिए जब तक कि यह तार्किक स्टैंडबाय डेटाबेस में कनवर्ट करने के लिए तैयार न हो, निम्न SQL कथन जारी करें:
```
SQL> ALTER DATABASE RECOVER TO LOGICAL STANDBY db_name;
```

लॉजिकल स्टैंडबाय डेटाबेस के लिए आरंभीकरण पैरामीटर समायोजित करें

LOG_ARCHIVE_DEST_1=
  'LOCATION=/arch1/severalnines_remote/
   VALID_FOR=(ONLINE_LOGFILES,ALL_ROLES)
   DB_UNIQUE_NAME=severalnines_remote'
LOG_ARCHIVE_DEST_2=
  'SERVICE=severalnines ASYNC
   VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE)
   DB_UNIQUE_NAME=severalnines'
LOG_ARCHIVE_DEST_3=
  'LOCATION=/arch2/severalnines_remote/
VALID_FOR=(STANDBY_LOGFILES,STANDBY_ROLE)
   DB_UNIQUE_NAME=severalnines_remote'
LOG_ARCHIVE_DEST_STATE_1=ENABLE
LOG_ARCHIVE_DEST_STATE_2=ENABLE
LOG_ARCHIVE_DEST_STATE_3=ENABLE

लॉजिकल स्टैंडबाय डेटाबेस खोलें

SQL> ALTER DATABASE OPEN RESETLOGS;

सत्यापित करें कि तार्किक स्टैंडबाय डेटाबेस ठीक से काम कर रहा है

v$data_guard_stats व्यू

SQL> COL NAME FORMAT A20
SQL> COL VALUE FORMAT A12
SQL> COL UNIT FORMAT A30
SQL> SELECT NAME, VALUE, UNIT FROM V$Data_Guard_STATS;
 NAME                 VALUE        UNIT
-------------------- ------------ ------------------------------
apply finish time    +00 00:00:00 day(2) to second(1) interval
apply lag            +00 00:00:00 day(2) to second(0) interval
transport lag        +00 00:00:00 day(2) to second(0) interval

v$logstdby_process दृश्य

SQL> COLUMN SERIAL# FORMAT 9999
SQL> COLUMN SID FORMAT 9999
SQL> SELECT SID, SERIAL#, SPID, TYPE, HIGH_SCN FROM V$LOGSTDBY_PROCESS;
   SID   SERIAL#   SPID         TYPE            HIGH_SCN
  ----- -------   ----------- ---------------- ----------
48        6    11074        COORDINATOR     7178242899
   56       56    10858        READER          7178243497
   46        1    10860        BUILDER         7178242901
   45        1    10862        PREPARER        7178243295
   37        1    10864        ANALYZER        7178242900
   36        1    10866        APPLIER         7178239467
   35        3    10868        APPLIER         7178239463
   34        7    10870        APPLIER         7178239461
   33        1    10872        APPLIER         7178239472
 9 rows selected.

Oracle डेटा गार्ड तार्किक प्रतिकृति बनाने के लिए ये आवश्यक कदम हैं। यदि आप इस ऑपरेशन को गैर-डिफ़ॉल्ट संगतता सेट या Oracle RAC वातावरण में चलने वाले डेटाबेस के साथ करते हैं तो क्रियाएँ थोड़ी भिन्न होंगी।

MySQL प्रतिकृति सेट करना

मास्टर डेटाबेस कॉन्फ़िगर करें। अद्वितीय सर्वर_आईडी सेट करें, विभिन्न प्रतिकृति लॉग निर्दिष्ट करें - लॉग-बेसनाम (मारियाडीबी), बाइनरी लॉग सक्रिय करें। नीचे दी गई जानकारी के साथ my.cnf फ़ाइल को संशोधित करें।
```
log-bin
server_id=1
log-basename=master1
```
मास्टर डेटाबेस में लॉग इन करें और प्रतिकृति उपयोगकर्ता को मास्टर डेटा तक पहुंचने की अनुमति दें।
```
GRANT REPLICATION SLAVE ON *.* TO replication_user
```
सक्षम GTID वाले दोनों सर्वर प्रारंभ करें।
```
gtid_mode=ON
enforce-gtid-consistency=true
```

GTID-आधारित ऑटो-पोजिशनिंग का उपयोग करने के लिए स्लेव को कॉन्फ़िगर करें।

mysql> CHANGE MASTER TO
     >     MASTER_HOST = host,
     >     MASTER_PORT = port,
     >     MASTER_USER = replication_user,
     >     MASTER_PASSWORD = password,
     >     MASTER_AUTO_POSITION = 1;

यदि आप डेटा के साथ मास्टर में दास जोड़ना चाहते हैं, तो आपको बैकअप लेना होगा और इसे दास सर्वर पर पुनर्स्थापित करना होगा।
```
mysqldump --all-databases --single-transaction --triggers --routines --host=127.0.0.1 --user=root --password=rootpassword > dump_replication.sql
```
स्लेव डेटाबेस में लॉग इन करें और निष्पादित करें:
```
slave> tee dump_replication_insert.log
slave> source dump_replication.sql
slave> CHANGE MASTER TO MASTER_HOST="host", MASTER_USER=" replication_user ", MASTER_PASSWORD="password ", MASTER_PORT=port, MASTER_AUTO_POSITION = 1;
```