🥇Kubernetes'i juhend, osa 1: rakendused, mikroteenused ja konteinerid

Meie palvele vastates lõi Habr keskuse Kubernetes ja meil on hea meel avaldada selles meie esimene artikkel. Liituge meiega!

Kubernetes on lihtne. Miks maksavad pangad mulle selle valdkonna eest suuri summasid, kui igaüks võib selle tehnoloogia õige pea selgeks õppida?

Kui te kahtlete, kas Kubernetes on võimalik nii kiiresti omandada, siis proovige seda ise. Nimelt, pärast selle materjali selgeks õppimist suudate te käivitada mikroteenustel põhineva rakenduse Kubernetes'e klastris. Ma võin seda garanteerida, kuna just sellise meetodiga, mida siin kasutatakse, koolitan ma meie kliente Kubernetes'ega töötama. Mis eristab seda juhendit teistest? Tegelikult on neid palju. Enamiku sarnaste materjalide algus keskendub lihtsate asjade selgitamisele — Kubernetes'e kontseptsioonidele ja kubectl'i käsu eripäradele. Nende materjalide autorid eeldavad, et nende lugeja on tuttav rakenduste arendamisega, mikroteenustega ja Docker'i konteineritega. Me järgime aga teistsugust teed. Alustame sellega, kuidas käivitada arvutis mikroteenustel põhinev rakendus. Seejärel vaatame konteinerite piltide koostamist iga mikroteenuse jaoks. Ja juba pärast seda tutvume Kubernetes'ega ning arutame mikroteenustel põhineva rakenduse juurutamist Kubernetes'e haldatud klastris.

Selline lähenemine, mis samm-sammult siseneb Kubernetesesse, annab tavalisele inimesele sügava arusaamise, mis toimub, ning vajalikud teadmised, et mõista, kui lihtne Kubernetes tegelikult on. Kubernetes on kindlasti lihtne tehnoloogia, tingimusel et selle kasutaja teab, kus ja kuidas seda kasutatakse.

Nüüd, ilma liigsete sõnadeta, asume tööle ja räägime rakendusest, millega me töötame.

Eksperimentaalne rakendus

Meie rakendus täidab vaid ühte funktsiooni. See võtab sisendina ühe lause ja analüüsib selle abil, kasutades tekstianalüüsi vahendeid, lause tonaalsust (sentiment analysis), andes emotsionaalse suhtumise hinnangu lause autori poolt mingi objekti suhtes.

Nii näeb välja selle rakenduse põhaken.

Veebirakendus tekstide tonaalsuse analüüsimiseks

Tehniliselt koosneb rakendus kolmest mikroteenusest, millest igaüks lahendab kindlat ülesannete kogumit:

SA-Frontend — veebiserver Nginx, mis teenindab Reacti staatilisi faile.
SA-WebApp — Java-l põhinev veebirakendus, mis töötleb päringud frontendilt.
SA-Logic — Pythoni rakendus, mis teostab teksti toonianalüüsi.

Oluline on märkida, et mikroteenused ei eksisteeri eraldi. Need teostavad kohustuste jagamise ideed, kuid peavad seejuures omavahel suhtlema.

Rakenduse andmevood

Ülaltoodud skeemil on nähtavad nummerdatud etapid, mis illustreerivad andmevooge rakenduses. Vaatame neid lähemalt:

Brauser küsib serverilt faili index.html (mis omakorda käivitab React-rakenduse paketi laadimise).
Kasutaja suhtleb rakendusega, mis kutsub esile päringu Springi põhisele veebirakendusele.
Veebirakendus suunab päringu teksti analüüsimiseks Pythoni rakendusele.
Pythoni rakendus teeb teksti toonianalüüsi ja tagastab tulemuse päringule vastusena.
Springi rakendus saadab vastuse React-rakendusele (mis omakorda näitab analüüsi tulemust kasutajale).

Kõikide nende rakenduste koodi leiate siit. Soovitan sul kohe ära kopeerida see repositoorium, sest ees on meid ootamas palju huvitavaid katsetusi sellega.

Mikroteenustel põhineva rakenduse käivitamine kohalikul arvutil

Et rakendus toimiks, peame käivitama kõik kolm mikroteenust. Alustame neist kõige toredamast — esikülje rakendusest.

▍Reacti seadistamine kohalikuks arenduseks

React-rakenduse käivitamiseks peab sul olema arvutisse installitud Node.js ja NPM. Pärast nende paigaldamist mine terminalis projekti kausta sa-frontend ja tee järgmine käsk:

npm install

Käsku täites laaditakse kausta node_modules React-rakenduse sõltuvused, mille kohta andmed on failis package.json. Kui sõltuvuste laadimine on lõpetatud, tee samas kaustas järgmine käsk:

npm start

Ja ongi kõik. Nüüd on React-rakendus käivitatud, sellele pääseb ligi, minnes brauseris aadressile localhost:3000. Saate selle koodi midagi muuta. Nende muudatuste mõju on kohe näha brauseris. See on võimalik tänu nn „kuumale“ moodulite asendamisele. See muudab esmakordselt arendamise lihtsaks ja meeldivaks tegevuseks.

▍React-rakenduse ettevalmistamine tootmiseks

React-rakenduse reaalseks kasutamiseks peame selle muutma staatilisteks failideks ja edastama need klientidele veebiserveri kaudu.

React-rakenduse koostamiseks minge uuesti terminalis kausta sa-frontend ja tee järgmine käsk:

npm run build

See loob projekti kausta kausta build, kus asuvad kõik staatilised failid, mis on vajalikud React-rakenduse toimimiseks.

▍Staatiliste failide haldamine Nginxiga

Esiteks tuleb installida ja käivitada veebiserver Nginx. Siit saate selle alla laadida ja leidke juhised installimiseks ja käivitamiseks. Seejärel peate kopeerima kausta sisu sa-frontend/build kausta [your_nginx_installation_dir]/html.

Sellise lähenemisega on React-rakenduse koostamisel genereeritud fail index.html saadav aadressil [your_nginx_installation_dir]/html/index.html. See on fail, mille nginx-server kuvab õigel ajal, kui sellele pöördutakse. Server on seadistatud kuulama porti 80, kuid seda saab konfigureerida vastavalt teie vajadusele, redigeerides faili [your_nginx_installation_dir]/conf/nginx.conf.

Nüüd avage brauser ja minge aadressile localhost:80. Te näete React-rakenduse lehte.

React-rakendus, mille teenindab nginx-server

Kui te praegu midagi sisestate väljale Type your sentence ja vajutate nuppu Send , ei juhtu midagi. Kuid kui vaatate konsooli, saate näha veateateid. Et mõista, kus täpselt need vead toimuvad, vaatame rakenduse koodi.

▍ Kliendi-rakenduse koodi analüüs

Vaadates faili koodi App.js, saame näha, et nupu vajutamine Send kutsub välja meetodi analyzeSentence(). Selle meetodi kood on allpool. Samuti pöörake tähelepanu, et igal real, millel on kommentaar vormis # Номер, on alloleva koodi kohta selgitus. Sellisel viisil vaatame üle ka teised koodijupid.

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. URL, kuhu POST-päring saadetakse. Eeldatakse, et sellel aadressil asub rakendus, mis ootab sarnaseid päringuid.

2.Päringu keha, mis saadetakse rakendusele. Siin on näide päringu kehast:

{
    sentence: "I like yogobella!"
}

3.Päringu vastuse saamisel uuendatakse komponenti olekut. See põhjustab komponendi korduva renderdamise. Kui saame andmed (st JSON-objekti, mis sisaldab sisestatud andmeid ja arvutatud tekstihinnangut), kuvame komponendi Polarity, kui vastavad tingimused on täidetud. Nii kirjeldame komponenti:

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

Kood, nagu tundub, on täiesti töökorras. Mis on siis vale? Kui arvate, et aadressil, kuhu rakendus proovib POST-päringut saata, pole midagi, mis selle päringu vastu võtaks ja töötleks, siis olete täiesti õigel teel. Nimelt, et töötleda päringuid, mis saabuvad aadressile http://localhost:8080/sentiment, peame seadma üles Spring-põhise veebirakenduse.

Meile on vaja Spring-rakendust, mis suudab vastu võtta POST-päringu

▍Spring-põhise veebirakenduse seadistamine

Spring-rakenduse käivitamiseks on teil vaja JDK8 ja Mavenit ning õigesti seadistatud keskkonnamuutujaid. Pärast nende paigaldamist saate jätkata meie projektiga.

▍Rakenduse pakkimine jar-failiks

Liikuge terminali kaudu kausta sa-webapp ja sisestage järgmine käsk:

mvn install

Pärast selle käsu täitmist luuakse kausta sa-webapp kaust target. Siin asub Java-rakendus, mis on pakitud jar-faili, failina sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java-rakenduse käivitamine

Liikuge kausta target ja käitage rakendust järgmise käsuga:

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

Selle käsu täitmise käigus esineb viga. Selle parandamiseks saame analüüsida erandi teavet, mis on virnastamisjälgede andmetes:

Viga bean'i loomisel nimega 'sentimentController': Autowire'itud sõltuvuste süstimine ebaõnnestus; pesas olev erand on java.lang.IllegalArgumentException: Kohandatavat märki 'sa.logic.api.url' ei saanud väärtuses "${sa.logic.api.url}" lahendada

Meie jaoks on siin kõige olulisem mainida, et väärtust ei suudeta määrata sa.logic.api.url. Analüüsime koodi, kus viga esineb.

▍Java rakenduse analüüs

Siin on koodifragmend, kus viga esineb.

@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 on väli saLogicApiUrl. Selle väärtus määratakse omaduse järgi sa.logic.api.url.
String saLogicApiUrl konkateeritakse väärtusega /analyse/sentiment. Koos moodustavad need aadressi mikroteenuse kõne tegemiseks, mis teostab tekstianalüüsi.

▍Omaduse väärtuse määramine

Springi standardseks omaduste väärtuste allikaks on fail application.properties, mille leiad aadressilt sa-webapp/src/main/resources. Kuid selle kasutamine ei ole ainus viis omaduste väärtuste määramiseks. Seda saab teha ka järgmise tüüpi käsklusega:

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

Selle omaduse väärtus peab viitama meie Python-rakenduse aadressile.

Seda seadistades teavitame Springi veebirakendust, kuhu tuleb pöörduda tekstianalüüsi päringute täitmiseks.

Kuna ei soovi elu endale keeruliseks teha, oletame, et Python-rakendus on saadaval aadressil localhost:5000 ja püüame sellest mitte unustada. Seega näeb Springi rakenduse käivitamise käsk välja järgmiselt:

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

Meie süsteemis puudub Python-rakendus

Nüüd peab meil lihtsalt käivitama Python-rakenduse ja süsteem töötab ootuspäraselt.

▍Python-rakenduse seadistamine

Python-rakenduse käivitamiseks peavad teil olema installitud Python 3 ja Pip, ning vastavad keskkonnamuutujad peavad olema õigesti seadistatud.

▍ Sõltuvuste paigaldamine

Liikuge projekti kausta sa-logic/sa ja käivitage järgmised käsud:

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

▍ Rakenduse käivitamine

Pärast sõltuvuste paigaldamist oleme valmis rakenduse käivitamiseks:

python sentiment_analysis.py

Pärast selle käsu täitmist saame järgmise teate:

* Käivitatud aadressil http://0.0.0.0:5000/ (Vajutage CTRL+C, et lõpetada)

See tähendab, et rakendus on käivitatud ja ootab päringuid aadressil localhost:5000/

▍ Koodi uurimine

Vaadakem Python-rakenduse koodi, et mõista, kuidas see päringutele reageerib:

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

Objekti initsialiseerimine Flask.
Aadressi määramine POST-päringute tegemiseks.
Mõiste väljavõttmine sentence päringu kehast.
Anonüümse objekti initsialiseerimine TextBlob ja väärtuse saamine polarity esimese esitatud ettepaneku (meie puhul on see ainus ettepanek, mis edastatakse analüüsiks) sisu.
Vastuse tagastamine, mille sees on ettepaneku tekst ja arvutatud näitaja selle jaoks. polarity.
Flaski rakenduse käivitamine, mis on saadaval aadressil 0.0.0.0:5000 (sa saad sellele ligi ka konstruktsiooni kaudu nagu localhost:5000).

Nüüd on rakenduse koosseisus olevad mikroteenused käivitatud. Need on seadistatud üksteisega suhtlemiseks. Nii näeb rakenduse skeem selle töö käigus välja.

Kõik rakenduse koosseisus olevad mikroteenused on töökorras.

Nüüd, enne jätkamist, avage React rakendus brauseris ja proovige analüüsida mõnda ettepanekut. Kui kõik on õigesti tehtud — pärast nupu vajutamist Send näete teksti sisestamise välja all analüüsitulemusi.

Järgnevates lõikudes räägime, kuidas käivitada meie mikroteenused Docker konteinerites. See on vajalik rakenduse ettevalmistamiseks Kubernetes klastri käivitamiseks.

Docker konteinerid

Kubernetes — on automatiseerimise süsteem, mis haldab konteinerirakendite juurutamist, skaleerimist ja haldamist. Seda tuntakse ka kui „konteinerite orkestrit“ (container orchestrator). Kui Kubernetes töötab konteineritega, siis peame enne selle süsteemi kasutamist esmalt nendesse konteineritesse varuma. Alustame aga sellest, mis on konteinerid. Parim vastus küsimusele, mis need on, on leida dokumentatsioonis Dockerist:

Konteineri pilt on kergekaaluline, iseseisev ja käitatav pakett, mis sisaldab rakendust ning kõike vajalikku selle tööks: rakenduse koodi, käituskeskkonna, süsteemivahendeid ja raamatukogusid, seadistusi. Konteinerirakendusi saab kasutada nii Linuxi kui ka Windowsi keskkondades, samas töötavad nad alati ühtemoodi sõltumata infrastruktuurist.

See tähendab, et konteinerid saavad töötada igasugustes arvutites, sealhulgas tootmisserverites, ja kõigis keskkondades töötavad neis sisalduvad rakendused ühtemoodi.

Konteinerite omaduste uurimiseks ja nende teiste rakenduste käitamise viisidega võrdlemiseks vaatame näidet React-rakenduse haldamisest virtuaalmasina ja konteineri abil.

▍React-rakenduse staatiliste failide haldamine virtuaalmasina meetoditega

Püüdes korraldada staatiliste failide haldamist virtuaalmasinate vahendusel, seisame silmitsi järgmiste puudustega:

Resursside ebaefektiivne kasutamine, kuna iga virtuaalmasin on täisväärtuslik operatsioonisüsteem.
Platvormi sõltuvus. See, mis töötab mingil kohalikul arvutil, ei pruugi toimida tootmisserveris.
Aeglane ja ressursimahukas lahenduse skaleerimine, mis põhineb virtuaalmasinatel.

Nginx veebiserver, mis haldab staatilisi faile ja töötab virtuaalmasinas

Kui aga sellele sarnase ülesande lahendamiseks kasutada konteinerite, siis virtuaalmasinatega võrreldes saab tuvastada järgmised nende tugevused:

Energiate tõhus kasutamine: töö operatsioonisüsteemiga Dockeriga.
Platvormist sõltumatu. Arendaja loodud konteiner töötab igal pool, kus ta seda käivitab.
Kerge juurutamine piltide kihtide kasutamise tõttu.

Nginx veebiserver, mis teenindab staatilisi faile konteineris.

Oleme võrrelnud virtuaalmasinaid ja konteidereid vaid mõne punkti põhjal, ent isegi see on piisav, et tunnetada konteinerite tugevaid külgi. Siit võite leida üksikasju Docker konteinerite kohta.

▍Konteineri pildi koostamine React rakenduse jaoks

Docker konteineri peamine ehitusplokk on fail Dockerfile. Selle faili alguses on märge konteineri baaspildist ja seejärel sisaldab see käsurea järjekorda, mis näitab konteineri loomise järjekorda vastavalt rakenduse vajadustele.

Enne kui hakkame failiga tegelema Dockerfile, meenutame, mida oleme teinud, et valmistada ette React rakenduse failid Nginx serverisse laadimiseks:

React rakenduse paketi koostamine (npm run build).
Nginx serveri käivitamine.
Kopeerimine kausta build projekti kaustast sa-frontend serveri kausta nginx/html.

Allpool näete paralleele konteineri loomise ja kohaliku arvuti peal teostatud ülalnimetatud toimingute vahel.

▍Dockerfile'i faili ettevalmistamine SA-Frontend rakendusele

Juhised, mis sisaldavad Dockerfile rakendusele SA-Frontend, koosnevad ainult kahest käsust. Asi on selles, et Nginx-i arendajate rühm on ette valmistanud aluse pildi Nginxi jaoks, mida kasutame oma pildi loomisel. Siin on need kaks sammu, mille peame kirjeldama:

Aluseks olev pilt peab olema Nginx'i pilt.
Kaustas sa-frontend/build peame sisu kopeerima pildi kausta nginx/html.

Kui liikuda sellest kirjeldusest faili Dockerfile, näeb see välja nii:

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

Nagu näete, on kõik siin väga lihtne ja faili sisu osutub isegi üsna loetavaks ja arusaadavaks. See fail ütleb süsteemile, et tuleb kasutada pilti nginx kõik, mis selles juba on, ja kopeerida kausta sisu build kausta nginx/html.

Siin võib teil tekkida küsimus, kust ma tean, kuhu täpselt faile kaustast build, st — kust see tee pärineb /usr/share/nginx/html. Tegelikult ei ole siin midagi keerulist. Asi on selles, et vajalikke andmeid leiab kirjeldusest pildist.

▍Pildi koostamine ja selle üleslaadimine repositooriumisse

Enne kui saame valmis pildiga töötada, peame selle üles laadima piltide repositooriumisse. Selleks kasutame tasuta pilveplatvormi Docker Hub. Selle töö etapi jooksul peate tegema järgmist:

Installi Docker.
Registreeruma Docker Hub veebilehel.
Logi sisse oma kontole, täites terminalis järgmise käsu:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Nüüd tuleb terminali abil minna kausta sa-frontend ja seal täita järgmine käsk:

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

Siin ja edaspidistes sarnastes käskudes $DOCKER_USER_ID on vaja asendada oma Docker Hub kasutajanimega. Näiteks võiks see osa käsust välja näha nii: rinormaloku/sentiment-analysis-frontend.

Selle käsu saab lühendada, eemaldades sellest -f Dockerfile, kuna selles kaustas, kus me seda käsku täidame, see fail juba olemas on.

Valmis pildi üleslaadimiseks repositooriumisse vajame järgmist käsku:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Pärast selle täitmist kontrollige oma Docker Hubi hoidlate loendit, et veenduda, kas pildi saatmine pilve salvestusse õnnestus.

▍Konteineri käivitamine

Nüüd võib igaüks alla laadida ja käivitada pilti, mis on tuntud kui $DOCKER_USER_ID/sentiment-analysis-frontend. Selleks tuleb järgida järgmisi käsku:

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

Nüüd on konteiner käivitunud ning saame jätkata, luues teisi vajalikke pilte. Enne jätkamist vaatame aga üle struktuuri 80:80, mis esineb pildi käivitamise käskudes ja võib tunduda segadust tekitav.

Esimene number 80 on hosti (st kohalik arvuti) port.
Teine number 80 on konteineri port, kuhu peab päring suunatama.

Vaatame järgmist illustreerimist.

Portide suunamine

Süsteem suunab päringud portilt <hostPort> portile <containerPort>. See tähendab, et päring porti 80 arvutils suunatakse konteineri porti. 80 Kuna port

Так как порт 80 kui see on avatud kohalikul arvutil, siis saab sellele rakendusele sellele arvutile juurde pääseda aadressilt localhost:80. Kui teie süsteem ei toeta Dockerit, saab rakendust käivitada Docker virtuaalmasinas, mille aadress näeb välja järgmine :80. Et välja selgitada Docker virtuaalmasina IP-aadress, saab kasutada käsku docker-machine ip.

Sel hetkel, pärast konteineri edukat käivitamist, peaksite saama avada selle lehe brauseris.

▍Fail .dockerignore

Rakenduse pildi kogumise käigus SA-Frontend, oleme võinud märgata, et see protsess osutub äärmiselt aeglaseks. See juhtub seetõttu, et Docker daemonile tuleb edastada pildi kogumise kontekst. Kogu konteksti määrab viimane argument käsus docker build. Meie juhul on selle käsu lõpus punkt. See põhjustab, et järgmine struktuur kaasatakse kogumise konteksti:

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

Aga me vajame siin kõigist neis kaustadest vaid kausta build. Midagi muud laadimist on täiesti ajaraiskamine. Tootmise kiirendamiseks saab Dockerile öelda, millised kaustad on ignoreeritavad. Just selleks on meil vajalik fail .dockerignore. Kui olete tuttav faili .gitignore, struktuur tundub kindlasti tuttav. Selles loetletakse kaustad, mida pildi koostamissüsteem ignoreerida saab. Meie puhul näeb selle failisisu välja selline:

node_modules
src
public

File .dockerignore peab olema samas kaustas nagu fail Dockerfile. Nüüd kestab pildi koostamine vaid sekundeid.

Hakkame nüüd tegelema Java-rakenduse pildiga.

▍Java-rakenduse konteineripildi koostamine

Teate, te olete juba omandanud kõik vajalikud teadmised konteineripiltide loomiseks. Seetõttu on see jaotis üsna lühike.

Avage fail Dockerfile, mis asub projekti kaustas sa-webapp. Kui loete selle faili sisu, leiate seal vaid kaks uut konstruktsiooni, mis algavad märksõnadega ENV ja EXPOSE:

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

Märksõna ENV lubab keskkonnamuutujate määramine Docker konteinerites. Eelkõige meie puhul võimaldab see seada API rakenduse URL-i, mis teostab tekstianalüüsi.

Märksõna EXPOSE töönäitab Docker'ile, et port tuleb avada. Me kavatseme seda porti kasutada rakenduse töö käigus. Siit võib märgata, et Dockerfile rakendusele SA-Frontend sellist käsku ei ole. See on vajalik vaid dokumenteerimise eesmärkidel, teisisõnu, see konstruktsioon on mõeldud lugejale, kes selle üle vaatab. Dockerfile.

Konteineri pildi koostamine ja selle saatmine repositooriumisse toimub täpselt nagu eelnevas näites. Kui te pole enda oskustes veel kindel, siis sobivad käsud leiab failist README.md kaustast sa-webapp.

▍Konteineri pildi koostamine Python-rakendusele

Kui vaatate faili sisu Dockerfile kaustast sa-logic, siis ei leia te seal midagi uut. Pildi koostamiseks ja selle saatmiseks repositooriumisse mõeldud käsud peaksid teile ka tuttavad olema, kuid need, nagu ka teiste meie rakenduste puhul, on leitavad failist README.md kaustast sa-logic.

▍Konteineriseeritud rakenduste testimine

Kas saate usaldada midagi, mida te ei ole proovinud? Mina ka ei saa. Proovime meie konteinerit.

Käivita rakenduse konteiner sa-logic ja seadista see pordi kuulamiseks 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Käivita rakenduse konteiner sa-webapp ja seadista see pordi kuulamiseks 8080. Lisaks peame seadistama pordi, kus Python rakendus ootab Java rakenduselt päringuid, määrates ümber keskkonnamuutuja SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Kuidas leida konteineri või Docker'i virtuaalmasina IP-aadressi — vaadake faili README.

Käivita rakenduse konteiner sa-frontend:

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

Nüüd on kõik valmis, et minna brauserisse aadressile localhost:80 ja rakendust testida.

Pange tähele, et kui olete muutnud portaali jaoks sa-webapp, või kui töötate Docker'i virtuaalmasinaga, peate redigeerima faili App.js kaustast sa-frontend, muutes IP-aadressi või porti meetodis analyzeSentence(), asendades vanad andmed aktuaalsete andmetega. Pärast seda peate pildi uuesti ehitama ja seda kasutama.

Nii näeb meie rakenduse skeem nüüd välja.

Mikroteenused töötavad konteinerites.

Kokkuvõte: miks meil on vaja Kubernetes klastrit?

Just nüüd uurisime faile Dockerfile, rääkisime, kuidas luua pilte ja saata neid Docker'i hoidlasse. Lisaks õpime, kuidas kiirendada piltide loomist, kasutades faili .dockerignore. Tulemusena töötavad meie mikroteenused nüüd Docker'i konteinerites. Siinkohal võib teil tekkida arusaadav küsimus, miks me vajame Kubernetes'e. Sellele küsimusele pühendab meid järgmine osa sellest materjalist. Seni mõelge järgmise küsimuse üle:
Kujutage ette, et meie tekstianalüüsi veebirakendus on muutunud maailmas väga populaarseks. Iga minuti jooksul saab see miljoneid päringuid. See tähendab, et mikroteenused sa-webapp ja sa-logic on tohutu koormuse all. Kuidas skaleerida konteinerite, milles mikroteenused töötavad?

Allikas: habr.com