Apache load balancing és MySQL replication

Ebben a kicsit hosszabb lélegzetvételű leírásban szeretném ismertetni, hogy hogyan is használhatjuk az Apache(2) webszerverünket terhelés-elosztásra, illetve hogyan klónozhatunk egy MySQL szervert több másik szerverre.

Első lépésben a terhelés-elosztásról osztanék meg pár gondolatot azokkal, akik még most ismerkednek a dologgal, ahogyan én is.

A terhelés-elosztás lényege, hogy az adott szerverre érkező kapcsolatokat szétosszuk 2 vagy több szerverre. A terhelés lehet adatbázis-intenzív, front-end-intenzív, stb.. A terhelés az alkalmazástól és az alkalmazott infrastruktúrától, illetve a kiszolgálni kívánt program minőségétől nagyban függ. Egy terhelés-mentesítési módszerekben viszont az összes terhelés típus megegyezik.

A legegyszerűbb terhelés-mentesítési módszer a szerver erősebbre cserélése. Ez gondolom mindenkinek tiszta sor, nem szorul különösebb magyarázatra.

Ha viszont egy szerver kevés a kiszolgáláshoz, akkor elkezdhetünk több szerveres rendszerben gondolkozni és ekkor jöhet szóba a load-balancing vagyis a terhelés-elosztás. Ennek főbb típusai az alábbiak:

• IP alapon (ún. roud-robin DNS segítségével)
• terhelés alapon
• idő alapon
• a fentitek tetszőleges kombinációja

Vegyük szépen sorba a kis listát:

IP alapú terhelés-elosztás

Valójában ez a módszer több mindenre is jó, nem csak terhelés-elosztásra. A módszer lényege, hogy egy domain névhez több IP címet is felveszünk és így a kliens (vagy annak hálózata) dönti el, hogy melyikhez csatlakozik. Ha a domain-hez tartozó egyik IP címen levő szerver nem válaszol, akkor a kliens megpróbálkozik egy másik címmel, és így a szolgáltatásunk folyamatosan elérhető. Ha több IP címmel rendelkezünk és a szervereink is földrajzilag különböző helyen vannak, akkor a csatlakozó kliens általában a hozzá legközelebb eső IP-hez csatlakozik, ezzel tehermentesítve a szervereket, és pontosan ezért használható egyfajta load-balancing megoldásként a backup lehetőségek mellett.

Terhelés alapú load-balancing

Ennek a módszernek a lényege az, hogy a kéréseket egy szerver fogadja, ami mögött 2-n szerver található. A terhelés-elosztó szerver továbbítja a kéréseket a mögötte levő szerverek egyikének, attól függően, hogy melyik szerver terhelése a legkisebb a kérés pillanatában. Ennek következtében minden egyes szerver arányaiban ugyanannyira terhelődik. A módszer előnye, hogy növekvő terhelés esetén elég csak egy új szervert beállítani és már ki is lehet szolgálni a megnövekedett igényeket.

Idő alapú load-balancing

A felépítése és működése hasonló a terhelés alapú elosztáshoz, a különbség mindössze annyi, hogy előre beállított értékek alapján változik a kiszolgáló szerver. Az előre beállított érték lehet a kérések száma alapján, session-ök száma alapján, stb.. Pl.: 2 kiszolgáló szerver esetén beállítható, hogy minden 3 látogatót a 2-es szerver szolgálja ki, a többit pedig az 1-es (mivel jelen példában az 1-es szerver 2-szer erősebb, így feltételezhetően 2x annyi kéréssel is boldogul).

A "kis" bevezető után elértünk a lényeghez, innentől kezdve konkrét kódok is lesznek.

Apache load-balancing

Az Apache webszerverünk a beépített moduljai segítségével könnyen átváltoztatható load-balancing szerverré és ehhez szinte alig kell csinálnunk vele valamit. Elég csak bekapcsolni a proxy, illetve a proxy_html modulokat. Windows alatt az apache telepítési útvonala\conf\http.conf fájlt kell csak szerkesztenünk. Megkeressük a LoadModule részt és kivesszük az előbb említett két modul elől a ;-ket, majd újraindítjuk a szerverünket. Linux alatt pedig feltelepítjük a libapache2-mod-proxy-html modult (ha még nincs telepítve) és betöltjük az apache2-be. Ezt a legegyszerűbben az alábbi parancsokkal tehetjük meg (debian alapú disztribúciók esetén)

sudo apt-get install libapache2-mod-proxy-html
sudo a2enmod proxy
sudo a2enmod proxy_html
sudo service apache2 restart

Miután sikeresen beállítottuk az Apache szerverünket, jöhet a load-balancing-olás. Először közzéteszem a kódot, utána elmondom, hogy mit miért csináltam.

apache<VirtualHost *:80>
        ServerName fefy.ga
#       ServerAlias router.lo

        ProxyRequests Off
        ProxyPreserveHost On
        <Proxy *>
                Order allow,deny
                Deny from all
        </Proxy>

        ProxyPass /balancer-manager !
        <Proxy balancer://fefy.ga>
                BalancerMember http://192.168.254.2 route=primary redirect=backup timeout=2 connectiontimeout=2
                BalancerMember http://192.168.254.100 route=backup status=+H
                ProxySet stickysession=ROUTEID
                Order allow,deny
                Allow from all
        </Proxy>

        ProxyPass / balancer://fefy.ga/ nofailover=On
        ProxyPassReverse / balancer://fefy.ga/

        <Location />
                Order allow,deny
                Allow from all
        </Location>
        <Location /balancer-manager>
                SetHandler balancer-manager
#               Require host fefy.ga

                Order Deny,Allow
                Deny from all
                Allow from 192.168.254
        </Location>
</VirtualHost>

A kódot vagy a httpd.conf-ban vagy egy külön erre a célra létrehozott fájlban kell elhelyezni (linuxon az /etc/apache2/site-enabled könyvtárban, windows-on az apache telepítési könyvtára\conf\httpd.conf-ban).

A kód a <Virtualhost *:80> sorral indul. Ezzel jelezzük az Apache szervernek, hogy több szájtot is üzemeltetünk a 80-as porton és domain név alapján döntjük el, hogy mit és honnan szolgálunk ki.

A ServerName-el jelezzük, hogy melyik domain-t szeretnék kiszolgálni (ServerAlias-ként felvehetünk másik domain-(eke)t is, pl ha intraneten/localhoston külön domain-t tartunk fel a kiszolgálni kívánt oldalnak).

A következő pár sorral jelezzük az Apache-nak, hogy nem akarunk publikus webproxy-t üzemeltetni.

A ProxyPass /balancer-manager ! sorról egy kicsit később írok.

Következzen a <Proxy balancer://fefy.ga></Proxy> blokk. A balancer://fefy.ga-val jelezzük, hogy egy clustert kívánunk definiálni fefy.ga néven. A blokkon belül a BalancerMember sorokkal tudjuk a cluster tagjait felvenni. Minden egyes tagot külön beállíthatunk, hogy mi történjen vele. Meghadhatunk route-id (route=primary, route=backup), megadhatjuk, hogy az adott szerver ha kiesik, melyik vegye át helyette a terhelést (redirect=backup), illetve megadhatjuk az időtúllépési limiteket másodpercben (timeout, connectiontimeout). Ezen felül képezhetünk tartalék szervereket a clustben (status=+H), melyek csak akkor kerülnek aktiválásra, ha az összes nem standby státuszú szerver kiesett (hacsak nem bíráljuk velül a redirect-el)).

A ProxyPass / balancer://fefy.ga sorral jelezzük az Apache szervernek, hogy a domain root-ját a fefy.ga cluster szolgálja ki, a következő sor pedig az átirányítások és http header-ök miatt kell.

A <Location /></Location> blokkal a site hozzáférését szabályozzuk, ezen megint csak nincs mit magyarázni.

Az utolsó blokk (<Location /balancer-manager></Location>) pedig a cluster beállító oldalának elérését szabályozza. A ProxyPass /balanacer-manager ! sorral tudjuk elérni, hogy a balancer-manager linket ne adja át az Apache a clusternek, hanem helyileg futtassa le és jelenítse meg a cluster beállításait.

Az apache load-balancing tehát ilyen egyszerű, nem igényel több beállítást. A bejegyzés folytatásaként jöjjön a MySQL replication.

MySQL replication

A MySQL replication nem más, mint a MySQL szerverek szinkronizációja. Legegyszerűbben (és tényleg csak pár kattintással) PHPMyAdmin segítségével kapcsolhatjuk be. Az "A" szerverre bejelentkezünk, megkeressük menüben a "Többszörözés"-t (vagy "Replication"-), kiválasztjuk, hogy Master szerverként  szeretnénk használni, kiválasztjuk, hogy melyik adatbázisokat szeretnénk tükrözni, a varázsló a végén kidob egy pár soros konfigot, amit a mysql telepítési könyvtárában található my.cnf fájlba bemásolunk, majd újraindítjuk a szerverünket. A "B" szerveren hasonlóan járunk el. Ezután az A és B szerveren is elindítjuk a slave varázslót, megadjuk a master szerveren a replication user nevét, jelszavát (A-n a B szerverét, B-n az A szerverét). Ezután kézzel szinkronizáljuk a két szervert (A-n export, B-n import oda-vissza). Ezután a biztonság kedvéért az "A" és "B" szerveren is kiadjuk a "start slave" parancsokat. Röviden ennyi lenne a konfiguráció.