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

Meie palvel lõi Habr hubi Kubernetes ja meil on hea meel avaldada selles esimene postitus. Liituge!

Kubernetes on lihtne. Miks maksavad pangad mulle selle valdkonna töö eest palju raha, kui igaüks saab selle tehnoloogia omandada vaid mõne tunni jooksul?

Kui te kahtlete, et Kubernetes on nii kiiresti õpitav — soovitan teil proovida seda ise. Omades seda materjali, suudate töötada mikroteenustel põhineva rakendusega Kubernetes klastris. Ma saan seda kinnitada, kuna just sellise meetodi järgi, mis on siin kasutatud, õpetan me Kubernetese kasutusele meie kliente. Mis eristab seda juhendit teistest? Tegelikult – palju. Nimelt, enamik sarnaseid materjale algab lihtsate asjade selgitamisega — Kubernetes kontseptsioonid ja kubectl käsu omadused. Nende materjalide autorid arvavad, et nende lugeja on tuttav rakenduste arendamisega, mikroteenustega ja Docker konteineritega. Meie läheneme teisiti. Esiteks räägime sellest, kuidas käivitada oma arvutis mikroteenustel põhinev rakendus. Siis vaatame konteinerite piltide koostamist iga mikroteenuse jaoks. Ja alles pärast seda tutvume Kubernetese ja käsitleme mikroteenustel põhineva rakenduse käitamise klastris, mida haldab Kubernetes.

Selline lähenemine, mis läheneb Kubernetesele järk-järgult, annab tavainimesele vajalikku sügavust, et mõista, kui lihtne kõik Kubernetesis on. Kubernetes on kindlasti lihtne tehnoloogia, tingimusel, et kes tahab seda omandada, teab, kus ja kuidas seda kasutatakse.

Nüüd, ilma liialdava jututa, alustame tööd ja räägime rakendusest, millega me töötame.

Eksperimentaalne rakendus

Meie rakendus täidab ainult ühte funktsiooni. See võtab sisendiks ühe lause ja analüüsib selle lause sentimenti (sentiment analysis), kasutades tekstianalüüsi vahendeid, saades emotsionaalset suhtumist autori objekti suhtes.

Nii näeb välja selle rakenduse peamine aken.

Veebirakendus tekstide sentimenti analüüsimiseks

Tehnilisest vaatenurgast koosneb rakendus kolmest mikroteenusest, millest igaühel on oma kindel ülesanne.

SA-Frontend — Nginxi veebiserver, mis teenindab Reacti staatilisi faile.
SA-WebApp — Java keeles kirjutatud veebirakendus, mis töötleb päringuid frontendilt.
SA-Logic — Pythonirakendus, mis analüüsib teksti tunnetust.

Oluline on märkida, et mikroteenused ei eksisteeri isolatsioonis. Need rakendavad "kohustuste jagamise" ideed, kuid peavad omavahel suhtlema.

Rakenduses olevad andmevood

Ülaltoodud skeemil on näha nummerdatud etapid süsteemi töös, mis illustreerivad andmevooge rakenduses. Vaatame need läbi:

Brauser pärib serverilt faili index.html (mis omakorda laadib alla Reacti rakenduse paketi).
Kasutaja suhtleb rakendusega, mis kutsub esile pöördumise veebirakendusse, mis põhineb Springil.
Veebirakendus suunab päringu teksti analüüsimiseks Pythonirakendusse.
Pythonirakendus analüüsib teksti tunnetust ja tagastab tulemuse päringu vastusena.
Springi rakendus saadab vastuse Reacti rakendusele (mis omakorda näitab analüüsi tulemust kasutajale).

Kood nende rakenduste jaoks on saadaval siin. Soovitan teil seda reposi kohe endale kopeerida, sest ees ootavad palju huvitavaid katseid sellega.

Mikroteenustel põhineva rakenduse käivitamine kohalikul arvutil

Kuna rakendus tööle hakkaks, peame käivitama kõik kolm mikroteenust. Alustame neist kõige toredamast — frontend rakendusest.

▍Reacti seadistamine kohalikuks arendamiseks

Reacti rakenduse käivitamiseks peate installima oma arvutisse Node.js ja NPM platvormi. Pärast nende installimist minge terminali abil projekti kausta sa-frontend ja käivitage järgmine käsk:

npm install

Selle käsu täitmisega Laaditakse kausta node_modules Reacti rakenduse sõltuvused, mille kirjed on failis package.json. Pärast sõltuvuste allalaadimist täitke samas kaustas järgmine käsk:

npm start

Nüüd on kõik. Reacti rakendus on käivitunud, sellele pääseb juurde, minnes brauserisse aadressile localhost:3000. Saate selle koodi muuta. Muudatused, mida teete, будете kohe näha brauseris. See on võimalik tänu nn „kuumale” moodulite vahetusele. Tänu sellele muutub frontend-arendus lihtsaks ja nauditavaks tegevuseks.

▍React rakenduse ettevalmistamine tootmisse viimiseks

Reaalseks kasutamiseks mõeldud React rakenduse jaoks peame selle muutma staatilisteks failide kogumiks ja edastama need klientidele, kasutades veebi serverit.

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

npm run build

See loob projekti kausta katalooge build. Sellesse kausta paigutatakse kõik staatilised failid, mis on vajalikud React rakenduse tööks.

▍Staatiliste failide teenindamine Nginxiga

Esmalt peate installima ja käivitama veebi serveri Nginx. Siin selle saab alla laadida ja leida installimise ja käivitamise juhised. Seejärel tuleb kopeerida kausta sisu sa-frontend/build kausta [your_nginx_installation_dir]/html.

Seda lähenemist kasutades on genereeritud React rakenduse fail index.html saadaval aadressil [your_nginx_installation_dir]/html/index.html. See on fail, mille Nginx server vaikimisi esitab, kui sellele pöördutakse. Server on konfigureeritud kuulama porti 80, kuid selle saab konfigureerida teie soovil, muutes 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, mida teenindab Nginx server

Kui te hetkel midagi kirjutate väljale Type your sentence ja vajutate nuppu Send — ei juhtu midagi. Kuid kui vaadata konsooli, võib seal näha tõrketeateid. Et mõista, kus need vead täpselt esinevad, vaatame rakenduse koodi.

▍Frontend rakenduse koodi analüüs

Vaadates faili koodi App.js, näeme, et nupu vajutamine Send kutsib meetodi analyzeSentence(). Selle meetodi kood on allpool. Samuti pange tähele, et igal real, millel on kommentaar, on selle koodi all selgitus. Samamoodi uurime ka teisi koodifragmente. # НомерKommentaaridega ridadele on allpool koodi toimetamiseks lisatud selgitus.

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, mille kaudu POST-päring toimub. Eeldatakse, et sellel aadressil on rakendus, mis ootab selliseid päringuid.

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

{
    sentence: "I like yogobella!"
}

3.Päringule vastuse saamisel uuendatakse komponenti olekut. See kutsub esile komponendi taasrenderdamise. Kui saame andmed (st JSON-objekti, mis sisaldab sisestatud andmeid ja arvutatud teksti hinnangut), näitame komponenti. Polaarusus, kuna sobivad tingimused on täidetud. Nii kirjeldame komponenti:

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

Kood tundub olevat täiesti töökorras. Mis siis ikkagi valesti on? Kui arvate, et sellel aadressil, kuhu rakendus püüab saata POST-päringu, pole midagi, mis seda päringut vastu võtaks ja töötleks, olete täiesti õige. Nimelt, et töödelda päringuid, mis tulevad aadressilt http://localhost:8080/sentiment, peame käivitama Spring-põhise veebirakenduse.

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

▍Spring-põhise veebirakenduse seadistamine

Spring-rakenduse kasutamiseks vajate JDK8 ja Mavenit ning õigesti seadistatud keskkonnamuutujaid. Pärast nende kõigi paigaldamist saate jätkata meie projektiga.

▍Rakenduse pakkimine jar-failiks

Liikuge terminali abil 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, pakitud jar-failiks, mis on esindatud failiga sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Java-rakenduse käivitamine

Minge kausta target ja käivitage rakendus järgmise käsuga:

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

Selle käsu täitmisel tekib viga. Selle parandamise alustamiseks saame analüüsida erandiandmeid virnastamise jälgimise andmetest:

Viga bean'i loomisel nimega 'sentimentController': Autowired sõltuvuste süstimise ebaõnnestumine; pesitud erand on java.lang.IllegalArgumentException: Ei õnnestunud lahendada kohatäitjat 'sa.logic.api.url' väärtuses "${sa.logic.api.url}"

Meie jaoks on siin kõige olulisem mainida, et väärtust ei saa välja selgitada sa.logic.api.url. Analüüsime koodi, kus viga toimub.

▍Java rakenduse koodi analüüs

Siin on koodifragmend, kus viga toimub.

@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 atribuudiga sa.logic.api.url.
Rida saLogicApiUrl konkateniseeritakse väärtusega /analyse/sentiment. Koos moodustavad nad aadressi teenuse poole pöördumiseks, mis teostab tekstianalüüsi.

▍Atribuudi väärtuse määramine

Springis on atribuutide väärtuste standardne allikas fail application.properties, mille leiab aadressilt sa-webapp/src/main/resources. Kuid selle kasutamine pole ainus viis atribuutide väärtuste määramiseks. Seda saab teha ka järgmise käsu abil:

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

Selle atribuudiväärtus peab osutama meie Python rakenduse aadressile.

Seda seadistades teavitame veebirakendust Spring, kuhu peab see pöörduma tekstianalüüsi päringute täitmiseks.

Kuna elamise endale keeruliseks tegemine pole soovitav, otsustame, et Python rakendus on saadaval aadressil localhost:5000 ja püüame sellest mitte unustada. Seetõttu näeb käsu käivitamiseks Spring rakendust välja järgmiselt:

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

Meie süsteemist puudub Python rakendus

Praegu on meil jäänud ainult käivitada Python rakendus ja süsteem töötab nagu oodatud.

▍Python rakenduse seadistamine

Et käivitada Python rakendust, peavad teil olema installitud Python 3 ja Pip, ning asjakohased keskkonnamuutujad peavad olema õigesti seadistatud.

▍Sõltuvuste installimine

Minge 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 installimist oleme valmis rakendust käivitama:

python sentiment_analysis.py

Pärast selle käsu täitmist teavitatakse meid järgmistest:

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

See tähendaks, et rakendus on käivitatud ja ootab päringute vastuvõtmist aadressil localhost:5000/

▍Koodi uurimine

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

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 esitamiseks.
Atribuudi saamine sentence päringu kehast.
Anonüümse objekti initsialiseerimine TextBlob ja väärtuse saamine polarity esimese saadetud lause jaoks (meie juhul on see ainus lause, mis analüüsiks edastatakse).
Vastus, mille keha sisaldab lause teksti ja selle arvutatud näitajat polarity.
Flaski rakenduse käivitamine, mis on saadaval aadressil 0.0.0.0:5000 (sellele saab juurde pääseda ka järgmise struktuuri kaudu localhost:5000).

Nüüd on rakenduse moodulite mikroteenused käivitatud. Need on konfigureeritud omavaheliseks suhtlemiseks. Nii näeb välja rakenduse skeem praeguses töös.

Kõik rakenduse moodulite mikroteenused on töövalmis viidud

Enne jätkamist avage React-rakendus brauseris ja proovige analüüsida mõnd lauset. Kui kõik on õigesti tehtud — pärast nupu vajutamist Send näete tekstikasti all analüüsi tulemusi.

Järgmises osas räägime sellest, kuidas käivitada meie mikroteenuseid Docker konteinerites. See on vajalik rakenduse ettevalmistamiseks Kubernetes klastris käivitamiseks.

Docker konteinerid

Kubernetes — see on süsteem konteineriseeritud rakenduste juurutamise, skaleerimise ja haldamise automatiseerimiseks. Seda tuntakse ka kui "konteinerite orkestrator" (container orchestrator). Kui Kubernetes töötab konteineritega, siis peame enne selle süsteemi kasutamist esmalt need konteinerid hankima. Aga enne seda räägime konteineridest. Võib-olla parim vastus küsimusele, mis need on, leiab... dokumentatsioon Dockerist:

Konteineri pilt on kerge, iseseisev, täidetav paket, mis sisaldab teatud rakendust ja kõike vajalikku selle käivitamiseks: rakenduse kood, käituskeskkond, süsteemi tööriistad ja teegid, seadistused. Konteineriseeritud rakendusi saab kasutada Linuxi ja Windowsi keskkondades, kusjuures need töötavad alati ühtemoodi sõltumata infrastruktuurist.

See tähendab, et konteinerid saab käivitada kõikidel arvutitel, sealhulgas tootmisserverites, ja kõigis keskkondades, kus neid sisaldavad rakendused töötavad ühtemoodi.

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

▍React-rakenduse staatiliste failide haldamine virtuaalmasina vahenditega

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

Ebaefektiivne ressursside kasutamine, kuna iga virtuaalmasin on täieõiguslik operatsioonisüsteem.
Platvormi sõltuvus. See, mis töötab kohaliku arvuti peal, ei pruugi töötada tootmisserveris.
Aeglane ja ressursinõudlik virtuaalmasinadel põhinev lahenduste skaleerimine.

Veebiserver Nginx, mis haldab staatilisi faile, käivitub virtuaalmasinas

Kui aga kasutada sama ülesande lahendamiseks konteinerite, siis võrreldes virtuaalmasinatega on nende tugevused järgmised:

Tõhus ressursside kasutamine: töö operatsioonisüsteemiga Dockeriga.
Platvormidest sõltumatus. Arendaja arvutis käivitatav konteiner töötab igal pool.
Kerge juurutamine, kasutades pildikihti.

Nginx veebiserver, mis teenindab staatilisi faile konteineris.

Oleme võrrelnud virtuaalmasinaid ja konteinerite vaid mõne punkti põhjal, kuid isegi see on piisav, et aru saada konteinerite tugevustest. Siin Üksikasju Docker konteinerite kohta leiate siit.

▍Konteineri pildi koostamine React rakenduse jaoks.

Docker konteineri põhielement on fail. Dockerfile. Selle faili alguses tehakse kirje konteineri põhikuul, seejärel lisatakse juhiste jada, mis näitab konteineri loomise järjekorda, mis vastab konkreetse rakenduse vajadustele.

Enne kui hakkame failiga töötama. Dockerfile, meenutame, mida me tegime React rakenduse failide ettevalmistamiseks Nginx serverisse laadimiseks:

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

Allpool näete paralleele konteineri loomise ja eelnevalt mainitud toimingute vahel, mida tehakse kohalikus arvutis.

▍Dockerfile’i ettevalmistamine SA-Frontend rakenduse jaoks.

Käsklused, mis sisaldavad Dockerfile rakenduse jaoks SA-Frontend, koosnevad vaid kahest käsklusest. Nimelt on Nginxi arendajate rühm valmistanud põhipildi pilt Nginxi jaoks, mida me kasutame meie pildi loomisel. Siin on need kaks sammu, mida me peame kirjeldama:

Põhi pildiks peab saama Nginxi pilt.
Kausta sisu sa-frontend/build tuleb kopeerida pildi kausta. nginx/html.

Kui liikuda selle kirjelduse juurest faili juurde, siis näeb see välja järgmiselt: DockerfileFROM nginx COPY build /usr/share/nginx/html

Nagu näete, on kõik siin väga lihtne, samas on faili sisu täiesti loetav ja arusaadav. See fail ütleb süsteemile, et tuleb võtta pilt

kõik, mis seal juba on, ja kopeerida kausta sisu nginx kausta build Siin võib teil tekkida küsimus, kust ma tean, kuhu täpselt tuleb failid kaustast kopeerida. nginx/html.

, st kust tuli tee build. Tegelikult pole ka siin midagi keerulist. Asjaolu on see, et vastavad andmed on leitatavad /usr/share/nginx/htmlkirjeldusest. kirjeldus pildi.

▍Kujundamine ja selle üleslaadimine registrisse

Enne kui saame valmis kujundiga töötada, peame selle saatma pildiregistrisse. Selleks kasutame tasuta pilveteenust kujundite hostimiseks, Docker Hub'i. Selle etapi käigus peate tegema järgmist:

Paigaldada Docker.
Registreeruda Docker Hub'i saidil.
Logige sisse oma kontole, täites terminalis järgmise käsu:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Nüüd peame terminali abil minema kausta sa-frontend ja täitma seal järgmise käsu:

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

Siin ja tulevikus sarnastes käskudes $DOCKER_USER_ID tuleb asendada teie kasutajanimega Docker Hub'is. Näiteks võib see käsu osa välja näha nii: rinormaloku/sentiment-analysis-frontend.

Samuti võime seda käsku lühendada, eemaldades sellest -f Dockerfile, kuna selles kaustas, kus me seda käsku täidame, on see fail juba olemas.

Valmis kujundi saatmiseks registrisse vajame järgmist käsku:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Käsku täitmise järel kontrollige oma Docker Hub'i registrite loendit, et veenduda, kas kujundi saatmine pilveandmehoidlasse õnnestus.

▍Konteineri käivitamine

Nüüd saab igaüks laadida ja käivitada kujundi, mis on tuntud kui $DOCKER_USER_ID/sentiment-analysis-frontend. Selleks tuleb täita järgmine käskude jada:

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äivitatud ja saame jätkata tööd, luues teisi vajalikke kujundeid. Kuid enne jätkamist uurime käsu käivitamise struktuuri 80:80, mis võib tunduda segane.

Esimene number 80 on hosti (ehk kohaliku arvuti) port.
Teine number 80 on konteineri port, kuhu päring suunatakse.

Kehitame järgmise illustratsiooni.

Portide suunamine

Süsteem suunab päringud pordilt <hostPort> portile <containerPort>.Seega suunatakse päring, mis suunatakse arvuti pordile, konteineri pordile. 80 Kuna port 80 on avatud kohaliku arvuti peal, siis on sellele arvutile ligi pääsemiseks rakendusele pöördumise aadress

kasutaja arvutist. 80 открыт на локальном компьютере, то обратиться к приложению с этого компьютера можно по адресу localhost:80. Kui teie süsteem ei toeta Dockerit, saab rakendust käivitada Dockeriga virtuaalmasinas, mille aadress näeb välja nagu :80. Docker'i virtuaalmasina IP-aadressi väljaselgitamiseks saate kasutada käsku docker-machine ip.

Sel hetkel, pärast konteineri edukat käivitamist, peaks teil olema võimalik avada selle lehte brauseris.

▍Fail .dockerignore

Kogudes rakenduse pilti SA-Frontend, võib-olla olete märganud, et see protsess osutub äärmiselt aeglaseks. See juhtub seetõttu, et Docker'i demon peab saama konteineri pildi koostamise konteksti. Koostamiskonteksti määrab käsu viimane argument docker build. Meie puhul seisab selle käsu lõpus punkt. See toob kaasa selle, et koostamiskonteksti lisatakse järgmine struktuur:

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

Kuid me vajame vaid kausta build. Kõik muu laadimine on raiskamine. Koostamist saab kiirendada, andes Dockerile teada, milliseid kaustu saab ignoreerida. Just selleks on meil vajalik fail .dockerignore. Kui olete tuttav faili .gitignore, struktuur tundub kindlasti tuttav. See loetleb kaustad, mida pildi koostamissüsteem võib ignoreerida. Meie juhul näeb faili sisu välja järgmine:

node_modules
src
public

Fail .dockerignore peab olema samas kaustas kui fail Dockerfile. Nüüd võtab pildi koostamine mõne sekundi.

Liigume nüüd Java-rakenduse pildi juurde.

▍Java-rakenduse konteineri pildi koostamine

Teate, et olete juba õppinud kõik vajalikud konteineripiltide loomiseks. Seetõttu on see osa üsna lühike.

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

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

Võtmesõna ENV lubab deklareerida keskkonnamuutujad Docker'i konteinerites. Eelkõige võimaldab see antud juhul määrata rakenduse API-le ligipääsuks URL-i, mis tegeleb teksti analüüsimisega.

Võtmesõna EXPOSE lubab avada Docker, et port tuleb avada. Kasutame seda porti rakendusega töötamisel. Siit võib märgata, et Dockerfile rakenduse jaoks SA-Frontend sellist käsku pole. See on vajalik vaid dokumenteerimise eesmärkidel, teisisõnu, see konstruktsioon on mõeldud neile, kes seda loevad. Dockerfile.

Konteineri pildi koostamine ja selle saatmine reposse näeb täpselt välja nagu eelnevas näites. Kui te pole veel enda võimetes kindel, siis vajalikke käske saab leida failist README.md kaustas sa-webapp.

▍Konteineripildi koostamine Python-rakenduse jaoks

Kui vaatate faili sisu Dockerfile kaustas sa-logic, siis ei leia sealt midagi uut. Pildi koostamise ja selle reposse saatmise käsud peaksid teile olema juba tuttavad, kuid need, nagu ka teiste meie rakenduste puhul, leiate failist README.md kaustas sa-logic.

▍Konteineritud rakenduste testimine

Kas saate usaldada midagi, mida te ei ole testinud? Mina ka ei saa. Katsetame meie konteinerid.

Käivitame rakenduse konteineri sa-logic ja seadistame selle porti kuulama 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Käivitame rakenduse konteineri sa-webapp ja seadistame selle porti kuulama 8080. Lisaks peame seadistama portaali, millel Python-rakendus ootab päringuid Java-rakenduselt, 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 teada saada konteineri või Docker-virtuaalmasina IP-aadress — pöörduge faili poole näiteks, mis kuvatakse armatuurlaudade peal koos Prometheuse päringutega, mis täidavad armatuure..

Käivitame rakenduse konteineri 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 testida rakendust.

Pange tähele, et kui olete sadama numbrit muutnud sa-webapp, või kui töötate Docker-virtuaalmasinaga, peate redigeerima faili App.js Windowsis ja sa-frontend, muutes IP-aadressi või sadama numbri meetodis analyzeSentence(), asendades aegunud andmed актуальны ma infot. Pärast seda tuleb pilt uuesti koostada ja seda kasutada.

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

Mikroteenused töötavad konteinerites.

Kokkuvõte: miks meil on Kubernetes klaster?

Just nüüd õppisime faile Dockerfile, rääkisime sellest, kuidas pilte koostada ja need Docker-reposse saata. Lisaks õppisime, kuidas piltide koostamist kiirendada faili kasutades. .dockerignoreKokkuvõttes töötavad meie mikroteenused nüüd Docker'i konteinerites. Siinkohal võib teil tekkida täiesti õigustatud küsimus, miks me vajame Kubernetes't. Vastus sellele küsimusele saab olema teise osa teema. Enne seda mõelge järgmiselt küsimusele:
Kujutage ette, et meie veebirakendus tekstide analüüsimiseks on saanud ülemaailmseks populaarseks. Iga minut laekub sellele miljoneid päringuid. See tähendab, et mikroteenused sa-webapp ja sa-logic on tohutu koormuse all. Kuidas skaleerida konteinerite koormust, milles mikroteenused töötavad?

Allikas: habr.com