Mysql replikace více databází. Co je replikace v MySQL? Na Slave serveru provádíme další akce
Replikace dat mysql umožňuje mít přesnou kopii databáze z jednoho serveru - hlavního serveru (vedoucího serveru) na jednom nebo více dalších serverech (podřízený server). Ve výchozím nastavení je replikace Mysql asynchronní.
Což znamená, že hlavní server nemá žádnou kontrolu a neví, zda podřízené servery čtou soubor protokolu a zda to dělají správně.
Existují i další typy synchronizace, synchronní a semisynchronní, kde jsou tyto procesy řízeny.
V závislosti na nastavení můžete replikovat jak celé databáze, tak jednotlivé databázové tabulky.
K čemu můžete replikaci použít:
1. Rozložení zátěže mezi hostitele pro zlepšení výkonu.
V takovém schématu bude hlavní uzel provádět operace čtení a zápisu, uzly, které mají přihlášení k hlavnímu uzlu, poskytnou základnu pro čtení, čímž odlehčíme hlavnímu serveru od operací čtení.
2. Zabezpečení dat a snadná údržba, protože slave uzel obsahuje data pouze pro čtení, změny dat o účastníkovi budou omezené, snadná údržba - možnost spouštět procesy obsluhující databázi bez přerušení provozu aplikací
3. Distribuce dat na velké vzdálenosti. Můžete vytvořit kopii dat na libovolném hostiteli bez ohledu na jeho umístění
mysql podporuje následující metody replikace:
Tradiční - metoda je založena na replikaci událostí z binárního log souboru mastera a vyžaduje log soubory. Pozice mezi hlavním a podřízeným serverem musí být synchronizovány.
Metoda využívající globální identifikátory transakcí GTID (transakční metoda)
mysql podporuje následující typy synchronizace:
asynchronní (jednosměrná synchronizace)
semisynchronní (částečná kontrola účastníků)
synchronní (plná kontrola předplatitelů)
Nastavení replikace databáze Mysql tradiční metodou
Princip činnosti
Hlavní server obsahuje zásobník log soubory, které zaznamenávají všechny změny vyskytující se v hlavní databázi, soubor popisující jména zásobník soubory a také pozici v protokolu, kde byla zaznamenána poslední kmenová data
Podřízený uzel přijímá data od nadřízeného s informacemi o jménech zásobník soubory a umístění v souboru protokolu.
Nastavení průvodce
my.ini musí obsahovat jedinečný identifikátor – číslo od 1 do 2 do 32. mocniny – 1, server-id.
Ve výchozím nastavení server-id=0, což znamená nepřijímat odběry z podřízených serverů
log-bin=mysql-bin
server-id=1
Tyto dva řádky pro začátek stačí
Poznámka: Pokud se však používá InnoDB, doporučuje se navíc přidat
innodb_flush_log_at_trx_commit=1
sync_binlog=1
A musíte zkontrolovat, zda není zakázána možnost práce se sítí a zda je nastaven parametr skip-networking
Podřízený server se připojuje k hlavnímu serveru pomocí uživatelského jména a hesla, takže nejprve vytvoříme uživatele na hlavním serveru
CREATE USER repl@%.mydomain.com IDENTIFIED BY slavepass;
GRANT REPLICATION SLAVE NA *.* TO repl@%.mydomain.com;
Podívejme se na stav
ZOBRAZIT STAV HLAVNÍHO
Pokud byla procedura pro vytváření binárních protokolů již spuštěna, pak pro tabulky InnoDB musíte nejprve zamknout tabulky v jedné z relací
SPLACHOVACÍ STOLY SE ZÁMEKEM ČTENÍ;
Pokud relaci opustíte, zámek stolu se automaticky uvolní
V další relaci získáme hodnoty jmen zásobník log a pozice
Obě hodnoty představují replikační souřadnice, na kterých musí podřízený server začít číst ze souboru v požadovaném umístění, aby mohl zahájit replikaci.
Další krok závisí na tom, zda jsou data na podřízeném serveru, data z masteru
Pokud existují, pak necháme tabulky uzamčené a vytvoříme skládka(toto je doporučený způsob při používání InnoDB)
Typ databáze zjistíte pomocí příkazu
mysqlshow -u mysql_user -p -i název-databáze
Pokud je databáze uložena v binárních souborech, lze je zkopírovat z hlavního na podřízený server
Udělejme skládka
mysqldump --all-databases --master-data dbdump.db
pro výběr základny mysqldump --databases --master-data dbdump.db
master-data parametr, automaticky přidá ZMĚNIT MISTRU NA na podřízeném uzlu, pokud parametr není přidán, musí být všechny tabulky v relaci uzamčeny ručně
Odemknout
ODEMKNOUT STOLY;
Konfigurace slave uzlu A
Přidat do my.ini server-id z osobního z hlavního az jiných uzlů
server-id=2
Vytvořte předplatné
ZMĚNIT MISTRU NA
MASTER_HOST=master_host_name,
MASTER_USER=uživatelské_jméno_replikace,
MASTER_PASSWORD=heslo_replikace,
MASTER_LOG_FILE=recorded_log_file_name,
MASTER_LOG_POS=poloha_zaznamenaneho_logu;
Při nastavování replikace s existujícími daty musíte před zahájením replikace přenést snímek z hlavního do podřízeného zařízení
Používáme mysqldump
1.Spusťte podřízený uzel pomocí --skip-slave-start parametr, který zabrání spuštění replikace
2.Importujte soubor výpisu
mysql fulldb.dump
3. Spusťte proces předplatného
START SLAVE;
Kontrola stavu replikace
ZOBRAZIT STAV SLAVE\G
Slave_IO_State: - aktuální stav podřízeného zařízení
Slave_IO_Running: - zda je datový tok čten z masteru
Slave_SQL_Running: - běží? sql dotazy, mělo by být ano
Příklad Nakonfigurujeme Master (master) server – ip 11.11.11.10 V my.ini
[
mysqld] log-bin=mysql-bin server-id=1
Vytvořte uživatele mysql -u root -p GRANT REPLICATION SLAVE ON *.* TO replica@% IDENTIFIKOVANÉ heslem; FLUSH PRIVILEGES;
Dále zamkneme všechny tabulky v databázi SPLACHOVACÍ STOLY SE ZÁMEKEM ČTENÍ;
Díváme se na stav ZOBRAZIT STAV HLAVNÍHO;
Zapamatujeme si název souboru a pozici, použijeme je na Slave serveru pro přihlášení
Na Slave B my.ini
log-bin=mysql-bin server-id=2
Vytvořte předplatné ZMĚNIT MASTER NA MASTER_HOST=11.11.11.10, MASTER_PORT=3306,
MASTER_USER=replika, MASTER_PASSWORD=heslo,
MASTER_LOG_FILE=server-mysql-bin.000002,
MASTER_LOG_POS=1151664, MASTER_CONNECT_RETRY=10;
START SLAVE;
Stav replikace ZOBRAZIT STAV SLAVE\G
Termín replikace se používá k označení mechanismu pro synchronizaci více kopií dat, který zvyšuje bezpečnost informací, odolnost proti chybám a výkon systému. Pozoruhodným příkladem je replikace databáze mezi dvěma servery.
Master-Slave replikace MySQL
V terminologii Master-Slave je master primární server s databází, zapisuje do databáze, ale čtení je distribuováno mezi master a slave v závislosti na zatížení systému, což zvyšuje odolnost proti chybám a výkon. Navíc díky tomuto přístupu je kopie databáze vždy po ruce a lze ji obnovit, pokud některý ze serverů selže.
V jakých situacích může být potřeba podřízený server? Například když přijde velké pole dat k zápisu do databáze a nadřízený server prostě nestihne číst a klient musí čekat na konec zápisu, čemuž se lze vyhnout díky podřízenému serveru.
Mohou nastat situace, kdy selže hlavní server; v tomto případě podřízený server převezme všechny funkce hlavního serveru a pracuje sám, dokud není obnoven. Klient si nejspíš ničeho nevšimne a určitě nebude čekat hodinu, dvě nebo tři, než to technik opraví.
Nastavení replikace není vůbec obtížné, protože mechanismus byl zabudován do MySQL od samého začátku.
Nastavení na hlavním serveru
Začněme úpravou konfiguračního souboru my.cnf, který se nejčastěji nachází v /etc/mysql/my.cnf. Musíte najít a odkomentovat (odstranit #), nebo napsat takové řádky.
Bind-address = 0.0.0.0 server-id = 1 log_bin = /var/log/mysql/mysql-bin.log
Důležité! Pokud již byla adresa vazby zaregistrována, je třeba ji změnit, jinak nebude možné navázat spojení mezi servery.
Ihned poté restartujeme databázi na serveru.
/etc/init.d/mysql restartujte
Nyní musíme vytvořit uživatele s právy k replikaci naší databáze, to lze provést z rootu MySQL konzole pomocí příkazu
GRANT REPLICATION SLAVE ON *.* TO "slave_user"@"%" IDENTIFIKOVANÉ BY "slave_password"; FLUSH PRIVILEGES;
Kde místo „slave_user“ a „slave_password“ musíte napsat přihlašovací jméno a heslo pro slave.
Nyní se podíváme na kmenová data
ZOBRAZIT STAV HLAVNÍHO;
Hodnoty sloupců Soubor A Pozice musíte si pamatovat, že budou použity při nastavení otroka, k čemuž nyní přecházíme.
Nastavení na Slave serveru
Prvním krokem je vytvoření databáze se stejným názvem jako ta, kterou budeme replikovat. Toto je důležitý krok a neměl by být opomíjen. Dále přejděte do konfiguračního souboru, který je nám již známý my.cnf a zapište nastavení.
Server-id = 2 relay-log = /var/log/mysql/mysql-relay-bin.log bin-log = /var/log/mysql/mysql-bin.log
Důležité! V bin-log je zapsána cesta k bin-logu na serveru mester . ID serveru se musí lišit od hlavního ID, je vhodné jej nastavit na 1 více.
CHANGE MASTER TO MASTER_HOST="1.1.1.1", MASTER_USER="slave_user", MASTER_PASSWORD="slave_password", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 107; START SLAVE;
Kde hostitel je IP adresa hlavního serveru, přihlašovací jméno a heslo odpovídají těm, které jsme vytvořili na hlavním serveru, master_log_file a master_log_pos jsou vyplněny informacemi z poslední položka pro konfiguraci hlavního serveru .
Od tohoto okamžiku se všechny změny v databázi přenesou z master na slave.
Kontrola stavu replikace
Kromě příkazu SHOW MASTER STATUS; Podobný existuje pro slave SHOW SLAVE STATUS\G, který zobrazí tabulku s informacemi. Hlavním znakem toho, že se servery připojily a fungují správně, je přítomnost takových linek
Replikace- technika používaná v architektuře systémů pracujících pod zátěží, jejímž výsledkem je rozložení zátěže při práci s jednou databází na více serverů. Častěji se používá replikace MySQL MASTER SLAVE, ale používá se i druhý typ replikace - Master-Master.
Co je replikace MySQL MASTER SLAVE a k čemu se používá?
Replikace Otrokář Jedná se o duplikaci dat na podřízený server MySQL, přičemž tato duplikace se provádí většinou pro zajištění spolehlivosti. Pokud selže Master server, jeho funkce se přepnou na Slave.
Replikace může být také provedena pro zlepšení výkonu systému, ale výkon je zde téměř vždy sekundární.
Když aplikace pracuje s databází, jsou nejčastější operace VYBRAT- požadavky na čtení dat, úpravu dat - požadavky VYMAZAT, VLOŽIT, AKTUALIZACE, ZMĚNIT Statisticky se to stává mnohem méně často.
Aby se zabránilo ztrátě dat v případě selhání jednoho ze serverů, operace pro změnu informací v tabulkách vždy zpracovává hlavní server. Změny jsou poté replikovány do Slave. Čtení lze provádět ze serveru hrajícího roli Slave.
Díky tomu můžete získat zvýšení výkonu spolu se spolehlivostí.
Řešení je oblíbené, ale ne vždy použitelné, protože při replikaci může docházet ke zpožděním – pokud k tomu dojde, musí být informace načteny také z hlavního serveru.
Směrování požadavků určitého typu na konkrétní databázový server je v každém případě implementováno na aplikační úrovni.
Pokud uděláte rozdělení VYBERTE dotazy a všechny ostatní na úrovni programu, posílat je na požadovaný server, když jeden z nich selže, aplikace, kterou infrastruktura obsluhuje, bude nefunkční. Aby to fungovalo, musíte poskytnout více složitý obvod a rezervujte si každý ze serverů.
Replikace je pro odolnost proti chybám, nikoli pro škálování.
Replikace MySQL MASTER SLAVE - nastavení v Debianu
Použijeme dva servery s adresami:
- Hlavní server 192.168.0.1
- Slave server 192.168.0.2
Pro demonstraci jsou použity VDS připojené k místní síti.
Abychom vždy věděli, na kterém serveru provádíme ten či onen příkaz, upravíme soubory /etc/hosts na obou serverech
192.168.0.1 master
192.168.0.2 otrok
Nahraďte stávající hodnoty v /etc/hostname za master a slave, aby se změny projevily a restartujte server.
1. Provádíme nastavení na hlavním serveru.
root@master:/#
Úprava toho hlavního konfigurační soubor databázový server
mcedit /etc/mysql/my.cnf
Vyberte ID serveru - můžete zadat libovolné číslo, výchozí je 1 - stačí odkomentovat řádek
server-id = 1
Nastavte cestu k binárnímu protokolu – také je standardně specifikována, odkomentujte ji
Nastavte název databáze, kterou budeme replikovat na jiný server
binlog_do_db = db1
Restartujte Mysql, aby se konfigurační soubor znovu přečetl a změny se projevily:
/etc/init.d/mysql restartujte
2. Nastavte potřebná práva uživatele
Přejděte do konzoly databázového serveru:
Uživateli na podřízeném serveru poskytujeme potřebná práva:
GRANT REPLICATION SLAVE ON *.* TO "slave_user"@"%" IDENTIFIKOVANÉ "123";
Uzamčení všech tabulek v databázi
SPLACHOVACÍ STOLY SE ZÁMEKEM ČTENÍ;
Kontrola stavu hlavního serveru:
+——————+———-+—————+——————+
| Soubor | Pozice | Binlog_Do_DB | Binlog_Ignore_DB |
+——————+———-+—————+——————+
| mysql-bin.000001 | 327 | db1 | |
+——————+———-+—————+——————+
1 řádek v sadě (0,00 s)
3. Vytvořte výpis databáze na serveru
Vytvořte výpis databáze:
mysqldump -u root -p db1 > db1.sql
Odemkněte tabulky v konzoli mysql:
4. Přeneste výpis databáze na podřízený server
scp db1.sql [e-mail chráněný]:/Domov
Na Slave serveru provádíme další akce
root@slave:/#
5. Vytvoření databáze
Načítání výpisu:
mysql -u root -p db1< db1.sql
6. Proveďte změny v souboru my.cnf
mcedit /etc/mysql/my.cnf
ID přiřadíme zvýšením hodnoty nastavené na Master serveru
server-id = 2
Nastavte cestu k protokolu přenosu
relay-log = /var/log/mysql/mysql-relay-bin.log
a cestu k protokolu přihrádky na hlavním serveru
log_bin = /var/log/mysql/mysql-bin.log
Určete základnu
binlog_do_db = db1
Restartování služby
/etc/init.d/mysql restartujte
7. Nastavte připojení k hlavnímu serveru
CHANGE MASTER TO MASTER_HOST="192.168.0.1", MASTER_USER="slave_user", MASTER_PASSWORD="123", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 327;
Spustíme replikaci na podřízeném serveru:
Fungování replikace na Slave můžete zkontrolovat pomocí následujícího požadavku:
***************************** 1. řádek ******************** * ********
Slave_IO_State: Čeká se, až master odešle událost
Hlavní_hostitel: 192.168.0.1
Master_User: slave_user
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000002
Read_Master_Log_Pos: 107
Relay_Log_File: mysql-relay-bin.000003
Relay_Log_Pos: 253
Relay_Master_Log_File: mysql-bin.000002
Slave_IO_Running: Ano
Slave_SQL_Running: Ano
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: 107
Relay_Log_Space: 555
Until_Condition: Žádný
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: Ne
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Hlavní_SSL_Key:
Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: Ne
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Master_Server_Id: 1
1 řádek v sadě (0,00 s)
Protože nedošlo k žádným chybám, můžeme dojít k závěru, že replikace je nakonfigurována správně.
Je dobrý nástrojškálování, ale hlavní nevýhodou je desynchronizace kopírování dat a zpoždění, které může být kritické.
Použití modernějšího řešení vám umožňuje se jim zcela vyhnout. Snadno se nastavuje, je spolehlivý a eliminuje potřebu ručního kopírování výpisů z databáze.
metla 8. dubna 2009 v 11:10 hodin
Základy replikace MySQL
- MySQL
S replikací MySQL serverů jsem se seznámil poměrně nedávno a jak jsem s konfigurací prováděl různé experimenty, zapisoval jsem si, co se mi osvědčilo. Když jsem nasbíral poměrně hodně materiálu, přišel nápad napsat tento článek. Snažil jsem se shromáždit tipy a řešení některých nejzákladnějších problémů, se kterými jsem se setkal. Po cestě poskytnu odkazy na dokumentaci a další zdroje. Nemohu předstírat, že to úplně popíšu, ale doufám, že článek bude užitečný.
Krátký úvod
Replikace (z latinského repliko - opakuji) je replikace změn dat z hlavního databázového serveru na jeden nebo více závislých serverů. Zavoláme na hlavní server mistr a závislý - repliky.Změny dat, ke kterým dojde na předloze, se opakují na replikách (ale ne naopak). Dotazy na změnu dat (INSERT, UPDATE, DELETE atd.) jsou tedy prováděny pouze na masteru, zatímco dotazy na čtení dat (jinými slovy SELECT) mohou být prováděny jak na replikách, tak na masteru. Proces replikace na jedné z replik neovlivňuje provoz ostatních replik a prakticky neovlivňuje práci hlavního serveru.
Replikace se provádí pomocí binárních protokolů udržovaných na hlavním serveru. Ukládají všechny dotazy, které vedou (nebo potenciálně vedou) ke změnám v databázi (dotazy se neukládají explicitně, takže pokud se na ně chcete podívat, budete muset použít utilitu mysqlbinlog). Binlogy se přenesou do replik (binlog stažený z masteru se nazývá "reléový binlog") a uložené dotazy se provedou od určité pozice. Je důležité pochopit, že během replikace se nepřenášejí samotná změněná data, ale pouze požadavky, které způsobují změny.
Při replikaci je obsah databáze duplikován na několik serverů. Proč je nutné uchýlit se k duplicitě? Důvodů je několik:
- výkon a škálovatelnost. Jeden server nemusí být schopen zvládnout zátěž způsobenou simultánními operacemi čtení a zápisu v databázi. Výhody vytváření replik budou tím větší, čím více čtení na zápis budete mít ve svém systému.
- odolnost proti chybám. V případě selhání repliky lze všechny požadavky na čtení bezpečně přenést na hlavní server. Pokud hlavní server selže, požadavky na zápis lze přenést do repliky (po obnovení může hlavní server převzít roli repliky).
- zálohování dat. Replika může být na chvíli „zpomalena“, aby se provedla mysqldump, ale master ne.
- odložené výpočty. Těžké a pomalé SQL dotazy lze provádět na samostatné replice bez obav z narušení normálního provozu celého systému.
Nastavení replikace
Řekněme, že máme funkční databázi Data MySQL, již vyplněný údaji a zařazený do práce. A z jednoho z výše popsaných důvodů umožníme replikaci našeho serveru. Naše počáteční údaje:- Hlavní IP adresa je 192.168.1.101, repliky jsou 192.168.1.102.
- MySQL nainstalované a nakonfigurované
- musíte nakonfigurovat replikaci databáze testdb
- můžeme průvodce na chvíli pozastavit
- samozřejmě máme root na obou strojích
Nastavení průvodce
Nezapomeňte uvést jedinečné ID serveru, cestu k binárním protokolům a název databáze pro replikaci v části:server-id = 1
log-bin = /var/lib/mysql/mysql-bin
replikovat-do-db = testdb
Ujistěte se, že máte na disku dostatek místa pro binární protokoly.
Přidáme uživatele replikace, pod jehož právy bude replikace prováděna. Oprávnění „replication slave“ bude stačit:
mysql@master> GRANT replikace slave ON "testdb".* TO "replication"@"192.168.1.102" IDENTIFIKOVÁNO "heslem";
Restartujte MySQL, aby se změny v konfiguraci projevily:
restart služby root@master# mysqld
Pokud vše proběhlo v pořádku, příkaz „show master status“ by měl ukazovat něco takového:
mysql@master>ZOBRAZIT STAV MASTER\G
Soubor: mysql-bin.000003
Pozice: 98
Binlog_Do_DB:
Binlog_Ignore_DB:
Hodnota pozice by se měla zvyšovat se změnami v databázi na masteru.
Nastavení repliky
Zadáme ID serveru, název databáze pro replikaci a cestu k předávacím binlogům v sekci config, poté restartujeme MySQL:server-id = 2
relay-log = /var/lib/mysql/mysql-relay-bin
relay-log-index = /var/lib/mysql/mysql-relay-bin.index
replikovat-do-db = testdb
Restart služby mysqld Root@replica#
Přenos dat
Zde budeme muset zamknout databázi pro zápis. Chcete-li to provést, můžete buď zastavit aplikace, nebo použít příznak read_only na hlavním serveru (pozor: tento příznak nemá žádný vliv na uživatele s oprávněním SUPER). Pokud máme tabulky MyISAM, pojďme také "vyprázdnit tabulky":mysql@master> VYPLACHOVÁNÍ TABULEK SE ZÁMEKEM ČTENÍ;
mysql@master> SET GLOBAL read_only = ON;
Podívejme se na stav mastera pomocí příkazu „show master status“ a zapamatujte si hodnoty File a Position (po úspěšném zablokování mastera by se neměly měnit):
Soubor: mysql-bin.000003
Pozice: 98
Vypíšeme databázi a po dokončení operace odstraníme hlavní zámek:
mysql@master> SET GLOBAL read_only = OFF;
Přeneseme výpis do repliky a obnovíme z ní data.
Nakonec spustíme replikaci pomocí příkazů „change master to“ a „start slave“ a uvidíme, zda vše proběhlo v pořádku:
mysql@replica> CHANGE MASTER TO MASTER_HOST = "192.168.1.101", MASTER_USER = "replikace", MASTER_PASSWORD = "heslo", MASTER_LOG_FILE = "mysql-bin.000003", MASTER_LOG_POS = 98;
mysql@replica> start slave;
Hodnoty MASTER_LOG_FILE a MASTER_LOG_POS přebíráme z hlavního serveru.
Podívejme se, jak probíhá replikace pomocí příkazu „show slave status“:
mysql@replica> ZOBRAZIT STAV SLAVE\G
Slave_IO_State: Čeká se, až master odešle událost
Master_Host: 192.168.1.101
Master_User: replikace
Master_Port: 3306
Connect_Retry: 60
Master_Log_File: mysql-bin.000003
Read_Master_Log_Pos: 98
Relay_Log_File: mysql-relay-bin.001152
Relay_Log_Pos: 235
Relay_Master_Log_File: mysql-bin.000003
Slave_IO_Running: Ano
Slave_SQL_Running: Ano
Replicate_Do_DB: testdb,testdb
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: 98
Relay_Log_Space: 235
Until_Condition: Žádný
Until_Log_File:
Until_Log_Pos: 0
Master_SSL_Allowed: Ne
Master_SSL_CA_File:
Master_SSL_CA_Path:
Master_SSL_Cert:
Master_SSL_Cipher:
Hlavní_SSL_Key:
Seconds_Behind_Master: 5
Nyní jsem zdůraznil nejzajímavější hodnoty. Pokud se replikace spustí úspěšně, jejich hodnoty by měly být přibližně stejné jako ve výpisu (viz popis příkazu "show slave status" v dokumentaci). Hodnota Seconds_Behind_Master může být libovolné celé číslo.
Pokud je replikace normální, bude replika následovat master (číslo protokolu v Master_Log_File a pozice Exec_Master_Log_Pos se zvýší). Doba zpoždění repliky od předlohy (Seconds_Behind_Master) by v ideálním případě měla být rovna nule. Pokud se nezmenšuje nebo neroste, je možné, že zatížení repliky je příliš vysoké - prostě nemá čas zopakovat změny vyskytující se na předloze.
Pokud je Slave_IO_State prázdný a Seconds_Behind_Master je NULL, replikace se nespustila. Podívejte se do protokolu MySQL, abyste zjistili důvod, odstraňte jej a restartujte replikaci:
mysql@replica> start slave;
Těmito jednoduchými kroky získáme repliku, jejíž data jsou identická s daty na masteru.
Mimochodem, čas zablokování hlavního serveru je čas vytvoření výpisu. Pokud vytvoření trvá nepřijatelně dlouho, můžete zkusit toto:
- zablokujte zápis na master s příznakem read_only, zapamatujte si pozici a zastavte MySQL.
- poté zkopírujte databázové soubory do repliky a povolte hlavní server.
- spusťte replikaci obvyklým způsobem.
Přidávání replik
Předpokládejme, že již máme funkční předlohu a repliku a potřebujeme k nim přidat ještě jednu. To je ještě jednodušší než přidat první repliku do předlohy. A co je mnohem hezčí, že kvůli tomu není třeba zastavovat mistra.Nejprve nakonfigurujme MySQL na druhé replice a ujistěte se, že jsme do konfigurace zadali potřebné parametry:
server-id = 3
replikovat-do-db = testdb
Nyní zastavme replikaci na první replice:
mysql@replica-1> stop slave;
Replika bude nadále normálně fungovat, ale data na ní již nebudou aktuální. Pojďme se podívat na stav a zapamatovat si hlavní pozici, které replika dosáhla před zastavením replikace:
mysql@replica-1> ZOBRAZIT STAV SLAVE\G
Hodnoty, které potřebujeme, budou Master_Log_File a Exec_Master_Log_Pos:
Master_Log_File: mysql-bin.000004
Exec_Master_Log_Pos: 155
Pojďme vytvořit výpis databáze a pokračovat v replikaci na první replice:
mysql@replica-1> START SLAVE;
Obnovme data z výpisu na druhé replice. Poté povolte replikaci:
mysql@replica-2> CHANGE MASTER TO MASTER_HOST = "192.168.1.101", MASTER_USER = "replikace", MASTER_PASSWORD = "heslo", MASTER_LOG_FILE = "mysql-bin.000004", MASTER_LOG_POS = 155;
mysql@replica-2> START SLAVE;
Hodnoty MASTER_LOG_FILE a MASTER_LOG_POS jsou hodnoty Master_Log_File a Exec_Master_Log_Pos z výsledku příkazu „show slave status“ na první replice.
Replikace musí začít z pozice, kde byla zastavena první replika (a podle toho se vytvoří výpis). Budeme mít tedy dvě repliky se stejnými daty.
Sloučení replik
Někdy nastane následující situace: na hlavním serveru jsou dvě databáze, z nichž jedna je replikována na jedné replice a druhá na jiné. Jak nastavit replikaci dvou databází na obou replikách, aniž byste je uložili na hlavní server nebo jej vypnuli? Zcela jednoduše pomocí příkazu "start slave dokud".Máme tedy hlavní databázi testdb1 a testdb2, které jsou replikovány na replikách replica-1 a replica-2. Pojďme nakonfigurovat replikaci obou databází na repliku-1 bez zastavení hlavní.
Zastavte replikaci na replice-2 pomocí příkazu a zapamatujte si pozici hlavního:
mysql@replica-2> STOP SLAVE;
mysql@replica-2> ZOBRAZIT STAV SLAVE\G
Master_Log_File: mysql-bin.000015
Exec_Master_Log_Pos: 231
Vytvořme výpis databáze testdb2 a obnovíme replikaci (tím jsou dokončeny manipulace s replikou-2). Obnovíme výpis na repliku-1.
Situace na replice-1 je tato: databáze testdb1 je na jedné hlavní pozici a pokračuje v replikaci, databáze testdb2 byla obnovena z výpisu z jiné pozice. Pojďme je synchronizovat.
Zastavme replikaci a zapamatujme si pozici mistra:
mysql@replica-1> STOP SLAVE;
mysql@replica-1> ZOBRAZIT STAV SLAVE\G
Exec_Master_Log_Pos: 501
Ujistíme se, že v konfiguraci pro repliku-1 je název druhé databáze uveden v sekci:
replikovat-do-db = testdb2
Restartujme MySQL, aby se změny v konfiguraci projevily. Mimochodem, MySQL bychom mohli jednoduše restartovat bez zastavení replikace – z logu bychom věděli, na jaké pozici v masteru se replikace zastavila.
Nyní replikujme z pozice, kde byla replika-2 pozastavena, do pozice, kde jsme právě pozastavili replikaci:
mysql@replica-1> CHANGE MASTER TO MASTER_HOST = "192.168.1.101", MASTER_USER = "replikace", MASTER_PASSWORD = "heslo", MASTER_LOG_FILE = "mysql-bin.000015", MASTER_LOG_POS = 231;
mysql@replica-1> spustit slave do MASTER_LOG_FILE = "mysql-bin.000016", MASTER_LOG_POS = 501;
Replikace bude ukončena, jakmile replika dosáhne zadané pozice v sekci do, poté budou obě naše databáze odpovídat stejné hlavní pozici (na které jsme zastavili replikaci na replice-1). Přesvědčte se o tom:
mysql@replica-1> ZOBRAZIT STAV SLAVE\G
mysql@replica-1> START SLAVE;
Master_Log_File: mysql-bin.000016
Exec_Master_Log_Pos: 501
Pojďme přidat názvy obou databází do konfigurace pro repliku-1 v sekci:
replikovat-do-db = testdb1
replikovat-do-db = testdb2
Důležité: každá databáze musí být uvedena na samostatném řádku.
Restartujte MySQL a pokračujte v replikaci:
mysql@replica-1> CHANGE MASTER TO MASTER_HOST = "192.168.1.101", MASTER_USER = "replikace", MASTER_PASSWORD = "heslo", MASTER_LOG_FILE = "mysql-bin.000016", MASTER_LOG_POS = 501;
Poté, co replika-1 dohoní master, bude obsah jejich databáze identický. Databázi můžete sloučit do repliky-2 buď podobným způsobem, nebo vytvořením úplného výpisu repliky-1.
Castling master a replika
Může být nutné přepnout repliku do hlavního režimu, například v případě selhání hlavní jednotky nebo při provádění technické práce. Aby byl takový přepínač možný, musíte repliku nakonfigurovat jako hlavní nebo ji vyrobit pasivní mistr.Povolme binární protokolování (kromě reléových binlogů) v konfiguraci v sekci:
log-bin = /var/lib/mysql/mysql-bin
A přidejte uživatele pro replikaci:
mysql@master> GRANT replikace slave ON 'testdb'.* TO 'replication'@'192.168.1.101′ IDENTIFIKOVANÉ BY "heslo";
Pasivní master provádí replikaci jako běžná replika, ale navíc vytváří binární logie – tedy z ní můžeme replikaci spustit. Ověřte si to příkazem "show master status":
mysql@replica> ZOBRAZIT STAV MASTER\G
Soubor: mysql-bin.000001
Pozice: 61
Binlog_Do_DB:
Binlog_Ignore_DB:
Chcete-li nyní přepnout pasivní hlavní server do aktivního režimu, musíte na něm zastavit replikaci a povolit replikaci na předchozím aktivním hlavním serveru. Aby se zajistilo, že data nebudou ztracena v době přepnutí, aktivní mistr musí být uzamčen pro zápis.
mysql@master> VYPLACHOVÁNÍ TABULEK SE ZÁMEKEM ČTENÍ
mysql@master> SET GLOBAL read_only = ON;
mysql@replica> STOP SLAVE;
mysql@replica> ZOBRAZIT STAV MASTER;
Soubor: mysql-bin.000001
Pozice: 61
mysql@master> CHANGE MASTER TO MASTER_HOST = "192.168.1.102", MASTER_USER = "replikace", MASTER_PASSWORD = "heslo", MASTER_LOG_FILE = "mysql-bin.000001", MASTER_LOG_POS = 61;
mysql@master> start slave;
To je vše, takže jsme změnili aktivního mastera. Blok můžete odebrat z bývalého předlohy.
Závěr
Naučili jsme se něco o tom, jak nastavit replikaci v MySQL a provádět některé základní operace. Bohužel následující důležité otázky zůstávají mimo rozsah tohoto článku:
- odstranění jednotlivých bodů selhání (SPF, Single Points of Failure). Při použití jediné MySQL server, jeho selhání vedlo k selhání celého systému. Při použití více serverů bude mít selhání kteréhokoli z nich za následek selhání systému, pokud se o to konkrétně nepostaráme. Musíme zajistit řešení situace se selháním předlohy a repliky. Jedním z existujících nástrojů je MMM, ale vyžaduje úpravu pomocí souboru.
- vyvažování zátěže. Při použití více replik bychom rádi použili transparentní vyvažovací mechanismus, zejména pokud je výkon replik nerovnoměrný. Pod Linuxem je možné použít standardní řešení - LVS.
- změna logiky aplikace. V ideální situaci by měly být požadavky na čtení dat odeslány do replik a požadavky na změnu dat by měly být zaslány masteru. Kvůli možnému zpoždění replik je však takové schéma často neúčinné a je nutné identifikovat takové požadavky na čtení, které je třeba ještě provést na masteru.
Děkuji za pozornost!
Štítky:
- mysql
- replikace
Nedávno jsem byl požádán, abych o tom promluvil replikace v MySQL. Rozhodl jsem se, že toto téma by mohlo být užitečné pro mnohé, takže v tomto článku budu hovořit co je replikace v MySQL, kdy je potřeba a jak ji nakonfigurovat.
Hlavním úkolem replikace je kombinovat výkon několika serverů. Řekněme, že váš web má dedikovaný server, ale časem se stane velmi navštěvovaným a již nevydrží zátěž. V důsledku toho se server začne pravidelně zpomalovat a padá. Nejjednodušší způsob je koupit výkonnější server, a to dělá většina lidí. Ale dříve nebo později přijde čas, kdy náklady na zvýšení ceny serveru neodpovídají nárůstu jeho výkonu, takže je výhodnější koupit 2 různé servery za méně peněz.
Výsledkem je, že vaše databáze bude na dvou serverech najednou. Když jeden hlavní server (také známý jako hlavní server) již nezvládá, přepne se na náhradní.
Všechno požadavky na aktualizaci databáze vždy jdou na hlavní server. Po aktualizaci hlavního serveru umístí informace o tomto do samostatný soubor, odkud podřízené servery získávají všechny informace. Ale vzorkovací operace, kterých je obvykle většina a jsou nejpomalejší, již lze přenést na podřízené servery, protože data jsou na obou stejná.
Teď na to přijdeme jak nakonfigurovat replikaci v MySQL:
- Nainstalujte nejvíce nejnovější verze MySQL na všechny servery.
- Vytvořte uživatele s oprávněním na hlavním serveru VÝMĚNA SLAVE. Pro adresu, ze které se může připojit, zadejte " Všechno".
- Zastavte všechny servery.
- V nastavení MySQL(v souboru my.cnf) V kapitole
přidejte následující řádky: log-bin
server-id=1 Vezměte prosím na vědomí server-id musí být na všech serverech odlišné. Ve skutečnosti je to to, co odlišuje jeden server od druhého. - Na podřízených serverech přidejte do nastavení MySQL následující řádky: master-host=master_host_name
master-user=přihlášení vytvořeného_uživatele
master-password=heslo vytvořeného_uživatele
master-port=port_for_connecting_to_the_master_server
server-id=id_of_tohoto_slave_serveru - Přesuňte všechny základny od hlavního serveru k otrokům.
- Běh hlavní server, pak všichni otroci.
