ProHoster > Blog > Adminisztráció > Kubernetes oktatóanyag 1. rész: Alkalmazások, mikroszolgáltatások és tárolók
Kubernetes oktatóanyag 1. rész: Alkalmazások, mikroszolgáltatások és tárolók
Kérésünkre Habr létrehozott egy hubot Kubernetes és örömmel helyezzük el benne az első kiadványt. Iratkozz fel!
A Kubernetes egyszerű. Miért fizetnek nekem a bankok sok pénzt azért, hogy ezen a területen dolgozhassak, miközben bárki el tudja sajátítani ezt a technológiát néhány óra alatt?
Ha kétségei vannak abban, hogy a Kubernetes ilyen gyorsan megtanulható, azt javaslom, próbálja meg saját maga. Ugyanis ennek az anyagnak az elsajátításával képes lesz egy Kubernetes-fürtben mikroszolgáltatásokon alapuló alkalmazás futtatására. Ezt garantálhatom, mert az általam itt használt módszertanban tanítom meg ügyfeleinket a Kubernetes-el való munkavégzésre. Miben különbözik ez az útmutató a többitől? Valójában sok minden. Tehát a legtöbb ilyen anyag egyszerű dolgok magyarázatával kezdődik - a Kubernetes fogalmaival és a kubectl parancs jellemzőivel. E cikkek szerzői feltételezik, hogy olvasójuk ismeri az alkalmazásfejlesztést, a mikroszolgáltatásokat és a Docker-tárolókat. A másik irányba megyünk. Először is beszéljünk arról, hogyan lehet mikroszolgáltatásokon alapuló alkalmazást futtatni a számítógépen. Ezután megvizsgáljuk az egyes mikroszolgáltatásokhoz tartozó konténerképeket. Ezt követően pedig megismerkedünk a Kubernetes-szel, és elemezzük egy mikroszolgáltatásokon alapuló alkalmazás telepítését a Kubernetes által kezelt klaszterben.
Ez a megközelítés, a Kubernetes fokozatos megközelítésével, megadja a történések megértésének mélységét, amelyre az átlagembernek szüksége van ahhoz, hogy megértse, milyen egyszerűen minden el van rendezve a Kubernetesben. A Kubernetes minden bizonnyal egyszerű technológia, feltéve, hogy aki el akarja sajátítani, tudja, hol és hogyan használják.
Most pedig minden további nélkül kezdjük a munkát, és beszéljünk az alkalmazásról, amellyel dolgozni fogunk.
Kísérleti alkalmazás
Alkalmazásunk csak egy funkciót fog végrehajtani. Bemenetként egy mondatot vesz igénybe, majd a szövegelemző eszközök segítségével ennek a mondatnak a hangulatelemzését végzi el, értékelve a mondat szerzőjének egy bizonyos tárgyhoz való érzelmi attitűdjét.
Így néz ki az alkalmazás főablakja.
Hangulatelemző webalkalmazás
Technikai szempontból az alkalmazás három mikroszolgáltatásból áll, amelyek mindegyike egy bizonyos feladatsort old meg:
Az SA-Frontend egy Nginx webszerver, amely a React statikus fájlokat szolgálja ki.
Az SA-WebApp egy Java nyelven írt webalkalmazás, amely kezeli a frontendtől érkező kéréseket.
Az SA-Logic egy Python alkalmazás, amely szöveges hangulatelemzést végez.
Fontos megjegyezni, hogy a mikroszolgáltatások nem léteznek elszigetelten. Megvalósítják a "feladatok szétválasztásának" gondolatát, de ugyanakkor kölcsönhatásba kell lépniük egymással.
Adatáramlás az alkalmazásban
A fenti ábrán a rendszer számozott szakaszai láthatók, illusztrálva az alkalmazás adatfolyamait. Bontsuk fel őket:
A böngésző kér egy fájlt a szervertől index.html (ami viszont betölti a React alkalmazáscsomagot).
A felhasználó interakcióba lép az alkalmazással, ez egy Springen alapuló webalkalmazás hívását idézi elő.
A webalkalmazás továbbítja a szöveg elemzésére vonatkozó kérést a Python alkalmazásnak.
A Python alkalmazás elemzi a szöveg hangulatát, és az eredményt válaszként adja vissza a kérésre.
A Spring alkalmazás választ küld a React alkalmazásnak (amely viszont az elemzett szöveg eredményét mutatja a felhasználónak).
Ezeknek az alkalmazásoknak a kódja megtalálható itt. Azt javaslom, hogy most azonnal másold át magadnak ezt az adattárat, mivel sok érdekes kísérlet vár még ránk.
Mikroszolgáltatásokon alapuló alkalmazás futtatása a helyi gépen
Ahhoz, hogy az alkalmazás működjön, mindhárom mikroszolgáltatást el kell indítanunk. Kezdjük közülük a legszebbvel – a front-end alkalmazással.
▍A React beállítása a helyi fejlesztés érdekében
A React alkalmazás futtatásához telepítenie kell a Node.js keretrendszert és az NPM-et a számítógépére. Miután mindezt telepítette, a terminál használatával lépjen a projekt mappába sa-frontend és futtassa a következő parancsot:
npm install
A parancs végrehajtásával a mappában node_modules betöltődnek a React alkalmazás függőségei, amelyek rekordjai a fájlban vannak package.json. Miután letöltötte a függőségeket ugyanabban a mappában, futtassa a következő parancsot:
npm start
Ez minden. A React alkalmazás most fut, és a böngésző címére navigálva érhető el localhost:3000. Valamit megváltoztathatsz a kódjában. A módosítások hatását azonnal látni fogja a böngészőben. Ez a modulok úgynevezett "meleg" cseréjének köszönhetően lehetséges. Ennek köszönhetően a front-end fejlesztés egyszerű és élvezetes élménnyé válik.
▍React alkalmazás előkészítése élesre
A React alkalmazás tényleges használatához statikus fájlokká kell konvertálnunk, és webszerver segítségével ki kell szolgálnunk azokat az ügyfeleknek.
A React alkalmazás létrehozásához ismét a terminál használatával navigáljon a mappához sa-frontend és futtassa a következő parancsot:
npm run build
Ez létrehoz egy könyvtárat a projekt mappájában build. Tartalmazni fogja az összes statikus fájlt, amely a React alkalmazás működéséhez szükséges.
▍Statikus fájlok kiszolgálása az Nginx segítségével
Először telepítenie és futtatnia kell az Nginx webszervert. Itt letöltheti, és utasításokat talál a telepítéséhez és futtatásához. Ezután át kell másolnia a mappa tartalmát sa-frontend/build mappába [your_nginx_installation_dir]/html.
Ezzel a megközelítéssel a React alkalmazás összeállítása során generált fájl index.html címen lesz elérhető [your_nginx_installation_dir]/html/index.html. Ez az a fájl, amelyet alapértelmezés szerint az Nginx szerver kiad, amikor hozzáfér. A szerver úgy van beállítva, hogy egy porton figyeljen 80, de a fájl szerkesztésével a kívánt módon testreszabhatja [your_nginx_installation_dir]/conf/nginx.conf.
Most nyissa meg a böngészőt, és lépjen a következőre localhost:80. Látni fogja a React alkalmazás oldalát.
Az Nginx szerver által kiszolgált React alkalmazás
Ha most beír valamit a mezőbe Type your sentence és nyomja meg a gombot Send - semmi sem fog történni. De ha ránéz a konzolra, ott hibaüzeneteket láthat. Annak érdekében, hogy pontosan megértsük, hol fordulnak elő ezek a hibák, elemezzük az alkalmazás kódját.
▍A front-end alkalmazás kódjának elemzése
Nézzük a fájl kódját App.js, láthatjuk, hogy a gombra kattintva Send módszert nevezi analyzeSentence(). A módszer kódja alább látható. Ugyanakkor ügyeljen arra, hogy minden sorhoz, amelyhez az űrlap megjegyzése tartozik # Номер, a kód alatt található magyarázat. Ugyanígy elemezzük a többi kódrészletet is.
1. Az URL, amelyre a POST-kérés érkezik. Feltételezhető, hogy ez a cím egy ilyen kérésekre váró alkalmazás.
2.A kérelemhez küldött kérelmező szerv. Íme egy példa a kérelem törzsére:
{
sentence: "I like yogobella!"
}
3.Amikor válasz érkezik egy kérésre, az összetevő állapota frissül. Ez a komponens újbóli megjelenítését okozza. Ha adatokat kapunk (vagyis egy JSON objektumot, amely tartalmazza a bevitt adatokat és a számított szöveges pontszámot), akkor a komponenst kiadjuk. Polarityamíg a feltételek teljesülnek. Így írjuk le az összetevőt:
Úgy tűnik, a kód elég jól működik. Egyébként mi a baj itt? Ha azt feltételezi, hogy azon a címen, amelyre az alkalmazás POST kérést próbál küldeni, még nincs semmi, ami elfogadná és feldolgozná ezt a kérést, akkor teljesen igaza lesz. Mégpedig a címre érkező kérések feldolgozására http://localhost:8080/sentiment, a tavaszi alapú webalkalmazást kell futtatnunk.
Szükségünk van egy tavaszi alkalmazásra, amely képes elfogadni a POST kérést
▍Webes alkalmazás beállítása Spring alapján
A Spring alkalmazás üzembe helyezéséhez JDK8 és Maven, valamint megfelelően konfigurált környezeti változók szükségesek. Miután mindezt telepítette, folytathatja a munkát a projektünkön.
▍Az alkalmazás becsomagolása jar fájlba
A terminál használatával navigáljon a mappához sa-webapp és írja be a következő parancsot:
mvn install
A parancs végrehajtása után a mappában sa-webapp könyvtár jön létre target. Ez az a hely, ahol a Java alkalmazás található, egy jar fájlba csomagolva, amelyet a fájl képvisel sentiment-analysis-web-0.0.1-SNAPSHOT.jar.
▍ Java alkalmazás indítása
Menjen a mappába target és futtassa az alkalmazást a következő paranccsal:
A parancs végrehajtása közben hiba történik. A javítás megkezdéséhez elemezhetjük a kivétel részleteit a verem nyomkövetési adataiban:
Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"
Számunkra itt a legfontosabb a jelentés tisztázásának lehetetlenségének megemlítése sa.logic.api.url. Elemezzük a kódot, ahol a hiba előfordul.
▍Java alkalmazáskód elemzése
Itt van a kódrészlet, ahol a hiba előfordul.
@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
@Value("${sa.logic.api.url}") // #1
private String saLogicApiUrl;
@PostMapping("/sentiment")
public SentimentDto sentimentAnalysis(
@RequestBody SentenceDto sentenceDto)
{
RestTemplate restTemplate = new RestTemplate();
return restTemplate.postForEntity(
saLogicApiUrl + "/analyse/sentiment", // #2
sentenceDto, SentimentDto.class)
.getBody();
}
}
SentimentController van egy mező saLogicApiUrl. Értékét az ingatlan határozza meg sa.logic.api.url.
Vonal saLogicApiUrl összefűződik az értékkel /analyse/sentiment. Ezek együtt egy címet alkotnak a szövegelemzést végző mikroszolgáltatás felhívásához.
▍Tulajdonság értékének beállítása
Tavasszal a tulajdonságértékek alapértelmezett forrása egy fájl application.properties, amely a címen található sa-webapp/src/main/resources. De nem az egyetlen módja a tulajdonságértékek beállításának. Ezt a következő paranccsal is megteheti:
A tulajdonság értékének a Python-alkalmazásunk címére kell mutatnia.
A konfigurálásával közöljük a Spring webalkalmazással, hogy hova kell mennie a szövegelemzési kérelmek végrehajtásához.
Hogy ne bonyolítsuk az életünket, úgy döntünk, hogy a Python alkalmazás elérhető lesz a címen localhost:5000 és próbálj meg nem feledkezni róla. Ennek eredményeként a Spring alkalmazás indításának parancsa így fog kinézni:
Ingatlan visszaszerzése sentence a kérelmező szervtől.
Névtelen objektum inicializálás TextBlob és megszerezni az értéket polarity a kérelem törzsében beérkezett első javaslatra (esetünkben ez az egyetlen elemzésre benyújtott javaslat).
Válasz visszaküldése, melynek törzsében az ajánlat szövege és a hozzá számított mutató szerepel polarity.
A Flask alkalmazás elindítása, amely a címen lesz elérhető 0.0.0.0:5000 (az űrlap konstrukciójával is elérheti localhost:5000).
Most már futnak az alkalmazást alkotó mikroszolgáltatások. Úgy vannak beállítva, hogy kölcsönhatásba lépjenek egymással. Így néz ki az alkalmazási diagram a munka ezen szakaszában.
Az alkalmazást alkotó összes mikroszolgáltatás egészséges állapotba kerül
Most, mielőtt folytatnánk, nyissa meg a React alkalmazást egy böngészőben, és próbáljon meg elemezni vele néhány mondatot. Ha minden helyesen történik - a gomb megnyomása után Send az elemzés eredményeit a szövegmező alatt láthatja.
A következő részben arról fogunk beszélni, hogyan futtassuk mikroszolgáltatásainkat Docker konténerekben. Erre azért van szükség, hogy az alkalmazást a Kubernetes-fürtben való futtatásra előkészítse.
Docker konténerek
Kubernetes a konténeres alkalmazások telepítésének, méretezésének és kezelésének automatizálására szolgáló rendszer. "Container Orchestrator"-nak is nevezik. Ha a Kubernetes konténerekkel működik, akkor a rendszer használata előtt először be kell szereznünk ezeket a konténereket. De először beszéljünk arról, mik azok a konténerek. Talán a legjobb válasz arra a kérdésre, hogy mi ez dokumentáció Dockerhez:
A konténerkép egy könnyű, önálló, futtatható csomag, amely egy alkalmazást tartalmaz, amely tartalmazza a futtatásához szükséges mindent: alkalmazáskódot, futási környezetet, rendszereszközöket és -könyvtárakat, beállításokat. A konténeres programok Linux és Windows környezetben is használhatók, és az infrastruktúrától függetlenül mindig ugyanúgy működnek.
Ez azt jelenti, hogy a konténerek bármilyen számítógépen futtathatók, beleértve a termelési szervereket is, és bármilyen környezetben a bennük lévő alkalmazások ugyanúgy működnek.
A tárolók funkcióinak felfedezéséhez és az alkalmazások futtatásának más módjaival való összehasonlításához nézzük meg a React-alkalmazások virtuális gép és tároló használatával történő kiszolgálásának példáját.
▍React alkalmazás statikus fájljainak kiszolgálása virtuális gép segítségével
Ha a statikus fájlok karbantartását virtuális gépekkel próbáljuk megszervezni, a következő hátrányokkal találkozunk:
Az erőforrások nem hatékony felhasználása, mivel minden virtuális gép egy komplett operációs rendszer.
Platformfüggőség. Ami néhány helyi számítógépen működik, az lehet, hogy nem működik egy éles kiszolgálón.
A virtuálisgép-megoldás lassú és erőforrásigényes skálázása.
Virtuális gépen futó statikus fájlokat kiszolgáló Nginx webszerver
Ha konténereket használnak hasonló probléma megoldására, akkor a virtuális gépekkel összehasonlítva a következő erősségek figyelhetők meg:
Erőforrások hatékony felhasználása: dolgozzon az operációs rendszerrel a Docker segítségével.
Platformfüggetlenség. A fejlesztő által a saját számítógépén futtatható tároló bárhol futni fog.
Könnyű telepítés képrétegek használatával.
Nginx webszerver, amely egy tárolóban futó statikus fájlokat szolgál ki
A virtuális gépeket és a konténereket csak néhány ponton hasonlítottuk össze, de még ez is elég ahhoz, hogy átérezzük a konténerek erősségeit. Itt Részleteket talál a Docker konténerekről.
▍Konténerkép készítése egy React alkalmazáshoz
A Docker-tároló alapvető építőeleme a fájl Dockerfile. Ennek a fájlnak az elején rögzítésre kerül a tároló alapképe, majd egy utasítássorozatot tartalmaz, amely bemutatja, hogyan kell létrehozni egy olyan tárolót, amely megfelel egy alkalmazás igényeinek.
Mielőtt elkezdenénk dolgozni a fájllal Dockerfile, ne feledje, mit tettünk annak érdekében, hogy előkészítsük a React alkalmazás fájljait az Nginx szerverre való feltöltésre:
React alkalmazáscsomag készítése (npm run build).
Az Nginx szerver indítása.
Könyvtár tartalmának másolása build projekt mappából sa-frontend a szerver mappájába nginx/html.
Az alábbiakban láthatja a párhuzamot a tároló létrehozása és a fenti, a helyi számítógépen végrehajtott műveletek között.
▍Dokkerfájl előkészítése az SA-Frontend alkalmazáshoz
Hozzá kell tenni az utasításokat Dockerfile alkalmazásra SA-Frontend, csak két parancsból áll. A helyzet az, hogy az Nginx fejlesztőcsapata elkészítette az alapokat kép az Nginx számára, amelyet az arculatunk felépítéséhez fogunk használni. Itt van a két lépés, amelyet le kell írnunk:
Az Nginx-képet kell a kép alapjává tenni.
Mappa tartalma sa-frontend/build át kell másolni a kép mappába nginx/html.
Ha ettől a leírástól a fájlhoz megyünk Dockerfile, akkor így fog kinézni:
FROM nginx
COPY build /usr/share/nginx/html
Amint látja, itt minden nagyon egyszerű, miközben a fájl tartalma még jól olvashatónak és érthetőnek bizonyul. Ez a fájl utasítja a rendszert, hogy készítse el a képet nginx mindennel, amivel már rendelkezik, és másolja ki a könyvtár tartalmát build a címtárba nginx/html.
Itt felmerülhet egy kérdés, hogy honnan tudom, hogy pontosan hova kell másolni a fájlokat a mappából build, azaz honnan jött az út /usr/share/nginx/html. Valójában itt sincs semmi bonyolult. Az a tény, hogy a vonatkozó információk megtalálhatók a leírás kép.
▍A kép összeállítása és feltöltése az adattárba
Mielőtt egy kész képpel dolgozhatnánk, be kell küldenünk a képtárba. Ehhez az ingyenes felhő alapú Docker Hub képtárolási platformot fogjuk használni. A munka ezen szakaszában a következőket kell tennie:
Itt és lent hasonló parancsokban $DOCKER_USER_ID le kell cserélni a felhasználónevére a Docker Hubon. Például a parancsnak ez a része így nézhet ki: rinormaloku/sentiment-analysis-frontend.
Ebben az esetben ez a parancs lerövidíthető, ha eltávolítjuk belőle -f Dockerfile, mivel abban a mappában, amelyben ezt a parancsot végrehajtjuk, már van ez a fájl.
A kész kép tárba küldéséhez a következő parancsra van szükségünk:
A befejezése után ellenőrizze a Docker Hub tárolóinak listáját, és ellenőrizze, hogy a kép sikeresen továbbításra került-e a felhőtárhelyre.
▍Konténer indítása
Most már bárki letöltheti és futtathatja az úgynevezett képet $DOCKER_USER_ID/sentiment-analysis-frontend. Ehhez a következő parancssort kell futtatnia:
docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Most a tároló fut, és folytathatjuk a munkát más szükséges képek létrehozásával. De mielőtt folytatnánk, értsük meg a tervezést 80:80, amely a kép futtatására szolgáló parancsban található, és zavarónak tűnhet.
Első szám 80 a gazdagép (vagyis a helyi számítógép) portszáma.
Második szám 80 a konténer kikötője, ahová a kérést át kell irányítani.
Vegye figyelembe a következő illusztrációt.
Port Forwarding
A rendszer a porttól továbbítja a kéréseket <hostPort> a kikötőbe <containerPort>. Vagyis a kikötő elérése 80 számítógép át van irányítva egy portra 80 tartály.
A kikötő óta 80 a helyi számítógépen megnyitva az alkalmazást erről a számítógépről a következő címen érheti el localhost:80. Ha a rendszer nem támogatja a Dockert, az alkalmazást futtathatja egy Docker virtuális gépen, amelynek címe így fog kinézni <docker-machine ip>:80. A Docker virtuális gép IP-címének megtudásához használja a parancsot docker-machine ip.
Ezen a ponton, miután az előtérbeli alkalmazástároló sikeresen elindult, meg kell tudnia nyitni az oldalát egy böngészőben.
▍.dockerignore fájl
Az alkalmazás képének elkészítése SA-Frontend, észrevehettük, hogy ez a folyamat rendkívül lassú. Ennek az az oka, hogy a képfelépítési környezetet el kell küldeni a Docker démonnak. A felépítési környezetet képviselő könyvtár a parancs utolsó argumentumaként van megadva docker build. Esetünkben ennek a parancsnak a végén van egy pont. Ennek eredményeként a következő struktúra szerepel az összeállítási kontextusban:
De az itt található összes mappa közül csak egy mappára van szükségünk build. Bármi más letöltése időpocsékolás. Felgyorsíthatja a felépítést, ha megadja a Dockernek, hogy mely könyvtárakat hagyja figyelmen kívül. Ehhez szükségünk van egy fájlra .dockerignore. Ön, ha ismeri a fájlt .gitignore, ennek a fájlnak a szerkezete valószínűleg ismerősnek tűnik. Felsorolja azokat a könyvtárakat, amelyeket az image build rendszer figyelmen kívül hagyhat. A mi esetünkben ennek a fájlnak a tartalma így néz ki:
node_modules
src
public
fájl .dockerignore ugyanabban a mappában kell lennie, mint a fájlnak Dockerfile. Most a kép összeállítása néhány másodpercet vesz igénybe.
Most foglalkozzunk egy Java-alkalmazás képével.
▍Konténer kép létrehozása egy Java-alkalmazáshoz
Tudja mit, és már mindent megtanult, ami a tárolóképek létrehozásához szükséges. Ezért lesz ez a rész nagyon rövid.
Nyissa meg a fájlt Dockerfile, amely a projekt mappájában található sa-webapp. Ha elolvassa ennek a fájlnak a szövegét, akkor csak két új konstrukcióval találkozik, amelyek kulcsszavakkal kezdődnek ENV и EXPOSE:
Kulcsszó ENV lehetővé teszi a környezeti változók deklarálását a Docker-tárolókon belül. Esetünkben különösen lehetővé teszi egy URL beállítását a szövegelemzést végző alkalmazás API-jának eléréséhez.
Kulcsszó EXPOSE lehetővé teszi, hogy megmondja a Dockernek, hogy nyissa meg a portot. Ezt a portot fogjuk használni, amikor az alkalmazással dolgozunk. Itt ezt láthatod Dockerfile alkalmazásra SA-Frontend nincs ilyen parancs. Ez csak dokumentációs célokat szolgál, más szóval ez a konstrukció az olvasóé Dockerfile.
A kép elkészítése és a tárolóba helyezése pontosan úgy néz ki, mint az előző példában. Ha még nem vagy nagyon magabiztos a képességeidben, a megfelelő parancsokat megtalálod a fájlban README.md mappában sa-webapp.
▍Konténerkép készítése Python alkalmazáshoz
Ha egy pillantást vet a fájl tartalmára Dockerfile mappában sa-logicnem találsz ott semmi újat. A kép készítéséhez és a tárba tolásához szükséges parancsok már ismerősek lehetnek, de a többi alkalmazásunkhoz hasonlóan a fájlban találhatók. README.md mappában sa-logic.
▍Konténeres alkalmazások tesztelése
Megbízhat valamiben, amit még nem tesztelt? én sem tudok. Teszteljük a konténereinket.
Indítsuk el az alkalmazástárolót sa-logic és konfigurálja úgy, hogy egy porton hallgasson 5050:
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
Indítsuk el az alkalmazástárolót sa-webapp és konfigurálja úgy, hogy egy porton hallgasson 8080. Ezenkívül be kell állítanunk azt a portot, amelyen a Python alkalmazás figyelni fogja a Java alkalmazástól érkező kéréseket a környezeti változó újbóli hozzárendelésével SA_LOGIC_API_URL:
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
Ha meg szeretné tudni, hogyan tudhatja meg egy tároló vagy Docker virtuális gép IP-címét, tekintse meg a fájlt README.
Indítsuk el az alkalmazástárolót sa-frontend:
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
Most már minden készen áll, hogy a böngészőben navigáljon a címre localhost:80 és tesztelje az alkalmazást.
Kérjük, vegye figyelembe, hogy ha megváltoztatja a portot sa-webapp, vagy ha Docker virtuális gépet használ, szerkesztenie kell a fájlt App.js mappából sa-frontendaz IP-cím vagy a portszám módosításával a metódusban analyzeSentence()az elavult adatok helyett aktuális információk helyettesítésével. Ezt követően újra össze kell szerelnie a képet és használnia kell.
Így néz ki most az alkalmazási diagramunk.
A mikroszolgáltatások konténerekben futnak
Összegzés: miért van szükségünk Kubernetes klaszterre?
Most néztük át a fájlokat Dockerfile, arról beszélt, hogyan lehet képeket készíteni és Docker-tárba tolni. Ezen kívül megtanultuk, hogyan lehet a fájl segítségével felgyorsítani a képek összeállítását .dockerignore. Ennek eredményeként mikroszolgáltatásaink most Docker konténerekben futnak. Itt teljesen jogos kérdés merülhet fel, hogy miért van szükségünk a Kubernetesre. A kérdésre adott választ az anyag második részében fogjuk szentelni. Addig is fontolja meg a következő kérdést:
Tegyük fel, hogy szövegelemző webalkalmazásunk világszerte népszerűvé vált. Percenként milliónyi kérés érkezik hozzá. Ez azt jelenti, hogy mikroszolgáltatások sa-webapp и sa-logic hatalmas stressz alatt lesz. Hogyan lehet méretezni a mikroszolgáltatásokat futtató konténereket?