Útmutató Apache Mesoshoz

1. Áttekintés

Különböző alkalmazásokat általában ugyanazon a gépcsoporton telepítünk. Például manapság elterjedt, hogy egy olyan elosztott feldolgozó motor, mint az Apache Spark vagy az Apache Flink, ugyanazon a fürtön olyan elosztott adatbázisokkal rendelkezik, mint az Apache Cassandra.

Az Apache Mesos egy olyan platform, amely lehetővé teszi az erőforrások hatékony megosztását az ilyen alkalmazások között.

Ebben a cikkben először az erőforrás-elosztás néhány problémáját tárgyaljuk ugyanazon a fürtön telepített alkalmazásokon belül. Később meglátjuk, hogy az Apache Mesos hogyan biztosítja az erőforrások jobb kihasználását az alkalmazások között.

2. A Klaszter megosztása

Sok alkalmazásnak meg kell osztania a fürtöt. Nagyjából kétféle megközelítés létezik:

  • Statikusan particionálja a fürtöt, és futtasson egy alkalmazást minden partíción
  • Rendeljen gépeket egy alkalmazáshoz

Bár ezek a megközelítések lehetővé teszik az alkalmazások egymástól független futtatását, ez nem éri el az erőforrások magas kihasználtságát.

Vegyünk egy alkalmazást például csak rövid ideig fut, amelyet inaktivitás követ. Most, hogy statikus gépeket vagy partíciókat rendeltünk ehhez az alkalmazáshoz, meg is tettük kihasználatlan erőforrások az inaktív időszakban.

Optimalizálhatjuk az erőforrás-felhasználást azáltal, hogy az inaktív időszakban a szabad erőforrásokat átcsoportosítjuk más alkalmazásokra.

Az Apache Mesos segít az alkalmazások közötti dinamikus erőforrás-elosztásban.

3. Apache Mesos

A fentiekben tárgyalt mindkét fürtmegosztási megközelítéssel az alkalmazások csak az általuk futtatott partíció vagy gép erőforrásaival vannak tisztában. Az Apache Mesos azonban absztrakt képet nyújt a fürt összes erőforrásáról az alkalmazások számára.

Amint hamarosan látni fogjuk, a Mesos interfészként működik a gépek és az alkalmazások között. Alkalmazásokat biztosít a rendelkezésre álló erőforrások a fürt összes gépén. Azt gyakran frissíti ezeket az információkat az alkalmazások által felszabadított erőforrásokkal amelyek elérték a befejezési státuszt. Ez lehetővé teszi az alkalmazások számára a legjobb döntést arról, hogy melyik feladatot melyik gépen hajtsák végre.

A Mesos működésének megértéséhez vessünk egy pillantást az architektúrájára:

Ez a kép a Mesos (forrás) hivatalos dokumentációjának része. Itt, Hadoop és MPI két olyan alkalmazás, amelyek megosztják a fürtöt.

Az itt bemutatott egyes összetevőkről a következő szakaszokban fogunk beszélni.

3.1. Mesos Mester

A Master a fő összetevő ebben a beállításban, és az erőforrások aktuális állapotát tárolja a fürtben. Továbbá, mint egy hangszerelő az ügynökök között az alkalmazások pedig olyan információk átadásával, mint az erőforrások és a feladatok.

Mivel a master bármely meghibásodása az erőforrások és feladatok állapotának elvesztését eredményezi, magas rendelkezésre állású konfigurációban telepítjük. Amint az a fenti ábrán látható, Mesos készenléti mester démonokat telepít egy vezetővel együtt. Ezek a démonok a Zookeeperre támaszkodnak az állapot helyreállításában kudarc esetén.

3.2. Mesos ügynökök

A Mesos-fürtnek ügynököt kell futtatnia minden gépen. Ezek az ügynökök időszakonként jelentse erőforrásait a parancsnoknak és viszont olyan feladatok fogadása, amelyeket egy alkalmazás futtatni tervezett. Ez a ciklus az ütemezett feladat befejezése vagy elvesztése után megismétlődik.

A következő szakaszokban láthatjuk, hogyan ütemezik és hajtják végre az alkalmazások ezeket az ügynököket.

3.3. Mesos keretrendszerek

A Mesos lehetővé teszi az alkalmazások számára egy absztrakt komponens megvalósítását, amely kölcsönhatásba lép a Mesterrel megkapja a fürtben rendelkezésre álló erőforrásokat és ráadásul ütemezési döntéseket hoz azok alapján. Ezeket az összetevőket keretként ismerjük.

A Mesos keretrendszer két alkomponensből áll:

  • Ütemező - Lehetővé teszi az alkalmazások számára a feladatok ütemezését az összes ügynök rendelkezésre álló erőforrásai alapján
  • Végrehajtó - Minden ügynökön fut, és minden információt tartalmaz, amely az ügynök bármely ütemezett feladatának végrehajtásához szükséges

Ez az egész folyamat ezzel az áramlással van ábrázolva:

Először az ügynökök jelentik erőforrásaikat a mesternek. Ebben a pillanatban a master felajánlja ezeket az erőforrásokat az összes regisztrált ütemezőnek. Ez a folyamat erőforrás-ajánlatként ismert, és a következő szakaszban részletesen megvitatjuk.

Ezután az ütemező kiválasztja a legjobb ügynököt, és különféle feladatokat hajt végre rajta a Mesteren keresztül. Amint a végrehajtó befejezi a kiosztott feladatot, az ügynökök újból közzéteszik erőforrásaikat a master számára. A Master megismétli az erőforrás-megosztás ezt a folyamatát a fürt összes keretrendszerénél.

Mesos lehetővé teszi az alkalmazások számára implementálják egyéni ütemezőjüket és végrehajtójukat különféle programozási nyelveken. Az ütemező Java implementációjának meg kell lennie megvalósítania Ütemező felület:

public class HelloWorldScheduler végrehajtja az ütemezőt {@Orride public void regisztrált (SchedulerDriver schedulerDriver, Protos.FrameworkID frameworkID, Protos.MasterInfo masterInfo) {} @Override public void újraregisztrált (SchedulerDriver SchulerDriverOfderer schedulerDriver, List list) {} @Orride public void offerRescinded (SchedulerDriver schedulerDriver, OfferID offerID) {} @Orride public void statusUpdate (SchedulerDriver schedulerDriver, Protos.TaskStatus taskStatus) {} @OverulidDriverDate , Protos.SlaveID slaveID, bájt [] bájt) {} @Orride public void disconnected (SchedulerDriver schedulerDriver) {} @Orride public void slaveLost (SchedulerDriver schedulerDriver, Protos.SlaveID schedulerDriver, Protos.SlaveID slaveIDravid .ExecutorID végrehajtóazonosító, Protos.SlaveID slaveID, i nt i) {} @Orride public void error (SchedulerDriver schedulerDriver, String s) {}}

Mint látható, többnyire abból áll különféle visszahívási módszerek a mesterrel való kommunikációhoz különösen.

Ehhez hasonlóan a végrehajtó végrehajtásának is végre kell hajtania a Végrehajtó felület:

public class HelloWorldExecutor végrehajtja az Executor {@Override public void regisztrált (ExecutorDriver illesztőprogram, Protos.ExecutorInfo végrehajtóInfo, Protos.FrameworkInfo frameworkInfo, Protos.SlaveInfo slaveInfo) {} @Override public voidroSliverSloverSloverSloverSloverSloverSloverSloverSloverSloverSloverSloverSloverSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSloveSlove.love.love.love.Reader_Server.Server.Reader.Slove.InfoRofile.lista public void disconnected (ExecutorDriver driver) {} @Orride public void launchTask (ExecutorDriver driver, Protos.TaskInfo task) {} @Orride public void killTask ​​(ExecutorDriver driver, Protos.TaskID taskId) {} ​​@Orride public void frameworkMrage (ExecutorD) bájt [] adatok) {} @Orride public void shutdown (ExecutorDriver driver) {}}

Az ütemező és végrehajtó operatív verzióját egy későbbi szakaszban láthatjuk.

4. Erőforrás-kezelés

4.1. Forrásajánlatok

Amint arról korábban tárgyaltunk, az ügynökök közzéteszik erőforrás-információikat a master számára. Viszont a master felajánlja ezeket az erőforrásokat a fürtben futó keretrendszereknek. Ez a folyamat a erőforrás ajánlat.

Az erőforrás-ajánlat két részből áll - erőforrásokból és attribútumokból.

A források megszokták közzéteszi az ügynökgép hardveres adatait mint például a memória, a CPU és a lemez.

Öt előre meghatározott erőforrás van minden ügynök számára:

  • processzor
  • gpus
  • mem
  • korong
  • kikötők

Ezen erőforrások értékei a három típus egyikében határozhatók meg:

  • Skalár - Numerikus információk ábrázolására lebegőpontos számokkal, olyan töredékértékek, mint például 1,5 G memória engedélyezéséhez
  • Hatótávolság - A skalárértékek - például egy porttartomány - képviseletére szolgál
  • Készlet - Több szövegérték képviseletére szolgál

Alapértelmezés szerint a Mesos-ügynök megpróbálja felismerni ezeket az erőforrásokat a gépből.

Bizonyos esetekben azonban konfigurálhatunk egyéni erőforrásokat egy ügynökön. Az ilyen egyéni erőforrások értékeinek ismét a fent tárgyalt típusok bármelyikében kell lenniük.

Például az alábbi forrásokkal indíthatjuk ügynökünket:

--resources = 'cpus: 24; gpus: 2; mem: 24576; lemez: 409600; portok: [21000-24000,30000-34000]; hibák (debug_role): {a, b, c}'

Mint látható, az ügynököt néhány előre definiált erőforrással és egy egyedi erőforrással neveztük el hibákat amely a készlet típus.

Az erőforrások mellett az ügynökök kulcsérték-attribútumokat is közzétehetnek a master számára. Ezek az attribútumok további metaadatokként működnek az ügynök számára, és segítséget nyújtanak a döntések ütemezéséhez.

Hasznos példa lehet ügynököket adjon különböző állványokba vagy zónákba és akkor ütemezzen különféle feladatokat ugyanazon állványon vagy zónán az adat lokalitásának eléréséhez:

--attributes = 'rack: abc; zóna: nyugati; os: centos5; szint: 10; kulcsok: [1000-1500]'

Az erőforrásokhoz hasonlóan az attribútumok értékei lehetnek skalár, tartomány vagy szövegtípus.

4.2. Erőforrás szerepek

Számos mai operációs rendszer több felhasználót támogat. Hasonlóképpen, a Mesos több felhasználót is támogat ugyanabban a fürtben. Ezek a felhasználók néven ismertek szerepek. Az egyes szerepeket erőforrás-fogyasztóként tekinthetjük egy fürtön belül.

Emiatt a Mesos-ügynökök feloszthatják az erőforrásokat különböző szerepkörök alatt, különböző allokációs stratégiák alapján. Ezenkívül a keretrendszerek feliratkozhatnak ezekre a szerepkörökre a fürtön belül, és alapos ellenőrzést gyakorolhatnak a különböző szerepkörök alatt lévő erőforrások felett.

Vegyük például a klasztereket tároló alkalmazások, amelyek különböző felhasználókat szolgálnak ki egy szervezetben. Tehát az erőforrásokat szerepekre osztva, minden alkalmazás külön-külön is működhet egymástól.

Ezenkívül a keretrendszerek felhasználhatják ezeket a szerepeket az adatok lokalitásának elérésére.

Tegyük fel például, hogy két alkalmazásunk van a megnevezett fürtben termelő és fogyasztó. Itt, termelő adatokat ír egy állandó kötetbe, amely fogyasztó utána tud olvasni. Optimalizálhatjuk a fogyasztó alkalmazás megosztásával a kötet a termelő.

Mivel a Mesos lehetővé teszi, hogy több alkalmazás feliratkozhasson ugyanarra a szerepre, társíthatjuk a tartós kötetet egy erőforrás-szerepkörhöz. Továbbá mindkettő keretei termelő és fogyasztó mindkettő ugyanarra az erőforrásszerepre fog feliratkozni. Ezért a fogyasztó alkalmazás elindíthatja az adatolvasási feladatot ugyanazon a köteten mint a termelő Alkalmazás.

4.3. Forrásfoglalás

Most felmerülhet a kérdés, hogyan osztja Mesos a fürt erőforrásait különböző szerepekre. Mesos fenntartások útján osztja ki az erőforrásokat.

Kétféle fenntartás létezik:

  • Statikus foglalás
  • Dinamikus foglalás

A statikus foglalás hasonló az erőforrás-hozzárendeléshez az ügynök indításakor, amelyet a korábbi szakaszokban tárgyaltunk:

 --resources = "cpus: 4; mem: 2048; cpus (baeldung): 8; mem (baeldung): 4096"

Az egyetlen különbség itt az, hogy most a Mesos-ügynök Nyolc CPU-t és 4096 m memóriát tart fenn a megnevezett szerephez baeldung.

A dinamikus foglalás lehetővé teszi számunkra, hogy a statikus fenntartással ellentétben átalakítsuk a szerepkörök erőforrásait. A Mesos lehetővé teszi a keretrendszerek és a fürtüzemeltetők számára, hogy az erőforrások felosztását dinamikusan módosítsák keretrendszer-üzenetek útján, válaszként az erőforrás-ajánlatra vagy a HTTP-végpontokon keresztül.

Mesos az összes erőforrást szerep nélkül allokálja a (*) nevű alapértelmezett szerepkörbe. A Master ilyen keretrendszereket kínál minden keretrendszernek, függetlenül attól, hogy feliratkoztak-e rá.

4.4. Erőforrás-súlyok és kvóták

Általában a Mesos mester erőforrásokat kínál méltányossági stratégia felhasználásával. A súlyozott domináns erőforrás-méltányosságot (wDRF) használja az erőforráshiányos szerepek azonosítására. Ezután a fő több erőforrást kínál azoknak a keretrendszereknek, amelyek feliratkoztak ezekre a szerepekre.

Bár az erőforrások igazságos megosztása az alkalmazások között fontos jellemzője Mesosnak, nem mindig szükséges. Tegyük fel, hogy egy olyan fürt, amely alacsony erőforrás-igényű alkalmazásokat tárol, valamint a nagy erőforrás-igényűek. Ilyen telepítéseknél erőforrásokat szeretnénk kiosztani az alkalmazás jellege alapján.

Mesos lehetővé teszi a keretrendszereket igényeljen több erőforrást a szerepkörökre való feliratkozással és a súly nagyobb súlyának hozzáadásával. Ebből kifolyólag, ha két szerep van, az egyik az 1. súlyú, a másik a 2. súlyú, akkor Mesos az erőforrások méltányos részesedésének kétszerét fogja elosztani a második szerephez.

Az erőforrásokhoz hasonlóan a súlyokat is konfigurálhatjuk HTTP végpontokon keresztül.

Az erőforrások méltányos arányának biztosítása mellett a súlyokkal való szerephez Mesos ezt is biztosítja egy szerep minimális erőforrásait elosztják.

Mesos megengedi nekünk kvótákat adjon hozzá az erőforrás-szerepkörökhöz. Kvóta határozza meg az a minimális erőforrásmennyiség, amelyet egy szerep garantáltan megkap.

5. Végrehajtási keretrendszer

Amint azt egy korábbi szakaszban tárgyaltuk, a Mesos lehetővé teszi az alkalmazások számára, hogy keretrendszereket valósítsanak meg az általuk választott nyelven. A Java-ban egy keretrendszert a főosztály - amely a keretrendszer folyamatának belépési pontjaként működik - és a Ütemező és Végrehajtó korábban tárgyaltuk.

5.1. Keret főosztály

Mielőtt bevezetnénk egy ütemezőt és egy végrehajtót, először be kell vezetnünk a keretrendszerünk belépési pontját, amely:

  • Regisztrálja magát a mesternél
  • Végrehajtó futásidejű információkat szolgáltat az ügynököknek
  • Elindítja az ütemezőt

Először hozzáadunk egy Maven-függőséget Mesoshoz:

 org.apache.mesos mesos 0.28.3 

Ezután megvalósítjuk a HelloWorldMain kereteinkhez. Az egyik első dolog, amit meg fogunk tenni, hogy elindítsuk a végrehajtó folyamatot a Mesos ügynökön:

public static void main (String [] args) {String path = System.getProperty ("user.dir") + "/target/libraries2-1.0.0-SNAPSHOT.jar"; CommandInfo.URI uri = CommandInfo.URI.newBuilder (). SetValue (elérési út) .setExtract (hamis) .build (); String helloWorldCommand = "java -cp könyvtárak2-1.0.0-SNAPSHOT.jar com.baeldung.mesos.executors.HelloWorldExecutor"; CommandInfo commandInfoHelloWorld = CommandInfo.newBuilder () .setValue (helloWorldCommand) .addUris (uri) .build (); ExecutorInfo executorHelloWorld = ExecutorInfo.newBuilder () .setExecutorId (Protos.ExecutorID.newBuilder () .setValue ("HelloWorldExecutor")) .setCommand (commandInfoHelloWorld) .setName ("Hello World (Java)." Hello World (Java). épít(); }

Itt először konfiguráltuk a végrehajtó bináris helyét. A Mesos-ügynök a regisztráció során letölti ezt a bináris fájlt. Ezután az ügynök futtatja a megadott parancsot a végrehajtó folyamat elindításához.

Ezután inicializáljuk a keretrendszert, és elindítjuk az ütemezőt:

FrameworkInfo.Builder frameworkBuilder = FrameworkInfo.newBuilder () .setFailoverTimeout (120000) .setUser ("") .setName ("Hello World Framework (Java)"); frameworkBuilder.setPrincipal ("test-framework-java"); MesosSchedulerDriver illesztőprogram = new MesosSchedulerDriver (új HelloWorldScheduler (), frameworkBuilder.build (), args [0]);

Végül, elkezdjük a MesosSchedulerDriver amely regisztrálja magát a Mesternél. A sikeres regisztrációhoz a Master IP-jét program argumentumként kell átadnunk args [0] ennek a fő osztálynak:

int állapot = driver.run () == Protos.Status.DRIVER_STOPPED? 0: 1; driver.stop (); System.exit (állapot);

A fenti osztályban CommandInfo, ExecutorInfo, és FrameworkInfo mind a protobuf üzenetek Java reprezentációi a master és a keretrendszerek között.

5.2. Ütemező megvalósítása

A Mesos 1.0 óta bármely HTTP alkalmazásból meghívhatjuk a HTTP végpontot, hogy üzeneteket küldjünk és fogadjunk a Mesos mesterhez. Ezen üzenetek közül néhány tartalmaz például keretregisztrációt, erőforrás-ajánlatokat és ajánlat-elutasításokat.

Mert Mesos 0,28 vagy korábbi, végre kell hajtanunk a Ütemező felület:

Nagyrészt csak a következőkre fogunk összpontosítani resourceOffers módszere Ütemező. Lássuk, hogyan fogadja az ütemező az erőforrásokat, és ezek alapján inicializálja a feladatokat.

Először meglátjuk, hogy az ütemező hogyan osztja el az erőforrásokat egy feladathoz:

@Orride public void resourceOffers (SchedulerDriver schedulerDriver, List list) {for (Ajánlati ajánlat: lista) {Lista feladatok = új ArrayList (); Protos.TaskID taskId = Protos.TaskID.newBuilder () .setValue (Integer.toString (launchTasks ++)). Build (); System.out.println ("A printHelloWorld elindítása" + taskId.getValue () + "Hello World Java"); Protos.Resource.Builder cpus = Protos.Resource.newBuilder () .setName ("cpus") .setType (Protos.Value.Type.SCALAR) .setScalar (Protos.Value.Scalar.newBuilder () .setValue (1)) ; Protos.Resource.Builder mem = Protos.Resource.newBuilder () .setName ("mem") .setType (Protos.Value.Type.SCALAR) .setScalar (Protos.Value.Scalar.newBuilder () .setValue (128)) ;

Itt 1 CPU-t és 128 MB memóriát rendeltünk el feladatunkhoz. Ezután a SchedulerDriver a feladat elindítása egy ügynökön:

 TaskInfo printHelloWorld = TaskInfo.newBuilder () .setName ("printHelloWorld" + taskId.getValue ()) .setTaskId (taskId) .setSlaveId (ajánlat.getSlaveId ()) .addResources (cpus) .addResourcesIn (Expusz). newBuilder (helloWorldExecutor)) .build (); Lista offerIDS = new ArrayList (); offerIDS.add (ajánlat.getId ()); feladatok.add (printHelloWorld); schedulerDriver.launchTasks (offerIDS, feladatok); }}

Alternatív megoldásként Ütemező gyakran úgy találja, hogy el kell utasítani az erőforrás-ajánlatokat. Például, ha a Ütemező Az erőforrások hiánya miatt nem tud feladatot indítani egy ügynökön, ezért azonnal el kell utasítania az ajánlatot:

schedulerDriver.declineOffer (ajánlat.getId ());

5.3. Végrehajtás Végrehajtó

Ahogy korábban megbeszéltük, a keretrendszer végrehajtó összetevője felelős a Mesos-ügynök alkalmazásfeladatainak végrehajtásáért.

A megvalósításhoz a HTTP végpontokat használtuk Ütemező a Mesos 1.0-ban. Hasonlóképpen használhatjuk a végrehajtó HTTP végpontját is.

Egy korábbi szakaszban megvitattuk, hogy a keretrendszer hogyan konfigurálja az ügynököt a végrehajtó folyamat elindításához:

java -cp libraries2-1.0.0-SNAPSHOT.jar com.baeldung.mesos.executors.HelloWorldExecutor

Nevezetesen, ez a parancs figyelembe veszi HelloWorldExecutor mint főosztály. Ezt megvalósítjuk fő- módszer a inicializálja a MesosExecutorDriver amely kapcsolatba lép a Mesos ügynökeivel feladatok fogadásához és egyéb információk, például a feladat állapotának megosztásához:

public class HelloWorldExecutor végrehajtja Executor {public static void main (String [] args) {MesosExecutorDriver driver = new MesosExecutorDriver (new HelloWorldExecutor ()); System.exit (driver.run () == Protos.Status.DRIVER_STOPPED? 0: 1); }}

Az utolsó tennivaló az, hogy elfogadja a keretből a feladatokat, és elindítja azokat az ügynökön. A feladatok elindításához szükséges információk a HelloWorldExecutor:

public void launchTask (ExecutorDriver illesztőprogram, TaskInfo feladat) {Protos.TaskStatus status = Protos.TaskStatus.newBuilder () .setTaskId (task.getTaskId ()) .setState (Protos.TaskState.TASK_RUNNING) .build (); driver.sendStatusUpdate (állapot); System.out.println ("Feladat végrehajtása !!!"); status = Protos.TaskStatus.newBuilder () .setTaskId (task.getTaskId ()) .setState (Protos.TaskState.TASK_FINISHED) .build (); driver.sendStatusUpdate (állapot); }

Természetesen ez csak egy egyszerű megvalósítás, de elmagyarázza, hogy egy végrehajtó hogyan osztja meg a feladat állapotát a masterrel minden szakaszban, majd végrehajtja a feladatot, mielőtt elküldené a befejezési állapotot.

Bizonyos esetekben a végrehajtók adatokat is visszaküldhetnek az ütemezőnek:

String myStatus = "Hello Framework"; driver.sendFrameworkMessage (myStatus.getBytes ());

6. Következtetés

Ebben a cikkben röviden megvitattuk az ugyanabban a fürtben futó alkalmazások közötti erőforrás-megosztást. Megbeszéltük azt is, hogy az Apache Mesos miként segíti az alkalmazásokat a maximális kihasználtság elérésében a fürt erőforrások, például a CPU és a memória elvont nézetével.

Később megbeszéltük a az erőforrások dinamikus elosztása az alkalmazások között alapján különféle méltányossági politikák és szerepek. A Mesos lehetővé teszi az alkalmazások elkészítését az erőforrás-ajánlatokon alapuló döntések ütemezése a klaszterben lévő Mesos-ügynököktől.

Végül láttuk a Mesos keretrendszer megvalósítását a Java-ban.

Szokás szerint az összes példa elérhető a GitHubon.