🥇Kubernetes útmutató, 1. rész: alkalmazások, mikroszolgáltatások és tartályok

Kérésünkre a Habr létrehozott egy központot Kubernetes és örömmel tesszük közzé az első bejegyzést benne. Iratkozz fel!

A Kubernetes egyszerű. Miért fizetnek nekem akkor a bankok nagy összegeket ezért a területért, amikor bárki elsajátíthatja ezt a technológiát mindössze néhány óra alatt?

Ha kételkedsz benne, hogy a Kubernetes ilyen gyorsan megtanulható — javaslom, próbáld meg saját magad. Ezen anyag elsajátításával képes leszel elindítani egy mikroszolgáltatásokra épülő alkalmazást egy Kubernetes klaszterben. Ezt garantálhatom, mivel éppen ezen az módszeren tanítom ügyfeleinket, akik a Kubernetes használatára szeretnének megtanulni. Mi különbözteti meg ezt az útmutatót másoktól? Valójában sok minden. Az ilyen anyagok többsége egyszerű dolgokkal kezdődik — a Kubernetes koncepcióival és a kubectl parancsok sajátosságaival. E segédletek szerzői azt hiszik, hogy az olvasóik ismerik az alkalmazásfejlesztést, a mikroszolgáltatásokat és a Docker konténereket. Mi azonban más utat választunk. Először megmutatjuk, hogyan indítható el a számítógépen egy mikroszolgáltatásokra épülő alkalmazás. Ezután megnézzük a konténerképek összeszerelését minden egyes mikroszolgáltatáshoz. Ezt követően ismerkedünk meg a Kubernetes-szel, és áttekintjük egy mikroszolgáltatásokra épülő alkalmazás telepítését a Kubernetes által kezelt klaszterben.

Ez a megközelítés, fokozatosan közelítve a Kuberneteshez, mélyebb megértést ad arról, hogy mi történik, ami szükséges ahhoz, hogy egy átlagos ember számára világos legyen, mennyire egyszerű is a Kubernetes. A Kubernetes kétségtelenül egy egyszerű technológia, feltéve, hogy az, aki szeretné elsajátítani, tudja, hol és hogyan használják.

Most, felesleges szavak nélkül, kezdjünk hozzá a munkánkhoz, és beszéljünk az alkalmazásról, amellyel dolgozni fogunk.

Kísérleti alkalmazás

Alkalmazásunk egyetlen funkciót fog ellátni. Egy mondatot vesz bemeneti adatként, majd szövegelemző eszközök segítségével elvégzi a mondat hangulatának (sentiment analysis) elemzését, amellyel megkapja az író érzelmi viszonyulását egy bizonyos objektumhoz.

Így néz ki ennek az alkalmazásnak a fő ablaka.

Webalkalmazás szövegek hangulati elemzésére

Technikai szempontból az alkalmazás három mikroservice-ből áll, amelyek mindegyike egy meghatározott feladatkört lát el:

SA-Frontend — Nginx webkiszolgáló, amely a React statikus fájlokat szolgálja ki.
SA-WebApp — Java nyelven írt webalkalmazás, amely feldolgozza a frontendtől érkező kéréseket.
SA-Logic — Python alkalmazás, amely a szöveg hangulatának elemzését végzi.

Fontos megjegyezni, hogy a mikroservice-ek nem elszigetelten működnek. Megvalósítják a „feladatkörök elkülönítésének” elvét, de szükségük van arra, hogy kapcsolatba lépjenek egymással.

Adatfolyamok az alkalmazásban

A fent idézett ábrán láthatók a rendszer működési fázisai, amelyek az alkalmazás adatfolyamait szemléltetik. Nézzük meg őket:

A böngésző fájlt kér a szervertől index.html (ami viszont a React alkalmazás csomagjának betöltését végzi).
A felhasználó interakcióba lép az alkalmazással, ami egy kérést vált ki a Spring alapú webalkalmazás felé.
A webalkalmazás a kérdést továbbítja a Python alkalmazásnak a szövegelemzés végrehajtására.
A Python alkalmazás végrehajtja a szöveg hangulatának elemzését, és a választ visszaküldi a kérésre.
A Spring alkalmazás a választ visszaküldi a React alkalmazásnak (amely ezután megjeleníti a szövegelemzés eredményét a felhasználónak).

A kódot ezekhez az alkalmazásokhoz megtalálhatja itt. Azt javaslom, hogy most azonnal másolja le ezt a repót, mert még sok érdekes kísérlet vár ránk vele.

Mikroszolgáltatás alapú alkalmazás indítása helyi számítógépen

Ahhoz, hogy az alkalmazás működjön, el kell indítanunk mindhárom mikroservice-t. Kezdjük a legszebbikkel — a frontend alkalmazással.

▍React beállítása helyi fejlesztéshez

Ahhoz, hogy elindítsa a React alkalmazást, telepítenie kell a Node.js platformot és az NPM-et a számítógépére. Miután ezeket telepítette, nyissa meg a terminált, és lépjen a projekt mappájába sa-frontend és futtassa a következő parancsot:

npm install

Ennek a parancsnak a végrehajtásával a React alkalmazás függőségei letöltődnek a mappába, node_modules amelyekről a package.jsonfájlban találhatóak. A függőségek letöltésének befejezése után a mappában futtasson egy ilyen parancsot:

npm start

Ennyi. Most a React alkalmazás fut, és elérheti a böngészőben a következő címen: localhost:3000. Bármilyen változtatást végezhet a kódjában. A módosítások hatását azonnal láthatja a böngészőben. Ez a „forró” modulcsere miatt lehetséges. Ennek köszönhetően a frontend fejlesztés egyszerű és kellemes tevékenységgé válik.

▍A React-alkalmazás előkészítése éles környezetbe

A React-alkalmazás valós felhasználásra való átalakításához statikus fájlok halmazává kell alakítanunk, és ezeket egy webszerver segítségével kell átadnunk az ügyfeleknek.

A React-alkalmazás felépítéséhez, ismét a terminál használatával, lépjen a mappába sa-frontend és futtassa a következő parancsot:

npm run build

Ez létrehoz egy mappát a projekt mappájában build. Ebben megtalálhatók a React-alkalmazás működéséhez szükséges összes statikus fájl.

▍Statikus fájlok kiszolgálása Nginx segítségével

Először telepíteni és elindítani kell az Nginx webszervert. Itt letöltse és keresse meg a telepítési és indítási útmutatót. Ezután másolja át a sa-frontend/build tartalmát a mappába [your_nginx_installation_dir]/html.

E megközelítés keretében a React-alkalmazás építése során generált fájl index.html az alábbi címen lesz elérhető: [your_nginx_installation_dir]/html/index.html. Ez az a fájl, amely alapértelmezés szerint az Nginx-szerver által szolgáltatott, amikor hozzáférünk. A szerver az 80portot figyeli, de úgy is beállítható, ahogyan szükséges, az [your_nginx_installation_dir]/conf/nginx.conf.

fájl szerkesztésével. Most nyissa meg a böngészőt, és navigáljon az alábbi címre:localhost:80

. Látni fogja a React-alkalmazás oldalát.

React-alkalmazás kiszolgálása Nginx által Ha most beír valamit a mezőbe, Type your sentence majd rákattint a Send

gombot, nem fog történni semmi. De ha megnézi a konzolt, ott hibaüzeneteket láthat. Annak megértésére, hogy hol történnek ezek a hibák, nézzük át az alkalmazás kódját.

▍A frontend alkalmazás kódjának elemzése App.jsHa megnézi a fájl kódját, majd rákattint a látni fogja, hogy a gomb megnyomása az analyzeSentence()módszert hívja meg. E módszer kódja az alábbiakban található. Kérjük, vegye figyelembe, hogy minden sorhoz, amelyhez megjegyzés tartozik, # Номерaz alábbiakban található magyarázat van. Így fogjuk elemezni a kód többi részét 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. A URL, ahol a POST-kérés végrehajtásra kerül. Feltételezzük, hogy ezen a címen egy alkalmazás vár ilyen kérdésekre.

2.A kérés törzse, amelyet az alkalmazásnak küldünk. Íme egy példa a kérés törzséhez:

{
    sentence: "Szeretem a yogobellát!"
}

3.A kérésre adott válasz megérkezésekor frissítjük a komponens állapotát. Ez újrarendelést vált ki a komponens esetében. Ha adatokat kapunk (azaz egy JSON-objektumot, amely tartalmazza a megadott adatokat és a szöveg kiértékelt eredményét), megjelenítjük a komponenst Polarizáció, mivel a megfelelő feltételek teljesülnek. Szóval így írjuk le a komponenst:

const polarityComponent = this.state.polarity !== undefined ?
     :
    null;

A kód, véleményem szerint, megfelelően működik. Mi is lehet itt a baj? Ha arra gondolsz, hogy azon a címen, ahova az alkalmazás a POST-kérését próbálja elküldeni, még nincs olyan dolog, ami ezt a kérést fogadni és feldolgozni tudná, akkor teljes mértékben igazad van. Ugyanis ahhoz, hogy a kérdéseket fogadni tudjuk a címen http://localhost:8080/sentiment, el kell indítanunk egy Spring alapú webalkalmazást.

Szükségünk van egy Spring alkalmazásra, amely képes fogadni a POST-kérelmet

▍Webalkalmazás beállítása, amely Spring alapú

Ahhoz, hogy a Spring alkalmazást telepíthessük, szükség lesz JDK8-ra és Mavenre, valamint megfelelően konfigurált környezeti változókra. Miután mindezt telepítetted, folytathatod a projektünk fejlesztését.

▍Az alkalmazás csomagolása jar fájlba

Navigálj a terminál segítségével a mappába sa-webapp és írd be a következő parancsot:

mvn install

E parancs végrehajtása után a mappában sa-webapp egy mappa jön létre target. Itt lesz megtalálható a Java alkalmazás, amely jar fájlba van csomagolva és amelyről a következő fájl gondoskodik: sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍A Java alkalmazás indítása

Nyissa meg a mappát target és indítsd el az alkalmazást a következő paranccsal:

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

A parancs végrehajtása során hiba lép fel. A hiba elhárításához elemezhetjük a kivétel információit a verem nyomvonalában:

Hiba a 'sentimentController' névvel rendelkező bean létrehozásakor: az autowired függőségek injektálása sikertelen; a belső kivétel java.lang.IllegalArgumentException: nem sikerült feloldani a '${sa.logic.api.url}' helyőrzőt a "${sa.logic.api.url}" értékben.

Számunkra a legfontosabb itt a hozzászólás arról, hogy lehetetlen meghatározni az értéket. sa.logic.api.url. Elemezzük a kódot, amelyben a hiba történik.

▍Java alkalmazás kódjának elemzése

Itt van a kód egy fragmentuma, amelyben a hiba történik.

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

AsentimentController mező van saLogicApiUrl. Az értékét a tulajdonság adja meg sa.logic.api.url.
A sor saLogicApiUrl a következő értékkel van összevonva /analyse/sentiment. Ezek együtt alkotják azt a címet, amelyen keresztül hívást indítunk a mikroszolgáltatásra, amely a szöveg elemzését végzi.

▍Tulajdonság értékének beállítása

A Spring keretrendszerben a tulajdonságértékek szabványos forrása egy fájl application.properties, amely a következő címen található sa-webapp/src/main/resources. De ennek használata nem az egyetlen módja a tulajdonságok értékeinek megadására. Ezt a következő formátumú parancs segítségével is megtehetjük:

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

Ennek a tulajdonságnak a értékének a mi Python alkalmazásunk címére kell mutatnia.

A beállításával értesítjük a Spring webalkalmazást arról, hová kell fordulnia a szövegelemzési kérések teljesítéséhez.

Annak érdekében, hogy ne bonyolítsuk túl a dolgunkat, döntsük el, hogy a Python alkalmazás a következő címen lesz elérhető localhost:5000 és igyekszünk ezt megjegyezni. Ennek eredményeként a Spring alkalmazás indításához a parancs így néz ki:

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

Rendszerünkből hiányzik a Python alkalmazás.

Most már csak annyit kell tennünk, hogy elindítjuk a Python alkalmazást, és a rendszerünk úgy fog működni, ahogyan azt elvártuk.

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

A Python alkalmazás elindításához telepítve kell lennie a Python 3-nak és a Pip-nek, és helyesen kell beállítani a megfelelő környezeti változókat.

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

Lépjen be a projekt mappájá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 függőségek telepítése után készen állunk az alkalmazás elindítására:

python sentiment_analysis.py

A parancs végrehajtása után a következőt fogjuk látni:

* Futtatás: http://0.0.0.0:5000/ (A kilépéshez nyomja meg a CTRL+C-t)

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

▍Kód elemzése

Vizsgáljuk meg a Python alkalmazás kódját, hogy megértsük, hogyan reagál 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

Objektum inicializálása Flask.
Cím megadása a POST kérések végrehajtásához.
Tulajdonság kinyerése sentence a kérés testéből.
Névtelen objektum inicializálása TextBlob és a polarity értékének kinyerése az első beérkezett mondatra (a mi esetünkben ez az egyetlen mondat, amelyet elemzésre küldünk).
Válasz visszaadása, amelynek törzsében a mondat szövege és a hozzá számított érték található. polarity.
A Flask alkalmazás elindítása, amely a következő címen érhető el 0.0.0.0:5000 (ezt a címet úgy is elérheti, hogy localhost:5000).

Most az alkalmazás mikro-szolgáltatásai elindultak. Ezek be vannak állítva, hogy kölcsönhatásba lépjenek egymással. Így néz ki az alkalmazás sémája ebben a munkafázisban.

Az összes mikro-szolgáltatás, amely az alkalmazást alkotja, működő állapotba került.

Most, mielőtt folytatnánk, nyissa meg a React alkalmazást a böngészőben, és próbáljon meg elemezni egy mondatot. Ha minden rendben van, a nyomógomb megnyomása után majd rákattint a látni fogja az elemzés eredményeit a szövegmező alatt.

A következő részben arról beszélünk, hogyan indíthatjuk el mikro-szolgáltatásainkat Docker konténerekben. Ez szükséges ahhoz, hogy az alkalmazást felkészítsük a Kubernetes klaszterben történő futtatásra.

Docker konténerek

Kubernetes — ez egy rendszer a konténerizált alkalmazások telepítésének, skálázásának és kezelésének automatizálására. Más néven "konténer-orchestrátornak" (container orchestrator) is nevezik. Ha a Kubernetes a konténerekkel foglalkozik, először beszereznünk kell a konténereket, mielőtt használni tudnánk ezt a rendszert. De először beszéljünk arról, hogy mik is azok a konténerek. Talán a legjobb válasz arra a kérdésre, hogy mik ezek, a dokumentáció Dockerből származik:

A konténer kép egy könnyű, független, futtatható csomag, amely egy adott alkalmazást tartalmaz, és mindent magában foglal, ami a futtatásához szükséges: az alkalmazás kódját, a végrehajtási környezetet, a rendszereszközöket és könyvtárakat, valamint a beállításokat. A konténerizált programok használhatók Linux és Windows környezetekben, és függetlenül az infrastruktúrától mindig egyformán fognak működni.

Ez azt jelenti, hogy a konténereket bármilyen számítógépen futtathatjuk, beleértve a termelési szervereket is, és bármilyen környezetben a bennük található alkalmazások azonos módon fognak működni.

Ahhoz, hogy megismerjük a konténerek jellemzőit és összehasonlítsuk őket más alkalmazásindítási módokkal, nézzük meg egy React-alkalmazás kiszolgálásának példáját virtuális gép és konténer használatával.

▍A React-alkalmazás statikus fájljainak kiszolgálása virtuális gép segítségével

A statikus fájlok virtuális gépek segítségével történő kiszolgálásának megkísérlése során a következő hátrányokkal találkozunk:

Erőforrások nem hatékony felhasználása, mivel minden egyes virtuális gép egy teljes operációs rendszert képvisel.
Platformfüggőség. Ami egy helyi számítógépen működik, az előfordulhat, hogy nem működik egy termelési szerveren.
Lassú és erőforrás-igényes skálázási megoldás, amely virtuális gépeken alapul.

Az Nginx webszerver, amely statikus fájlokat szolgál ki, virtuális gépen futva

Ha ugyanazt a feladatot konténerek alkalmazásával oldjuk meg, akkor a virtuális gépekhez képest a következő erősségeik emelhetők ki:

Erőforrások hatékony felhasználása: az operációs rendszerrel való munka Docker segítségével.
Platformfüggetlenség. Az a konténer, amelyet a fejlesztő a saját számítógépén futtat, bárhol működni fog.
Könnyed telepítés a képrétegek használatának köszönhetően.

Az Nginx webserver, amely statikus fájlokat szolgál ki, egy konténerben fut.

Csak néhány szempont alapján hasonlítottuk össze a virtuális gépeket és a konténereket, de ez is elegendő ahhoz, hogy érezzük a konténerek erősségeit. Itt részleteket talál a Docker konténerekről.

▍Konténerkép felépítése a React alkalmazáshoz

A Docker konténer alapvető építőeleme a fájl Dockerfile. E fájl elején a konténer alapképe kerül megadásra, majd egy utasítás sorozat következik, amely meghatározza a konténer felépítésének sorrendjét, amely megfelel egy alkalmazás igényeinek.

Mielőtt foglalkoznánk a fájllal Dockerfile, emlékezzünk arra, mit tettünk, hogy előkészítsük a React alkalmazás fájljait az Nginx szerverre történő telepítéshez:

A React alkalmazás csomagolása (npm run build).
Az Nginx szerver indítása.
A könyvtár tartalmának másolása build a projekt mappából sa-frontend a szerver mappájába nginx/html.

Az alábbiakban párhuzamokat láthatsz a konténer létrehozása és a helyi számítógépen végzett fent említett tevékenységek között.

▍Dockerfile előkészítése SA-Frontend alkalmazáshoz

Az utasítások, amelyek a benne szerepelnek Dockerfile az alkalmazás számára SA-Frontend, mindössze két parancsból állnak. Az Nginx fejlesztőcsoport egy alapot készített image az Nginx számára, amelyet használni fogunk a képünk létrehozásához. Íme a két lépés, amelyet le kell írni:

Az alapképet Nginx képként kell meghatározni.
A mappa tartalmát sa-frontend/build a konténer kép mappájába kell másolni. nginx/html.

Ha ezt a leírást átkonvertáljuk a fájlra Dockerfile, így fog kinézni:

FROM nginx
COPY build /usr/share/nginx/html

Ahogy látjátok, minden nagyon egyszerű, a fájl tartalma pedig tényleg jól olvasható és érthető. Ez a fájl azt mondja a rendszernek, hogy vegye el a képet nginx minden benne lévő dologgal együtt, és másolja a könyvtár tartalmát build a könyvtárba. nginx/html.

Itt felmerülhet a kérdés, hogy honnan tudom, hová kell másolni a fájlokat a könyvtárból build, vagyis — honnan származik az útvonal. /usr/share/nginx/htmlValójában itt sincs semmi bonyolult. A megfelelő információk megtalálhatók a leírásban. kép.

▍Kép létrehozása és feltöltése a tárolóba

Mielőtt elkezdhetnénk dolgozni a kész képpel, el kell küldenünk azt a képtárolóba. Ehhez egy ingyenes felhő alapú platformot használunk a képek tárolására, a Docker Hub-ot. Ezen a munkafázison a következő teendők vannak:

Telepítse Docker.
Regisztráljon a Docker Hub honlapján.
Jelentkezzen be a fiókjába a terminálban a következő parancs végrehajtásával:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Most a terminál segítségével lépjen a könyvtárba sa-frontend és ott hajtsa végre a következő parancsot:

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

A következő parancsokban $DOCKER_USER_ID azt az ön Docker Hub-beli felhasználónevére kell cserélni. Például, ez a parancs így nézhet ki: rinormaloku/sentiment-analysis-frontend.

Ebben az esetben ezt a parancsot a következőképpen lehet rövidíteni: -f Dockerfile, mivel a mappában, ahol ezt a parancsot végrehajtjuk, már ott van ez a fájl.

A kész kép tárolóba küldéséhez az alábbi parancsra lesz szükség:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

A végrehajtása után ellenőrizze a Docker Hub-on a tárolói listáját, hogy lássa, a kép küldése sikeres volt-e a felhőtárolóba.

▍Konténer indítása

Most bárki letöltheti és futtathatja a képet, amelyet így neveznek: $DOCKER_USER_ID/sentiment-analysis-frontend. Ehhez a következő parancsok sorozatát kell végrehajtani:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Most a konténer fut, és folytathatjuk a munkát, létrehozva más szükséges képeket. De mielőtt folytatnánk, nézzük át a 80:80, amely a kép indítási parancsában található, és lehet, hogy zavarónak tűnik.

Az első szám 80 — a gazdaszám (azaz a helyi számítógép) portszáma.
A második szám 80 — a konténer portja, ahová a kérésnek irányulnia kell.

Nézzük meg a következő ábrát.

Portok átirányítása

A rendszer átirányítja a kéréseket a <hostPort> portról a <containerPort>. Azaz a számítógép portjára irányuló kérés átirányításra kerül a konténer portjára. 80 Mivel a port 80 nyitva van a helyi számítógépen, a számítógépről az alkalmazásra a következő címen lehet hivatkozni

Mivel a port 80 nyitva van a helyi számítógépen, ezért erről a számítógépről az alkalmazásra a következő címen lehet hivatkozni Most nyissa meg a böngészőt, és navigáljon az alábbi címre:. Ha a rendszered nem támogatja a Dockert, az alkalmazás Docker virtuális gépen futtatható, amelynek címe a következőképpen néz ki :80. A Docker virtuális gép IP-címének megállapításához a következő parancsot használhatjuk docker-machine ip.

Ebben a szakaszban, miután a frontend alkalmazás konténere sikeresen elindult, lehetőséged van megnyitni annak oldalát a böngészőben.

▍.dockerignore fájl

Amikor az alkalmazás képét építjük SA-Frontend, észlelhettük, hogy ez a folyamat rendkívül lassú. Ez azért történik, mert a Docker démon számára el kell küldeni a kép építési kontextusát. Az építési kontextust meghatározó könyvtár a parancs utolsó argumentumaként van megadva, docker build. A mi esetünkben ennek a parancsnak a végén egy pont áll. Ez azt eredményezi, hogy a következő struktúra kerül bele az építési kontextusba:

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

De nekünk az itt található mappák közül csak a mappa kell build. Bármi más betöltése időpazarlás. Az építést felgyorsíthatjuk, ha megmondjuk a Dockernak, hogy mely könyvtárakat lehet figyelmen kívül hagyni. Erre való a .dockerignore. Ha ismered a fájlt, a fájl struktúrája biztosan ismerősnek tűnik. Ebben a fájlban azok a könyvtárak szerepelnek, amelyeket a képkészítő rendszer figyelmen kívül hagyhat. A mi esetünkben a fájl tartalma a következőképpen néz ki: .gitignorenode_modules src public

a fájlnak abban a mappában kell lennie, ahol a

Fájl .dockerignore . Mostantól a kép építése másodpercek kérdése lesz. DockerfileMost a Java alkalmazás képével foglalkozzunk.

▍Java alkalmazás konténerének képének építése

Tudod mit, már mindent megtanultál, ami szükséges a konténerképek készítéséhez. Éppen ezért ez a szakasz meglehetősen rövid lesz.

, amely a projekt mappájában található

Nyissa meg a fájlt Dockerfile. Ha elolvasod ennek a fájlnak a tartalmát, akkor csupán két új szerkezetet találhatsz, amelyek a következő kulcsszavakkal kezdődnek: sa-webappENV SA_LOGIC_API_URL http://localhost:5000 … EXPOSE 8080 ENV és EXPOSE:

A kulcsszó

lehetővé teszi a környezeti változók deklarálását a Docker konténerek belsejében. Különösen a mi esetünkben lehetővé teszi egy URL megadását az alkalmazás API-jának eléréséhez, amely a szövegelemzést végzi. ENV lehetővé teszi környezeti változók deklarálását a Docker konténereken belül. Különösen a mi esetünkben lehetővé teszi az alkalmazás API-jához való hozzáférés URL-jének megadását, amely szövegelemzést végez.

lehetővé teszi a környezeti változók deklarálását a Docker konténerek belsejében. Különösen a mi esetünkben lehetővé teszi egy URL megadását az alkalmazás API-jának eléréséhez, amely a szövegelemzést végzi. EXPOSE megengedi a Docker számára, hogy megnyissa a portot. Ezt a portot fogjuk használni az alkalmazásunk futása során. Itt észlelhetjük, hogy a Dockerfile az alkalmazás számára SA-Frontend ilyen parancs nem létezik. Ez csupán dokumentációs célokat szolgál, más szavakkal, ez a konstrukció azok számára készült, akik olvasni fogják. Dockerfile.

A képfájl összeállítása és a tárolóba történő küldése pontosan úgy néz ki, mint az előző példában. Ha még nem vagy teljesen biztos a dolgodban, a megfelelő parancsokat megtalálhatod a README.md mappában sa-webapp.

▍A Docker-kép összeállítása Python-alkalmazás számára

Ha megnézed a fájl tartalmát Dockerfile mappában sa-logic, akkor nem találsz benne semmi újat. A képfájl összeállításához és a tárolóba való küldéshez szükséges parancsok ismerősek lehetnek számodra, de ezeket, mint más alkalmazásainknál, a README.md mappában sa-logic.

▍Konténerizált alkalmazások tesztelése

Bízhatsz olyasmiben, amit nem teszteltél? Én sem tudok. Próbáljuk ki a konténereinket.

Indítsuk el az alkalmazás konténerét sa-logic és állítsuk be, hogy a 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Indítsuk el az alkalmazás konténerét sa-webapp és állítsuk be, hogy a 8080. Ezen kívül be kell állítanunk a portot, amelyen a Python-alkalmazás a Java-alkalmazástól érkező kéréseket várja, átnevezve a környezeti változót SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Annak érdekében, hogy megtudd, hogyan állapítsd meg a konténer vagy a Docker virtuális gép IP-címét, fordulj a README.

Indítsuk el az alkalmazás konténerét sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

Most minden készen áll arra, hogy a böngészőben a következő címen keressük fel Most nyissa meg a böngészőt, és navigáljon az alábbi címre: és teszteljük az alkalmazást.

Felhívjuk figyelmedet, hogy ha megváltoztattad a portot a sa-webapp, vagy ha Docker virtuális gépen dolgozol, módosítanod kell a fájlt App.js a mappából sa-frontend, megváltoztatva az IP-címet vagy a portszámot a módszerben, az analyzeSentence(), helyettesítve a régi adatokkal a megfelelő információkat. Ezután újra össze kell állítanod a képet, és használnod kell azt.

Így néz ki most a projektünk ábrája.

A mikroszolgáltatások konténerekben futnak.

Összefoglalás: miért szükségünk a Kubernetes klaszterre?

Éppen most tanulmányoztuk a fájlokat, Dockerfilebeszéltünk arról, hogyan kell képeket összeállítani és tárolókba küldeni. Ezen kívül megtanultuk felgyorsítani a képek összeállítását a fájl segítségével. .dockerignoreVégül a mikroszolgáltatásaink most Docker tartályokban futnak. Itt jogosan merülhet fel a kérdés, hogy miért van szükségünk Kubernetesre. A kérdésre adott válaszra a cikk második része fog összpontosítani. De addig is gondolkodjon el a következő kérdésen:
Tegyük fel, hogy a szövegelemző webalkalmazásunk világszerte népszerűvé vált. Percenként milliók keresnek rá. Ez azt jelenti, hogy a mikroszolgáltatások sa-webapp és sa-logic hatalmas terhelés alatt fognak állni. Hogyan skálázzuk a tartályokat, amelyekben a mikroszolgáltatások futnak?

Forrás: habr.com

Kubernetes útmutató, 1. rész: alkalmazások, mikroszolgáltatások és konténerek