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:

1. A böngésző kér egy fájlt a szervertől index.html (ami viszont betölti a React alkalmazáscsomagot).
2. A felhasználó interakcióba lép az alkalmazással, ez egy Springen alapuló webalkalmazás hívását idézi elő.
3. A webalkalmazás továbbítja a szöveg elemzésére vonatkozó kérést a Python alkalmazásnak.
4. A Python alkalmazás elemzi a szöveg hangulatát, és az eredményt válaszként adja vissza a kérésre.
5. 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.

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

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:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

Ú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:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

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();
    }
}

1. SentimentController van egy mező saLogicApiUrl. Értékét az ingatlan határozza meg sa.logic.api.url.
2. 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:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

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:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

Rendszerünkből hiányzik egy Python alkalmazás

Most már csak le kell futtatnunk a Python alkalmazást, és a rendszer a várt módon fog működni.

▍Python alkalmazás beállítása

Egy Python-alkalmazás futtatásához telepíteni kell a Python 3-at és a Pip-et, és megfelelően be kell állítani a megfelelő környezeti változókat.

▍Függőségek telepítése

Lépjen a projekt mappába sa-logic/sa és futtassa a következő parancsokat:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍Alkalmazás indítása

A telepített függőségek után készen állunk az alkalmazás futtatására:

python sentiment_analysis.py

A parancs végrehajtása után a következőket kapjuk:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

Ez azt jelenti, hogy az alkalmazás fut, és a következő címen várja a kéréseket localhost:5000/

▍Kódkutatás

Nézzük meg a Python alkalmazáskódot, hogy megértsük, hogyan válaszol a kérésekre:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

1. Objektum inicializálás Flask.
2. A cím megadása a POST-kérésekhez.
3. Ingatlan visszaszerzése sentence a kérelmező szervtől.
4. 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).
5. Válasz visszaküldése, melynek törzsében az ajánlat szövege és a hozzá számított mutató szerepel polarity.
6. 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űsúlyú, önálló, futtatható csomag, amely egy alkalmazást tartalmaz, és mindent tartalmaz, ami a futtatásához szükséges: alkalmazáskódot, futási környezetet, rendszereszközöket és könyvtárakat, valamint beállításokat. A konténerizált programok használhatók olyan környezetekben, amelyek Linux и Windows, és mindig ugyanúgy fognak működni, függetlenül az infrastruktúrától.

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:

1. Az erőforrások nem hatékony felhasználása, mivel minden virtuális gép egy komplett operációs rendszer.
2. 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.
3. 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:

1. Erőforrások hatékony felhasználása: dolgozzon az operációs rendszerrel a Docker segítségével.
2. Platformfüggetlenség. A fejlesztő által a saját számítógépén futtatható tároló bárhol futni fog.
3. 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:

1. React alkalmazáscsomag készítése (npm run build).
2. Az Nginx szerver indítása.
3. 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:

1. Az Nginx-képet kell a kép alapjává tenni.
2. 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:

1. megállapítása Dokkmunkás.
2. Regisztráljon a Docker Hub webhelyén.
3. Jelentkezzen be fiókjába a következő parancs futtatásával a terminálban:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

Most a terminál használatával el kell lépnie a könyvtárba sa-frontend és ott futtasd a következő parancsot:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

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:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

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:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

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:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

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.

1. 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

2. 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?

Forrás: will.com