Kubernetese õpetus, 1. osa: rakendused, mikroteenused ja konteinerid

Meie palvel lõi Habr keskuse Kubernetes ja meil on hea meel sellesse avaldada esimene väljaanne. Telli!

Kubernetes on lihtne. Miks maksavad pangad mulle selles valdkonnas töötamise eest palju raha, samas kui igaüks saab selle tehnoloogia omaks saada vaid mõne tunniga?

Kui kahtlete, et Kubernetes saab nii kiiresti selgeks õppida, soovitan teil proovida seda ise teha. Nimelt, olles selle materjali selgeks õppinud, saad Kubernetese klastris käivitada mikroteenustel põhineva rakenduse. Võin seda garanteerida, sest sama metoodika järgi, mida siin kasutan, õpetan ka meie klientidele Kubernetesega töötamist. Mille poolest see juhend teistest erineb? Tegelikult palju asju. Seega algab enamik neist materjalidest lihtsate asjade - Kubernetese kontseptsioonide ja käsu kubectl funktsioonide - selgitamisega. Nende artiklite autorid eeldavad, et nende lugeja tunneb rakenduste arendamist, mikroteenuseid ja Dockeri konteinereid. Me läheme teist teed. Kõigepealt räägime sellest, kuidas arvutis mikroteenustel põhinevat rakendust käivitada. Seejärel vaatame iga mikroteenuse jaoks konteinerikujutisi. Ja pärast seda tutvume Kubernetesega ja analüüsime mikroteenustel põhineva rakenduse juurutamist Kubernetese hallatavas klastris.

Selline lähenemine koos Kubernetesele järkjärgulise lähenemisega annab toimuvast arusaamise sügavuse, mida keskmine inimene vajab, et mõista, kui lihtsalt kõik Kubernetesis korraldatud on. Kubernetes on kindlasti lihtne tehnoloogia, eeldusel, et kes tahab, teab, kus ja kuidas seda kasutatakse.

Nüüd, ilma pikema jututa, asume tööle ja räägime rakendusest, millega töötame.

Eksperimentaalne rakendus

Meie rakendus täidab ainult ühte funktsiooni. See võtab sisendiks ühe lause, misjärel teostab tekstianalüüsi vahendeid kasutades selle lause sentimentanalüüsi, saades hinnangu lause autori emotsionaalsele suhtumisele teatud objekti suhtes.

Selline näeb välja selle rakenduse peaaken.

Sentiment Analüüsi veebirakendus

Tehnilisest vaatenurgast koosneb rakendus kolmest mikroteenusest, millest igaüks lahendab teatud ülesandeid:

• SA-Frontend on Nginxi veebiserver, mis teenindab Reacti staatilisi faile.
• SA-WebApp on Java keeles kirjutatud veebirakendus, mis käsitleb kasutajaliidese päringuid.
• SA-Logic on Pythoni rakendus, mis teostab teksti sentimentide analüüsi.

Oluline on märkida, et mikroteenused ei eksisteeri isoleeritult. Nad rakendavad "ülesannete lahususe" ideed, kuid samal ajal peavad nad üksteisega suhtlema.

Andmevood rakenduses

Ülaltoodud diagrammil näete süsteemi nummerdatud etappe, illustreerides andmevooge rakenduses. Jagame need lahti:

1. Brauser küsib serverilt faili index.html (mis omakorda laadib rakenduse React paketi).
2. Kasutaja suhtleb rakendusega, see kutsub esile Springil põhineva veebirakenduse.
3. Veebirakendus edastab teksti sõelumise taotluse Pythoni rakendusele.
4. Pythoni rakendus analüüsib teksti sentimenti ja tagastab tulemuse vastusena päringule.
5. Spring rakendus saadab vastuse rakendusele React (mis omakorda näitab kasutajale sõelutud teksti tulemust).

Kõigi nende rakenduste koodid leiate siin. Soovitan teil see hoidla kohe endale kopeerida, kuna meid ootab ees palju huvitavaid katseid sellega.

Mikroteenustel põhineva rakenduse käitamine kohalikus masinas

Selleks, et rakendus töötaks, peame käivitama kõik kolm mikroteenust. Alustame neist ilusaimast – esiotsa rakendusest.

▍Reacti seadistamine kohalikuks arenguks

Reacti rakenduse käitamiseks peate oma arvutisse installima Node.js raamistiku ja NPM. Pärast selle kõige installimist minge terminali abil projekti kausta sa-frontend ja käivitage järgmine käsk:

npm install

Selle käsu käivitamisel kaustas node_modules laaditakse Reacti rakenduse sõltuvused, mille kirjed on failis package.json. Pärast sõltuvuste allalaadimist samas kaustas käivitage järgmine käsk:

npm start

See on kõik. Rakendus React töötab nüüd ja sellele pääseb juurde brauseri aadressile navigeerides localhost:3000. Saate tema koodis midagi muuta. Nende muudatuste mõju näete brauseris kohe. See on võimalik tänu moodulite niinimetatud "kuumale" asendamisele. Tänu sellele muutub esiotsa arendamine lihtsaks ja nauditavaks kogemuseks.

▍Reacti rakenduse ettevalmistamine tootmiseks

Reacti rakenduse tegelikuks kasutamiseks peame selle teisendama staatiliste failide komplektiks ja serveerima neid veebiserveri abil klientidele.

Rakenduse React loomiseks navigeerige uuesti terminali kasutades kausta sa-frontend ja käivitage järgmine käsk:

npm run build

See loob projekti kausta kataloogi build. See sisaldab kõiki staatilisi faile, mis on vajalikud rakenduse React töötamiseks.

▍ Staatiliste failide teenindamine Nginxiga

Kõigepealt peate installima ja käivitama Nginxi veebiserveri. see on saate selle alla laadida ja leida juhiseid selle installimiseks ja käitamiseks. Seejärel peate kausta sisu kopeerima sa-frontend/build kausta [your_nginx_installation_dir]/html.

Selle lähenemisviisi korral luuakse Reacti rakenduse kokkupanemise käigus loodud fail index.html on saadaval aadressil [your_nginx_installation_dir]/html/index.html. See on fail, mille Nginxi server sellele juurdepääsul vaikimisi väljastab. Server on konfigureeritud kuulama pordi kaudu 80, kuid saate faili redigeerides seda soovitud viisil kohandada [your_nginx_installation_dir]/conf/nginx.conf.

Nüüd avage brauser ja minge aadressile localhost:80. Näete Reacti rakenduse lehte.

Reaktsioonirakendust teenindab Nginxi server

Kui nüüd midagi väljale sisestada Type your sentence ja vajutage nuppu Send - midagi ei juhtu. Kuid kui vaatate konsooli, näete seal veateateid. Et mõista, kus need vead täpselt ilmnevad, analüüsime rakenduse koodi.

▍Esirakenduse koodi analüüs

Faili koodi vaatamine App.js, näeme seda nupul klõpsates Send kutsub meetodit analyzeSentence(). Selle meetodi kood on näidatud allpool. Samal ajal pöörake tähelepanu asjaolule, et iga rea ​​kohta, mille kohta on vormi kommentaar # Номер, on koodi all antud selgitus. Samamoodi sõelume ka teisi koodifragmente.

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, millele POST-i päring tehakse. Eeldatakse, et see aadress on rakendus, mis ootab selliseid päringuid.

2.Taotlusele saadetud päringu asutus. Siin on päringu keha näide:

{
    sentence: "I like yogobella!"
}

3.Kui päringule saabub vastus, värskendatakse komponendi olekut. See põhjustab komponendi uuesti renderdamise. Kui saame andmeid (st JSON-objekti, mis sisaldab sisestatud andmeid ja arvutatud tekstiskoori), väljastame komponendi Polarityseni, kuni tingimused on täidetud. Siin kirjeldame komponenti:

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

Tundub, et kood töötab üsna hästi. Mis siin ikkagi viga on? Kui eeldate, et aadressil, millele rakendus üritab POST-päringut saata, pole veel midagi, mis saaks seda päringut vastu võtta ja töödelda, siis on teil täiesti õigus. Nimelt aadressile tulevate päringute menetlemiseks http://localhost:8080/sentiment, peame käivitama Springil põhineva veebirakenduse.

Vajame kevadist rakendust, mis suudab vastu võtta POST-päringu

▍Kevadel põhineva veebirakenduse seadistamine

Spring-rakenduse juurutamiseks vajate JDK8 ja Mavenit ning õigesti konfigureeritud keskkonnamuutujaid. Pärast selle kõige installimist saate meie projektiga edasi töötada.

▍Rakenduse pakkimine jar-faili

Navigeerige terminali kasutades kausta sa-webapp ja sisestage järgmine käsk:

mvn install

Pärast selle käsu täitmist kaustas sa-webapp kataloog luuakse target. Siin asub Java-rakendus, mis on pakitud jar-faili, mida fail esindab 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 ilmneb tõrge. Selle parandamise alustamiseks saame virna jälgimise andmetes erandi üksikasju sõeluda:

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}"

Meie jaoks on siinkohal kõige olulisem tähenduse selgitamise võimatuse mainimine sa.logic.api.url. Analüüsime koodi, kus viga ilmneb.

▍Java rakenduse koodi analüüs

Siin on koodilõik, kus viga ilmneb.

@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. In SentimentController seal on põld saLogicApiUrl. Selle väärtuse määrab kinnisvara sa.logic.api.url.
2. Rida saLogicApiUrl haakub väärtusega /analyse/sentiment. Üheskoos moodustavad need aadressi tekstianalüüsi teostavale mikroteenusele helistamiseks.

▍Atribuudi väärtuse määramine

Kevadel on atribuutide väärtuste vaikeallikaks fail application.properties, mille leiate aadressilt sa-webapp/src/main/resources. Kuid selle kasutamine ei ole ainus viis vara väärtuste määramiseks. Seda saate teha ka järgmise käsuga:

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

Selle atribuudi väärtus peaks osutama meie Pythoni rakenduse aadressile.

Seda konfigureerides anname Spring veebirakendusele teada, kuhu see teksti sõelumistaotluste täitmiseks minema peab.

Et mitte oma elu keeruliseks teha, otsustame, et Pythoni rakendus on saadaval aadressil localhost:5000 ja proovige seda mitte unustada. Selle tulemusel näeb kevadrakenduse käivitamise käsk välja järgmine:

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

Meie süsteemis puudub Pythoni rakendus

Nüüd peame lihtsalt Pythoni rakenduse käivitama ja süsteem töötab ootuspäraselt.

▍Pythoni rakenduse seadistamine

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

▍ Installige sõltuvused

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

Kui sõltuvused on installitud, oleme rakenduse käivitamiseks valmis:

python sentiment_analysis.py

Pärast selle käsu täitmist öeldakse meile järgmist:

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

See tähendab, et rakendus töötab ja ootab päringuid aadressil localhost:5000/

▍Koodiuuring

Vaatame Pythoni rakenduse koodi, et mõista, kuidas see päringutele vastab:

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. Objekti lähtestamine Flask.
2. Aadressi määramine sellele POST-päringute tegemiseks.
3. Kinnisvara kättesaamine sentence taotluse esitanud organilt.
4. Anonüümse objekti lähtestamine TextBlob ja väärtuse saamine polarity päringu põhitekstis laekunud esimese ettepaneku puhul (meie puhul on see ainus analüüsimiseks esitatud ettepanek).
5. Vastuse tagastamine, mille sisuks on pakkumise tekst ja sellele arvutatud näitaja polarity.
6. Rakenduse Flask käivitamine, mis on saadaval aadressil 0.0.0.0:5000 (sellele pääsete juurde ka vormi konstruktsiooni abil localhost:5000).

Nüüd töötavad rakenduse moodustavad mikroteenused. Nad on seatud üksteisega suhtlema. Siin näeb rakenduse diagramm selles tööetapis välja.

Kõik rakenduse moodustavad mikroteenused viiakse normaalsesse olekusse

Nüüd, enne kui jätkame, avage brauseris rakendus React ja proovige sellega mõnda lauset sõeluda. Kui kõik on õigesti tehtud - pärast nupu vajutamist Send analüüsitulemusi näete tekstikasti all.

Järgmises jaotises räägime sellest, kuidas oma mikroteenuseid Dockeri konteinerites käitada. See on vajalik rakenduse ettevalmistamiseks Kubernetese klastris käitamiseks.

Dockeri konteinerid

Kubernetes on süsteem konteinerite rakenduste juurutamise, skaleerimise ja haldamise automatiseerimiseks. Seda nimetatakse ka "konteineri orkestraatoriks". Kui Kubernetes töötab konteineritega, siis enne selle süsteemi kasutamist peame esmalt need konteinerid hankima. Kuid kõigepealt räägime sellest, mis on konteinerid. Võib-olla leiate parima vastuse küsimusele, mis see on dokumentatsioon Dockerile:

Konteinerpilt on kerge, iseseisev käivitatav pakett, mis sisaldab rakendust, mis sisaldab kõike selle käitamiseks vajalikku: rakenduse koodi, käituskeskkonda, süsteemitööriistu ja teeke, sätteid. Konteinerprogramme saab kasutada nii Linuxi kui ka Windowsi keskkondades ning need töötavad alati samamoodi, olenemata infrastruktuurist.

See tähendab, et konteinereid saab käivitada igas arvutis, sealhulgas tootmisserverites, ja igas keskkonnas töötavad neisse suletud rakendused samamoodi.

Konteinerite funktsioonide uurimiseks ja nende võrdlemiseks muude rakenduste käitamise viisidega vaatame näidet Reacti rakenduse teenindamisest virtuaalmasina ja konteineri abil.

▍Reacti rakenduse staatiliste failide teenindamine virtuaalmasina abil

Püüdes korraldada staatiliste failide hooldust virtuaalmasinate abil, puutume kokku järgmiste puudustega:

1. Ebaefektiivne ressursside kasutamine, kuna iga virtuaalmasin on terviklik operatsioonisüsteem.
2. Platvormi sõltuvus. Mis töötab mõnes kohalikus arvutis, ei pruugi tootmisserveris töötada.
3. Virtuaalse masina lahenduse aeglane ja ressursimahukas skaleerimine.

Nginxi veebiserver, mis teenindab virtuaalmasinas töötavaid staatilisi faile

Kui sarnase probleemi lahendamiseks kasutatakse konteinereid, võib võrreldes virtuaalsete masinatega märkida järgmisi tugevusi:

1. Tõhus ressursside kasutamine: töötage operatsioonisüsteemiga Dockeri abil.
2. Platvormi sõltumatus. Konteiner, mida arendaja saab oma arvutis käivitada, töötab kõikjal.
3. Kerge juurutus pildikihtide kasutamise kaudu.

Nginxi veebiserver, mis teenindab konteineris töötavaid staatilisi faile

Oleme virtuaalmasinaid ja konteinereid võrrelnud vaid mõnes punktis, kuid sellestki piisab, et mõista konteinerite tugevaid külgi. see on Leiate üksikasju Dockeri konteinerite kohta.

▍Reacti rakenduse jaoks konteineri kujutise loomine

Dockeri konteineri põhiline ehitusplokk on fail Dockerfile. Selle faili alguses salvestatakse konteineri põhipilt, seejärel on lisatud juhiste jada, mis näitab, kuidas luua rakenduse vajadustele vastav konteiner.

Enne kui hakkame failiga töötama Dockerfile, pidage meeles, mida tegime rakenduse React failide ettevalmistamiseks Nginxi serverisse üleslaadimiseks:

1. Reacti rakenduse paketi loomine (npm run build).
2. Nginxi serveri käivitamine.
3. Kataloogi sisu kopeerimine build projekti kaustast sa-frontend serveri kausta nginx/html.

Allpool näete paralleele konteineri loomise ja ülaltoodud toimingute vahel kohalikus arvutis.

▍Sa-Frontendi rakenduse jaoks Dockeri faili ettevalmistamine

Juhised, mis tuleb lisada Dockerfile rakenduseks SA-Frontend, koosneb ainult kahest meeskonnast. Fakt on see, et Nginxi arendusmeeskond on ette valmistanud põhi образ Nginxi jaoks, mida kasutame oma kuvandi loomiseks. Siin on kaks sammu, mida peame kirjeldama.

1. Pildi aluseks peate tegema Nginxi kujutise.
2. Kausta sisu sa-frontend/build tuleb kopeerida piltide kausta nginx/html.

Kui läheme selle kirjelduse juurest faili Dockerfile, siis näeb see välja selline:

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

Nagu näete, on siin kõik väga lihtne, samas kui faili sisu osutub isegi üsna loetavaks ja arusaadavaks. See fail käsib süsteemil pildi teha nginx koos kõigega, mis tal juba on, ja kopeerige kataloogi sisu build kataloogi nginx/html.

Siin võib teil tekkida küsimus, kuidas ma tean, kuhu failid kaustast täpselt kopeerida buildst kust see tee tuli /usr/share/nginx/html. Tegelikult pole siin ka midagi keerulist. Fakt on see, et asjakohase teabe leiate aadressilt kirjeldus pilt.

▍Pildi kokkupanek ja hoidlasse üleslaadimine

Enne kui saame valmis pildiga töötada, peame selle pildihoidlasse esitama. Selleks kasutame tasuta pilvepõhist pildimajutusplatvormi Docker Hub. Selles tööetapis peate tegema järgmist.

1. Installi laevalaadija.
2. Registreeruge Docker Hubi saidil.
3. Logige oma kontole sisse, käivitades terminalis järgmise käsu:

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

Nüüd peate terminali kasutades minema kataloogi sa-frontend ja käivitage seal järgmine käsk:

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

Siin ja allpool sarnastes käskudes $DOCKER_USER_ID tuleks Docker Hubis teie kasutajanimega asendada. Näiteks võib see käsu osa välja näha järgmine: rinormaloku/sentiment-analysis-frontend.

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

Valmis pildi hoidlasse saatmiseks vajame järgmist käsku:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Pärast selle lõpetamist kontrollige oma hoidlate loendit Docker Hubis, et näha, kas pilt õnnestus pilvesalvestusse lükata.

▍Konteineri käivitamine

Nüüd saab igaüks alla laadida ja käivitada pildi, mida tuntakse kui $DOCKER_USER_ID/sentiment-analysis-frontend. Selleks peate käivitama järgmise 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 konteiner töötab ja saame jätkata tööd, luues muid vajalikke pilte. Aga enne kui jätkame, mõistame disaini 80:80, mis asub pildi käivitamise käsus ja võib tunduda segane.

• Esimene number 80 on hosti (st kohaliku arvuti) pordi number.
• Teine number 80 on konteineri sadam, kuhu päring tuleks ümber suunata.

Mõelge järgmisele illustratsioonile.

Pordi edastamine

Süsteem edastab päringud pordist <hostPort> sadamasse <containerPort>. See tähendab, et pääseb sadamasse 80 arvuti suunatakse porti 80 konteiner.

Alates sadamast 80 avatud kohalikus arvutis, pääsete rakendusele sellest arvutist juurde aadressil localhost:80. Kui teie süsteem Dockerit ei toeta, saate rakenduse käivitada Dockeri virtuaalmasinas, mille aadress näeb välja selline <docker-machine ip>:80. Dockeri virtuaalmasina IP-aadressi väljaselgitamiseks võite kasutada käsku docker-machine ip.

Sel hetkel, kui esiotsa rakenduse konteiner on edukalt käivitatud, peaksite saama selle lehe brauseris avada.

▍.dockerignore fail

Rakenduse pildi loomine SA-Frontend, võisime märgata, et see protsess on äärmiselt aeglane. Seda seetõttu, et pildi koostamise kontekst tuleb saata Dockeri deemonile. Ehitamise konteksti esindav kataloog antakse käsu viimase argumendina docker build. Meie puhul on selle käsu lõpus punkt. Selle tulemusel kaasatakse montaaži konteksti järgmine struktuur:

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

Kuid kõigist siin olevatest kaustadest vajame ainult kausta build. Millegi muu allalaadimine on ajaraiskamine. Ehitamist saate kiirendada, öeldes Dockerile, milliseid katalooge ignoreerida. Selleks vajame faili .dockerignore. Teie, kui olete failiga tuttav .gitignore, tundub selle faili struktuur ilmselt tuttav. See loetleb kataloogid, mida pildiehitussüsteem võib ignoreerida. Meie puhul näeb selle faili sisu välja järgmine:

node_modules
src
public

fail .dockerignore peab olema failiga samas kaustas Dockerfile. Nüüd võtab pildi kokkupanek mõne sekundi.

Nüüd käsitleme Java-rakenduse pilti.

▍Java rakenduse jaoks konteineri kujutise loomine

Teate küll, ja olete juba õppinud kõike, mida konteinerpiltide loomiseks vajate. Seetõttu jääb see osa väga lühikeseks.

Avage fail Dockerfile, mis asub projekti kaustas sa-webapp. Kui lugeda selle faili teksti, siis kohtab selles vaid kahte uut konstruktsiooni, mis algavad märksõnadega ENV и EXPOSE:

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

Märksõna ENV võimaldab deklareerida keskkonnamuutujaid Dockeri konteinerites. Eelkõige võimaldab see meie puhul määrata URL-i, et pääseda juurde tekstianalüüsi teostava rakenduse API-le.

Märksõna EXPOSE võimaldab teil käskida Dockeril port avada. Kasutame seda porti rakendusega töötamisel. Siin näete seda sisse Dockerfile rakenduseks SA-Frontend sellist käsku pole. See on mõeldud ainult dokumenteerimiseks, teisisõnu, see konstruktsioon on lugeja jaoks Dockerfile.

Kujutise ehitamine ja hoidlasse lükkamine näeb välja täpselt nagu eelmine näide. Kui sa pole oma võimetes veel väga kindel, siis vastavad käsud leiab failist README.md kaustas sa-webapp.

▍Pythoni rakenduse jaoks konteineri kujutise loomine

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

▍Konteinerite rakenduste testimine

Kas saate usaldada midagi, mida te pole testinud? ma ei saa ka. Testime oma konteinereid.

1. Käivitame rakenduste konteineri sa-logic ja seadistage see pordis kuulama 5050:

   docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic

2. Käivitame rakenduste konteineri sa-webapp ja seadistage see pordis kuulama 8080. Lisaks peame määrama pordi, millel Pythoni rakendus kuulab Java rakenduse päringuid, määrates ümber keskkonnamuutuja 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

Konteineri või Dockeri VM-i IP-aadressi teadasaamiseks vaadake faili README.

Käivitame rakenduste konteineri sa-frontend:

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

Nüüd on kõik valmis brauseris aadressile navigeerimiseks localhost:80 ja testige rakendust.

Pange tähele, et kui muudate porti sa-webapp, või kui kasutate Dockeri VM-i, peate faili redigeerima App.js kaustast sa-frontendmuutes meetodis IP-aadressi või pordi numbrit analyzeSentence()asendades vananenud andmete asemel praeguse teabe. Pärast seda peate pildi uuesti kokku panema ja seda kasutama.

Selline näeb meie rakendusskeem praegu välja.

Mikroteenused töötavad konteinerites

Kokkuvõte: miks me vajame Kubernetese klastrit?

Vaatasime just failid üle Dockerfile, rääkis, kuidas luua pilte ja lükata need Dockeri hoidlasse. Lisaks õppisime, kuidas faili abil piltide kokkupanemist kiirendada .dockerignore. Selle tulemusena töötavad meie mikroteenused nüüd Dockeri konteinerites. Siin võib teil tekkida täiesti õigustatud küsimus selle kohta, miks me Kubernetest vajame. Vastus sellele küsimusele on pühendatud selle materjali teisele osale. Vahepeal kaaluge järgmist küsimust:
Oletame, et meie tekstianalüüsi veebirakendus on kogu maailmas populaarseks saanud. Iga minut saabub talle miljoneid taotlusi. See tähendab, et mikroteenused sa-webapp и sa-logic saab olema tohutu stressi all. Kuidas skaleerida mikroteenuseid pakkuvaid konteinereid?

Allikas: www.habr.com